X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FFunction.h;h=ef824579262f0afa4d1f9a6e7c1b07ed781b688c;hb=1ff4ed726bb8526d1e49030245365f8c86a8bb49;hp=2c4f9d9e27dea5c85e0d4c203cccb5e876a6bee7;hpb=49269d9e7eb5ce6e1a84a10ca0bdeab044d0db3d;p=oota-llvm.git

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 2c4f9d9e27d..ef824579262 100644
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -22,11 +22,11 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/Argument.h"
 #include "llvm/Support/Annotation.h"
+#include "llvm/ParameterAttributes.h"
 
 namespace llvm {
 
 class FunctionType;
-class ParamAttrsList;
 
 // Traits for intrusive list of instructions...
 template<> struct ilist_traits<BasicBlock>
@@ -68,7 +68,7 @@ private:
   BasicBlockListType  BasicBlocks;        ///< The basic blocks
   mutable ArgumentListType ArgumentList;  ///< The formal arguments
   ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
-  const ParamAttrsList *ParamAttrs;       ///< Parameter attributes
+  PAListPtr ParamAttrs;                   ///< Parameter attributes
   
   // The Calling Convention is stored in Value::SubclassData.
   /*unsigned CallingConvention;*/
@@ -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
@@ -144,16 +151,13 @@ public:
     SubclassData = (SubclassData & 1) | (CC << 1);
   }
   
-  /// Obtains a constant pointer to the ParamAttrsList object which holds the
-  /// parameter attributes information, if any. 
-  /// @returns 0 if no parameter attributes have been set.
-  /// @brief Get the parameter attributes.
-  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
+  /// getParamAttrs - Return the parameter attributes for this Function.
+  ///
+  const PAListPtr &getParamAttrs() const { return ParamAttrs; }
 
-  /// Sets the parameter attributes for this Function. To construct a 
-  /// ParamAttrsList, see ParameterAttributes.h
-  /// @brief Set the parameter attributes.
-  void setParamAttrs(const ParamAttrsList *attrs);
+  /// setParamAttrs - Set the parameter attributes for this Function.
+  ///
+  void setParamAttrs(const PAListPtr &attrs) { ParamAttrs = attrs; }
 
   /// hasCollector/getCollector/setCollector/clearCollector - The name of the
   /// garbage collection algorithm to use during code generation.
@@ -163,22 +167,46 @@ public:
   void clearCollector();
 
   /// @brief Determine whether the function has the given attribute.
-  bool paramHasAttr(uint16_t i, unsigned attr) const;
+  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);
   
+  /// @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;
+  bool doesNotReturn() const { return paramHasAttr(0, ParamAttr::NoReturn); }
+  void setDoesNotThrow(bool doesNotThrow = true);
 
   /// @brief Determine if the function cannot unwind.
-  bool doesNotThrow() const;
+  bool doesNotThrow() const {
+    return paramHasAttr(0, ParamAttr::NoUnwind);
+  }
 
   /// @brief Determine if the function does not access memory.
-  bool doesNotAccessMemory() const;
+  bool doesNotAccessMemory() const {
+    return paramHasAttr(0, ParamAttr::ReadNone);
+  }
 
   /// @brief Determine if the function does not access or only reads memory.
-  bool onlyReadsMemory() const;
+  bool onlyReadsMemory() const {
+    return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
+  }
+
+  /// @brief Determine if the function returns a structure through first 
+  /// pointer argument.
+  bool hasStructRetAttr() const {
+    return paramHasAttr(1, ParamAttr::StructRet);
+  }
 
-  /// @brief Determine if the function returns a structure.
-  bool isStructReturn() const;
+  /// 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.