diff options
Diffstat (limited to 'include/llvm/IR')
| -rw-r--r-- | include/llvm/IR/Attributes.h | 10 | ||||
| -rw-r--r-- | include/llvm/IR/DataLayout.h | 11 | ||||
| -rw-r--r-- | include/llvm/IR/DerivedTypes.h | 22 | ||||
| -rw-r--r-- | include/llvm/IR/Function.h | 18 | ||||
| -rw-r--r-- | include/llvm/IR/Instructions.h | 158 | ||||
| -rw-r--r-- | include/llvm/IR/LLVMContext.h | 3 |
6 files changed, 115 insertions, 107 deletions
diff --git a/include/llvm/IR/Attributes.h b/include/llvm/IR/Attributes.h index 30c0965..074b387 100644 --- a/include/llvm/IR/Attributes.h +++ b/include/llvm/IR/Attributes.h @@ -226,11 +226,6 @@ private: explicit AttributeSet(AttributeSetImpl *LI) : pImpl(LI) {} public: AttributeSet() : pImpl(0) {} - AttributeSet(const AttributeSet &P) : pImpl(P.pImpl) {} - const AttributeSet &operator=(const AttributeSet &RHS) { - pImpl = RHS.pImpl; - return *this; - } //===--------------------------------------------------------------------===// // AttributeSet Construction and Mutation @@ -247,6 +242,11 @@ public: AttributeSet addAttribute(LLVMContext &C, unsigned Idx, Attribute::AttrKind Attr) const; + /// \brief Add an attribute to the attribute set at the given index. Since + /// attribute sets are immutable, this returns a new set. + AttributeSet addAttribute(LLVMContext &C, unsigned Idx, + StringRef Kind) const; + /// \brief Add attributes to the attribute set at the given index. Since /// attribute sets are immutable, this returns a new set. AttributeSet addAttributes(LLVMContext &C, unsigned Idx, diff --git a/include/llvm/IR/DataLayout.h b/include/llvm/IR/DataLayout.h index bfdb057..4d3016c 100644 --- a/include/llvm/IR/DataLayout.h +++ b/include/llvm/IR/DataLayout.h @@ -172,6 +172,7 @@ public: DataLayout(const DataLayout &TD) : ImmutablePass(ID), LittleEndian(TD.isLittleEndian()), + StackNaturalAlign(TD.StackNaturalAlign), LegalIntWidths(TD.LegalIntWidths), Alignments(TD.Alignments), Pointers(TD.Pointers), @@ -180,6 +181,10 @@ public: ~DataLayout(); // Not virtual, do not subclass this class + /// DataLayout is an immutable pass, but holds state. This allows the pass + /// manager to clear its mutable state. + bool doFinalization(Module &M); + /// Parse a data layout string (with fallback to default values). Ensure that /// the data layout pass is registered. void init(StringRef LayoutDescription); @@ -283,7 +288,7 @@ public: /// getTypeSizeInBits - Return the number of bits necessary to hold the /// specified type. For example, returns 36 for i36 and 80 for x86_fp80. /// The type passed must have a size (Type::isSized() must return true). - uint64_t getTypeSizeInBits(Type* Ty) const; + uint64_t getTypeSizeInBits(Type *Ty) const; /// getTypeStoreSize - Return the maximum number of bytes that may be /// overwritten by storing the specified type. For example, returns 5 @@ -303,7 +308,7 @@ public: /// of the specified type, including alignment padding. This is the amount /// that alloca reserves for this type. For example, returns 12 or 16 for /// x86_fp80, depending on alignment. - uint64_t getTypeAllocSize(Type* Ty) const { + uint64_t getTypeAllocSize(Type *Ty) const { // Round up to the next alignment boundary. return RoundUpAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); } @@ -312,7 +317,7 @@ public: /// objects of the specified type, including alignment padding; always a /// multiple of 8. This is the amount that alloca reserves for this type. /// For example, returns 96 or 128 for x86_fp80, depending on alignment. - uint64_t getTypeAllocSizeInBits(Type* Ty) const { + uint64_t getTypeAllocSizeInBits(Type *Ty) const { return 8*getTypeAllocSize(Ty); } diff --git a/include/llvm/IR/DerivedTypes.h b/include/llvm/IR/DerivedTypes.h index 3bf7885..6c00f59 100644 --- a/include/llvm/IR/DerivedTypes.h +++ b/include/llvm/IR/DerivedTypes.h @@ -84,7 +84,7 @@ public: /// @brief Is this a power-of-2 byte-width IntegerType ? bool isPowerOf2ByteWidth() const; - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == IntegerTyID; } @@ -124,7 +124,7 @@ public: param_iterator param_begin() const { return ContainedTys + 1; } param_iterator param_end() const { return &ContainedTys[NumContainedTys]; } - // Parameter type accessors. + /// Parameter type accessors. Type *getParamType(unsigned i) const { return ContainedTys[i+1]; } /// getNumParams - Return the number of fixed parameters this function type @@ -132,7 +132,7 @@ public: /// unsigned getNumParams() const { return NumContainedTys - 1; } - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == FunctionTyID; } @@ -154,7 +154,7 @@ public: bool indexValid(const Value *V) const; bool indexValid(unsigned Idx) const; - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == ArrayTyID || T->getTypeID() == StructTyID || @@ -190,7 +190,7 @@ class StructType : public CompositeType { StructType(LLVMContext &C) : CompositeType(C, StructTyID), SymbolTableEntry(0) {} enum { - // This is the contents of the SubClassData field. + /// This is the contents of the SubClassData field. SCDB_HasBody = 1, SCDB_Packed = 2, SCDB_IsLiteral = 4, @@ -282,14 +282,14 @@ public: /// specified struct. bool isLayoutIdentical(StructType *Other) const; - // Random access to the elements + /// Random access to the elements unsigned getNumElements() const { return NumContainedTys; } Type *getElementType(unsigned N) const { assert(N < NumContainedTys && "Element number out of range!"); return ContainedTys[N]; } - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == StructTyID; } @@ -318,7 +318,7 @@ protected: public: Type *getElementType() const { return ContainedTys[0]; } - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == ArrayTyID || T->getTypeID() == PointerTyID || @@ -347,7 +347,7 @@ public: uint64_t getNumElements() const { return NumElements; } - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == ArrayTyID; } @@ -413,7 +413,7 @@ public: return NumElements * getElementType()->getPrimitiveSizeInBits(); } - // Methods for support type inquiry through isa, cast, and dyn_cast. + /// Methods for support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == VectorTyID; } @@ -444,7 +444,7 @@ public: /// @brief Return the address space of the Pointer type. inline unsigned getAddressSpace() const { return getSubclassData(); } - // Implement support type inquiry through isa, cast, and dyn_cast. + /// Implement support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const Type *T) { return T->getTypeID() == PointerTyID; } diff --git a/include/llvm/IR/Function.h b/include/llvm/IR/Function.h index 568b55c..f97929f 100644 --- a/include/llvm/IR/Function.h +++ b/include/llvm/IR/Function.h @@ -113,6 +113,10 @@ private: Function(const Function&) LLVM_DELETED_FUNCTION; void operator=(const Function&) LLVM_DELETED_FUNCTION; + /// Do the actual lookup of an intrinsic ID when the query could not be + /// answered from the cache. + unsigned lookupIntrinsicID() const LLVM_READONLY; + /// Function ctor - If the (optional) Module argument is specified, the /// function is automatically inserted into the end of the function list for /// the module. @@ -141,10 +145,12 @@ public: /// getIntrinsicID - This method returns the ID number of the specified /// function, or Intrinsic::not_intrinsic if the function is not an - /// instrinsic, or if the pointer is null. This value is always defined to be + /// intrinsic, or if the pointer is null. This value is always defined to be /// zero to allow easy checking for whether a function is intrinsic or not. /// The particular intrinsic functions which correspond to this value are - /// defined in llvm/Intrinsics.h. + /// defined in llvm/Intrinsics.h. Results are cached in the LLVM context, + /// subsequent requests for the same ID return results much faster from the + /// cache. /// unsigned getIntrinsicID() const LLVM_READONLY; bool isIntrinsic() const { return getName().startswith("llvm."); } @@ -175,6 +181,14 @@ public: AttributeSet::FunctionIndex, N)); } + /// addFnAttr - Add function attributes to this function. + /// + void addFnAttr(StringRef Kind) { + setAttributes( + AttributeSets.addAttribute(getContext(), + AttributeSet::FunctionIndex, Kind)); + } + /// \brief Return true if the function has the attribute. bool hasFnAttribute(Attribute::AttrKind Kind) const { return AttributeSets.hasAttribute(AttributeSet::FunctionIndex, Kind); diff --git a/include/llvm/IR/Instructions.h b/include/llvm/IR/Instructions.h index 1ae8850..7e29699 100644 --- a/include/llvm/IR/Instructions.h +++ b/include/llvm/IR/Instructions.h @@ -281,7 +281,7 @@ public: unsigned Align, AtomicOrdering Order, SynchronizationScope SynchScope, BasicBlock *InsertAtEnd); - + /// isVolatile - Return true if this is a store to a volatile memory /// location. @@ -516,15 +516,15 @@ public: Value *getCompareOperand() { return getOperand(1); } const Value *getCompareOperand() const { return getOperand(1); } - + Value *getNewValOperand() { return getOperand(2); } const Value *getNewValOperand() const { return getOperand(2); } - + /// \brief Returns the address space of the pointer operand. unsigned getPointerAddressSpace() const { return getPointerOperand()->getType()->getPointerAddressSpace(); } - + // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const Instruction *I) { return I->getOpcode() == Instruction::AtomicCmpXchg; @@ -1272,7 +1272,7 @@ public: void setAttributes(const AttributeSet &Attrs) { AttributeList = Attrs; } /// addAttribute - adds the attribute to the list of attributes. - void addAttribute(unsigned i, Attribute attr); + void addAttribute(unsigned i, Attribute::AttrKind attr); /// removeAttribute - removes the attribute from the list of attributes. void removeAttribute(unsigned i, Attribute attr); @@ -1291,8 +1291,7 @@ public: /// \brief Return true if the call should not be inlined. bool isNoInline() const { return hasFnAttr(Attribute::NoInline); } void setIsNoInline() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoInline)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoInline); } /// \brief Return true if the call can return twice @@ -1300,8 +1299,7 @@ public: return hasFnAttr(Attribute::ReturnsTwice); } void setCanReturnTwice() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::ReturnsTwice)); + addAttribute(AttributeSet::FunctionIndex, Attribute::ReturnsTwice); } /// \brief Determine if the call does not access memory. @@ -1309,8 +1307,7 @@ public: return hasFnAttr(Attribute::ReadNone); } void setDoesNotAccessMemory() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::ReadNone)); + addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); } /// \brief Determine if the call does not access or only reads memory. @@ -1318,29 +1315,25 @@ public: return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); } void setOnlyReadsMemory() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::ReadOnly)); + addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly); } /// \brief Determine if the call cannot return. bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); } void setDoesNotReturn() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoReturn)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn); } /// \brief Determine if the call cannot unwind. bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); } void setDoesNotThrow() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoUnwind)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); } /// \brief Determine if the call cannot be duplicated. bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); } void setCannotDuplicate() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoDuplicate)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoDuplicate); } /// \brief Determine if the call returns a structure through first @@ -1690,7 +1683,7 @@ public: Constant *getMask() const { return cast<Constant>(getOperand(2)); } - + /// getMaskValue - Return the index from the shuffle mask for the specified /// output result. This is either -1 if the element is undef or a number less /// than 2*numelements. @@ -1699,7 +1692,7 @@ public: int getMaskValue(unsigned i) const { return getMaskValue(getMask(), i); } - + /// getShuffleMask - Return the full mask for this instruction, where each /// element is the element number and undef's are returned as -1. static void getShuffleMask(Constant *Mask, SmallVectorImpl<int> &Result); @@ -2016,7 +2009,7 @@ public: Instruction *InsertBefore = 0) { return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore); } - static PHINode *Create(Type *Ty, unsigned NumReservedValues, + static PHINode *Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr, BasicBlock *InsertAtEnd) { return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd); } @@ -2455,7 +2448,7 @@ class SwitchInst : public TerminatorInst { // Operand[1] = Default basic block destination // Operand[2n ] = Value to match // Operand[2n+1] = BasicBlock to go to on match - + // Store case values separately from operands list. We needn't User-Use // concept here, since it is just a case value, it will always constant, // and case value couldn't reused with another instructions/values. @@ -2472,9 +2465,9 @@ class SwitchInst : public TerminatorInst { typedef std::list<IntegersSubset> Subsets; typedef Subsets::iterator SubsetsIt; typedef Subsets::const_iterator SubsetsConstIt; - + Subsets TheSubsets; - + SwitchInst(const SwitchInst &SI); void init(Value *Value, BasicBlock *Default, unsigned NumReserved); void growOperands(); @@ -2498,7 +2491,7 @@ class SwitchInst : public TerminatorInst { protected: virtual SwitchInst *clone_impl() const; public: - + // FIXME: Currently there are a lot of unclean template parameters, // we need to make refactoring in future. // All these parameters are used to implement both iterator and const_iterator @@ -2508,16 +2501,16 @@ public: // SubsetsItTy may be SubsetsConstIt or SubsetsIt // BasicBlockTy may be "const BasicBlock" or "BasicBlock" template <class SwitchInstTy, class ConstantIntTy, - class SubsetsItTy, class BasicBlockTy> + class SubsetsItTy, class BasicBlockTy> class CaseIteratorT; typedef CaseIteratorT<const SwitchInst, const ConstantInt, SubsetsConstIt, const BasicBlock> ConstCaseIt; class CaseIt; - + // -2 static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1); - + static SwitchInst *Create(Value *Value, BasicBlock *Default, unsigned NumCases, Instruction *InsertBefore = 0) { return new SwitchInst(Value, Default, NumCases, InsertBefore); @@ -2526,7 +2519,7 @@ public: unsigned NumCases, BasicBlock *InsertAtEnd) { return new SwitchInst(Value, Default, NumCases, InsertAtEnd); } - + ~SwitchInst(); /// Provide fast operand accessors @@ -2560,7 +2553,7 @@ public: ConstCaseIt case_begin() const { return ConstCaseIt(this, 0, TheSubsets.begin()); } - + /// Returns a read/write iterator that points one past the last /// in the SwitchInst. CaseIt case_end() { @@ -2575,14 +2568,14 @@ public: /// Note: this iterator allows to resolve successor only. Attempt /// to resolve case value causes an assertion. /// Also note, that increment and decrement also causes an assertion and - /// makes iterator invalid. + /// makes iterator invalid. CaseIt case_default() { return CaseIt(this, DefaultPseudoIndex, TheSubsets.end()); } ConstCaseIt case_default() const { return ConstCaseIt(this, DefaultPseudoIndex, TheSubsets.end()); } - + /// findCaseValue - Search all of the case values for the specified constant. /// If it is explicitly handled, return the case iterator of it, otherwise /// return default case iterator to indicate @@ -2598,8 +2591,8 @@ public: if (i.getCaseValueEx().isSatisfies(IntItem::fromConstantInt(C))) return i; return case_default(); - } - + } + /// findCaseDest - Finds the unique case value for a given successor. Returns /// null if the successor is not found, not unique, or is the default case. ConstantInt *findCaseDest(BasicBlock *BB) { @@ -2621,7 +2614,7 @@ public: /// This action invalidates case_end(). Old case_end() iterator will /// point to the added case. void addCase(ConstantInt *OnVal, BasicBlock *Dest); - + /// addCase - Add an entry to the switch instruction. /// Note: /// This action invalidates case_end(). Old case_end() iterator will @@ -2645,31 +2638,31 @@ public: assert(idx < getNumSuccessors() && "Successor # out of range for switch!"); setOperand(idx*2+1, (Value*)NewSucc); } - + uint16_t hash() const { uint32_t NumberOfCases = (uint32_t)getNumCases(); uint16_t Hash = (0xFFFF & NumberOfCases) ^ (NumberOfCases >> 16); for (ConstCaseIt i = case_begin(), e = case_end(); i != e; ++i) { - uint32_t NumItems = (uint32_t)i.getCaseValueEx().getNumItems(); + uint32_t NumItems = (uint32_t)i.getCaseValueEx().getNumItems(); Hash = (Hash << 1) ^ (0xFFFF & NumItems) ^ (NumItems >> 16); } return Hash; - } - + } + // Case iterators definition. template <class SwitchInstTy, class ConstantIntTy, - class SubsetsItTy, class BasicBlockTy> + class SubsetsItTy, class BasicBlockTy> class CaseIteratorT { protected: - + SwitchInstTy *SI; - unsigned long Index; + unsigned Index; SubsetsItTy SubsetIt; - + /// Initializes case iterator for given SwitchInst and for given - /// case number. + /// case number. friend class SwitchInst; CaseIteratorT(SwitchInstTy *SI, unsigned SuccessorIndex, SubsetsItTy CaseValueIt) { @@ -2677,36 +2670,36 @@ public: Index = SuccessorIndex; this->SubsetIt = CaseValueIt; } - + public: typedef typename SubsetsItTy::reference IntegersSubsetRef; typedef CaseIteratorT<SwitchInstTy, ConstantIntTy, SubsetsItTy, BasicBlockTy> Self; - + CaseIteratorT(SwitchInstTy *SI, unsigned CaseNum) { this->SI = SI; Index = CaseNum; SubsetIt = SI->TheSubsets.begin(); std::advance(SubsetIt, CaseNum); } - - + + /// Initializes case iterator for given SwitchInst and for given /// TerminatorInst's successor index. static Self fromSuccessorIndex(SwitchInstTy *SI, unsigned SuccessorIndex) { assert(SuccessorIndex < SI->getNumSuccessors() && - "Successor index # out of range!"); - return SuccessorIndex != 0 ? + "Successor index # out of range!"); + return SuccessorIndex != 0 ? Self(SI, SuccessorIndex - 1) : - Self(SI, DefaultPseudoIndex); + Self(SI, DefaultPseudoIndex); } - + /// Resolves case value for current case. /// @deprecated ConstantIntTy *getCaseValue() { assert(Index < SI->getNumCases() && "Index out the number of cases."); IntegersSubsetRef CaseRanges = *SubsetIt; - + // FIXME: Currently we work with ConstantInt based cases. // So return CaseValue as ConstantInt. return CaseRanges.getSingleNumber(0).toConstantInt(); @@ -2717,25 +2710,25 @@ public: assert(Index < SI->getNumCases() && "Index out the number of cases."); return *SubsetIt; } - + /// Resolves successor for current case. BasicBlockTy *getCaseSuccessor() { assert((Index < SI->getNumCases() || Index == DefaultPseudoIndex) && "Index out the number of cases."); - return SI->getSuccessor(getSuccessorIndex()); + return SI->getSuccessor(getSuccessorIndex()); } - + /// Returns number of current case. unsigned getCaseIndex() const { return Index; } - + /// Returns TerminatorInst's successor index for current case successor. unsigned getSuccessorIndex() const { assert((Index == DefaultPseudoIndex || Index < SI->getNumCases()) && "Index out the number of cases."); return Index != DefaultPseudoIndex ? Index + 1 : 0; } - + Self operator++() { // Check index correctness after increment. // Note: Index == getNumCases() means end(). @@ -2752,7 +2745,7 @@ public: ++(*this); return tmp; } - Self operator--() { + Self operator--() { // Check index correctness after decrement. // Note: Index == getNumCases() means end(). // Also allow "-1" iterator here. That will became valid after ++. @@ -2764,10 +2757,10 @@ public: SubsetIt = SI->TheSubsets.end(); return *this; } - - if (Index != -1UL) + + if (Index != -1U) --SubsetIt; - + return *this; } Self operator--(int) { @@ -2789,23 +2782,23 @@ public: SubsetsIt, BasicBlock> { typedef CaseIteratorT<SwitchInst, ConstantInt, SubsetsIt, BasicBlock> ParentTy; - + protected: friend class SwitchInst; CaseIt(SwitchInst *SI, unsigned CaseNum, SubsetsIt SubsetIt) : ParentTy(SI, CaseNum, SubsetIt) {} - + void updateCaseValueOperand(IntegersSubset& V) { - SI->setOperand(2 + Index*2, reinterpret_cast<Value*>((Constant*)V)); + SI->setOperand(2 + Index*2, reinterpret_cast<Value*>((Constant*)V)); } - + public: - CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {} - + CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {} + CaseIt(const ParentTy& Src) : ParentTy(Src) {} - /// Sets the new value for current case. + /// Sets the new value for current case. /// @deprecated. void setValue(ConstantInt *V) { assert(Index < SI->getNumCases() && "Index out the number of cases."); @@ -2816,17 +2809,17 @@ public: *SubsetIt = Mapping.getCase(); updateCaseValueOperand(*SubsetIt); } - + /// Sets the new value for current case. void setValueEx(IntegersSubset& V) { assert(Index < SI->getNumCases() && "Index out the number of cases."); *SubsetIt = V; - updateCaseValueOperand(*SubsetIt); + updateCaseValueOperand(*SubsetIt); } - + /// Sets the new successor for current case. void setSuccessor(BasicBlock *S) { - SI->setSuccessor(getSuccessorIndex(), S); + SI->setSuccessor(getSuccessorIndex(), S); } }; @@ -3025,7 +3018,7 @@ public: void setAttributes(const AttributeSet &Attrs) { AttributeList = Attrs; } /// addAttribute - adds the attribute to the list of attributes. - void addAttribute(unsigned i, Attribute attr); + void addAttribute(unsigned i, Attribute::AttrKind attr); /// removeAttribute - removes the attribute from the list of attributes. void removeAttribute(unsigned i, Attribute attr); @@ -3044,8 +3037,7 @@ public: /// \brief Return true if the call should not be inlined. bool isNoInline() const { return hasFnAttr(Attribute::NoInline); } void setIsNoInline() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoInline)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoInline); } /// \brief Determine if the call does not access memory. @@ -3053,8 +3045,7 @@ public: return hasFnAttr(Attribute::ReadNone); } void setDoesNotAccessMemory() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::ReadNone)); + addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); } /// \brief Determine if the call does not access or only reads memory. @@ -3062,22 +3053,19 @@ public: return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); } void setOnlyReadsMemory() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::ReadOnly)); + addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly); } /// \brief Determine if the call cannot return. bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); } void setDoesNotReturn() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoReturn)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn); } /// \brief Determine if the call cannot unwind. bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); } void setDoesNotThrow() { - addAttribute(AttributeSet::FunctionIndex, - Attribute::get(getContext(), Attribute::NoUnwind)); + addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); } /// \brief Determine if the call returns a structure through first diff --git a/include/llvm/IR/LLVMContext.h b/include/llvm/IR/LLVMContext.h index b3c558b..ae81e5b 100644 --- a/include/llvm/IR/LLVMContext.h +++ b/include/llvm/IR/LLVMContext.h @@ -46,7 +46,8 @@ public: MD_prof = 2, // "prof" MD_fpmath = 3, // "fpmath" MD_range = 4, // "range" - MD_tbaa_struct = 5 // "tbaa.struct" + MD_tbaa_struct = 5, // "tbaa.struct" + MD_invariant_load = 6 // "invariant.load" }; /// getMDKindID - Return a unique non-zero ID for the specified metadata kind. |