Emit & read more compressed bytecode by not emitting a bytecodeblock for

each basic block in function.  Instead, just emit a stream of instructions,
chopping up basic blocks based on when we find terminator instructions.  This
saves a fairly substantial chunk of bytecode space.  In stripped, sample
cases, for example, we get this reduction in size:

197.parser: 163036 -> 137180:  18.8% reduction
254.gap   : 844936 -> 689392:  22.6%
255.vortex: 621724 -> 528444:  17.7%

...

Not bad for something this simple.  :)  Note that this doesn't require a new
bytecode version number at all, though version 1.1 should not need to support
the old format.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10280 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-12-01 07:05:31 +00:00
parent d540e2c995
commit 8d1dbd2134
4 changed files with 51 additions and 14 deletions

View File

@ -188,7 +188,8 @@ Constant *BytecodeParser::getConstantValue(unsigned TypeSlot, unsigned Slot) {
}
}
/// ParseBasicBlock - In LLVM 1.0 bytecode files, we used to output one
/// basicblock at a time. This method reads in one of the basicblock packets.
BasicBlock *BytecodeParser::ParseBasicBlock(const unsigned char *&Buf,
const unsigned char *EndBuf,
unsigned BlockNo) {
@ -207,6 +208,38 @@ BasicBlock *BytecodeParser::ParseBasicBlock(const unsigned char *&Buf,
return BB;
}
/// ParseInstructionList - Parse all of the BasicBlock's & Instruction's in the
/// body of a function. In post 1.0 bytecode files, we no longer emit basic
/// block individually, in order to avoid per-basic-block overhead.
unsigned BytecodeParser::ParseInstructionList(Function *F,
const unsigned char *&Buf,
const unsigned char *EndBuf) {
unsigned BlockNo = 0;
std::vector<unsigned> Args;
while (Buf < EndBuf) {
BasicBlock *BB;
if (ParsedBasicBlocks.size() == BlockNo)
ParsedBasicBlocks.push_back(BB = new BasicBlock());
else if (ParsedBasicBlocks[BlockNo] == 0)
BB = ParsedBasicBlocks[BlockNo] = new BasicBlock();
else
BB = ParsedBasicBlocks[BlockNo];
++BlockNo;
F->getBasicBlockList().push_back(BB);
// Read instructions into this basic block until we get to a terminator
while (Buf < EndBuf && !BB->getTerminator())
ParseInstruction(Buf, EndBuf, Args, BB);
if (!BB->getTerminator())
throw std::string("Non-terminated basic block found!");
}
return BlockNo;
}
void BytecodeParser::ParseSymbolTable(const unsigned char *&Buf,
const unsigned char *EndBuf,
SymbolTable *ST,
@ -345,6 +378,13 @@ void BytecodeParser::materializeFunction(Function* F) {
break;
}
case BytecodeFormat::InstructionList: {
BCR_TRACE(2, "BLOCK BytecodeFormat::InstructionList: {\n");
if (BlockNum) throw std::string("Already parsed basic blocks!");
BlockNum = ParseInstructionList(F, Buf, Buf+Size);
break;
}
case BytecodeFormat::SymbolTable:
BCR_TRACE(2, "BLOCK BytecodeFormat::SymbolTable: {\n");
ParseSymbolTable(Buf, Buf+Size, &F->getSymbolTable(), F);

View File

@ -162,6 +162,8 @@ private:
BasicBlock *ParseBasicBlock(const unsigned char *&Buf,
const unsigned char *End,
unsigned BlockNo);
unsigned ParseInstructionList(Function *F, const unsigned char *&Buf,
const unsigned char *EndBuf);
void ParseInstruction(const unsigned char *&Buf, const unsigned char *End,
std::vector<unsigned> &Args, BasicBlock *BB);

View File

@ -225,9 +225,13 @@ void BytecodeWriter::outputFunction(const Function *F) {
// Output information about the constants in the function...
outputConstants(true);
// Output basic block nodes...
for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
processBasicBlock(*I);
{ // Output all of the instructions in the body of the function
BytecodeBlock ILBlock(BytecodeFormat::InstructionList, Out);
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);
}
// If needed, output the symbol table for the function...
outputSymbolTable(F->getSymbolTable());
@ -236,14 +240,6 @@ void BytecodeWriter::outputFunction(const Function *F) {
}
}
void BytecodeWriter::processBasicBlock(const BasicBlock &BB) {
BytecodeBlock FunctionBlock(BytecodeFormat::BasicBlock, Out);
// Process all the instructions in the bb...
for(BasicBlock::const_iterator I = BB.begin(), E = BB.end(); I != E; ++I)
processInstruction(*I);
}
void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) {
BytecodeBlock FunctionBlock(BytecodeFormat::SymbolTable, Out);

View File

@ -36,7 +36,6 @@ public:
protected:
void outputConstants(bool isFunction);
void outputFunction(const Function *F);
void processBasicBlock(const BasicBlock &BB);
void processInstruction(const Instruction &I);
private :