From 78d033e086e19e016273de014f9214aa6f3f844b Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Sat, 6 Jan 2007 07:24:44 +0000 Subject: [PATCH] For PR411: Take an incremental step towards type plane elimination. This change separates types from values in the symbol tables by finally making use of the TypeSymbolTable class. This yields more natural interfaces for dealing with types and unclutters the SymbolTable class. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32956 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bytecode/Format.h | 5 +- include/llvm/Function.h | 4 +- include/llvm/Module.h | 12 ++- include/llvm/SymbolTable.h | 52 +--------- include/llvm/TypeSymbolTable.h | 4 +- lib/AsmParser/llvmAsmParser.cpp.cvs | 8 +- lib/AsmParser/llvmAsmParser.y | 8 +- lib/AsmParser/llvmAsmParser.y.cvs | 8 +- lib/Bytecode/Reader/Analyzer.cpp | 10 +- lib/Bytecode/Reader/Reader.cpp | 47 +++++---- lib/Bytecode/Reader/Reader.h | 8 +- lib/Bytecode/Writer/SlotCalculator.cpp | 36 +++---- lib/Bytecode/Writer/SlotCalculator.h | 4 +- lib/Bytecode/Writer/Writer.cpp | 35 ++++--- lib/Bytecode/Writer/WriterInternals.h | 4 +- lib/Linker/LinkModules.cpp | 40 ++++---- lib/Target/CBackend/CBackend.cpp | 23 ++--- lib/Target/CBackend/Writer.cpp | 23 ++--- lib/Transforms/IPO/DeadTypeElimination.cpp | 9 +- lib/Transforms/IPO/StripSymbols.cpp | 7 +- lib/Transforms/Utils/CloneModule.cpp | 10 +- lib/VMCore/AsmWriter.cpp | 28 +++--- lib/VMCore/Function.cpp | 4 +- lib/VMCore/Module.cpp | 27 ++--- lib/VMCore/SymbolTable.cpp | 110 --------------------- lib/VMCore/SymbolTableListTraitsImpl.h | 12 +-- lib/VMCore/TypeSymbolTable.cpp | 8 +- lib/VMCore/Value.cpp | 8 +- lib/VMCore/Verifier.cpp | 12 ++- tools/bugpoint/CrashDebugger.cpp | 2 +- tools/llvm2cpp/CppWriter.cpp | 17 ++-- 31 files changed, 241 insertions(+), 344 deletions(-) diff --git a/include/llvm/Bytecode/Format.h b/include/llvm/Bytecode/Format.h index 562d8ff011a..fc896b895d0 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 7346c3b3e36..a31e7f48347 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 42214af1ac3..e5c157be954 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 : public SymbolTableListTraits { @@ -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 52a2c29ea78..6451f9c8e22 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 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 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 c9f8d3107b5..b95415377e4 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 e78dc6fe128..ebbffeb7abb 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(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 0059531518d..192b5608190 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(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 0059531518d..192b5608190 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(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 078360249c6..899a5342727 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 afff24adb65..b1e4bf639cc 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 1d2fe32af61..677c39f99f4 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 cf770c4bbc9..fdf7174b855 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 e88a88f726b..405c0edbd3a 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 58cc13a1414..37e4abfae2f 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 &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 f8c276e8581..c518c01b94f 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 &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 &Plane, unsigned StartNo); diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 9346c118240..4e298898b12 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 *DestST, const std::string &Name) { if (DestTy == SrcTy) return false; // If already equal, noop // Does the type already exist in the module? @@ -93,7 +94,8 @@ static const StructType *getST(const PATypeHolder &TH) { // are compatible. static bool RecursiveResolveTypesI(const PATypeHolder &DestTy, const PATypeHolder &SrcTy, - SymbolTable *DestST, const std::string &Name, + TypeSymbolTable *DestST, + const std::string &Name, std::vector > &Pointers) { const Type *SrcTyT = SrcTy.get(); const Type *DestTyT = DestTy.get(); @@ -164,7 +166,8 @@ static bool RecursiveResolveTypesI(const PATypeHolder &DestTy, static bool RecursiveResolveTypes(const PATypeHolder &DestTy, const PATypeHolder &SrcTy, - SymbolTable *DestST, const std::string &Name){ + TypeSymbolTable *DestST, + const std::string &Name){ std::vector > PointerTypes; return RecursiveResolveTypesI(DestTy, SrcTy, DestST, Name, PointerTypes); } @@ -174,12 +177,12 @@ static bool RecursiveResolveTypes(const PATypeHolder &DestTy, // types are named in the src module that are not named in the Dst module. // Make sure there are no type name conflicts. static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) { - SymbolTable *DestST = &Dest->getSymbolTable(); - const SymbolTable *SrcST = &Src->getSymbolTable(); + TypeSymbolTable *DestST = &Dest->getTypeSymbolTable(); + const TypeSymbolTable *SrcST = &Src->getTypeSymbolTable(); // Look for a type plane for Type's... - SymbolTable::type_const_iterator TI = SrcST->type_begin(); - SymbolTable::type_const_iterator TE = SrcST->type_end(); + TypeSymbolTable::const_iterator TI = SrcST->begin(); + TypeSymbolTable::const_iterator TE = SrcST->end(); if (TI == TE) return false; // No named types, do nothing. // Some types cannot be resolved immediately because they depend on other @@ -192,7 +195,7 @@ static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) { const Type *RHS = TI->second; // Check to see if this type name is already in the dest module... - Type *Entry = DestST->lookupType(Name); + Type *Entry = DestST->lookup(Name); if (ResolveTypes(Entry, RHS, DestST, Name)) { // They look different, save the types 'till later to resolve. @@ -208,8 +211,8 @@ static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) { // Try direct resolution by name... for (unsigned i = 0; i != DelayedTypesToResolve.size(); ++i) { const std::string &Name = DelayedTypesToResolve[i]; - Type *T1 = SrcST->lookupType(Name); - Type *T2 = DestST->lookupType(Name); + Type *T1 = SrcST->lookup(Name); + Type *T2 = DestST->lookup(Name); if (!ResolveTypes(T2, T1, DestST, Name)) { // We are making progress! DelayedTypesToResolve.erase(DelayedTypesToResolve.begin()+i); @@ -223,8 +226,8 @@ static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) { // two types: { int* } and { opaque* } for (unsigned i = 0, e = DelayedTypesToResolve.size(); i != e; ++i) { const std::string &Name = DelayedTypesToResolve[i]; - PATypeHolder T1(SrcST->lookupType(Name)); - PATypeHolder T2(DestST->lookupType(Name)); + PATypeHolder T1(SrcST->lookup(Name)); + PATypeHolder T2(DestST->lookup(Name)); if (!RecursiveResolveTypes(T2, T1, DestST, Name)) { // We are making progress! @@ -326,7 +329,7 @@ static Value *RemapOperand(const Value *In, /// through the trouble to force this back. static void ForceRenaming(GlobalValue *GV, const std::string &Name) { assert(GV->getName() != Name && "Can't force rename to self"); - SymbolTable &ST = GV->getParent()->getSymbolTable(); + SymbolTable &ST = GV->getParent()->getValueSymbolTable(); // If there is a conflict, rename the conflict. Value *ConflictVal = ST.lookup(GV->getType(), Name); @@ -427,7 +430,7 @@ static bool LinkGlobals(Module *Dest, Module *Src, std::string *Err) { // We will need a module level symbol table if the src module has a module // level symbol table... - SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable(); + TypeSymbolTable *TST = &Dest->getTypeSymbolTable(); // Loop over all of the globals in the src module, mapping them over as we go for (Module::global_iterator I = Src->global_begin(), E = Src->global_end(); @@ -444,7 +447,7 @@ static bool LinkGlobals(Module *Dest, Module *Src, DGV = dyn_cast(EGV->second); if (DGV) // If types don't agree due to opaque types, try to resolve them. - RecursiveResolveTypes(SGV->getType(), DGV->getType(),ST, ""); + RecursiveResolveTypes(SGV->getType(), DGV->getType(), TST, ""); } if (DGV && DGV->hasInternalLinkage()) @@ -591,9 +594,10 @@ static bool LinkGlobalInits(Module *Dest, const Module *Src, // static bool LinkFunctionProtos(Module *Dest, const Module *Src, std::map &ValueMap, - std::map &GlobalsByName, + std::map &GlobalsByName, std::string *Err) { - SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable(); + TypeSymbolTable *TST = &Dest->getTypeSymbolTable(); // Loop over all of the functions in the src module, mapping them over as we // go @@ -607,7 +611,7 @@ static bool LinkFunctionProtos(Module *Dest, const Module *Src, GlobalsByName.find(SF->getName()); if (EF != GlobalsByName.end()) DF = dyn_cast(EF->second); - if (DF && RecursiveResolveTypes(SF->getType(), DF->getType(), ST, "")) + if (DF && RecursiveResolveTypes(SF->getType(), DF->getType(), TST, "")) DF = 0; // FIXME: gross. } } diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index bb9f801b8af..35ee1a74e56 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -21,6 +21,7 @@ #include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h" #include "llvm/InlineAsm.h" @@ -136,7 +137,7 @@ namespace { void lowerIntrinsics(Function &F); void printModule(Module *M); - void printModuleTypes(const SymbolTable &ST); + void printModuleTypes(const TypeSymbolTable &ST); void printContainedStructs(const Type *Ty, std::set &); void printFloatingPointConstants(Function &F); void printFunctionSignature(const Function *F, bool Prototype); @@ -263,15 +264,15 @@ bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) { // Loop over the module symbol table, removing types from UT that are // already named, and removing names for types that are not used. // - SymbolTable &MST = M.getSymbolTable(); - for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end(); + TypeSymbolTable &TST = M.getTypeSymbolTable(); + for (TypeSymbolTable::iterator TI = TST.begin(), TE = TST.end(); TI != TE; ) { - SymbolTable::type_iterator I = TI++; + TypeSymbolTable::iterator I = TI++; // If this is not used, remove it from the symbol table. std::set::iterator UTI = UT.find(I->second); if (UTI == UT.end()) - MST.remove(I); + TST.remove(I); else UT.erase(UTI); // Only keep one name for this type. } @@ -1421,7 +1422,7 @@ bool CWriter::doInitialization(Module &M) { // // Loop over the symbol table, emitting all named constants... - printModuleTypes(M.getSymbolTable()); + printModuleTypes(M.getTypeSymbolTable()); // Global variable declarations... if (!M.global_empty()) { @@ -1589,7 +1590,7 @@ void CWriter::printFloatingPointConstants(Function &F) { /// printSymbolTable - Run through symbol table looking for type names. If a /// type name is found, emit its declaration... /// -void CWriter::printModuleTypes(const SymbolTable &ST) { +void CWriter::printModuleTypes(const TypeSymbolTable &TST) { Out << "/* Helper union for bitcasts */\n"; Out << "typedef union {\n"; Out << " unsigned int Int32;\n"; @@ -1599,8 +1600,8 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { Out << "} llvmBitCastUnion;\n"; // We are only interested in the type plane of the symbol table. - SymbolTable::type_const_iterator I = ST.type_begin(); - SymbolTable::type_const_iterator End = ST.type_end(); + TypeSymbolTable::const_iterator I = TST.begin(); + TypeSymbolTable::const_iterator End = TST.end(); // If there are no type names, exit early. if (I == End) return; @@ -1618,7 +1619,7 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { // Now we can print out typedefs... Out << "/* Typedefs */\n"; - for (I = ST.type_begin(); I != End; ++I) { + for (I = TST.begin(); I != End; ++I) { const Type *Ty = cast(I->second); std::string Name = "l_" + Mang->makeNameProper(I->first); Out << "typedef "; @@ -1635,7 +1636,7 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { // printed in the correct order. // Out << "/* Structure contents */\n"; - for (I = ST.type_begin(); I != End; ++I) + for (I = TST.begin(); I != End; ++I) if (const StructType *STy = dyn_cast(I->second)) // Only print out used types! printContainedStructs(STy, StructPrinted); diff --git a/lib/Target/CBackend/Writer.cpp b/lib/Target/CBackend/Writer.cpp index bb9f801b8af..35ee1a74e56 100644 --- a/lib/Target/CBackend/Writer.cpp +++ b/lib/Target/CBackend/Writer.cpp @@ -21,6 +21,7 @@ #include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h" #include "llvm/InlineAsm.h" @@ -136,7 +137,7 @@ namespace { void lowerIntrinsics(Function &F); void printModule(Module *M); - void printModuleTypes(const SymbolTable &ST); + void printModuleTypes(const TypeSymbolTable &ST); void printContainedStructs(const Type *Ty, std::set &); void printFloatingPointConstants(Function &F); void printFunctionSignature(const Function *F, bool Prototype); @@ -263,15 +264,15 @@ bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) { // Loop over the module symbol table, removing types from UT that are // already named, and removing names for types that are not used. // - SymbolTable &MST = M.getSymbolTable(); - for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end(); + TypeSymbolTable &TST = M.getTypeSymbolTable(); + for (TypeSymbolTable::iterator TI = TST.begin(), TE = TST.end(); TI != TE; ) { - SymbolTable::type_iterator I = TI++; + TypeSymbolTable::iterator I = TI++; // If this is not used, remove it from the symbol table. std::set::iterator UTI = UT.find(I->second); if (UTI == UT.end()) - MST.remove(I); + TST.remove(I); else UT.erase(UTI); // Only keep one name for this type. } @@ -1421,7 +1422,7 @@ bool CWriter::doInitialization(Module &M) { // // Loop over the symbol table, emitting all named constants... - printModuleTypes(M.getSymbolTable()); + printModuleTypes(M.getTypeSymbolTable()); // Global variable declarations... if (!M.global_empty()) { @@ -1589,7 +1590,7 @@ void CWriter::printFloatingPointConstants(Function &F) { /// printSymbolTable - Run through symbol table looking for type names. If a /// type name is found, emit its declaration... /// -void CWriter::printModuleTypes(const SymbolTable &ST) { +void CWriter::printModuleTypes(const TypeSymbolTable &TST) { Out << "/* Helper union for bitcasts */\n"; Out << "typedef union {\n"; Out << " unsigned int Int32;\n"; @@ -1599,8 +1600,8 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { Out << "} llvmBitCastUnion;\n"; // We are only interested in the type plane of the symbol table. - SymbolTable::type_const_iterator I = ST.type_begin(); - SymbolTable::type_const_iterator End = ST.type_end(); + TypeSymbolTable::const_iterator I = TST.begin(); + TypeSymbolTable::const_iterator End = TST.end(); // If there are no type names, exit early. if (I == End) return; @@ -1618,7 +1619,7 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { // Now we can print out typedefs... Out << "/* Typedefs */\n"; - for (I = ST.type_begin(); I != End; ++I) { + for (I = TST.begin(); I != End; ++I) { const Type *Ty = cast(I->second); std::string Name = "l_" + Mang->makeNameProper(I->first); Out << "typedef "; @@ -1635,7 +1636,7 @@ void CWriter::printModuleTypes(const SymbolTable &ST) { // printed in the correct order. // Out << "/* Structure contents */\n"; - for (I = ST.type_begin(); I != End; ++I) + for (I = TST.begin(); I != End; ++I) if (const StructType *STy = dyn_cast(I->second)) // Only print out used types! printContainedStructs(STy, StructPrinted); diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index 8199f746a2b..871bcff1585 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -16,7 +16,7 @@ #include "llvm/Transforms/IPO.h" #include "llvm/Analysis/FindUsedTypes.h" #include "llvm/Module.h" -#include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/DerivedTypes.h" #include "llvm/ADT/Statistic.h" using namespace llvm; @@ -69,14 +69,15 @@ static inline bool ShouldNukeSymtabEntry(const Type *Ty){ bool DTE::runOnModule(Module &M) { bool Changed = false; - SymbolTable &ST = M.getSymbolTable(); + TypeSymbolTable &ST = M.getTypeSymbolTable(); std::set UsedTypes = getAnalysis().getTypes(); // Check the symbol table for superfluous type entries... // // Grab the 'type' plane of the module symbol... - SymbolTable::type_iterator TI = ST.type_begin(); - while ( TI != ST.type_end() ) { + TypeSymbolTable::iterator TI = ST.begin(); + TypeSymbolTable::iterator TE = ST.end(); + while ( TI != TE ) { // If this entry should be unconditionally removed, or if we detect that // the type is not used, remove it. const Type *RHS = TI->second; diff --git a/lib/Transforms/IPO/StripSymbols.cpp b/lib/Transforms/IPO/StripSymbols.cpp index 75b24a72826..12cd7fe8938 100644 --- a/lib/Transforms/IPO/StripSymbols.cpp +++ b/lib/Transforms/IPO/StripSymbols.cpp @@ -29,6 +29,7 @@ #include "llvm/Module.h" #include "llvm/Pass.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" using namespace llvm; namespace { @@ -83,13 +84,11 @@ bool StripSymbols::runOnModule(Module &M) { for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { if (I->hasInternalLinkage()) I->setName(""); // Internal symbols can't participate in linkage - I->getSymbolTable().strip(); + I->getValueSymbolTable().strip(); } // Remove all names from types. - SymbolTable &SymTab = M.getSymbolTable(); - while (SymTab.type_begin() != SymTab.type_end()) - SymTab.remove(SymTab.type_begin()); + M.getTypeSymbolTable().strip(); } // Strip debug info in the module if it exists. To do this, we remove diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp index 229debf1980..696d9d1b051 100644 --- a/lib/Transforms/Utils/CloneModule.cpp +++ b/lib/Transforms/Utils/CloneModule.cpp @@ -16,6 +16,7 @@ #include "llvm/Module.h" #include "llvm/DerivedTypes.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/Constant.h" #include "ValueMapper.h" using namespace llvm; @@ -42,11 +43,10 @@ Module *llvm::CloneModule(const Module *M, std::map &Value New->setModuleInlineAsm(M->getModuleInlineAsm()); // Copy all of the type symbol table entries over. - const SymbolTable &SymTab = M->getSymbolTable(); - SymbolTable::type_const_iterator TypeI = SymTab.type_begin(); - SymbolTable::type_const_iterator TypeE = SymTab.type_end(); - for (; TypeI != TypeE; ++TypeI) - New->addTypeName(TypeI->first, TypeI->second); + const TypeSymbolTable &TST = M->getTypeSymbolTable(); + for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); + TI != TE; ++TI) + New->addTypeName(TI->first, TI->second); // Copy all of the dependent libraries over. for (Module::lib_iterator I = M->lib_begin(), E = M->lib_end(); I != E; ++I) diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index f5b24844295..64cac8c518c 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -25,6 +25,7 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/CFG.h" @@ -216,9 +217,9 @@ static std::string getLLVMName(const std::string &Name, static void fillTypeNameTable(const Module *M, std::map &TypeNames) { if (!M) return; - const SymbolTable &ST = M->getSymbolTable(); - SymbolTable::type_const_iterator TI = ST.type_begin(); - for (; TI != ST.type_end(); ++TI) { + const TypeSymbolTable &ST = M->getTypeSymbolTable(); + TypeSymbolTable::const_iterator TI = ST.begin(); + for (; TI != ST.end(); ++TI) { // As a heuristic, don't insert pointer to primitive types, because // they are used too often to have a single useful name. // @@ -666,7 +667,8 @@ public: private: void printModule(const Module *M); - void printSymbolTable(const SymbolTable &ST); + void printTypeSymbolTable(const TypeSymbolTable &ST); + void printValueSymbolTable(const SymbolTable &ST); void printConstant(const Constant *CPV); void printGlobal(const GlobalVariable *GV); void printFunction(const Function *F); @@ -818,7 +820,8 @@ void AssemblyWriter::printModule(const Module *M) { } // Loop over the symbol table, emitting all named constants. - printSymbolTable(M->getSymbolTable()); + printTypeSymbolTable(M->getTypeSymbolTable()); + printValueSymbolTable(M->getValueSymbolTable()); for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) @@ -873,14 +876,10 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) { Out << "\n"; } - -// printSymbolTable - Run through symbol table looking for constants -// and types. Emit their declarations. -void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { - +void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) { // Print the types. - for (SymbolTable::type_const_iterator TI = ST.type_begin(); - TI != ST.type_end(); ++TI) { + for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end(); + TI != TE; ++TI) { Out << "\t" << getLLVMName(TI->first) << " = type "; // Make sure we print out at least one level of the type structure, so @@ -888,6 +887,11 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { // printTypeAtLeastOneLevel(TI->second) << "\n"; } +} + +// printSymbolTable - Run through symbol table looking for constants +// and types. Emit their declarations. +void AssemblyWriter::printValueSymbolTable(const SymbolTable &ST) { // Print the constants, in type plane order. for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index e8bbd865906..4bc93dbb2cc 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -144,8 +144,8 @@ void Function::eraseFromParent() { /// required before printing out to a textual form, to ensure that there is no /// ambiguity when parsing. void Function::renameLocalSymbols() { - SymbolTable &LST = getSymbolTable(); // Local Symtab - SymbolTable &GST = getParent()->getSymbolTable(); // Global Symtab + SymbolTable &LST = getValueSymbolTable(); // Local Symtab + SymbolTable &GST = getParent()->getValueSymbolTable(); // Global Symtab for (SymbolTable::plane_iterator LPI = LST.plane_begin(), E = LST.plane_end(); LPI != E; ++LPI) diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp index 6897a4f92d2..98faff1d332 100644 --- a/lib/VMCore/Module.cpp +++ b/lib/VMCore/Module.cpp @@ -19,6 +19,7 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/Support/LeakDetector.h" #include "SymbolTableListTraitsImpl.h" +#include "llvm/TypeSymbolTable.h" #include #include #include @@ -68,7 +69,8 @@ Module::Module(const std::string &MID) FunctionList.setParent(this); GlobalList.setItemParent(this); GlobalList.setParent(this); - SymTab = new SymbolTable(); + ValSymTab = new SymbolTable(); + TypeSymTab = new TypeSymbolTable(); } Module::~Module() { @@ -78,7 +80,8 @@ Module::~Module() { FunctionList.clear(); FunctionList.setParent(0); LibraryList.clear(); - delete SymTab; + delete ValSymTab; + delete TypeSymTab; } // Module::dump() - Allow printing from debugger @@ -156,7 +159,7 @@ void Module::setPointerSize(PointerSize PS) { // Function *Module::getOrInsertFunction(const std::string &Name, const FunctionType *Ty) { - SymbolTable &SymTab = getSymbolTable(); + SymbolTable &SymTab = getValueSymbolTable(); // See if we have a definitions for the specified function already... if (Value *V = SymTab.lookup(PointerType::get(Ty), Name)) { @@ -194,7 +197,7 @@ Function *Module::getOrInsertFunction(const std::string &Name, // If it does not exist, return null. // Function *Module::getFunction(const std::string &Name, const FunctionType *Ty) { - SymbolTable &SymTab = getSymbolTable(); + SymbolTable &SymTab = getValueSymbolTable(); return cast_or_null(SymTab.lookup(PointerType::get(Ty), Name)); } @@ -275,7 +278,7 @@ Function *Module::getNamedFunction(const std::string &Name) const { /// GlobalVariable *Module::getGlobalVariable(const std::string &Name, const Type *Ty, bool AllowInternal) { - if (Value *V = getSymbolTable().lookup(PointerType::get(Ty), Name)) { + if (Value *V = getValueSymbolTable().lookup(PointerType::get(Ty), Name)) { GlobalVariable *Result = cast(V); if (AllowInternal || !Result->hasInternalLinkage()) return Result; @@ -309,9 +312,9 @@ GlobalVariable *Module::getNamedGlobal(const std::string &Name) const { // table is not modified. // bool Module::addTypeName(const std::string &Name, const Type *Ty) { - SymbolTable &ST = getSymbolTable(); + TypeSymbolTable &ST = getTypeSymbolTable(); - if (ST.lookupType(Name)) return true; // Already in symtab... + if (ST.lookup(Name)) return true; // Already in symtab... // Not in symbol table? Set the name with the Symtab as an argument so the // type knows what to update... @@ -323,18 +326,18 @@ bool Module::addTypeName(const std::string &Name, const Type *Ty) { /// getTypeByName - Return the type with the specified name in this module, or /// null if there is none by that name. const Type *Module::getTypeByName(const std::string &Name) const { - const SymbolTable &ST = getSymbolTable(); - return cast_or_null(ST.lookupType(Name)); + const TypeSymbolTable &ST = getTypeSymbolTable(); + return cast_or_null(ST.lookup(Name)); } // getTypeName - If there is at least one entry in the symbol table for the // specified type, return it. // std::string Module::getTypeName(const Type *Ty) const { - const SymbolTable &ST = getSymbolTable(); + const TypeSymbolTable &ST = getTypeSymbolTable(); - SymbolTable::type_const_iterator TI = ST.type_begin(); - SymbolTable::type_const_iterator TE = ST.type_end(); + TypeSymbolTable::const_iterator TI = ST.begin(); + TypeSymbolTable::const_iterator TE = ST.end(); if ( TI == TE ) return ""; // No names for types while (TI != TE && TI->second != Ty) diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp index 7ea3377ab91..c20366cf356 100644 --- a/lib/VMCore/SymbolTable.cpp +++ b/lib/VMCore/SymbolTable.cpp @@ -24,12 +24,6 @@ using namespace llvm; #define DEBUG_ABSTYPE 0 SymbolTable::~SymbolTable() { - // Drop all abstract type references in the type plane... - for (type_iterator TI = tmap.begin(), TE = tmap.end(); TI != TE; ++TI) { - if (TI->second->isAbstract()) // If abstract, drop the reference... - cast(TI->second)->removeAbstractTypeUser(this); - } - // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the // planes that could still have entries! @@ -82,14 +76,6 @@ Value *SymbolTable::lookup(const Type *Ty, const std::string &Name) const { } -// lookup a type by name - returns null on failure -Type* SymbolTable::lookupType(const std::string& Name) const { - type_const_iterator TI = tmap.find(Name); - if (TI != tmap.end()) - return const_cast(TI->second); - return 0; -} - /// changeName - Given a value with a non-empty name, remove its existing entry /// from the symbol table and insert a new one for Name. This is equivalent to /// doing "remove(V), V->Name = Name, insert(V)", but is faster, and will not @@ -158,32 +144,6 @@ void SymbolTable::remove(Value *N) { } } -// remove - Remove a type from the symbol table... -Type* SymbolTable::remove(type_iterator Entry) { - assert(Entry != tmap.end() && "Invalid entry to remove!"); - - const Type* Result = Entry->second; - -#if DEBUG_SYMBOL_TABLE - dump(); - DOUT << " Removing type: " << Entry->first << "\n"; -#endif - - tmap.erase(Entry); - - // If we are removing an abstract type, remove the symbol table from it's use - // list... - if (Result->isAbstract()) { -#if DEBUG_ABSTYPE - DOUT << "Removing abstract type from symtab" - << Result->getDescription() << "\n"; -#endif - cast(Result)->removeAbstractTypeUser(this); - } - - return const_cast(Result); -} - // insertEntry - Insert a value into the symbol table with the specified name. void SymbolTable::insertEntry(const std::string &Name, const Type *VTy, @@ -230,34 +190,6 @@ void SymbolTable::insertEntry(const std::string &Name, const Type *VTy, } -// insertEntry - Insert a type into the symbol table with the specified -// name... -// -void SymbolTable::insert(const std::string& Name, const Type* T) { - assert(T && "Can't insert null type into symbol table!"); - - // Check to see if there is a naming conflict. If so, rename this type! - std::string UniqueName = Name; - if (lookupType(Name)) - UniqueName = getUniqueName(T, Name); - -#if DEBUG_SYMBOL_TABLE - dump(); - DOUT << " Inserting type: " << UniqueName << ": " - << T->getDescription() << "\n"; -#endif - - // Insert the tmap entry - tmap.insert(make_pair(UniqueName, T)); - - // If we are adding an abstract type, add the symbol table to it's use list. - if (T->isAbstract()) { - cast(T)->addAbstractTypeUser(this); -#if DEBUG_ABSTYPE - DOUT << "Added abstract type to ST: " << T->getDescription() << "\n"; -#endif - } -} // Strip the symbol table of its names. bool SymbolTable::strip() { @@ -278,11 +210,6 @@ bool SymbolTable::strip() { } } - for (type_iterator TI = tmap.begin(); TI != tmap.end(); ) { - remove(TI++); - RemovedSymbol = true; - } - return RemovedSymbol; } @@ -375,28 +302,6 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, // Remove the plane that is no longer used pmap.erase(PI); } - - // Loop over all of the types in the symbol table, replacing any references - // to OldType with references to NewType. Note that there may be multiple - // occurrences, and although we only need to remove one at a time, it's - // faster to remove them all in one pass. - // - for (type_iterator I = type_begin(), E = type_end(); I != E; ++I) { - if (I->second == (Type*)OldType) { // FIXME when Types aren't const. -#if DEBUG_ABSTYPE - DOUT << "Removing type " << OldType->getDescription() << "\n"; -#endif - OldType->removeAbstractTypeUser(this); - - I->second = (Type*)NewType; // TODO FIXME when types aren't const - if (NewType->isAbstract()) { -#if DEBUG_ABSTYPE - DOUT << "Added type " << NewType->getDescription() << "\n"; -#endif - cast(NewType)->addAbstractTypeUser(this); - } - } - } } @@ -408,13 +313,6 @@ void SymbolTable::typeBecameConcrete(const DerivedType *AbsTy) { // plane is a use of the abstract type which must be dropped. if (PI != pmap.end()) AbsTy->removeAbstractTypeUser(this); - - // Loop over all of the types in the symbol table, dropping any abstract - // type user entries for AbsTy which occur because there are names for the - // type. - for (type_iterator TI = type_begin(), TE = type_end(); TI != TE; ++TI) - if (TI->second == (Type*)AbsTy) // FIXME when Types aren't const. - AbsTy->removeAbstractTypeUser(this); } static void DumpVal(const std::pair &V) { @@ -430,17 +328,9 @@ static void DumpPlane(const std::pair& T ) { - DOUT << " '" << T.first << "' = "; - T.second->dump(); - DOUT << "\n"; -} - void SymbolTable::dump() const { DOUT << "Symbol table dump:\n Plane:"; for_each(pmap.begin(), pmap.end(), DumpPlane); - DOUT << " Types: "; - for_each(tmap.begin(), tmap.end(), DumpTypes); } // vim: sw=2 ai diff --git a/lib/VMCore/SymbolTableListTraitsImpl.h b/lib/VMCore/SymbolTableListTraitsImpl.h index 6d70401c89f..81849dd0319 100644 --- a/lib/VMCore/SymbolTableListTraitsImpl.h +++ b/lib/VMCore/SymbolTableListTraitsImpl.h @@ -29,7 +29,7 @@ void SymbolTableListTraits // Remove all of the items from the old symtab.. if (SymTabObject && !List.empty()) { - SymbolTable &SymTab = SymTabObject->getSymbolTable(); + SymbolTable &SymTab = SymTabObject->getValueSymbolTable(); for (typename iplist::iterator I = List.begin(); I != List.end(); ++I) if (I->hasName()) SymTab.remove(I); @@ -39,7 +39,7 @@ void SymbolTableListTraits // Add all of the items to the new symtab... if (SymTabObject && !List.empty()) { - SymbolTable &SymTab = SymTabObject->getSymbolTable(); + SymbolTable &SymTab = SymTabObject->getValueSymbolTable(); for (typename iplist::iterator I = List.begin(); I != List.end(); ++I) if (I->hasName()) SymTab.insert(I); @@ -53,7 +53,7 @@ void SymbolTableListTraits assert(V->getParent() == 0 && "Value already in a container!!"); V->setParent(ItemParent); if (V->hasName() && SymTabObject) - SymTabObject->getSymbolTable().insert(V); + SymTabObject->getValueSymbolTable().insert(V); } template ::removeNodeFromList(ValueSubClass *V) { V->setParent(0); if (V->hasName() && SymTabObject) - SymTabObject->getSymbolTable().remove(V); + SymTabObject->getValueSymbolTable().remove(V); } template ValueSubClass &V = *first; bool HasName = V.hasName(); if (OldSTO && HasName) - OldSTO->getSymbolTable().remove(&V); + OldSTO->getValueSymbolTable().remove(&V); V.setParent(NewIP); if (NewSTO && HasName) - NewSTO->getSymbolTable().insert(&V); + NewSTO->getValueSymbolTable().insert(&V); } } else { // Just transferring between blocks in the same function, simply update the diff --git a/lib/VMCore/TypeSymbolTable.cpp b/lib/VMCore/TypeSymbolTable.cpp index cfd8cbf9352..ac89bb66451 100644 --- a/lib/VMCore/TypeSymbolTable.cpp +++ b/lib/VMCore/TypeSymbolTable.cpp @@ -48,10 +48,10 @@ Type* TypeSymbolTable::lookup(const std::string& Name) const { } // Erase a specific type from the symbol table -bool TypeSymbolTable::erase(Type *N) { +bool TypeSymbolTable::remove(Type *N) { for (iterator TI = tmap.begin(), TE = tmap.end(); TI != TE; ++TI) { if (TI->second == N) { - this->erase(TI); + this->remove(TI); return true; } } @@ -59,7 +59,7 @@ bool TypeSymbolTable::erase(Type *N) { } // remove - Remove a type from the symbol table... -Type* TypeSymbolTable::erase(iterator Entry) { +Type* TypeSymbolTable::remove(iterator Entry) { assert(Entry != tmap.end() && "Invalid entry to remove!"); const Type* Result = Entry->second; @@ -115,7 +115,7 @@ void TypeSymbolTable::insert(const std::string& Name, const Type* T) { bool TypeSymbolTable::strip() { bool RemovedSymbol = false; for (iterator TI = tmap.begin(); TI != tmap.end(); ) { - erase(TI++); + remove(TI++); RemovedSymbol = true; } diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index 0d9dc07fa07..94c03b834ad 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -101,13 +101,13 @@ void Value::setName(const std::string &name) { if (Instruction *I = dyn_cast(this)) { if (BasicBlock *P = I->getParent()) if (Function *PP = P->getParent()) - ST = &PP->getSymbolTable(); + ST = &PP->getValueSymbolTable(); } else if (BasicBlock *BB = dyn_cast(this)) { - if (Function *P = BB->getParent()) ST = &P->getSymbolTable(); + if (Function *P = BB->getParent()) ST = &P->getValueSymbolTable(); } else if (GlobalValue *GV = dyn_cast(this)) { - if (Module *P = GV->getParent()) ST = &P->getSymbolTable(); + if (Module *P = GV->getParent()) ST = &P->getValueSymbolTable(); } else if (Argument *A = dyn_cast(this)) { - if (Function *P = A->getParent()) ST = &P->getSymbolTable(); + if (Function *P = A->getParent()) ST = &P->getValueSymbolTable(); } else { assert(isa(this) && "Unknown value type!"); return; // no name is setable for this. diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 719c6f2f5f0..e03bb6d1d9a 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -99,7 +99,8 @@ namespace { // Anonymous namespace for class bool doInitialization(Module &M) { Mod = &M; - verifySymbolTable(M.getSymbolTable()); + verifyTypeSymbolTable(M.getTypeSymbolTable()); + verifyValueSymbolTable(M.getValueSymbolTable()); // If this is a real pass, in a pass manager, we must abort before // returning back to the pass manager, or else the pass manager may try to @@ -173,7 +174,8 @@ namespace { // Anonymous namespace for class // Verification methods... - void verifySymbolTable(SymbolTable &ST); + void verifyTypeSymbolTable(TypeSymbolTable &ST); + void verifyValueSymbolTable(SymbolTable &ST); void visitGlobalValue(GlobalValue &GV); void visitGlobalVariable(GlobalVariable &GV); void visitFunction(Function &F); @@ -301,10 +303,12 @@ void Verifier::visitGlobalVariable(GlobalVariable &GV) { visitGlobalValue(GV); } +void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) { +} // verifySymbolTable - Verify that a function or module symbol table is ok // -void Verifier::verifySymbolTable(SymbolTable &ST) { +void Verifier::verifyValueSymbolTable(SymbolTable &ST) { // Loop over all of the values in all type planes in the symbol table. for (SymbolTable::plane_const_iterator PI = ST.plane_begin(), @@ -372,7 +376,7 @@ void Verifier::visitFunction(Function &F) { Assert1(F.getName().substr(0, 5) != "llvm.", "llvm intrinsics cannot be defined!", &F); - verifySymbolTable(F.getSymbolTable()); + verifyValueSymbolTable(F.getValueSymbolTable()); // Check the entry node BasicBlock *Entry = &F.getEntryBlock(); diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp index 73b49be212c..23aad53adf0 100644 --- a/tools/bugpoint/CrashDebugger.cpp +++ b/tools/bugpoint/CrashDebugger.cpp @@ -337,7 +337,7 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector &BBs) { // module, and that they don't include any deleted blocks. BBs.clear(); for (unsigned i = 0, e = BlockInfo.size(); i != e; ++i) { - SymbolTable &ST = BlockInfo[i].first->getSymbolTable(); + SymbolTable &ST = BlockInfo[i].first->getValueSymbolTable(); SymbolTable::plane_iterator PI = ST.find(Type::LabelTy); if (PI != ST.plane_end() && PI->second.count(BlockInfo[i].second)) BBs.push_back(cast(PI->second[BlockInfo[i].second])); diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp index d2d2d849f5f..b0eb1209e77 100644 --- a/tools/llvm2cpp/CppWriter.cpp +++ b/tools/llvm2cpp/CppWriter.cpp @@ -20,6 +20,7 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" +#include "llvm/TypeSymbolTable.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/CommandLine.h" @@ -189,10 +190,10 @@ getTypePrefix(const Type* Ty ) { // Mode::getTypeName function which will return an empty string, not a null // pointer if the name is not found. inline const std::string* -findTypeName(const SymbolTable& ST, const Type* Ty) +findTypeName(const TypeSymbolTable& ST, const Type* Ty) { - SymbolTable::type_const_iterator TI = ST.type_begin(); - SymbolTable::type_const_iterator TE = ST.type_end(); + TypeSymbolTable::const_iterator TI = ST.begin(); + TypeSymbolTable::const_iterator TE = ST.end(); for (;TI != TE; ++TI) if (TI->second == Ty) return &(TI->first); @@ -348,7 +349,7 @@ CppWriter::getCppName(const Type* Ty) } // See if the type has a name in the symboltable and build accordingly - const std::string* tName = findTypeName(TheModule->getSymbolTable(), Ty); + const std::string* tName = findTypeName(TheModule->getTypeSymbolTable(), Ty); std::string name; if (tName) name = std::string(prefix) + *tName; @@ -539,7 +540,7 @@ CppWriter::printTypeInternal(const Type* Ty) { // If the type had a name, make sure we recreate it. const std::string* progTypeName = - findTypeName(TheModule->getSymbolTable(),Ty); + findTypeName(TheModule->getTypeSymbolTable(),Ty); if (progTypeName) Out << "mod->addTypeName(\"" << *progTypeName << "\", " << typeName << ");"; @@ -596,9 +597,9 @@ void CppWriter::printTypes(const Module* M) { // Walk the symbol table and print out all its types - const SymbolTable& symtab = M->getSymbolTable(); - for (SymbolTable::type_const_iterator TI = symtab.type_begin(), - TE = symtab.type_end(); TI != TE; ++TI) { + const TypeSymbolTable& symtab = M->getTypeSymbolTable(); + for (TypeSymbolTable::const_iterator TI = symtab.begin(), TE = symtab.end(); + TI != TE; ++TI) { // For primitive types and types already defined, just add a name TypeMap::const_iterator TNI = TypeNames.find(TI->second);