This is an archive of the discontinued LLVM Phabricator instance.

Differential D3389

`nonnull` argument attribute.
AbandonedPublic

Authored by luqmana on Apr 15 2014, 9:02 PM.

Details

Reviewers
nicholas
Summary

This patch adds a new argument attribute nonnull. This lets LLVM get rid of certain null checks. GCC already has a nonnull attribute. Also, this would be useful in Rust since we can mark a lot of our pointers as such.

Diff Detail

Event Timeline

luqmana updated this revision to Unknown Object (????).Apr 15 2014, 9:05 PM

Added test.

hfinkel added a comment.Apr 16 2014, 4:32 AM

Thanks for working on this!

When uploading a patch to phabricator, please increase the number of context lines as documented here: http://llvm.org/docs/Phabricator.html

test/Analysis/BasicAA/nonnull.ll
1 ↗(On Diff #8553)

This test is in the wrong place. You seem to be testing instcombine here, not basicaa, and so the test should be in test/Transforms/InstCombine somewhere.

luqmana updated this revision to Unknown Object (????).Apr 16 2014, 7:14 AM

Added more context and moved test.

luqmana updated this revision to Unknown Object (????).Apr 16 2014, 10:22 AM
• tpoechtrager added a comment.Apr 16 2014, 5:14 PM

I didn't see any obvious problems remaining. LGTM.

rnk added a comment.Apr 16 2014, 6:06 PM

Seems pretty cool.

Is it meaningful to have a nonnull attribute on a non-pointer type? Mind outlawing that in the Verifier, and then adding a verifier test?

• tpoechtrager added a comment.Apr 17 2014, 8:47 PM

Your change to lib/IR/Value.cpp is wrong, a nonnull pointer is not
necessarily dereferenceable.

%a = inttoptr i32 123456 to i32*
call void @foo(i32* %a nonnull)

It's nonnull, but not dereferenceable.

Nick

Luqman Aden wrote:

Added test.

http://reviews.llvm.org/D3389

CHANGE SINCE LAST DIFF

http://reviews.llvm.org/D3389?vs=8552&id=8553#toc

Files:

lib/AsmParser/LLToken.h
lib/AsmParser/LLParser.cpp
lib/AsmParser/LLLexer.cpp
lib/Bitcode/Writer/BitcodeWriter.cpp
lib/Bitcode/Reader/BitcodeReader.cpp
lib/IR/Function.cpp
lib/IR/Attributes.cpp
lib/Analysis/ValueTracking.cpp
test/Bitcode/attributes.ll
test/Analysis/BasicAA/nonnull.ll
include/llvm/Bitcode/LLVMBitCodes.h
include/llvm/IR/Attributes.h
include/llvm/IR/Argument.h

llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

luqmana updated this revision to Unknown Object (????).Apr 18 2014, 8:01 AM

Removed check from isDereferenceablePointer and added Verifier test.

luqmana updated this revision to Unknown Object (????).Apr 18 2014, 7:46 PM

Added docs.

dotdash added a comment.Apr 21 2014, 3:01 AM

This information could also be used in ArgPromotion::isSafeToPromoteArgument(). Its second argument, isByValOrInAlloca, is used to determine whether a pointer argument is always valid.

luqmana added a comment.May 14 2014, 1:23 PM

dotdash:

This information could also be used in ArgPromotion::isSafeToPromoteArgument(). Its second argument, isByValOrInAlloca, is used to determine whether a pointer argument is always valid.

I don't that would be valid since a nonnull pointer is not necessarily dereferenceable.

luqmana updated this revision to Diff 9400.May 14 2014, 1:27 PM
luqmana added a reviewer: nicholas.
luqmana added a subscriber: nicholas.

Updated to address review comments.

luqmana abandoned this revision.Sep 1 2014, 2:38 PM

Revision Contents

PathSize
docs/
7 lines
include/
llvm-c/
3 lines
llvm/
Bitcode/
3 lines
IR/
4 lines
1 line
lib/
Analysis/
4 lines
AsmParser/
1 line
3 lines
1 line
Bitcode/
Reader/
2 lines
Writer/
2 lines
IR/
4 lines
8 lines
test/
Bitcode/
5 lines

Diff 9400

docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 841 Lines • ▼ Show 20 Lines``returned``
This indicates that the function always returns the argument as its return This indicates that the function always returns the argument as its return
value. This is an optimization hint to the code generator when generating value. This is an optimization hint to the code generator when generating
the caller, allowing tail call optimization and omission of register saves the caller, allowing tail call optimization and omission of register saves
and restores in some cases; it is not checked or enforced when generating and restores in some cases; it is not checked or enforced when generating
the callee. The parameter and the function return type must be valid the callee. The parameter and the function return type must be valid
operands for the :ref:`bitcast instruction <i_bitcast>`. This is not a operands for the :ref:`bitcast instruction <i_bitcast>`. This is not a
valid attribute for return values and can only be applied to one parameter. valid attribute for return values and can only be applied to one parameter.
``nonnull``
This indicates that the parameter or return pointer is not null. This
attribute may only be applied to pointer typed parameters. This is not
checked or enforced by LLVM, the caller must ensure that the pointer
passed in is non-null, or the callee must ensure that the returned pointer
is non-null.
.. _gc: .. _gc:
Garbage Collector Names Garbage Collector Names
----------------------- -----------------------
Each function may specify a garbage collector name, which is simply a Each function may specify a garbage collector name, which is simply a
string: string:
▲ Show 20 Lines • Show All 8,271 Lines • Show Last 20 Lines

include/llvm-c/Core.h

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Linestypedef enum {
/* FIXME: These attributes are currently not included in the C API as /* FIXME: These attributes are currently not included in the C API as
a temporary measure until the API/ABI impact to the C API is understood a temporary measure until the API/ABI impact to the C API is understood
and the path forward agreed upon. and the path forward agreed upon.
LLVMAddressSafety = 1ULL << 32, LLVMAddressSafety = 1ULL << 32,
LLVMStackProtectStrongAttribute = 1ULL<<33, LLVMStackProtectStrongAttribute = 1ULL<<33,
LLVMCold = 1ULL << 34, LLVMCold = 1ULL << 34,
LLVMOptimizeNone = 1ULL << 35, LLVMOptimizeNone = 1ULL << 35,
LLVMInAllocaAttribute = 1ULL << 36 LLVMInAllocaAttribute = 1ULL << 36,
LLVMNonNullAttribute = 1ULL << 37
*/ */
} LLVMAttribute; } LLVMAttribute;
typedef enum { typedef enum {
/* Terminator Instructions */ /* Terminator Instructions */
LLVMRet = 1, LLVMRet = 1,
LLVMBr = 2, LLVMBr = 2,
LLVMSwitch = 3, LLVMSwitch = 3,
▲ Show 20 Lines • Show All 2,712 Lines • Show Last 20 Lines

include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 365 Lines • ▼ Show 20 Lines enum AttributeKindCodes {
ATTR_KIND_SANITIZE_ADDRESS = 30, ATTR_KIND_SANITIZE_ADDRESS = 30,
ATTR_KIND_SANITIZE_THREAD = 31, ATTR_KIND_SANITIZE_THREAD = 31,
ATTR_KIND_SANITIZE_MEMORY = 32, ATTR_KIND_SANITIZE_MEMORY = 32,
ATTR_KIND_UW_TABLE = 33, ATTR_KIND_UW_TABLE = 33,
ATTR_KIND_Z_EXT = 34, ATTR_KIND_Z_EXT = 34,
ATTR_KIND_BUILTIN = 35, ATTR_KIND_BUILTIN = 35,
ATTR_KIND_COLD = 36, ATTR_KIND_COLD = 36,
ATTR_KIND_OPTIMIZE_NONE = 37, ATTR_KIND_OPTIMIZE_NONE = 37,
ATTR_KIND_IN_ALLOCA = 38 ATTR_KIND_IN_ALLOCA = 38,
ATTR_KIND_NON_NULL = 39
}; };
} // End bitc namespace } // End bitc namespace
} // End llvm namespace } // End llvm namespace
#endif #endif

