Update guards

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

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 20a43e285cfff021f35792936927e1f0563df6e9..ef824579262f0afa4d1f9a6e7c1b07ed781b688c 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -21,13 +21,12 @@
 #include "llvm/GlobalValue.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Argument.h"
-#include "llvm/ParameterAttributes.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>
@@ -69,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;*/
@@ -102,13 +101,23 @@ private:
       BuildLazyArguments();
   }
   void BuildLazyArguments() const;
-public:
+  
+  Function(const Function&); // DO NOT IMPLEMENT
+  void operator=(const Function&); // DO NOT IMPLEMENT
+
   /// 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
@@ -142,20 +151,41 @@ 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.
+  bool hasCollector() const;
+  const char *getCollector() const;
+  void setCollector(const char *Str);
+  void clearCollector();
 
   /// @brief Determine whether the function has the given attribute.
-  bool paramHasAttr(uint16_t i, ParameterAttributes attr) const {
-    return ParamAttrs && ParamAttrs->paramHasAttr(i, attr);
+  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 { return paramHasAttr(0, ParamAttr::NoReturn); }
+  void setDoesNotThrow(bool doesNotThrow = true);
+
+  /// @brief Determine if the function cannot unwind.
+  bool doesNotThrow() const {
+    return paramHasAttr(0, ParamAttr::NoUnwind);
   }
 
   /// @brief Determine if the function does not access memory.
@@ -168,11 +198,16 @@ public:
     return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
   }
 
-  /// @brief Determine if the function returns a structure.
-  bool isStructReturn() const {
+  /// @brief Determine if the function returns a structure through first 
+  /// pointer argument.
+  bool hasStructRetAttr() const {
     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.
   ///