From cf3e67f70a558792e2764bc107b245f50868288f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 18 Jan 2004 21:08:52 +0000 Subject: [PATCH] Add support for writing bytecode files with compactiontables for bytecode files. This shrinks the bytecode file for 176.gcc by about 200K (10%), and 254.gap by about 167K, a 25% reduction. There is still a lot of room for improvement in the encoding of the compaction table. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10915 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Bytecode/Writer/ConstantWriter.cpp | 8 --- lib/Bytecode/Writer/InstructionWriter.cpp | 7 +- lib/Bytecode/Writer/Writer.cpp | 87 +++++++++++++++++------ lib/Bytecode/Writer/WriterInternals.h | 7 +- 4 files changed, 73 insertions(+), 36 deletions(-) diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp index 088a5b787bc..2b75b9b4a79 100644 --- a/lib/Bytecode/Writer/ConstantWriter.cpp +++ b/lib/Bytecode/Writer/ConstantWriter.cpp @@ -26,11 +26,6 @@ ConstantBytes("bytecodewriter", "Bytes of constants"); static Statistic<> NumConstants("bytecodewriter", "Number of constants"); -static Statistic<> -NumStrConstants("bytecodewriter", "Number of string constants"); -static Statistic<> -NumStrBytes("bytecodewriter", "Number of string constant bytes"); - void BytecodeWriter::outputType(const Type *T) { TypeBytes -= Out.size(); @@ -231,7 +226,6 @@ void BytecodeWriter::outputConstantStrings() { output_vbr(Type::VoidTyID, Out); ConstantBytes -= Out.size(); - NumStrBytes -= Out.size();; // Emit all of the strings. for (I = Table.string_begin(); I != E; ++I) { @@ -246,8 +240,6 @@ void BytecodeWriter::outputConstantStrings() { output_data(Val.c_str(), Val.c_str()+Val.size(), Out); ++NumConstants; - ++NumStrConstants; } ConstantBytes += Out.size(); - NumStrBytes += Out.size();; } diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp index 0bf555d8b55..b93a812d52c 100644 --- a/lib/Bytecode/Writer/InstructionWriter.cpp +++ b/lib/Bytecode/Writer/InstructionWriter.cpp @@ -202,7 +202,7 @@ static void outputInstructionFormat3(const Instruction *I, unsigned Opcode, output(Bits, Out); } -void BytecodeWriter::processInstruction(const Instruction &I) { +void BytecodeWriter::outputInstruction(const Instruction &I) { assert(I.getOpcode() < 62 && "Opcode too big???"); unsigned Opcode = I.getOpcode(); @@ -216,9 +216,8 @@ void BytecodeWriter::processInstruction(const Instruction &I) { int MaxOpSlot = 0; int Slots[3]; Slots[0] = (1 << 12)-1; // Marker to signify 0 operands - for (unsigned i = 0; i < NumOperands; ++i) { - const Value *Def = I.getOperand(i); - int slot = Table.getSlot(Def); + for (unsigned i = 0; i != NumOperands; ++i) { + int slot = Table.getSlot(I.getOperand(i)); assert(slot != -1 && "Broken bytecode!"); if (slot > MaxOpSlot) MaxOpSlot = slot; if (i < 3) Slots[i] = slot; diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp index ff9e8a989b1..2fcc863c3c6 100644 --- a/lib/Bytecode/Writer/Writer.cpp +++ b/lib/Bytecode/Writer/Writer.cpp @@ -41,8 +41,6 @@ static Statistic<> BytesWritten("bytecodewriter", "Number of bytecode bytes written"); static Statistic<> ConstantTotalBytes("bytecodewriter", "Bytes of constants total"); -static Statistic<> -FunctionConstantTotalBytes("bytecodewriter", "Bytes of function constants total"); static Statistic<> ConstantPlaneHeaderBytes("bytecodewriter", "Constant plane header bytes"); static Statistic<> @@ -51,6 +49,8 @@ static Statistic<> SymTabBytes("bytecodewriter", "Bytes of symbol table"); static Statistic<> ModuleInfoBytes("bytecodewriter", "Bytes of module info"); +static Statistic<> +CompactionTableBytes("bytecodewriter", "Bytes of compaction tables"); BytecodeWriter::BytecodeWriter(std::deque &o, const Module *M) : Out(o), Table(M, true) { @@ -168,7 +168,6 @@ static inline bool hasNullValue(unsigned TyID) { void BytecodeWriter::outputConstants(bool isFunction) { ConstantTotalBytes -= Out.size(); - if (isFunction) FunctionConstantTotalBytes -= Out.size(); BytecodeBlock CPool(BytecodeFormat::ConstantPool, Out, true /* Elide block if empty */); @@ -206,7 +205,6 @@ void BytecodeWriter::outputConstants(bool isFunction) { } } ConstantTotalBytes += Out.size(); - if (isFunction) FunctionConstantTotalBytes += Out.size(); } static unsigned getEncodedLinkage(const GlobalValue *GV) { @@ -257,32 +255,75 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) { ModuleInfoBytes += Out.size(); } +void BytecodeWriter::outputInstructions(const Function *F) { + BytecodeBlock ILBlock(BytecodeFormat::InstructionList, Out); + InstructionBytes -= Out.size(); + for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) + for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) + outputInstruction(*I); + InstructionBytes += Out.size(); +} + void BytecodeWriter::outputFunction(const Function *F) { BytecodeBlock FunctionBlock(BytecodeFormat::Function, Out); output_vbr(getEncodedLinkage(F), Out); - // Only output the constant pool and other goodies if needed... - if (!F->isExternal()) { - // Get slot information about the function... - Table.incorporateFunction(F); + // If this is an external function, there is nothing else to emit! + if (F->isExternal()) return; - // Output information about the constants in the function... - outputConstants(true); + // Get slot information about the function... + Table.incorporateFunction(F); - { // Output all of the instructions in the body of the function - BytecodeBlock ILBlock(BytecodeFormat::InstructionList, Out); - InstructionBytes -= Out.size(); - for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E;++BB) - for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I) - processInstruction(*I); - InstructionBytes += Out.size(); - } - - // If needed, output the symbol table for the function... - outputSymbolTable(F->getSymbolTable()); - - Table.purgeFunction(); + if (Table.getCompactionTable().empty()) { + // Output information about the constants in the function if the compaction + // table is not being used. + outputConstants(true); + } else { + // Otherwise, emit the compaction table. + outputCompactionTable(); } + + // Output all of the instructions in the body of the function + outputInstructions(F); + + // If needed, output the symbol table for the function... + outputSymbolTable(F->getSymbolTable()); + + Table.purgeFunction(); +} + +void BytecodeWriter::outputCompactionTablePlane(unsigned PlaneNo, + const std::vector &Plane, + unsigned StartNo) { + unsigned End = Table.getModuleLevel(PlaneNo); + if (StartNo == End || End == 0) return; // Nothing to emit + assert(StartNo < End && "Cannot emit negative range!"); + assert(StartNo < Plane.size() && End <= Plane.size()); + + output_vbr(unsigned(End-StartNo), Out); // Output the number of things. + output_vbr(PlaneNo, Out); // Emit the type plane this is + + // Do not emit the null initializer! + if (PlaneNo != Type::TypeTyID) ++StartNo; + + for (unsigned i = StartNo; i != End; ++i) + output_vbr(Table.getGlobalSlot(Plane[i]), Out); +} + +void BytecodeWriter::outputCompactionTable() { + CompactionTableBytes -= Out.size(); + BytecodeBlock CTB(BytecodeFormat::CompactionTable, Out, true/*ElideIfEmpty*/); + const std::vector > &CT =Table.getCompactionTable(); + + // First thing is first, emit the type compaction table if there is one. + if (CT.size() > Type::TypeTyID) + outputCompactionTablePlane(Type::TypeTyID, CT[Type::TypeTyID], + Type::FirstDerivedTyID); + + for (unsigned i = 0, e = CT.size(); i != e; ++i) + if (i != Type::TypeTyID) + outputCompactionTablePlane(i, CT[i], 0); + CompactionTableBytes += Out.size(); } void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) { diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h index 15dbeffc869..1e47f5ef99e 100644 --- a/lib/Bytecode/Writer/WriterInternals.h +++ b/lib/Bytecode/Writer/WriterInternals.h @@ -37,7 +37,12 @@ private: void outputConstants(bool isFunction); void outputConstantStrings(); void outputFunction(const Function *F); - void processInstruction(const Instruction &I); + void outputCompactionTable(); + void outputCompactionTablePlane(unsigned PlaneNo, + const std::vector &TypePlane, + unsigned StartNo); + void outputInstructions(const Function *F); + void outputInstruction(const Instruction &I); void outputModuleInfoBlock(const Module *C); void outputSymbolTable(const SymbolTable &ST); -- 2.34.1