Add a #include for the uses of uint64_t.

[oota-llvm.git] / include / llvm / Function.h

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 36b0dd3df8cb424ac503c6a7185bc2aee7ba7501..2ec38e1d007306e835910544998e7d613fc441c1 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -104,13 +104,20 @@ private:
   
   Function(const Function&); // DO NOT IMPLEMENT
   void operator=(const Function&); // DO NOT IMPLEMENT
-public:
+
   /// Function ctor - If the (optional) Module argument is specified, the
   /// function is automatically inserted into the end of the function list for
   /// the module.
   ///
   Function(const FunctionType *Ty, LinkageTypes Linkage,
            const std::string &N = "", Module *M = 0);
+
+public:
+  static Function *Create(const FunctionType *Ty, LinkageTypes Linkage,
+                          const std::string &N = "", Module *M = 0) {
+    return new(0) Function(Ty, Linkage, N, M);
+  }
+
   ~Function();
 
   const Type *getReturnType() const;           // Return the type of the ret val
@@ -163,29 +170,53 @@ public:
   bool paramHasAttr(unsigned i, ParameterAttributes attr) const {
     return ParamAttrs.paramHasAttr(i, attr);
   }
+
+  /// addParamAttr - adds the attribute to the list of attributes.
+  void addParamAttr(unsigned i, ParameterAttributes attr);
   
+  /// removeParamAttr - removes the attribute from the list of attributes.
+  void removeParamAttr(unsigned i, ParameterAttributes attr);
+
   /// @brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
     return ParamAttrs.getParamAlignment(i);
   }
 
-  /// @brief Determine if the function cannot return.
-  bool doesNotReturn() const { return paramHasAttr(0, ParamAttr::NoReturn); }
-
-  /// @brief Determine if the function cannot unwind.
-  bool doesNotThrow() const {
-    return paramHasAttr(0, ParamAttr::NoUnwind);
-  }
-
   /// @brief Determine if the function does not access memory.
   bool doesNotAccessMemory() const {
     return paramHasAttr(0, ParamAttr::ReadNone);
   }
+  void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
+    if (DoesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone);
+    else removeParamAttr(0, ParamAttr::ReadNone);
+  }
 
   /// @brief Determine if the function does not access or only reads memory.
   bool onlyReadsMemory() const {
     return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
   }
+  void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
+    if (OnlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly);
+    else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone);
+  }
+
+  /// @brief Determine if the function cannot return.
+  bool doesNotReturn() const {
+    return paramHasAttr(0, ParamAttr::NoReturn);
+  }
+  void setDoesNotReturn(bool DoesNotReturn = true) {
+    if (DoesNotReturn) addParamAttr(0, ParamAttr::NoReturn);
+    else removeParamAttr(0, ParamAttr::NoReturn);
+  }
+
+  /// @brief Determine if the function cannot unwind.
+  bool doesNotThrow() const {
+    return paramHasAttr(0, ParamAttr::NoUnwind);
+  }
+  void setDoesNotThrow(bool DoesNotThrow = true) {
+    if (DoesNotThrow) addParamAttr(0, ParamAttr::NoUnwind);
+    else removeParamAttr(0, ParamAttr::NoUnwind);
+  }
 
   /// @brief Determine if the function returns a structure through first 
   /// pointer argument.
@@ -193,6 +224,10 @@ public:
     return paramHasAttr(1, ParamAttr::StructRet);
   }
 
+  /// 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.
   ///