Changes to the V2 bytecode format:
- Null values are implicitly encoded instead of explicitly, this makes
things more compact!
- More compactly represent ConstantPointerRefs
- Bytecode files are represented as:
Header|GlobalTypes|GlobalVars/Function Protos|Constants|Functions|SymTab
instead of
Header|GlobalTypes|Constants|GlobalVars/Function Protos|Functions|SymTab
which makes a lot of things simpler.
Writer changes:
- We now explictly encode versioning information in the bytecode files.
- This allows new code to read bytecode files produced by old code, but
new bytecode files can have enhancements such as the above. Although this
makes the reader a bit more complex (having to deal with old formats), the
writer only needs to be able to produce the most recent version.
llvm-svn: 5749
diff --git a/llvm/lib/Bytecode/Writer/Writer.cpp b/llvm/lib/Bytecode/Writer/Writer.cpp
index 92b6a62..8f4f785 100644
--- a/llvm/lib/Bytecode/Writer/Writer.cpp
+++ b/llvm/lib/Bytecode/Writer/Writer.cpp
@@ -43,19 +43,36 @@
// Emit the top level CLASS block.
BytecodeBlock ModuleBlock(BytecodeFormat::Module, Out);
- // Output the ID of first "derived" type:
- output_vbr((unsigned)Type::FirstDerivedTyID, Out);
+ bool isBigEndian = true;
+ bool hasLongPointers = true;
+
+ // Output the version identifier... we are currently on bytecode version #1
+ unsigned Version = (1 << 4) | isBigEndian | (hasLongPointers << 1);
+ output_vbr(Version, Out);
align32(Out);
- // Output module level constants, including types used by the function protos
- outputConstants(false);
+ {
+ BytecodeBlock CPool(BytecodeFormat::GlobalTypePlane, Out);
+
+ // Write the type plane for types first because earlier planes (e.g. for a
+ // primitive type like float) may have constants constructed using types
+ // coming later (e.g., via getelementptr from a pointer type). The type
+ // plane is needed before types can be fwd or bkwd referenced.
+ const std::vector<const Value*> &Plane = Table.getPlane(Type::TypeTyID);
+ assert(!Plane.empty() && "No types at all?");
+ unsigned ValNo = Type::FirstDerivedTyID; // Start at the derived types...
+ outputConstantsInPlane(Plane, ValNo); // Write out the types
+ }
- // The ModuleInfoBlock follows directly after the Module constant pool
+ // The ModuleInfoBlock follows directly after the type information
outputModuleInfoBlock(M);
+ // Output module level constants, used for global variable initializers
+ outputConstants(false);
+
// Do the whole module now! Process each function at a time...
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
- processMethod(I);
+ outputFunction(I);
// If needed, output the symbol table for the module...
outputSymbolTable(M->getSymbolTable());
@@ -68,8 +85,9 @@
&Plane, unsigned StartNo) {
unsigned ValNo = StartNo;
- // Scan through and ignore function arguments...
- for (; ValNo < Plane.size() && isa<Argument>(Plane[ValNo]); ValNo++)
+ // Scan through and ignore function arguments/global values...
+ for (; ValNo < Plane.size() && (isa<Argument>(Plane[ValNo]) ||
+ isa<GlobalValue>(Plane[ValNo])); ValNo++)
/*empty*/;
unsigned NC = ValNo; // Number of constants
@@ -98,7 +116,7 @@
// << Out.size() << "\n";
outputConstant(CPV);
} else {
- outputType(cast<const Type>(V));
+ outputType(cast<Type>(V));
}
}
}
@@ -108,26 +126,21 @@
unsigned NumPlanes = Table.getNumPlanes();
- // Write the type plane for types first because earlier planes
- // (e.g. for a primitive type like float) may have constants constructed
- // using types coming later (e.g., via getelementptr from a pointer type).
- // The type plane is needed before types can be fwd or bkwd referenced.
- if (!isFunction) {
- const std::vector<const Value*> &Plane = Table.getPlane(Type::TypeTyID);
- assert(!Plane.empty() && "No types at all?");
- unsigned ValNo = Type::FirstDerivedTyID; // Start at the derived types...
- outputConstantsInPlane(Plane, ValNo); // Write out the types
- }
-
for (unsigned pno = 0; pno != NumPlanes; pno++) {
const std::vector<const Value*> &Plane = Table.getPlane(pno);
- if (!Plane.empty()) { // Skip empty type planes...
+ if (!Plane.empty()) { // Skip empty type planes...
unsigned ValNo = 0;
- if (isFunction) // Don't reemit module constants
- ValNo = Table.getModuleLevel(pno);
+ if (isFunction) // Don't reemit module constants
+ ValNo += Table.getModuleLevel(pno);
else if (pno == Type::TypeTyID) // If type plane wasn't written out above
continue;
+ if (pno >= Type::FirstDerivedTyID) {
+ // Skip zero initializer
+ if (ValNo == 0)
+ ValNo = 1;
+ }
+
outputConstantsInPlane(Plane, ValNo); // Write out constants in the plane
}
}
@@ -142,7 +155,7 @@
assert(Slot != -1 && "Module global vars is broken!");
// Fields: bit0 = isConstant, bit1 = hasInitializer, bit2=InternalLinkage,
- // bit3+ = slot#
+ // bit3+ = Slot # for type
unsigned oSlot = ((unsigned)Slot << 3) | (I->hasInternalLinkage() << 2) |
(I->hasInitializer() << 1) | I->isConstant();
output_vbr(oSlot, Out);
@@ -165,11 +178,10 @@
}
output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out);
-
align32(Out);
}
-void BytecodeWriter::processMethod(const Function *F) {
+void BytecodeWriter::outputFunction(const Function *F) {
BytecodeBlock FunctionBlock(BytecodeFormat::Function, Out);
output_vbr((unsigned)F->hasInternalLinkage(), Out);
// Only output the constant pool and other goodies if needed...