Reappy r80998, now that the GlobalOpt bug that it exposed on MiniSAT is fixed.

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

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 942a5f00d54c6de1f5b5fa03124c2f776aa854d5..088c99952e9fb35f35cecbfa2327e7336de709d2 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -19,39 +19,54 @@
 #define LLVM_FUNCTION_H
 
 #include "llvm/GlobalValue.h"
+#include "llvm/CallingConv.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Argument.h"
-#include "llvm/Support/Annotation.h"
 #include "llvm/Attributes.h"
 
 namespace llvm {
 
 class FunctionType;
+class LLVMContext;
 
-// Traits for intrusive list of instructions...
+// Traits for intrusive list of basic blocks...
 template<> struct ilist_traits<BasicBlock>
   : public SymbolTableListTraits<BasicBlock, Function> {
 
-  // createSentinel is used to create a node that marks the end of the list...
-  static BasicBlock *createSentinel();
-  static void destroySentinel(BasicBlock *BB) { delete BB; }
-  static iplist<BasicBlock> &getList(Function *F);
+  // createSentinel is used to get hold of the node that marks the end of the
+  // list... (same trick used here as in ilist_traits<Instruction>)
+  BasicBlock *createSentinel() const {
+    return static_cast<BasicBlock*>(&Sentinel);
+  }
+  static void destroySentinel(BasicBlock*) {}
+
+  BasicBlock *provideInitialHead() const { return createSentinel(); }
+  BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); }
+  static void noteHead(BasicBlock*, BasicBlock*) {}
+
   static ValueSymbolTable *getSymTab(Function *ItemParent);
-  static int getListOffset();
+private:
+  mutable ilist_half_node<BasicBlock> Sentinel;
 };
 
 template<> struct ilist_traits<Argument>
   : public SymbolTableListTraits<Argument, Function> {
 
-  // createSentinel is used to create a node that marks the end of the list...
-  static Argument *createSentinel();
-  static void destroySentinel(Argument *A) { delete A; }
-  static iplist<Argument> &getList(Function *F);
+  Argument *createSentinel() const {
+    return static_cast<Argument*>(&Sentinel);
+  }
+  static void destroySentinel(Argument*) {}
+
+  Argument *provideInitialHead() const { return createSentinel(); }
+  Argument *ensureHead(Argument*) const { return createSentinel(); }
+  static void noteHead(Argument*, Argument*) {}
+
   static ValueSymbolTable *getSymTab(Function *ItemParent);
-  static int getListOffset();
+private:
+  mutable ilist_half_node<Argument> Sentinel;
 };
 
-class Function : public GlobalValue, public Annotable,
+class Function : public GlobalValue,
                  public ilist_node<Function> {
 public:
   typedef iplist<Argument> ArgumentListType;
@@ -72,7 +87,7 @@ private:
   AttrListPtr AttributeList;              ///< Parameter attributes
 
   // The Calling Convention is stored in Value::SubclassData.
-  /*unsigned CallingConvention;*/
+  /*CallingConv::ID CallingConvention;*/
 
   friend class SymbolTableListTraits<Function, Module>;
 
@@ -99,11 +114,11 @@ private:
   /// the module.
   ///
   Function(const FunctionType *Ty, LinkageTypes Linkage,
-           const std::string &N = "", Module *M = 0);
+           const Twine &N = "", Module *M = 0);
 
 public:
   static Function *Create(const FunctionType *Ty, LinkageTypes Linkage,
-                          const std::string &N = "", Module *M = 0) {
+                          const Twine &N = "", Module *M = 0) {
     return new(0) Function(Ty, Linkage, N, M);
   }
 
@@ -112,6 +127,10 @@ public:
   const Type *getReturnType() const;           // Return the type of the ret val
   const FunctionType *getFunctionType() const; // Return the FunctionType for me
 
+  /// getContext - Return a pointer to the LLVMContext associated with this 
+  /// function, or NULL if this function is not bound to a context yet.
+  LLVMContext &getContext() const;
+
   /// isVarArg - Return true if this function takes a variable number of
   /// arguments.
   bool isVarArg() const;
@@ -132,12 +151,14 @@ public:
   unsigned getIntrinsicID() const;
   bool isIntrinsic() const { return getIntrinsicID() != 0; }
 
-  /// getCallingConv()/setCallingConv(uint) - These method get and set the
+  /// getCallingConv()/setCallingConv(CC) - These method get and set the
   /// calling convention of this function.  The enum values for the known
   /// calling conventions are defined in CallingConv.h.
-  unsigned getCallingConv() const { return SubclassData >> 1; }
-  void setCallingConv(unsigned CC) {
-    SubclassData = (SubclassData & 1) | (CC << 1);
+  CallingConv::ID getCallingConv() const {
+    return static_cast<CallingConv::ID>(SubclassData >> 1);
+  }
+  void setCallingConv(CallingConv::ID CC) {
+    SubclassData = (SubclassData & 1) | (static_cast<unsigned>(CC) << 1);
   }
   
   /// getAttributes - Return the attribute list for this Function.
@@ -287,9 +308,15 @@ public:
     CheckLazyArguments();
     return ArgumentList;
   }
+  static iplist<Argument> Function::*getSublistAccess(Argument*) {
+    return &Function::ArgumentList;
+  }
 
   const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
         BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
+  static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
+    return &Function::BasicBlocks;
+  }
 
   const BasicBlock       &getEntryBlock() const   { return front(); }
         BasicBlock       &getEntryBlock()         { return front(); }
@@ -375,15 +402,10 @@ public:
   /// including any contained basic blocks.
   ///
   void dropAllReferences();
-  
-  static unsigned getBasicBlockListOffset() {
-    Function *Obj = 0;
-    return unsigned(reinterpret_cast<uintptr_t>(&Obj->BasicBlocks));
-  }
-  static unsigned getArgumentListOffset() {
-    Function *Obj = 0;
-    return unsigned(reinterpret_cast<uintptr_t>(&Obj->ArgumentList));
-  }
+
+  /// hasAddressTaken - returns true if there are any uses of this function
+  /// other than direct calls or invokes to it.
+  bool hasAddressTaken() const;
 };
 
 inline ValueSymbolTable *
@@ -396,17 +418,6 @@ ilist_traits<Argument>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : 0;
 }
 
-inline int 
-ilist_traits<BasicBlock>::getListOffset() {
-  return Function::getBasicBlockListOffset();
-}
-
-inline int 
-ilist_traits<Argument>::getListOffset() {
-  return Function::getArgumentListOffset();
-}
-
-
 } // End llvm namespace
 
 #endif