include/llvm/IR/Argument.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
inline Function *getParent() { return Parent; } inline Function *getParent() { return Parent; }
/// \brief Return the index of this formal argument in its containing /// \brief Return the index of this formal argument in its containing
/// function. /// function.
/// ///
/// For example in "void foo(int a, float b)" a is 0 and b is 1. /// For example in "void foo(int a, float b)" a is 0 and b is 1.
unsigned getArgNo() const; unsigned getArgNo() const;
/// \brief Return true if this argument has the nonnull attribute on it in
/// its containing function.
bool hasNonNullAttr() const;
/// \brief Return true if this argument has the byval attribute on it in its /// \brief Return true if this argument has the byval attribute on it in its
/// containing function. /// containing function.
bool hasByValAttr() const; bool hasByValAttr() const;
/// \brief Return true if this argument has the byval attribute or inalloca /// \brief Return true if this argument has the byval attribute or inalloca
/// attribute on it in its containing function. These attributes both /// attribute on it in its containing function. These attributes both
/// represent arguments being passed by value. /// represent arguments being passed by value.
bool hasByValOrInAllocaAttr() const; bool hasByValOrInAllocaAttr() const;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

include/llvm/IR/Attributes.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines enum AttrKind {
NoAlias, ///< Considered to not alias after call NoAlias, ///< Considered to not alias after call
NoBuiltin, ///< Callee isn't recognized as a builtin NoBuiltin, ///< Callee isn't recognized as a builtin
NoCapture, ///< Function creates no aliases of pointer NoCapture, ///< Function creates no aliases of pointer
NoDuplicate, ///< Call cannot be duplicated NoDuplicate, ///< Call cannot be duplicated
NoImplicitFloat, ///< Disable implicit floating point insts NoImplicitFloat, ///< Disable implicit floating point insts
NoInline, ///< inline=never NoInline, ///< inline=never
NonLazyBind, ///< Function is called early and/or NonLazyBind, ///< Function is called early and/or
///< often, so lazy binding isn't worthwhile ///< often, so lazy binding isn't worthwhile
NonNull, ///< Pointer is known to be not null
NoRedZone, ///< Disable redzone NoRedZone, ///< Disable redzone
NoReturn, ///< Mark the function as not returning NoReturn, ///< Mark the function as not returning
NoUnwind, ///< Function doesn't unwind stack NoUnwind, ///< Function doesn't unwind stack
OptimizeForSize, ///< opt_size OptimizeForSize, ///< opt_size
OptimizeNone, ///< Function must not be optimized. OptimizeNone, ///< Function must not be optimized.
ReadNone, ///< Function does not access memory ReadNone, ///< Function does not access memory
ReadOnly, ///< Function only reads from memory ReadOnly, ///< Function only reads from memory
Returned, ///< Return value is always equal to this argument Returned, ///< Return value is always equal to this argument
▲ Show 20 Lines • Show All 412 Lines • Show Last 20 Lines

lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 2,070 Lines • ▼ Show 20 Lines
} }
/// isKnownNonNull - Return true if we know that the specified value is never /// isKnownNonNull - Return true if we know that the specified value is never
/// null. /// null.
bool llvm::isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI) { bool llvm::isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI) {
// Alloca never returns null, malloc might. // Alloca never returns null, malloc might.
if (isa<AllocaInst>(V)) return true; if (isa<AllocaInst>(V)) return true;
// A byval or inalloca argument is never null. // A byval, inalloca, or nonnull argument is never null.
if (const Argument *A = dyn_cast<Argument>(V)) if (const Argument *A = dyn_cast<Argument>(V))
return A->hasByValOrInAllocaAttr(); return A->hasByValOrInAllocaAttr() || A->hasNonNullAttr();
// Global values are not null unless extern weak. // Global values are not null unless extern weak.
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
return !GV->hasExternalWeakLinkage(); return !GV->hasExternalWeakLinkage();
// operator new never returns null. // operator new never returns null.
if (isOperatorNewLikeFn(V, TLI, /*LookThroughBitCast=*/true)) if (isOperatorNewLikeFn(V, TLI, /*LookThroughBitCast=*/true))
return true; return true;
return false; return false;
} }

lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 587 Lines • ▼ Show 20 Lines#define KEYWORD(STR) \
KEYWORD(nest); KEYWORD(nest);
KEYWORD(noalias); KEYWORD(noalias);
KEYWORD(nobuiltin); KEYWORD(nobuiltin);
KEYWORD(nocapture); KEYWORD(nocapture);
KEYWORD(noduplicate); KEYWORD(noduplicate);
KEYWORD(noimplicitfloat); KEYWORD(noimplicitfloat);
KEYWORD(noinline); KEYWORD(noinline);
KEYWORD(nonlazybind); KEYWORD(nonlazybind);
KEYWORD(nonnull);
KEYWORD(noredzone); KEYWORD(noredzone);
KEYWORD(noreturn); KEYWORD(noreturn);
KEYWORD(nounwind); KEYWORD(nounwind);
KEYWORD(optnone); KEYWORD(optnone);
KEYWORD(optsize); KEYWORD(optsize);
KEYWORD(readnone); KEYWORD(readnone);
KEYWORD(readonly); KEYWORD(readonly);
KEYWORD(returned); KEYWORD(returned);
▲ Show 20 Lines • Show All 301 Lines • Show Last 20 Lines

lib/AsmParser/LLParser.cpp

Show First 20 Lines • Show All 968 Lines • ▼ Show 20 Lines case lltok::kw_zeroext:
Error(Lex.getLoc(), Error(Lex.getLoc(),
"invalid use of attribute on a function"); "invalid use of attribute on a function");
break; break;
case lltok::kw_byval: case lltok::kw_byval:
case lltok::kw_inalloca: case lltok::kw_inalloca:
case lltok::kw_nest: case lltok::kw_nest:
case lltok::kw_noalias: case lltok::kw_noalias:
case lltok::kw_nocapture: case lltok::kw_nocapture:
case lltok::kw_nonnull:
case lltok::kw_returned: case lltok::kw_returned:
case lltok::kw_sret: case lltok::kw_sret:
HaveError |= HaveError |=
Error(Lex.getLoc(), Error(Lex.getLoc(),
"invalid use of parameter-only attribute on a function"); "invalid use of parameter-only attribute on a function");
break; break;
} }
▲ Show 20 Lines • Show All 198 Lines • ▼ Show 20 Lines case lltok::kw_align: {
continue; continue;
} }
case lltok::kw_byval: B.addAttribute(Attribute::ByVal); break; case lltok::kw_byval: B.addAttribute(Attribute::ByVal); break;
case lltok::kw_inalloca: B.addAttribute(Attribute::InAlloca); break; case lltok::kw_inalloca: B.addAttribute(Attribute::InAlloca); break;
case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break; case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
case lltok::kw_nest: B.addAttribute(Attribute::Nest); break; case lltok::kw_nest: B.addAttribute(Attribute::Nest); break;
case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break; case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
case lltok::kw_nocapture: B.addAttribute(Attribute::NoCapture); break; case lltok::kw_nocapture: B.addAttribute(Attribute::NoCapture); break;
case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break; case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break; case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
case lltok::kw_returned: B.addAttribute(Attribute::Returned); break; case lltok::kw_returned: B.addAttribute(Attribute::Returned); break;
case lltok::kw_signext: B.addAttribute(Attribute::SExt); break; case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break; case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break;
case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break; case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
case lltok::kw_alignstack: case lltok::kw_alignstack:
Show All 36 Linesbool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
while (1) { while (1) {
lltok::Kind Token = Lex.getKind(); lltok::Kind Token = Lex.getKind();
switch (Token) { switch (Token) {
default: // End of attributes. default: // End of attributes.
return HaveError; return HaveError;
case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break; case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break; case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
case lltok::kw_signext: B.addAttribute(Attribute::SExt); break; case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break; case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
// Error handling. // Error handling.
case lltok::kw_align: case lltok::kw_align:
case lltok::kw_byval: case lltok::kw_byval:
case lltok::kw_inalloca: case lltok::kw_inalloca:
case lltok::kw_nest: case lltok::kw_nest:
▲ Show 20 Lines • Show All 3,221 Lines • Show Last 20 Lines

lib/AsmParser/LLToken.h

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines enum Kind {
kw_nest, kw_nest,
kw_noalias, kw_noalias,
kw_nobuiltin, kw_nobuiltin,
kw_nocapture, kw_nocapture,
kw_noduplicate, kw_noduplicate,
kw_noimplicitfloat, kw_noimplicitfloat,
kw_noinline, kw_noinline,
kw_nonlazybind, kw_nonlazybind,
kw_nonnull,
kw_noredzone, kw_noredzone,
kw_noreturn, kw_noreturn,
kw_nounwind, kw_nounwind,
kw_optnone, kw_optnone,
kw_optsize, kw_optsize,
kw_readnone, kw_readnone,
kw_readonly, kw_readonly,
kw_returned, kw_returned,
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 563 Lines • ▼ Show 20 Linesstatic Attribute::AttrKind GetAttrFromCode(uint64_t Code) {
case bitc::ATTR_KIND_NO_DUPLICATE: case bitc::ATTR_KIND_NO_DUPLICATE:
return Attribute::NoDuplicate; return Attribute::NoDuplicate;
case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT: case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
return Attribute::NoImplicitFloat; return Attribute::NoImplicitFloat;
case bitc::ATTR_KIND_NO_INLINE: case bitc::ATTR_KIND_NO_INLINE:
return Attribute::NoInline; return Attribute::NoInline;
case bitc::ATTR_KIND_NON_LAZY_BIND: case bitc::ATTR_KIND_NON_LAZY_BIND:
return Attribute::NonLazyBind; return Attribute::NonLazyBind;
case bitc::ATTR_KIND_NON_NULL:
return Attribute::NonNull;
case bitc::ATTR_KIND_NO_RED_ZONE: case bitc::ATTR_KIND_NO_RED_ZONE:
return Attribute::NoRedZone; return Attribute::NoRedZone;
case bitc::ATTR_KIND_NO_RETURN: case bitc::ATTR_KIND_NO_RETURN:
return Attribute::NoReturn; return Attribute::NoReturn;
case bitc::ATTR_KIND_NO_UNWIND: case bitc::ATTR_KIND_NO_UNWIND:
return Attribute::NoUnwind; return Attribute::NoUnwind;
case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
return Attribute::OptimizeForSize; return Attribute::OptimizeForSize;
▲ Show 20 Lines • Show All 2,845 Lines • Show Last 20 Lines

lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Linesstatic uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
case Attribute::NoDuplicate: case Attribute::NoDuplicate:
return bitc::ATTR_KIND_NO_DUPLICATE; return bitc::ATTR_KIND_NO_DUPLICATE;
case Attribute::NoImplicitFloat: case Attribute::NoImplicitFloat:
return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT; return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
case Attribute::NoInline: case Attribute::NoInline:
return bitc::ATTR_KIND_NO_INLINE; return bitc::ATTR_KIND_NO_INLINE;
case Attribute::NonLazyBind: case Attribute::NonLazyBind:
return bitc::ATTR_KIND_NON_LAZY_BIND; return bitc::ATTR_KIND_NON_LAZY_BIND;
case Attribute::NonNull:
return bitc::ATTR_KIND_NON_NULL;
case Attribute::NoRedZone: case Attribute::NoRedZone:
return bitc::ATTR_KIND_NO_RED_ZONE; return bitc::ATTR_KIND_NO_RED_ZONE;
case Attribute::NoReturn: case Attribute::NoReturn:
return bitc::ATTR_KIND_NO_RETURN; return bitc::ATTR_KIND_NO_RETURN;
case Attribute::NoUnwind: case Attribute::NoUnwind:
return bitc::ATTR_KIND_NO_UNWIND; return bitc::ATTR_KIND_NO_UNWIND;
case Attribute::OptimizeForSize: case Attribute::OptimizeForSize:
return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE; return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
▲ Show 20 Lines • Show All 1,841 Lines • Show Last 20 Lines

lib/IR/Attributes.cpp

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 Linesstd::string Attribute::getAsString(bool InAttrGrp) const {
if (hasAttribute(Attribute::NoDuplicate)) if (hasAttribute(Attribute::NoDuplicate))
return "noduplicate"; return "noduplicate";
if (hasAttribute(Attribute::NoImplicitFloat)) if (hasAttribute(Attribute::NoImplicitFloat))
return "noimplicitfloat"; return "noimplicitfloat";
if (hasAttribute(Attribute::NoInline)) if (hasAttribute(Attribute::NoInline))
return "noinline"; return "noinline";
if (hasAttribute(Attribute::NonLazyBind)) if (hasAttribute(Attribute::NonLazyBind))
return "nonlazybind"; return "nonlazybind";
if (hasAttribute(Attribute::NonNull))
return "nonnull";
if (hasAttribute(Attribute::NoRedZone)) if (hasAttribute(Attribute::NoRedZone))
return "noredzone"; return "noredzone";
if (hasAttribute(Attribute::NoReturn)) if (hasAttribute(Attribute::NoReturn))
return "noreturn"; return "noreturn";
if (hasAttribute(Attribute::NoUnwind)) if (hasAttribute(Attribute::NoUnwind))
return "nounwind"; return "nounwind";
if (hasAttribute(Attribute::OptimizeNone)) if (hasAttribute(Attribute::OptimizeNone))
return "optnone"; return "optnone";
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Linesuint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
case Attribute::SanitizeThread: return 1ULL << 36; case Attribute::SanitizeThread: return 1ULL << 36;
case Attribute::SanitizeMemory: return 1ULL << 37; case Attribute::SanitizeMemory: return 1ULL << 37;
case Attribute::NoBuiltin: return 1ULL << 38; case Attribute::NoBuiltin: return 1ULL << 38;
case Attribute::Returned: return 1ULL << 39; case Attribute::Returned: return 1ULL << 39;
case Attribute::Cold: return 1ULL << 40; case Attribute::Cold: return 1ULL << 40;
case Attribute::Builtin: return 1ULL << 41; case Attribute::Builtin: return 1ULL << 41;
case Attribute::OptimizeNone: return 1ULL << 42; case Attribute::OptimizeNone: return 1ULL << 42;
case Attribute::InAlloca: return 1ULL << 43; case Attribute::InAlloca: return 1ULL << 43;
case Attribute::NonNull: return 1ULL << 44;
} }
llvm_unreachable("Unsupported attribute type"); llvm_unreachable("Unsupported attribute type");
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeSetNode Definition // AttributeSetNode Definition
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 769 Lines • ▼ Show 20 Lines Incompatible.addAttribute(Attribute::SExt)
.addAttribute(Attribute::ZExt); .addAttribute(Attribute::ZExt);
if (!Ty->isPointerTy()) if (!Ty->isPointerTy())
// Attribute that only apply to pointers. // Attribute that only apply to pointers.
Incompatible.addAttribute(Attribute::ByVal) Incompatible.addAttribute(Attribute::ByVal)
.addAttribute(Attribute::Nest) .addAttribute(Attribute::Nest)
.addAttribute(Attribute::NoAlias) .addAttribute(Attribute::NoAlias)
.addAttribute(Attribute::NoCapture) .addAttribute(Attribute::NoCapture)
.addAttribute(Attribute::NonNull)
.addAttribute(Attribute::ReadNone) .addAttribute(Attribute::ReadNone)
.addAttribute(Attribute::ReadOnly) .addAttribute(Attribute::ReadOnly)
.addAttribute(Attribute::StructRet) .addAttribute(Attribute::StructRet)
.addAttribute(Attribute::InAlloca); .addAttribute(Attribute::InAlloca);
return AttributeSet::get(Ty->getContext(), Index, Incompatible); return AttributeSet::get(Ty->getContext(), Index, Incompatible);
} }

lib/IR/Function.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesunsigned Argument::getArgNo() const {
Function::const_arg_iterator AI = F->arg_begin(); Function::const_arg_iterator AI = F->arg_begin();
unsigned ArgIdx = 0; unsigned ArgIdx = 0;
for (; &*AI != this; ++AI) for (; &*AI != this; ++AI)
++ArgIdx; ++ArgIdx;
return ArgIdx; return ArgIdx;
} }
/// hasNonNullAttr - Return true if this argument has the nonnull attribute on
/// it in its containing function.
bool Argument::hasNonNullAttr() const {
if (!getType()->isPointerTy()) return false;
return getParent()->getAttributes().
hasAttribute(getArgNo()+1, Attribute::NonNull);
}
/// hasByValAttr - Return true if this argument has the byval attribute on it /// hasByValAttr - Return true if this argument has the byval attribute on it
/// in its containing function. /// in its containing function.
bool Argument::hasByValAttr() const { bool Argument::hasByValAttr() const {
if (!getType()->isPointerTy()) return false; if (!getType()->isPointerTy()) return false;
return getParent()->getAttributes(). return getParent()->getAttributes().
hasAttribute(getArgNo()+1, Attribute::ByVal); hasAttribute(getArgNo()+1, Attribute::ByVal);
} }
▲ Show 20 Lines • Show All 714 Lines • Show Last 20 Lines

test/Bitcode/attributes.ll

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines; CHECK: define void @f35() #23
ret void; ret void;
} }
define void @f36(i8* inalloca) { define void @f36(i8* inalloca) {
; CHECK: define void @f36(i8* inalloca) { ; CHECK: define void @f36(i8* inalloca) {
ret void ret void
} }
define nonnull i8* @f37(i8* nonnull %a) {
; CHECK: define nonnull i8* @f37(i8* nonnull %a) {
ret i8* %a
}
; CHECK: attributes #0 = { noreturn } ; CHECK: attributes #0 = { noreturn }
; CHECK: attributes #1 = { nounwind } ; CHECK: attributes #1 = { nounwind }
; CHECK: attributes #2 = { readnone } ; CHECK: attributes #2 = { readnone }
; CHECK: attributes #3 = { readonly } ; CHECK: attributes #3 = { readonly }
; CHECK: attributes #4 = { noinline } ; CHECK: attributes #4 = { noinline }
; CHECK: attributes #5 = { alwaysinline } ; CHECK: attributes #5 = { alwaysinline }
; CHECK: attributes #6 = { optsize } ; CHECK: attributes #6 = { optsize }
; CHECK: attributes #7 = { ssp } ; CHECK: attributes #7 = { ssp }
Show All 18 Lines