Change UsedPhysRegs from array bool to BitVector to save some space. Setting / gettin...

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

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 101de8ac3c2fa3da13ba10d913c730fc004c1f6a..c0984f636789daafe505cfe0681560b9e243ffcc 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -30,21 +30,25 @@ class ParamAttrsList;
 
 // Traits for intrusive list of instructions...
 template<> struct ilist_traits<BasicBlock>
-  : public SymbolTableListTraits<BasicBlock, Function, Function> {
+  : 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);
+  static ValueSymbolTable *getSymTab(Function *ItemParent);
+  static int getListOffset();
 };
 
 template<> struct ilist_traits<Argument>
-  : public SymbolTableListTraits<Argument, Function, Function> {
+  : 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);
+  static ValueSymbolTable *getSymTab(Function *ItemParent);
+  static int getListOffset();
 };
 
 class Function : public GlobalValue, public Annotable {
@@ -65,9 +69,12 @@ private:
   ArgumentListType ArgumentList;     ///< The formal arguments
   ValueSymbolTable *SymTab;          ///< Symbol table of args/instructions
   ParamAttrsList *ParamAttrs;        ///< Parameter attributes
-  unsigned CallingConvention;        ///< Calling convention to use
 
-  friend class SymbolTableListTraits<Function, Module, Module>;
+  
+  // The Calling Convention is stored in Value::SubclassData.
+  /*unsigned CallingConvention;*/
+
+  friend class SymbolTableListTraits<Function, Module>;
 
   void setParent(Module *parent);
   Function *Prev, *Next;
@@ -103,14 +110,14 @@ public:
   /// The particular intrinsic functions which correspond to this value are
   /// defined in llvm/Intrinsics.h.
   ///
-  unsigned getIntrinsicID() const;
+  unsigned getIntrinsicID(bool noAssert = false) const;
   bool isIntrinsic() const { return getIntrinsicID() != 0; }
 
   /// getCallingConv()/setCallingConv(uint) - 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 CallingConvention; }
-  void setCallingConv(unsigned CC) { CallingConvention = CC; }
+  unsigned getCallingConv() const { return SubclassData; }
+  void setCallingConv(unsigned CC) { SubclassData = CC; }
 
   /// Obtains a constant pointer to the ParamAttrsList object which holds the
   /// parameter attributes information, if any. 
@@ -121,7 +128,7 @@ public:
   /// Sets the parameter attributes for this Function. To construct a 
   /// ParamAttrsList, see ParameterAttributes.h
   /// @brief Set the parameter attributes.
-  void setParamAttrs(ParamAttrsList *attrs) { ParamAttrs = attrs; }
+  void setParamAttrs(ParamAttrsList *attrs);
 
   /// deleteBody - This method deletes the body of the function, and converts
   /// the linkage to external.
@@ -134,23 +141,14 @@ public:
   /// removeFromParent - This method unlinks 'this' from the containing module,
   /// but does not delete it.
   ///
-  void removeFromParent();
+  virtual void removeFromParent();
 
   /// eraseFromParent - This method unlinks 'this' from the containing module
   /// and deletes it.
   ///
-  void eraseFromParent();
+  virtual void eraseFromParent();
 
 
-  // getNext/Prev - Return the next or previous function in the list.  These
-  // methods should never be used directly, and are only used to implement the
-  // function list as part of the module.
-  //
-        Function *getNext()       { return Next; }
-  const Function *getNext() const { return Next; }
-        Function *getPrev()       { return Prev; }
-  const Function *getPrev() const { return Prev; }
-
   /// Get the underlying elements of the Function... the basic block list is
   /// empty for external functions.
   ///
@@ -220,7 +218,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Function *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == Value::FunctionVal;
+    return V->getValueID() == Value::FunctionVal;
   }
 
   /// dropAllReferences() - This method causes all the subinstructions to "let
@@ -236,8 +234,47 @@ 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));
+  }
+private:
+  // getNext/Prev - Return the next or previous function in the list.  These
+  // methods should never be used directly, and are only used to implement the
+  // function list as part of the module.
+  //
+  Function *getNext()             { return Next; }
+  const Function *getNext() const { return Next; }
+  Function *getPrev()             { return Prev; }
+  const Function *getPrev() const { return Prev; }
 };
 
+inline ValueSymbolTable *
+ilist_traits<BasicBlock>::getSymTab(Function *F) {
+  return F ? &F->getValueSymbolTable() : 0;
+}
+
+inline ValueSymbolTable *
+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