diff options
31 files changed, 241 insertions, 344 deletions
diff --git a/include/llvm/Bytecode/Format.h b/include/llvm/Bytecode/Format.h index 562d8ff011..fc896b895d 100644 --- a/include/llvm/Bytecode/Format.h +++ b/include/llvm/Bytecode/Format.h @@ -35,7 +35,7 @@ public: ModuleBlockID = 1, ///< Module block that contains other blocks. FunctionBlockID = 2, ///< Function block identifier ConstantPoolBlockID = 3, ///< Constant pool identifier - SymbolTableBlockID = 4, ///< Symbol table identifier + ValueSymbolTableBlockID= 4, ///< Value Symbol table identifier ModuleGlobalInfoBlockID= 5, ///< Module global info identifier GlobalTypePlaneBlockID = 6, ///< Global type plan identifier InstructionListBlockID = 7, ///< All instructions in a function @@ -46,8 +46,9 @@ public: /// instructions to be encoded more efficiently because VBR takes fewer /// bytes with smaller values. /// @brief Value Compaction Table Block - CompactionTableBlockID = 0x08, + CompactionTableBlockID = 8, + TypeSymbolTableBlockID = 9, ///< Value Symbol table identifier // Not a block id, just used to count them NumberOfBlockIDs }; diff --git a/include/llvm/Function.h b/include/llvm/Function.h index 7346c3b3e3..a31e7f4834 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -163,8 +163,8 @@ public: /// getSymbolTable() - Return the symbol table... /// - inline SymbolTable &getSymbolTable() { return *SymTab; } - inline const SymbolTable &getSymbolTable() const { return *SymTab; } + inline SymbolTable &getValueSymbolTable() { return *SymTab; } + inline const SymbolTable &getValueSymbolTable() const { return *SymTab; } //===--------------------------------------------------------------------===// diff --git a/include/llvm/Module.h b/include/llvm/Module.h index 42214af1ac..e5c157be95 100644 --- a/include/llvm/Module.h +++ b/include/llvm/Module.h @@ -25,6 +25,7 @@ class GlobalVariable; class GlobalValueRefMap; // Used by ConstantVals.cpp class FunctionType; class SymbolTable; +class TypeSymbolTable; template<> struct ilist_traits<Function> : public SymbolTableListTraits<Function, Module, Module> { @@ -91,7 +92,8 @@ private: FunctionListType FunctionList; ///< The Functions in the module LibraryListType LibraryList; ///< The Libraries needed by the module std::string GlobalScopeAsm; ///< Inline Asm at global scope. - SymbolTable *SymTab; ///< Symbol Table for the module + SymbolTable *ValSymTab; ///< Symbol table for values + TypeSymbolTable *TypeSymTab; ///< Symbol table for types std::string ModuleID; ///< Human readable identifier for the module std::string TargetTriple; ///< Platform target triple Module compiled on std::string DataLayout; ///< Target data description @@ -237,9 +239,13 @@ public: /// Get the Module's list of functions. FunctionListType &getFunctionList() { return FunctionList; } /// Get the symbol table of global variable and function identifiers - const SymbolTable &getSymbolTable() const { return *SymTab; } + const SymbolTable &getValueSymbolTable() const { return *ValSymTab; } /// Get the Module's symbol table of global variable and function identifiers. - SymbolTable &getSymbolTable() { return *SymTab; } + SymbolTable &getValueSymbolTable() { return *ValSymTab; } + /// Get the symbol table of types + const TypeSymbolTable &getTypeSymbolTable() const { return *TypeSymTab; } + /// Get the Module's symbol table of types + TypeSymbolTable &getTypeSymbolTable() { return *TypeSymTab; } /// @} /// @name Global Variable Iteration diff --git a/include/llvm/SymbolTable.h b/include/llvm/SymbolTable.h index 52a2c29ea7..6451f9c8e2 100644 --- a/include/llvm/SymbolTable.h +++ b/include/llvm/SymbolTable.h @@ -47,16 +47,6 @@ class SymbolTable : public AbstractTypeUser { /// @name Types /// @{ public: - - /// @brief A mapping of names to types. - typedef std::map<const std::string, const Type*> TypeMap; - - /// @brief An iterator over the TypeMap. - typedef TypeMap::iterator type_iterator; - - /// @brief A const_iterator over the TypeMap. - typedef TypeMap::const_iterator type_const_iterator; - /// @brief A mapping of names to values. typedef std::map<const std::string, Value *> ValueMap; @@ -96,20 +86,10 @@ public: /// @brief Lookup a named, typed value. Value *lookup(const Type *Ty, const std::string &name) const; - /// This method finds the type with the given \p name in the - /// type map and returns it. - /// @returns null if the name is not found, otherwise the Type - /// associated with the \p name. - /// @brief Lookup a type by name. - Type* lookupType(const std::string& name) const; - /// @returns true iff the type map and the type plane are both not /// empty. /// @brief Determine if the symbol table is empty - inline bool isEmpty() const { return pmap.empty() && tmap.empty(); } - - /// @brief The number of name/type pairs is returned. - inline unsigned num_types() const { return unsigned(tmap.size()); } + inline bool isEmpty() const { return pmap.empty(); } /// Given a base name, return a string that is either equal to it or /// derived from it that does not already occur in the symbol table @@ -178,20 +158,6 @@ public: return pmap.find(Typ)->second.end(); } - /// Get an iterator to the start of the name/Type map. - inline type_iterator type_begin() { return tmap.begin(); } - - /// @brief Get a const_iterator to the start of the name/Type map. - inline type_const_iterator type_begin() const { return tmap.begin(); } - - /// Get an iterator to the end of the name/Type map. This serves as the - /// marker for end of iteration of the types. - inline type_iterator type_end() { return tmap.end(); } - - /// Get a const-iterator to the end of the name/Type map. This serves - /// as the marker for end of iteration of the types. - inline type_const_iterator type_end() const { return tmap.end(); } - /// This method returns a plane_const_iterator for iteration over /// the type planes starting at a specific plane, given by \p Ty. /// @brief Find a type plane. @@ -219,16 +185,6 @@ public: /// @brief Strip the symbol table. bool strip(); - /// Inserts a type into the symbol table with the specified name. There can be - /// a many-to-one mapping between names and types. This method allows a type - /// with an existing entry in the symbol table to get a new name. - /// @brief Insert a type under a new name. - void insert(const std::string &Name, const Type *Typ); - - /// Remove a type at the specified position in the symbol table. - /// @returns the removed Type. - Type* remove(type_iterator TI); - /// @} /// @name Mutators used by Value::setName and other LLVM internals. /// @{ @@ -286,15 +242,9 @@ private: /// @brief The mapping of types to names to values. PlaneMap pmap; - /// This is the type plane. It is separated from the pmap - /// because the elements of the map are name/Type pairs not - /// name/Value pairs and Type is not a Value. - TypeMap tmap; - /// This value is used to retain the last unique value used /// by getUniqueName to generate unique names. mutable uint32_t LastUnique; - /// @} }; diff --git a/include/llvm/TypeSymbolTable.h b/include/llvm/TypeSymbolTable.h index c9f8d3107b..b95415377e 100644 --- a/include/llvm/TypeSymbolTable.h +++ b/include/llvm/TypeSymbolTable.h @@ -111,12 +111,12 @@ public: /// Remove a type at the specified position in the symbol table. /// @returns the removed Type. /// @returns the Type that was erased from the symbol table. - Type* erase(iterator TI); + Type* remove(iterator TI); /// Remove a specific Type from the symbol table. This isn't fast, linear /// search, O(n), algorithm. /// @returns true if the erase was successful (TI was found) - bool erase(Type* TI); + bool remove(Type* TI); /// Rename a type. This ain't fast, we have to linearly search for it first. /// @returns true if the rename was successful (type was found) diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs index e78dc6fe12..ebbffeb7ab 100644 --- a/lib/AsmParser/llvmAsmParser.cpp.cvs +++ b/lib/AsmParser/llvmAsmParser.cpp.cvs @@ -639,8 +639,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { SymbolTable &SymTab = - inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); + inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() : + CurModule.CurrentModule->getValueSymbolTable(); return SymTab.lookup(Ty, Name); } @@ -821,7 +821,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { case ValID::NameVal: // Is it a named definition? Name = ID.Name; if (Value *N = CurFun.CurrentFunction-> - getSymbolTable().lookup(Type::LabelTy, Name)) + getValueSymbolTable().lookup(Type::LabelTy, Name)) BB = cast<BasicBlock>(N); break; } @@ -961,7 +961,7 @@ static void setValueName(Value *V, char *NameStr) { } assert(inFunctionScope() && "Must be in function scope!"); - SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); + SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); if (ST.lookup(V->getType(), Name)) { GenerateError("Redefinition of value '" + Name + "' of type '" + V->getType()->getDescription() + "'!"); diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 0059531518..192b560819 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -311,8 +311,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { SymbolTable &SymTab = - inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); + inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() : + CurModule.CurrentModule->getValueSymbolTable(); return SymTab.lookup(Ty, Name); } @@ -493,7 +493,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { case ValID::NameVal: // Is it a named definition? Name = ID.Name; if (Value *N = CurFun.CurrentFunction-> - getSymbolTable().lookup(Type::LabelTy, Name)) + getValueSymbolTable().lookup(Type::LabelTy, Name)) BB = cast<BasicBlock>(N); break; } @@ -633,7 +633,7 @@ static void setValueName(Value *V, char *NameStr) { } assert(inFunctionScope() && "Must be in function scope!"); - SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); + SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); if (ST.lookup(V->getType(), Name)) { GenerateError("Redefinition of value '" + Name + "' of type '" + V->getType()->getDescription() + "'!"); diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs index 0059531518..192b560819 100644 --- a/lib/AsmParser/llvmAsmParser.y.cvs +++ b/lib/AsmParser/llvmAsmParser.y.cvs @@ -311,8 +311,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { SymbolTable &SymTab = - inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); + inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() : + CurModule.CurrentModule->getValueSymbolTable(); return SymTab.lookup(Ty, Name); } @@ -493,7 +493,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { case ValID::NameVal: // Is it a named definition? Name = ID.Name; if (Value *N = CurFun.CurrentFunction-> - getSymbolTable().lookup(Type::LabelTy, Name)) + getValueSymbolTable().lookup(Type::LabelTy, Name)) BB = cast<BasicBlock>(N); break; } @@ -633,7 +633,7 @@ static void setValueName(Value *V, char *NameStr) { } assert(inFunctionScope() && "Must be in function scope!"); - SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); + SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); if (ST.lookup(V->getType(), Name)) { GenerateError("Redefinition of value '" + Name + "' of type '" + V->getType()->getDescription() + "'!"); diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp index 078360249c..899a534272 100644 --- a/lib/Bytecode/Reader/Analyzer.cpp +++ b/lib/Bytecode/Reader/Analyzer.cpp @@ -96,11 +96,12 @@ public: bca.BlockSizes[BytecodeFormat::ModuleBlockID] = theSize; bca.BlockSizes[BytecodeFormat::FunctionBlockID] = 0; bca.BlockSizes[BytecodeFormat::ConstantPoolBlockID] = 0; - bca.BlockSizes[BytecodeFormat::SymbolTableBlockID] = 0; + bca.BlockSizes[BytecodeFormat::ValueSymbolTableBlockID] = 0; bca.BlockSizes[BytecodeFormat::ModuleGlobalInfoBlockID] = 0; bca.BlockSizes[BytecodeFormat::GlobalTypePlaneBlockID] = 0; bca.BlockSizes[BytecodeFormat::InstructionListBlockID] = 0; bca.BlockSizes[BytecodeFormat::CompactionTableBlockID] = 0; + bca.BlockSizes[BytecodeFormat::TypeSymbolTableBlockID] = 0; } virtual void handleFinish() { @@ -636,8 +637,11 @@ void PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out ) print(Out, "Compaction Table Bytes", double(bca.BlockSizes[BytecodeFormat::CompactionTableBlockID]), double(bca.byteSize)); - print(Out, "Symbol Table Bytes", - double(bca.BlockSizes[BytecodeFormat::SymbolTableBlockID]), + print(Out, "Value Symbol Table Bytes", + double(bca.BlockSizes[BytecodeFormat::ValueSymbolTableBlockID]), + double(bca.byteSize)); + print(Out, "Type Symbol Table Bytes", + double(bca.BlockSizes[BytecodeFormat::TypeSymbolTableBlockID]), double(bca.byteSize)); print(Out, "Alignment Bytes", double(bca.numAlignment), double(bca.byteSize)); diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp index afff24adb6..b1e4bf639c 100644 --- a/lib/Bytecode/Reader/Reader.cpp +++ b/lib/Bytecode/Reader/Reader.cpp @@ -24,6 +24,7 @@ #include "llvm/InlineAsm.h" #include "llvm/Instructions.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Bytecode/Format.h" #include "llvm/Config/alloca.h" #include "llvm/Support/GetElementPtrTypeIterator.h" @@ -1023,13 +1024,27 @@ unsigned BytecodeReader::ParseInstructionList(Function* F) { return BlockNo; } -/// Parse a symbol table. This works for both module level and function +/// Parse a type symbol table. +void BytecodeReader::ParseTypeSymbolTable(TypeSymbolTable *TST) { + // Type Symtab block header: [num entries] + unsigned NumEntries = read_vbr_uint(); + for (unsigned i = 0; i < NumEntries; ++i) { + // Symtab entry: [type slot #][name] + unsigned slot = read_vbr_uint(); + std::string Name = read_str(); + const Type* T = getType(slot); + TST->insert(Name, T); + } +} + +/// Parse a value symbol table. This works for both module level and function /// level symbol tables. For function level symbol tables, the CurrentFunction /// parameter must be non-zero and the ST parameter must correspond to /// CurrentFunction's symbol table. For Module level symbol tables, the /// CurrentFunction argument must be zero. -void BytecodeReader::ParseSymbolTable(Function *CurrentFunction, - SymbolTable *ST) { +void BytecodeReader::ParseValueSymbolTable(Function *CurrentFunction, + SymbolTable *ST) { + if (Handler) Handler->handleSymbolTableBegin(CurrentFunction,ST); // Allow efficient basic block lookup by number. @@ -1039,16 +1054,6 @@ void BytecodeReader::ParseSymbolTable(Function *CurrentFunction, E = CurrentFunction->end(); I != E; ++I) BBMap.push_back(I); - // Symtab block header: [num entries] - unsigned NumEntries = read_vbr_uint(); - for (unsigned i = 0; i < NumEntries; ++i) { - // Symtab entry: [def slot #][name] - unsigned slot = read_vbr_uint(); - std::string Name = read_str(); - const Type* T = getType(slot); - ST->insert(Name, T); - } - while (moreInBlock()) { // Symtab block header: [num entries][type id number] unsigned NumEntries = read_vbr_uint(); @@ -1683,8 +1688,12 @@ void BytecodeReader::ParseFunctionBody(Function* F) { break; } - case BytecodeFormat::SymbolTableBlockID: - ParseSymbolTable(F, &F->getSymbolTable()); + case BytecodeFormat::ValueSymbolTableBlockID: + ParseValueSymbolTable(F, &F->getValueSymbolTable()); + break; + + case BytecodeFormat::TypeSymbolTableBlockID: + error("Functions don't have type symbol tables"); break; default: @@ -2084,8 +2093,12 @@ void BytecodeReader::ParseModule() { ParseFunctionLazily(); break; - case BytecodeFormat::SymbolTableBlockID: - ParseSymbolTable(0, &TheModule->getSymbolTable()); + case BytecodeFormat::ValueSymbolTableBlockID: + ParseValueSymbolTable(0, &TheModule->getValueSymbolTable()); + break; + + case BytecodeFormat::TypeSymbolTableBlockID: + ParseTypeSymbolTable(&TheModule->getTypeSymbolTable()); break; default: diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h index 1d2fe32af6..677c39f99f 100644 --- a/lib/Bytecode/Reader/Reader.h +++ b/lib/Bytecode/Reader/Reader.h @@ -29,6 +29,7 @@ namespace llvm { class BytecodeHandler; ///< Forward declare the handler interface +class TypeSymbolTable; ///< Forward declare /// This class defines the interface for parsing a buffer of bytecode. The /// parser itself takes no action except to call the various functions of @@ -199,8 +200,11 @@ protected: /// @brief Parse the ModuleGlobalInfo block void ParseModuleGlobalInfo(); - /// @brief Parse a symbol table - void ParseSymbolTable( Function* Func, SymbolTable *ST); + /// @brief Parse a value symbol table + void ParseTypeSymbolTable(TypeSymbolTable *ST); + + /// @brief Parse a value symbol table + void ParseValueSymbolTable(Function* Func, SymbolTable *ST); /// @brief Parse functions lazily. void ParseFunctionLazily(); diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp index cf770c4bbc..fdf7174b85 100644 --- a/lib/Bytecode/Writer/SlotCalculator.cpp +++ b/lib/Bytecode/Writer/SlotCalculator.cpp @@ -22,6 +22,7 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Type.h" #include "llvm/Analysis/ConstantsScanner.h" #include "llvm/ADT/PostOrderIterator.h" @@ -189,13 +190,14 @@ void SlotCalculator::processModule() { } getOrCreateSlot(I->getType()); } - processSymbolTableConstants(&F->getSymbolTable()); + processSymbolTableConstants(&F->getValueSymbolTable()); } // Insert constants that are named at module level into the slot pool so that // the module symbol table can refer to them... SC_DEBUG("Inserting SymbolTable values:\n"); - processSymbolTable(&TheModule->getSymbolTable()); + processTypeSymbolTable(&TheModule->getTypeSymbolTable()); + processValueSymbolTable(&TheModule->getValueSymbolTable()); // Now that we have collected together all of the information relevant to the // module, compactify the type table if it is particularly big and outputting @@ -233,16 +235,18 @@ void SlotCalculator::processModule() { SC_DEBUG("end processModule!\n"); } +// processTypeSymbolTable - Insert all of the type sin the specified symbol +// table. +void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *ST) { + for (TypeSymbolTable::const_iterator TI = ST->begin(), TE = ST->end(); + TI != TE; ++TI ) + getOrCreateSlot(TI->second); +} + // processSymbolTable - Insert all of the values in the specified symbol table // into the values table... // -void SlotCalculator::processSymbolTable(const SymbolTable *ST) { - // Do the types first. - for (SymbolTable::type_const_iterator TI = ST->type_begin(), - TE = ST->type_end(); TI != TE; ++TI ) - getOrCreateSlot(TI->second); - - // Now do the values. +void SlotCalculator::processValueSymbolTable(const SymbolTable *ST) { for (SymbolTable::plane_const_iterator PI = ST->plane_begin(), PE = ST->plane_end(); PI != PE; ++PI) for (SymbolTable::value_const_iterator VI = PI->second.begin(), @@ -251,11 +255,6 @@ void SlotCalculator::processSymbolTable(const SymbolTable *ST) { } void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) { - // Do the types first - for (SymbolTable::type_const_iterator TI = ST->type_begin(), - TE = ST->type_end(); TI != TE; ++TI ) - getOrCreateSlot(TI->second); - // Now do the constant values in all planes for (SymbolTable::plane_const_iterator PI = ST->plane_begin(), PE = ST->plane_end(); PI != PE; ++PI) @@ -306,7 +305,7 @@ void SlotCalculator::incorporateFunction(const Function *F) { // symbol table references to constants not in the output. Scan for these // constants now. // - processSymbolTableConstants(&F->getSymbolTable()); + processSymbolTableConstants(&F->getValueSymbolTable()); } SC_DEBUG("Inserting Instructions:\n"); @@ -468,13 +467,8 @@ void SlotCalculator::buildCompactionTable(const Function *F) { getOrCreateCompactionTableSlot(I->getOperand(op)); } - // Do the types in the symbol table - const SymbolTable &ST = F->getSymbolTable(); - for (SymbolTable::type_const_iterator TI = ST.type_begin(), - TE = ST.type_end(); TI != TE; ++TI) - getOrCreateCompactionTableSlot(TI->second); - // Now do the constants and global values + const SymbolTable &ST = F->getValueSymbolTable(); for (SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE = ST.plane_end(); PI != PE; ++PI) for (SymbolTable::value_const_iterator VI = PI->second.begin(), diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h index e88a88f726..405c0edbd3 100644 --- a/lib/Bytecode/Writer/SlotCalculator.h +++ b/lib/Bytecode/Writer/SlotCalculator.h @@ -30,6 +30,7 @@ class Type; class Module; class Function; class SymbolTable; +class TypeSymbolTable; class ConstantArray; class SlotCalculator { @@ -168,7 +169,8 @@ private: // processSymbolTable - Insert all of the values in the specified symbol table // into the values table... // - void processSymbolTable(const SymbolTable *ST); + void processTypeSymbolTable(const TypeSymbolTable *ST); + void processValueSymbolTable(const SymbolTable *ST); void processSymbolTableConstants(const SymbolTable *ST); void buildCompactionTable(const Function *F); diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp index 58cc13a141..37e4abfae2 100644 --- a/lib/Bytecode/Writer/Writer.cpp +++ b/lib/Bytecode/Writer/Writer.cpp @@ -27,6 +27,7 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/Compressor.h" #include "llvm/Support/MathExtras.h" @@ -837,8 +838,11 @@ BytecodeWriter::BytecodeWriter(std::vector<unsigned char> &o, const Module *M) for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) outputFunction(I); - // If needed, output the symbol table for the module... - outputSymbolTable(M->getSymbolTable()); + // Output the symbole table for types + outputTypeSymbolTable(M->getTypeSymbolTable()); + + // Output the symbol table for values + outputValueSymbolTable(M->getValueSymbolTable()); } void BytecodeWriter::outputTypes(unsigned TypeNum) { @@ -1112,7 +1116,7 @@ void BytecodeWriter::outputFunction(const Function *F) { outputInstructions(F); // If needed, output the symbol table for the function... - outputSymbolTable(F->getSymbolTable()); + outputValueSymbolTable(F->getValueSymbolTable()); Table.purgeFunction(); } @@ -1187,24 +1191,33 @@ void BytecodeWriter::outputCompactionTable() { } } -void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) { - // Do not output the Bytecode block for an empty symbol table, it just wastes +void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) { + // Do not output the block for an empty symbol table, it just wastes // space! - if (MST.isEmpty()) return; + if (TST.empty()) return; - BytecodeBlock SymTabBlock(BytecodeFormat::SymbolTableBlockID, *this, + // Create a header for the symbol table + BytecodeBlock SymTabBlock(BytecodeFormat::TypeSymbolTableBlockID, *this, true/*ElideIfEmpty*/); - // Write the number of types - output_vbr(MST.num_types()); + output_vbr(TST.size()); // Write each of the types - for (SymbolTable::type_const_iterator TI = MST.type_begin(), - TE = MST.type_end(); TI != TE; ++TI) { + for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); + TI != TE; ++TI) { // Symtab entry:[def slot #][name] output_typeid((unsigned)Table.getSlot(TI->second)); output(TI->first); } +} + +void BytecodeWriter::outputValueSymbolTable(const SymbolTable &MST) { + // Do not output the Bytecode block for an empty symbol table, it just wastes + // space! + if (MST.isEmpty()) return; + + BytecodeBlock SymTabBlock(BytecodeFormat::ValueSymbolTableBlockID, *this, + true/*ElideIfEmpty*/); // Now do each of the type planes in order. for (SymbolTable::plane_const_iterator PI = MST.plane_begin(), diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h index f8c276e858..c518c01b94 100644 --- a/lib/Bytecode/Writer/WriterInternals.h +++ b/lib/Bytecode/Writer/WriterInternals.h @@ -25,6 +25,7 @@ namespace llvm { class InlineAsm; + class TypeSymbolTable; class BytecodeWriter { std::vector<unsigned char> &Out; @@ -64,7 +65,8 @@ private: unsigned Type) ; void outputModuleInfoBlock(const Module *C); - void outputSymbolTable(const SymbolTable &ST); + void outputTypeSymbolTable(const TypeSymbolTable &TST); + void outputValueSymbolTable(const SymbolTable &ST); void outputTypes(unsigned StartNo); void outputConstantsInPlane(const std::vector<const Value*> &Plane, unsigned StartNo); diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 9346c11824..4e298898b1 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -21,6 +21,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Instructions.h" #include "llvm/Assembly/Writer.h" #include "llvm/Support/Streams.h" @@ -61,7 +62,7 @@ static std::string ToStr(const Type *Ty, const Module *M) { // false - No errors. // static bool ResolveTypes(const Type *DestTy, const Type *SrcTy, - SymbolTable *DestST, const std::string &Name) { + TypeSymbolTable *Dest |