Copy ExpandInlineAsm to TargetLowering from TargetAsmInfo.

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

diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index fdd3ea87d6f222681c7f61a86ba81d35238f2710..4f4da1ca2fb65929ceb8f1054a49e9dd4dadbec1 100644 (file)
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -22,19 +22,32 @@
 namespace llvm {
 
 class TerminatorInst;
+class LLVMContext;
 
 template<> struct ilist_traits<Instruction>
   : public SymbolTableListTraits<Instruction, BasicBlock> {
-  // createSentinel is used to create a node that marks the end of the list...
+  // createSentinel is used to get hold of a node that marks the end of
+  // the list...
+  // The sentinel is relative to this instance, so we use a non-static
+  // method.
   Instruction *createSentinel() const {
-    return const_cast<Instruction*>(static_cast<const Instruction*>(&Sentinel));
+    // since i(p)lists always publicly derive from the corresponding
+    // traits, placing a data member in this class will augment i(p)list.
+    // But since the NodeTy is expected to publicly derive from
+    // ilist_node<NodeTy>, there is a legal viable downcast from it
+    // to NodeTy. We use this trick to superpose i(p)list with a "ghostly"
+    // NodeTy, which becomes the sentinel. Dereferencing the sentinel is
+    // forbidden (save the ilist_node<NodeTy>) so no one will ever notice
+    // the superposition.
+    return static_cast<Instruction*>(&Sentinel);
   }
-  static void destroySentinel(Instruction *I) { I = I; }
-  static iplist<Instruction> &getList(BasicBlock *BB);
-  static ValueSymbolTable *getSymTab(BasicBlock *ItemParent);
-  static int getListOffset();
+  static void destroySentinel(Instruction*) {}
+
+  Instruction *provideInitialHead() const { return createSentinel(); }
+  Instruction *ensureHead(Instruction*) const { return createSentinel(); }
+  static void noteHead(Instruction*, Instruction*) {}
 private:
-  ilist_node<Instruction> Sentinel;
+  mutable ilist_node<Instruction> Sentinel;
 };
 
 /// This represents a single basic block in LLVM. A basic block is simply a
@@ -73,6 +86,10 @@ private:
   explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
                       BasicBlock *InsertBefore = 0);
 public:
+  /// getContext - Get the context in which this basic block lives,
+  /// or null if it is not currently attached to a function.
+  LLVMContext *getContext() const;
+  
   /// Instruction iterators...
   typedef InstListType::iterator                              iterator;
   typedef InstListType::const_iterator                  const_iterator;
@@ -92,7 +109,8 @@ public:
         Function *getParent()       { return Parent; }
 
   /// use_back - Specialize the methods defined in Value, as we know that an
-  /// BasicBlock can only be used by Instructions (specifically PHI and terms).
+  /// BasicBlock can only be used by Instructions (specifically PHI nodes and
+  /// terminators).
   Instruction       *use_back()       { return cast<Instruction>(*use_begin());}
   const Instruction *use_back() const { return cast<Instruction>(*use_begin());}
   
@@ -170,6 +188,14 @@ public:
   const InstListType &getInstList() const { return InstList; }
         InstListType &getInstList()       { return InstList; }
 
+  /// getSublistAccess() - returns pointer to member of instruction list
+  static iplist<Instruction> BasicBlock::*getSublistAccess(Instruction*) {
+    return &BasicBlock::InstList;
+  }
+
+  /// getValueSymbolTable() - returns pointer to symbol table (if any)
+  ValueSymbolTable *getValueSymbolTable();
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BasicBlock *) { return true; }
   static inline bool classof(const Value *V) {
@@ -207,19 +233,8 @@ public:
   /// the basic block).
   ///
   BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = "");
-  
-  
-  static unsigned getInstListOffset() {
-    BasicBlock *Obj = 0;
-    return unsigned(reinterpret_cast<uintptr_t>(&Obj->InstList));
-  }
 };
 
-inline int 
-ilist_traits<Instruction>::getListOffset() {
-  return BasicBlock::getInstListOffset();
-}
-
 } // End llvm namespace
 
 #endif