Implement review feedback. Aliasees can be either GlobalValue's or

[oota-llvm.git] / include / llvm / Bytecode / BytecodeHandler.h

diff --git a/include/llvm/Bytecode/BytecodeHandler.h b/include/llvm/Bytecode/BytecodeHandler.h
index c3ddc62030380b3f4792aa60b8e2d3dee6cee377..e45266bb2c3ca03511124cc45fec0602ff69eb66 100644 (file)
--- a/include/llvm/Bytecode/BytecodeHandler.h
+++ b/include/llvm/Bytecode/BytecodeHandler.h
@@ -23,7 +23,7 @@ namespace llvm {
 class ArrayType;
 class StructType;
 class PointerType;
-class PackedType;
+class VectorType;
 class ConstantArray;
 class Module;
 
@@ -112,9 +112,16 @@ public:
     GlobalValue::LinkageTypes,///< The linkage type of the GV
     GlobalValue::VisibilityTypes,///< The visibility style of the GV
     unsigned SlotNum,         ///< Slot number of GV
-    unsigned initSlot         ///< Slot number of GV's initializer (0 if none)
+    unsigned initSlot,         ///< Slot number of GV's initializer (0 if none)
+    bool isThreadLocal        ///< Whether the GV is thread local or not
   ) {}
 
+  virtual void handleGlobalAlias(
+    const Type* ElemType,
+    GlobalValue::LinkageTypes Linkage,
+    unsigned TypeSlotNum,
+    unsigned AliaseeSlot) { }
+  
   /// This method is called when a type list is recognized. It simply
   /// provides the number of types that the list contains. The handler
   /// should expect that number of calls to handleType.
@@ -153,33 +160,6 @@ public:
   /// @brief Handle end of module globals block.
   virtual void handleModuleGlobalsEnd() {}
 
-  /// This method is called at the beginning of a compaction table.
-  /// @brief Handle start of compaction table.
-  virtual void handleCompactionTableBegin() {}
-
-  /// @brief Handle start of a compaction table plane
-  virtual void handleCompactionTablePlane(
-    unsigned Ty,         ///< The type of the plane (slot number)
-    unsigned NumEntries  ///< The number of entries in the plane
-  ) {}
-
-  /// @brief Handle a type entry in the compaction table
-  virtual void handleCompactionTableType(
-    unsigned i,       ///< Index in the plane of this type
-    unsigned TypSlot, ///< Slot number for this type
-    const Type*       ///< The type referenced by this slot
-  ) {}
-
-  /// @brief Handle a value entry in the compaction table
-  virtual void handleCompactionTableValue(
-    unsigned i,       ///< Index in the compaction table's type plane
-    unsigned TypSlot, ///< The slot (plane) of the type of this value
-    unsigned ValSlot  ///< The global value slot of the value
-  ) {}
-
-  /// @brief Handle end of a compaction table
-  virtual void handleCompactionTableEnd() {}
-
   /// @brief Handle start of a symbol table
   virtual void handleTypeSymbolTableBegin(
     TypeSymbolTable* ST  ///< The symbol table being filled
@@ -202,7 +182,7 @@ public:
   virtual void handleSymbolTableValue(
     unsigned i,              ///< The index of the value in this plane
     unsigned slot,           ///< Slot number of the named value
-    const std::string& name  ///< Name of the value.
+    const char *name, unsigned NameLen  ///< Name of the value.
   ) {}
 
   /// @brief Handle the end of a value symbol table
@@ -233,7 +213,7 @@ public:
   virtual bool handleInstruction(
     unsigned Opcode,                 ///< Opcode of the instruction
     const Type* iType,               ///< Instruction type
-    std::vector<unsigned>& Operands, ///< Vector of slot # operands
+    unsigned *Operands, unsigned NumOps, ///< Vector of slot # operands
     Instruction *Inst,               ///< The resulting instruction
     unsigned Length                  ///< Length of instruction in bc bytes
   ) { return false; }
@@ -249,14 +229,14 @@ public:
   /// @brief Handle a constant expression
   virtual void handleConstantExpression(
     unsigned Opcode,  ///< Opcode of primary expression operator
-    std::vector<Constant*> ArgVec, ///< expression args
+    Constant**Args, unsigned NumArgs, ///< expression args
     Constant* C ///< The constant value
   ) {}
 
   /// @brief Handle a constant array
   virtual void handleConstantArray(
     const ArrayType* AT,                ///< Type of the array
-    std::vector<Constant*>& ElementSlots,///< Slot nums for array values
+    Constant**ElementSlots, unsigned NumElts,///< Slot nums for array values
     unsigned TypeSlot,                  ///< Slot # of type
     Constant* Val                       ///< The constant value
   ) {}
@@ -264,14 +244,14 @@ public:
   /// @brief Handle a constant structure
   virtual void handleConstantStruct(
     const StructType* ST,               ///< Type of the struct
-    std::vector<Constant*>& ElementSlots,///< Slot nums for struct values
+    Constant**ElementSlots, unsigned NumElts,///< Slot nums for struct values
     Constant* Val                       ///< The constant value
   ) {}
 
   /// @brief Handle a constant packed
-  virtual void handleConstantPacked(
-    const PackedType* PT,                ///< Type of the array
-    std::vector<Constant*>& ElementSlots,///< Slot nums for packed values
+  virtual void handleConstantVector(
+    const VectorType* PT,                ///< Type of the array
+    Constant**ElementSlots, unsigned NumElts,///< Slot nums for packed values
     unsigned TypeSlot,                  ///< Slot # of type
     Constant* Val                       ///< The constant value
   ) {}
@@ -308,15 +288,6 @@ public:
     unsigned Size                  ///< The size of the block
   ) {}
 
-  /// @brief Handle a variable bit rate 32 bit unsigned
-  virtual void handleVBR32(
-    unsigned Size  ///< Number of bytes the vbr_uint took up
-  ) {}
-
-  /// @brief Handle a variable bit rate 64 bit unsigned
-  virtual void handleVBR64(
-    unsigned Size  ///< Number of byte sthe vbr_uint64 took up
-  ) {}
 /// @}
 
 };