From cd84396b58422048106540936982aa3d26b4d385 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 3 Aug 2004 23:41:28 +0000 Subject: [PATCH] Do not do a linear std::find to reconstruct information we had, but later threw away. This speeds up by .bc reader by 30% in a profile build on 252.eon. llvm-svn: 15450 --- llvm/lib/Bytecode/Reader/Reader.cpp | 27 ++++++++++----------------- llvm/lib/Bytecode/Reader/Reader.h | 26 ++++++++++++++------------ 2 files changed, 24 insertions(+), 29 deletions(-) diff --git a/llvm/lib/Bytecode/Reader/Reader.cpp b/llvm/lib/Bytecode/Reader/Reader.cpp index 3ebd7c88f4d3..13fecc53dfe0 100644 --- a/llvm/lib/Bytecode/Reader/Reader.cpp +++ b/llvm/lib/Bytecode/Reader/Reader.cpp @@ -26,7 +26,6 @@ #include "llvm/Support/GetElementPtrTypeIterator.h" #include "Support/StringExtras.h" #include - using namespace llvm; namespace { @@ -294,7 +293,7 @@ const Type *BytecodeReader::getType(unsigned ID) { if (!CompactionTypes.empty()) { if (ID >= CompactionTypes.size()) error("Type ID out of range for compaction table!"); - return CompactionTypes[ID]; + return CompactionTypes[ID].first; } // Is it a module-level type? @@ -337,12 +336,11 @@ unsigned BytecodeReader::getTypeSlot(const Type *Ty) { // Scan the compaction table for the type if needed. if (!CompactionTypes.empty()) { - std::vector::const_iterator I = - find(CompactionTypes.begin(), CompactionTypes.end(), Ty); + for (unsigned i = 0, e = CompactionTypes.size(); i != e; ++i) + if (CompactionTypes[i].first == Ty) + return Type::FirstDerivedTyID + i; - if (I == CompactionTypes.end()) - error("Couldn't find type specified in compaction table!"); - return Type::FirstDerivedTyID + (&*I - &CompactionTypes[0]); + error("Couldn't find type specified in compaction table!"); } // Check the function level types first... @@ -403,15 +401,10 @@ Value * BytecodeReader::getValue(unsigned type, unsigned oNum, bool Create) { // By default, the global type id is the type id passed in unsigned GlobalTyID = type; - // If the type plane was compactified, figure out the global type ID - // by adding the derived type ids and the distance. - if (!CompactionTypes.empty() && type >= Type::FirstDerivedTyID) { - const Type *Ty = CompactionTypes[type-Type::FirstDerivedTyID]; - TypeListTy::iterator I = - find(ModuleTypes.begin(), ModuleTypes.end(), Ty); - assert(I != ModuleTypes.end()); - GlobalTyID = Type::FirstDerivedTyID + (&*I - &ModuleTypes[0]); - } + // If the type plane was compactified, figure out the global type ID by + // adding the derived type ids and the distance. + if (!CompactionTypes.empty() && type >= Type::FirstDerivedTyID) + GlobalTyID = CompactionTypes[type-Type::FirstDerivedTyID].second; if (hasImplicitNull(GlobalTyID)) { if (Num == 0) @@ -1053,7 +1046,7 @@ void BytecodeReader::ParseCompactionTypes(unsigned NumEntries) { if (read_typeid(TypeSlot)) error("Invalid type in compaction table: type type"); const Type *Typ = getGlobalTableType(TypeSlot); - CompactionTypes.push_back(Typ); + CompactionTypes.push_back(std::make_pair(Typ, TypeSlot)); if (Handler) Handler->handleCompactionTableType(i, TypeSlot, Typ); } } diff --git a/llvm/lib/Bytecode/Reader/Reader.h b/llvm/lib/Bytecode/Reader/Reader.h index 97a82ca6e6e4..90853a927d27 100644 --- a/llvm/lib/Bytecode/Reader/Reader.h +++ b/llvm/lib/Bytecode/Reader/Reader.h @@ -193,7 +193,7 @@ protected: void ParseFunctionBody(Function* Func); /// @brief Parse the type list portion of a compaction table - void BytecodeReader::ParseCompactionTypes( unsigned NumEntries ); + void ParseCompactionTypes(unsigned NumEntries); /// @brief Parse a compaction table void ParseCompactionTable(); @@ -243,12 +243,13 @@ private: BufPtr At; ///< Where we're currently parsing at /// Information about the module, extracted from the bytecode revision number. + /// unsigned char RevisionNum; // The rev # itself /// Flags to distinguish LLVM 1.0 & 1.1 bytecode formats (revision #0) - /// Revision #0 had an explicit alignment of data only for the ModuleGlobalInfo - /// block. This was fixed to be like all other blocks in 1.2 + /// Revision #0 had an explicit alignment of data only for the + /// ModuleGlobalInfo block. This was fixed to be like all other blocks in 1.2 bool hasInconsistentModuleGlobalInfo; /// Revision #0 also explicitly encoded zero values for primitive types like @@ -270,12 +271,12 @@ private: bool hasTypeDerivedFromValue; /// LLVM 1.2 and earlier encoded block headers as two uint (8 bytes), one for - /// the size and one for the type. This is a bit wasteful, especially for small - /// files where the 8 bytes per block is a large fraction of the total block - /// size. In LLVM 1.3, the block type and length are encoded into a single - /// uint32 by restricting the number of block types (limit 31) and the maximum - /// size of a block (limit 2^27-1=134,217,727). Note that the module block - /// still uses the 8-byte format so the maximum size of a file can be + /// the size and one for the type. This is a bit wasteful, especially for + /// small files where the 8 bytes per block is a large fraction of the total + /// block size. In LLVM 1.3, the block type and length are encoded into a + /// single uint32 by restricting the number of block types (limit 31) and the + /// maximum size of a block (limit 2^27-1=134,217,727). Note that the module + /// block still uses the 8-byte format so the maximum size of a file can be /// 2^32-1 bytes long. bool hasLongBlockHeaders; @@ -295,9 +296,10 @@ private: /// LLVM 1.2 and earlier encoded the file version as part of the module block /// but this information may be needed to - /// CompactionTable - If a compaction table is active in the current function, - /// this is the mapping that it contains. - std::vector CompactionTypes; + /// CompactionTypes - If a compaction table is active in the current function, + /// this is the mapping that it contains. We keep track of what resolved type + /// it is as well as what global type entry it is. + std::vector > CompactionTypes; /// @brief If a compaction table is active in the current function, /// this is the mapping that it contains.