+ /// getAttributes - Return the attribute list for this Function.
+ ///
+ const AttrListPtr &getAttributes() const { return AttributeList; }
+
+ /// setAttributes - Set the attribute list for this Function.
+ ///
+ void setAttributes(const AttrListPtr &attrs) { AttributeList = attrs; }
+
+ /// hasFnAttr - Return true if this function has the given attribute.
+ bool hasFnAttr(Attributes N) const {
+ // Function Attributes are stored at ~0 index
+ return AttributeList.paramHasAttr(~0U, N);
+ }
+
+ /// addFnAttr - Add function attributes to this function.
+ ///
+ void addFnAttr(Attributes N) {
+ // Function Attributes are stored at ~0 index
+ addAttribute(~0U, N);
+ }
+
+ /// removeFnAttr - Remove function attributes from this function.
+ ///
+ void removeFnAttr(Attributes N) {
+ // Function Attributes are stored at ~0 index
+ removeAttribute(~0U, N);
+ }
+
+ /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
+ /// to use during code generation.
+ bool hasGC() const;
+ const char *getGC() const;
+ void setGC(const char *Str);
+ void clearGC();
+
+ /// @brief Determine whether the function has the given attribute.
+ bool paramHasAttr(unsigned i, Attributes attr) const {
+ return AttributeList.paramHasAttr(i, attr);
+ }
+
+ /// addAttribute - adds the attribute to the list of attributes.
+ void addAttribute(unsigned i, Attributes attr);
+
+ /// removeAttribute - removes the attribute from the list of attributes.
+ void removeAttribute(unsigned i, Attributes attr);
+
+ /// @brief Extract the alignment for a call or parameter (0=unknown).
+ unsigned getParamAlignment(unsigned i) const {
+ return AttributeList.getParamAlignment(i);
+ }
+
+ /// @brief Determine if the function does not access memory.
+ bool doesNotAccessMemory() const {
+ return hasFnAttr(Attribute::ReadNone);
+ }
+ void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
+ if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone);
+ else removeFnAttr(Attribute::ReadNone);
+ }
+
+ /// @brief Determine if the function does not access or only reads memory.
+ bool onlyReadsMemory() const {
+ return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
+ }
+ void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
+ if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly);
+ else removeFnAttr(Attribute::ReadOnly | Attribute::ReadNone);
+ }
+
+ /// @brief Determine if the function cannot return.
+ bool doesNotReturn() const {
+ return hasFnAttr(Attribute::NoReturn);
+ }
+ void setDoesNotReturn(bool DoesNotReturn = true) {
+ if (DoesNotReturn) addFnAttr(Attribute::NoReturn);
+ else removeFnAttr(Attribute::NoReturn);
+ }
+
+ /// @brief Determine if the function cannot unwind.
+ bool doesNotThrow() const {
+ return hasFnAttr(Attribute::NoUnwind);
+ }
+ void setDoesNotThrow(bool DoesNotThrow = true) {
+ if (DoesNotThrow) addFnAttr(Attribute::NoUnwind);
+ else removeFnAttr(Attribute::NoUnwind);
+ }
+
+ /// @brief Determine if the function returns a structure through first
+ /// pointer argument.
+ bool hasStructRetAttr() const {
+ return paramHasAttr(1, Attribute::StructRet);
+ }
+
+ /// @brief Determine if the parameter does not alias other parameters.
+ /// @param n The parameter to check. 1 is the first parameter, 0 is the return
+ bool doesNotAlias(unsigned n) const {
+ return paramHasAttr(n, Attribute::NoAlias);
+ }
+ void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) {
+ if (DoesNotAlias) addAttribute(n, Attribute::NoAlias);
+ else removeAttribute(n, Attribute::NoAlias);
+ }
+
+ /// @brief Determine if the parameter can be captured.
+ /// @param n The parameter to check. 1 is the first parameter, 0 is the return
+ bool doesNotCapture(unsigned n) const {
+ return paramHasAttr(n, Attribute::NoCapture);
+ }
+ void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) {
+ if (DoesNotCapture) addAttribute(n, Attribute::NoCapture);
+ else removeAttribute(n, Attribute::NoCapture);
+ }
+
+ /// copyAttributesFrom - copy all additional attributes (those not needed to
+ /// create a Function) from the Function Src to this one.
+ void copyAttributesFrom(const GlobalValue *Src);
+
+ /// deleteBody - This method deletes the body of the function, and converts
+ /// the linkage to external.
+ ///
+ void deleteBody() {
+ dropAllReferences();
+ setLinkage(ExternalLinkage);
+ }
+
+ /// removeFromParent - This method unlinks 'this' from the containing module,
+ /// but does not delete it.
+ ///
+ virtual void removeFromParent();
+
+ /// eraseFromParent - This method unlinks 'this' from the containing module
+ /// and deletes it.
+ ///
+ virtual void eraseFromParent();
+
+
+ /// Get the underlying elements of the Function... the basic block list is
+ /// empty for external functions.
+ ///
+ const ArgumentListType &getArgumentList() const {
+ CheckLazyArguments();
+ return ArgumentList;
+ }
+ ArgumentListType &getArgumentList() {
+ CheckLazyArguments();
+ return ArgumentList;
+ }
+
+ const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
+ BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
+
+ const BasicBlock &getEntryBlock() const { return front(); }
+ BasicBlock &getEntryBlock() { return front(); }
+
+ //===--------------------------------------------------------------------===//
+ // Symbol Table Accessing functions...
+
+ /// getSymbolTable() - Return the symbol table...
+ ///
+ inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; }
+ inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
+
+