/// Align the buffer position to a 32 bit boundary
inline void BytecodeReader::align32() {
- BufPtr Save = At;
- At = (const unsigned char *)((unsigned long)(At+3) & (~3UL));
- if (At > Save)
- if (Handler) Handler->handleAlignment(At - Save);
- if (At > BlockEnd)
- error("Ran out of data while aligning!");
+ if (hasAlignment) {
+ BufPtr Save = At;
+ At = (const unsigned char *)((unsigned long)(At+3) & (~3UL));
+ if (At > Save)
+ if (Handler) Handler->handleAlignment(At - Save);
+ if (At > BlockEnd)
+ error("Ran out of data while aligning!");
+ }
}
/// Read a whole unsigned integer
hasLongBlockHeaders = false;
has32BitTypes = false;
hasNoDependentLibraries = false;
+ hasAlignment = false;
switch (RevisionNum) {
case 0: // LLVM 1.0, 1.1 release version
// FALL THROUGH
case 3: // LLVM 1.3 release version
+ /// LLVM 1.3 and earlier caused alignment bytes to be written on some block
+ /// boundaries and at the end of some strings. In extreme cases (e.g. lots
+ /// of GEP references to a constant array), this can increase the file size
+ /// by 30% or more. In version 1.4 alignment is done away with completely.
+ hasAlignment = true;
+
+ // FALL THROUGH
+ case 4:
break;
default:
#include <algorithm>
using namespace llvm;
+/// This value needs to be incremented every time the bytecode format changes
+/// so that the reader can distinguish which format of the bytecode file has
+/// been written.
+/// @brief The bytecode version number
+const unsigned BCVersionNum = 4;
+
static RegisterPass<WriteBytecodePass> X("emitbytecode", "Bytecode Writer");
static Statistic<>
/// possible. This is useful because many of our "infinite" values are really
/// very small most of the time; but can be large a few times.
/// Data format used: If you read a byte with the high bit set, use the low
-/// seven bits as data and then read another byte. Note that using this may
-/// cause the output buffer to become unaligned.
+/// seven bits as data and then read another byte.
inline void BytecodeWriter::output_vbr(uint64_t i) {
while (1) {
if (i < 0x80) { // done?
output_vbr((unsigned)i << 1); // Low order bit is clear.
}
-// align32 - emit the minimal number of bytes that will bring us to 32 bit
-// alignment...
-//
-inline void BytecodeWriter::align32() {
- int NumPads = (4-(Out.size() & 3)) & 3; // Bytes to get padding to 32 bits
- while (NumPads--) Out.push_back((unsigned char)0xAB);
-}
-
-inline void BytecodeWriter::output(const std::string &s, bool Aligned ) {
+inline void BytecodeWriter::output(const std::string &s) {
unsigned Len = s.length();
output_vbr(Len ); // Strings may have an arbitrary length...
Out.insert(Out.end(), s.begin(), s.end());
-
- if (Aligned)
- align32(); // Make sure we are now aligned...
}
inline void BytecodeWriter::output_data(const void *Ptr, const void *End) {
Writer.output(unsigned(Writer.size()-Loc), int(Loc-4));
else
Writer.output(unsigned(Writer.size()-Loc) << 5 | (Id & 0x1F), int(Loc-4));
- Writer.align32(); // Blocks must ALWAYS be aligned
}
//===----------------------------------------------------------------------===//
output_vbr(unsigned(Slot));
}
}
-
- align32(); // We must maintain correct alignment!
}
assert(Slot >= 0 && "No slot number for value!?!?");
output_vbr((unsigned)Slot);
}
- align32(); // We must maintain correct alignment!
}
// Output the version identifier... we are currently on bytecode version #2,
// which corresponds to LLVM v1.3.
- unsigned Version = (3 << 4) | (unsigned)isBigEndian | (hasLongPointers << 1) |
- (hasNoEndianness << 2) | (hasNoPointerSize << 3);
+ unsigned Version = (BCVersionNum << 4) |
+ (unsigned)isBigEndian | (hasLongPointers << 1) |
+ (hasNoEndianness << 2) |
+ (hasNoPointerSize << 3);
output_vbr(Version);
- align32();
// The Global type plane comes first
{
Module::lib_iterator LE = M->lib_end();
output_vbr( unsigned(LE - LI) ); // Put out the number of dependent libraries
for ( ; LI != LE; ++LI ) {
- output(*LI, /*aligned=*/false);
+ output(*LI);
}
// Output the target triple from the module
- output(M->getTargetTriple(), /*aligned=*/ true);
+ output(M->getTargetTriple());
}
void BytecodeWriter::outputInstructions(const Function *F) {
TE = MST.type_end(); TI != TE; ++TI ) {
// Symtab entry:[def slot #][name]
output_typeid((unsigned)Table.getSlot(TI->second));
- output(TI->first, /*align=*/false);
+ output(TI->first);
}
// Now do each of the type planes in order.
Slot = Table.getSlot(I->second);
assert(Slot != -1 && "Value in symtab but has no slot number!!");
output_vbr((unsigned)Slot);
- output(I->first, false); // Don't force alignment...
+ output(I->first);
}
}
}