lib/Bytecode/Writer/Writer.cpp

   1 //===-- Writer.cpp - Library for writing LLVM bytecode files --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This library implements the functionality defined in llvm/Bytecode/Writer.h
  11 //
  12 // Note that this file uses an unusual technique of outputting all the bytecode
  13 // to a vector of unsigned char, then copies the vector to an ostream.  The
  14 // reason for this is that we must do "seeking" in the stream to do back-
  15 // patching, and some very important ostreams that we want to support (like
  16 // pipes) do not support seeking.  :( :( :(
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #define DEBUG_TYPE "bytecodewriter"
  21 #include "WriterInternals.h"
  22 #include "llvm/Bytecode/WriteBytecodePass.h"
  23 #include "llvm/CallingConv.h"
  24 #include "llvm/Constants.h"
  25 #include "llvm/DerivedTypes.h"
  26 #include "llvm/InlineAsm.h"
  27 #include "llvm/Instructions.h"
  28 #include "llvm/Module.h"
  29 #include "llvm/TypeSymbolTable.h"
  30 #include "llvm/ValueSymbolTable.h"
  31 #include "llvm/Support/GetElementPtrTypeIterator.h"
  32 #include "llvm/Support/Compressor.h"
  33 #include "llvm/Support/MathExtras.h"
  34 #include "llvm/Support/Streams.h"
  35 #include "llvm/System/Program.h"
  36 #include "llvm/ADT/SmallVector.h"
  37 #include "llvm/ADT/STLExtras.h"
  38 #include "llvm/ADT/Statistic.h"
  39 #include <cstring>
  40 #include <algorithm>
  41 using namespace llvm;
  42
  43 /// This value needs to be incremented every time the bytecode format changes
  44 /// so that the reader can distinguish which format of the bytecode file has
  45 /// been written.
  46 /// @brief The bytecode version number
  47 const unsigned BCVersionNum = 7;
  48
  49 static RegisterPass<WriteBytecodePass> X("emitbytecode", "Bytecode Writer");
  50
  51 STATISTIC(BytesWritten, "Number of bytecode bytes written");
  52
  53 //===----------------------------------------------------------------------===//
  54 //===                           Output Primitives                          ===//
  55 //===----------------------------------------------------------------------===//
  56
  57 // output - If a position is specified, it must be in the valid portion of the
  58 // string... note that this should be inlined always so only the relevant IF
  59 // body should be included.
  60 inline void BytecodeWriter::output(unsigned i, int pos) {
  61   if (pos == -1) { // Be endian clean, little endian is our friend
  62     Out.push_back((unsigned char)i);
  63     Out.push_back((unsigned char)(i >> 8));
  64     Out.push_back((unsigned char)(i >> 16));
  65     Out.push_back((unsigned char)(i >> 24));
  66   } else {
  67     Out[pos  ] = (unsigned char)i;
  68     Out[pos+1] = (unsigned char)(i >> 8);
  69     Out[pos+2] = (unsigned char)(i >> 16);
  70     Out[pos+3] = (unsigned char)(i >> 24);
  71   }
  72 }
  73
  74 inline void BytecodeWriter::output(int32_t i) {
  75   output((uint32_t)i);
  76 }
  77
  78 /// output_vbr - Output an unsigned value, by using the least number of bytes
  79 /// possible.  This is useful because many of our "infinite" values are really
  80 /// very small most of the time; but can be large a few times.
  81 /// Data format used:  If you read a byte with the high bit set, use the low
  82 /// seven bits as data and then read another byte.
  83 inline void BytecodeWriter::output_vbr(uint64_t i) {
  84   while (1) {
  85     if (i < 0x80) { // done?
  86       Out.push_back((unsigned char)i);   // We know the high bit is clear...
  87       return;
  88     }
  89
  90     // Nope, we are bigger than a character, output the next 7 bits and set the
  91     // high bit to say that there is more coming...
  92     Out.push_back(0x80 | ((unsigned char)i & 0x7F));
  93     i >>= 7;  // Shift out 7 bits now...
  94   }
  95 }
  96
  97 inline void BytecodeWriter::output_vbr(uint32_t i) {
  98   while (1) {
  99     if (i < 0x80) { // done?
 100       Out.push_back((unsigned char)i);   // We know the high bit is clear...
 101       return;
 102     }
 103
 104     // Nope, we are bigger than a character, output the next 7 bits and set the
 105     // high bit to say that there is more coming...
 106     Out.push_back(0x80 | ((unsigned char)i & 0x7F));
 107     i >>= 7;  // Shift out 7 bits now...
 108   }
 109 }
 110
 111 inline void BytecodeWriter::output_typeid(unsigned i) {
 112   if (i <= 0x00FFFFFF)
 113     this->output_vbr(i);
 114   else {
 115     this->output_vbr(0x00FFFFFF);
 116     this->output_vbr(i);
 117   }
 118 }
 119
 120 inline void BytecodeWriter::output_vbr(int64_t i) {
 121   if (i < 0)
 122     output_vbr(((uint64_t)(-i) << 1) | 1); // Set low order sign bit...
 123   else
 124     output_vbr((uint64_t)i << 1);          // Low order bit is clear.
 125 }
 126
 127
 128 inline void BytecodeWriter::output_vbr(int i) {
 129   if (i < 0)
 130     output_vbr(((unsigned)(-i) << 1) | 1); // Set low order sign bit...
 131   else
 132     output_vbr((unsigned)i << 1);          // Low order bit is clear.
 133 }
 134
 135 inline void BytecodeWriter::output(const std::string &s) {
 136   unsigned Len = s.length();
 137   output_vbr(Len);             // Strings may have an arbitrary length.
 138   Out.insert(Out.end(), s.begin(), s.end());
 139 }
 140
 141 inline void BytecodeWriter::output_data(const void *Ptr, const void *End) {
 142   Out.insert(Out.end(), (const unsigned char*)Ptr, (const unsigned char*)End);
 143 }
 144
 145 inline void BytecodeWriter::output_float(float& FloatVal) {
 146   /// FIXME: This isn't optimal, it has size problems on some platforms
 147   /// where FP is not IEEE.
 148   uint32_t i = FloatToBits(FloatVal);
 149   Out.push_back( static_cast<unsigned char>( (i      ) & 0xFF));
 150   Out.push_back( static_cast<unsigned char>( (i >> 8 ) & 0xFF));
 151   Out.push_back( static_cast<unsigned char>( (i >> 16) & 0xFF));
 152   Out.push_back( static_cast<unsigned char>( (i >> 24) & 0xFF));
 153 }
 154
 155 inline void BytecodeWriter::output_double(double& DoubleVal) {
 156   /// FIXME: This isn't optimal, it has size problems on some platforms
 157   /// where FP is not IEEE.
 158   uint64_t i = DoubleToBits(DoubleVal);
 159   Out.push_back( static_cast<unsigned char>( (i      ) & 0xFF));
 160   Out.push_back( static_cast<unsigned char>( (i >> 8 ) & 0xFF));
 161   Out.push_back( static_cast<unsigned char>( (i >> 16) & 0xFF));
 162   Out.push_back( static_cast<unsigned char>( (i >> 24) & 0xFF));
 163   Out.push_back( static_cast<unsigned char>( (i >> 32) & 0xFF));
 164   Out.push_back( static_cast<unsigned char>( (i >> 40) & 0xFF));
 165   Out.push_back( static_cast<unsigned char>( (i >> 48) & 0xFF));
 166   Out.push_back( static_cast<unsigned char>( (i >> 56) & 0xFF));
 167 }
 168
 169 inline BytecodeBlock::BytecodeBlock(unsigned ID, BytecodeWriter &w,
 170                                     bool elideIfEmpty, bool hasLongFormat)
 171   : Id(ID), Writer(w), ElideIfEmpty(elideIfEmpty), HasLongFormat(hasLongFormat){
 172
 173   if (HasLongFormat) {
 174     w.output(ID);
 175     w.output(0U); // For length in long format
 176   } else {
 177     w.output(0U); /// Place holder for ID and length for this block
 178   }
 179   Loc = w.size();
 180 }
 181
 182 inline BytecodeBlock::~BytecodeBlock() { // Do backpatch when block goes out
 183                                          // of scope...
 184   if (Loc == Writer.size() && ElideIfEmpty) {
 185     // If the block is empty, and we are allowed to, do not emit the block at
 186     // all!
 187     Writer.resize(Writer.size()-(HasLongFormat?8:4));
 188     return;
 189   }
 190
 191   if (HasLongFormat)
 192     Writer.output(unsigned(Writer.size()-Loc), int(Loc-4));
 193   else
 194     Writer.output(unsigned(Writer.size()-Loc) << 5 | (Id & 0x1F), int(Loc-4));
 195 }
 196
 197 //===----------------------------------------------------------------------===//
 198 //===                           Constant Output                            ===//
 199 //===----------------------------------------------------------------------===//
 200
 201 void BytecodeWriter::outputType(const Type *T) {
 202   const StructType* STy = dyn_cast<StructType>(T);
 203   if(STy && STy->isPacked())
 204     output_vbr((unsigned)Type::PackedStructTyID);
 205   else
 206     output_vbr((unsigned)T->getTypeID());
 207
 208   // That's all there is to handling primitive types...
 209   if (T->isPrimitiveType())
 210     return;     // We might do this if we alias a prim type: %x = type int
 211
 212   switch (T->getTypeID()) {   // Handle derived types now.
 213   case Type::IntegerTyID:
 214     output_vbr(cast<IntegerType>(T)->getBitWidth());
 215     break;
 216   case Type::FunctionTyID: {
 217     const FunctionType *MT = cast<FunctionType>(T);
 218     output_typeid(Table.getTypeSlot(MT->getReturnType()));
 219     output_vbr(unsigned(MT->getParamAttrs(0)));
 220
 221     // Output the number of arguments to function (+1 if varargs):
 222     output_vbr((unsigned)MT->getNumParams()+MT->isVarArg());
 223
 224     // Output all of the arguments...
 225     FunctionType::param_iterator I = MT->param_begin();
 226     unsigned Idx = 1;
 227     for (; I != MT->param_end(); ++I) {
 228       output_typeid(Table.getTypeSlot(*I));
 229       output_vbr(unsigned(MT->getParamAttrs(Idx)));
 230       Idx++;
 231     }
 232
 233     // Terminate list with VoidTy if we are a varargs function...
 234     if (MT->isVarArg())
 235       output_typeid((unsigned)Type::VoidTyID);
 236     break;
 237   }
 238
 239   case Type::ArrayTyID: {
 240     const ArrayType *AT = cast<ArrayType>(T);
 241     output_typeid(Table.getTypeSlot(AT->getElementType()));
 242     output_vbr(AT->getNumElements());
 243     break;
 244   }
 245
 246  case Type::PackedTyID: {
 247     const PackedType *PT = cast<PackedType>(T);
 248     output_typeid(Table.getTypeSlot(PT->getElementType()));
 249     output_vbr(PT->getNumElements());
 250     break;
 251   }
 252
 253   case Type::StructTyID: {
 254     const StructType *ST = cast<StructType>(T);
 255     // Output all of the element types...
 256     for (StructType::element_iterator I = ST->element_begin(),
 257            E = ST->element_end(); I != E; ++I) {
 258       output_typeid(Table.getTypeSlot(*I));
 259     }
 260
 261     // Terminate list with VoidTy
 262     output_typeid((unsigned)Type::VoidTyID);
 263     break;
 264   }
 265
 266   case Type::PointerTyID:
 267     output_typeid(Table.getTypeSlot(cast<PointerType>(T)->getElementType()));
 268     break;
 269
 270   case Type::OpaqueTyID:
 271     // No need to emit anything, just the count of opaque types is enough.
 272     break;
 273
 274   default:
 275     cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
 276          << " Type '" << T->getDescription() << "'\n";
 277     break;
 278   }
 279 }
 280
 281 void BytecodeWriter::outputConstant(const Constant *CPV) {
 282   assert(((CPV->getType()->isPrimitiveType() || CPV->getType()->isInteger()) ||
 283           !CPV->isNullValue()) && "Shouldn't output null constants!");
 284
 285   // We must check for a ConstantExpr before switching by type because
 286   // a ConstantExpr can be of any type, and has no explicit value.
 287   //
 288   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
 289     // FIXME: Encoding of constant exprs could be much more compact!
 290     assert(CE->getNumOperands() > 0 && "ConstantExpr with 0 operands");
 291     assert(CE->getNumOperands() != 1 || CE->isCast());
 292     output_vbr(1+CE->getNumOperands());   // flags as an expr
 293     output_vbr(CE->getOpcode());          // Put out the CE op code
 294
 295     for (User::const_op_iterator OI = CE->op_begin(); OI != CE->op_end(); ++OI){
 296       output_vbr(Table.getSlot(*OI));
 297       output_typeid(Table.getTypeSlot((*OI)->getType()));
 298     }
 299     if (CE->isCompare())
 300       output_vbr((unsigned)CE->getPredicate());
 301     return;
 302   } else if (isa<UndefValue>(CPV)) {
 303     output_vbr(1U);       // 1 -> UndefValue constant.
 304     return;
 305   } else {
 306     output_vbr(0U);       // flag as not a ConstantExpr (i.e. 0 operands)
 307   }
 308
 309   switch (CPV->getType()->getTypeID()) {
 310   case Type::IntegerTyID: { // Integer types...
 311     unsigned NumBits = cast<IntegerType>(CPV->getType())->getBitWidth();
 312     if (NumBits <= 32)
 313       output_vbr(uint32_t(cast<ConstantInt>(CPV)->getZExtValue()));
 314     else if (NumBits <= 64)
 315       output_vbr(uint64_t(cast<ConstantInt>(CPV)->getZExtValue()));
 316     else
 317       assert("Integer types > 64 bits not supported.");
 318     break;
 319   }
 320
 321   case Type::ArrayTyID: {
 322     const ConstantArray *CPA = cast<ConstantArray>(CPV);
 323     assert(!CPA->isString() && "Constant strings should be handled specially!");
 324
 325     for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
 326       output_vbr(Table.getSlot(CPA->getOperand(i)));
 327     break;
 328   }
 329
 330   case Type::PackedTyID: {
 331     const ConstantPacked *CP = cast<ConstantPacked>(CPV);
 332     for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
 333       output_vbr(Table.getSlot(CP->getOperand(i)));
 334     break;
 335   }
 336
 337   case Type::StructTyID: {
 338     const ConstantStruct *CPS = cast<ConstantStruct>(CPV);
 339
 340     for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
 341       output_vbr(Table.getSlot(CPS->getOperand(i)));
 342     break;
 343   }
 344
 345   case Type::PointerTyID:
 346     assert(0 && "No non-null, non-constant-expr constants allowed!");
 347     abort();
 348
 349   case Type::FloatTyID: {   // Floating point types...
 350     float Tmp = (float)cast<ConstantFP>(CPV)->getValue();
 351     output_float(Tmp);
 352     break;
 353   }
 354   case Type::DoubleTyID: {
 355     double Tmp = cast<ConstantFP>(CPV)->getValue();
 356     output_double(Tmp);
 357     break;
 358   }
 359
 360   case Type::VoidTyID:
 361   case Type::LabelTyID:
 362   default:
 363     cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
 364          << " type '" << *CPV->getType() << "'\n";
 365     break;
 366   }
 367   return;
 368 }
 369
 370 /// outputInlineAsm - InlineAsm's get emitted to the constant pool, so they can
 371 /// be shared by multiple uses.
 372 void BytecodeWriter::outputInlineAsm(const InlineAsm *IA) {
 373   // Output a marker, so we know when we have one one parsing the constant pool.
 374   // Note that this encoding is 5 bytes: not very efficient for a marker.  Since
 375   // unique inline asms are rare, this should hardly matter.
 376   output_vbr(~0U);
 377
 378   output(IA->getAsmString());
 379   output(IA->getConstraintString());
 380   output_vbr(unsigned(IA->hasSideEffects()));
 381 }
 382
 383 void BytecodeWriter::outputConstantStrings() {
 384   SlotCalculator::string_iterator I = Table.string_begin();
 385   SlotCalculator::string_iterator E = Table.string_end();
 386   if (I == E) return;  // No strings to emit
 387
 388   // If we have != 0 strings to emit, output them now.  Strings are emitted into
 389   // the 'void' type plane.
 390   output_vbr(unsigned(E-I));
 391   output_typeid(Type::VoidTyID);
 392
 393   // Emit all of the strings.
 394   for (I = Table.string_begin(); I != E; ++I) {
 395     const ConstantArray *Str = *I;
 396     output_typeid(Table.getTypeSlot(Str->getType()));
 397
 398     // Now that we emitted the type (which indicates the size of the string),
 399     // emit all of the characters.
 400     std::string Val = Str->getAsString();
 401     output_data(Val.c_str(), Val.c_str()+Val.size());
 402   }
 403 }
 404
 405 //===----------------------------------------------------------------------===//
 406 //===                           Instruction Output                         ===//
 407 //===----------------------------------------------------------------------===//
 408
 409 // outputInstructionFormat0 - Output those weird instructions that have a large
 410 // number of operands or have large operands themselves.
 411 //
 412 // Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
 413 //
 414 void BytecodeWriter::outputInstructionFormat0(const Instruction *I,
 415                                               unsigned Opcode,
 416                                               const SlotCalculator &Table,
 417                                               unsigned Type) {
 418   // Opcode must have top two bits clear...
 419   output_vbr(Opcode << 2);                  // Instruction Opcode ID
 420   output_typeid(Type);                      // Result type
 421
 422   unsigned NumArgs = I->getNumOperands();
 423   output_vbr(NumArgs + (isa<CastInst>(I)  || isa<InvokeInst>(I) ||
 424                         isa<CmpInst>(I) || isa<VAArgInst>(I) || Opcode == 58));
 425
 426   if (!isa<GetElementPtrInst>(&I)) {
 427     for (unsigned i = 0; i < NumArgs; ++i)
 428       output_vbr(Table.getSlot(I->getOperand(i)));
 429
 430     if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
 431       output_typeid(Table.getTypeSlot(I->getType()));
 432     } else if (isa<CmpInst>(I)) {
 433       output_vbr(unsigned(cast<CmpInst>(I)->getPredicate()));
 434     } else if (isa<InvokeInst>(I)) {
 435       output_vbr(cast<InvokeInst>(I)->getCallingConv());
 436     } else if (Opcode == 58) {  // Call escape sequence
 437       output_vbr((cast<CallInst>(I)->getCallingConv() << 1) |
 438                  unsigned(cast<CallInst>(I)->isTailCall()));
 439     }
 440   } else {
 441     output_vbr(Table.getSlot(I->getOperand(0)));
 442
 443     // We need to encode the type of sequential type indices into their slot #
 444     unsigned Idx = 1;
 445     for (gep_type_iterator TI = gep_type_begin(I), E = gep_type_end(I);
 446          Idx != NumArgs; ++TI, ++Idx) {
 447       unsigned Slot = Table.getSlot(I->getOperand(Idx));
 448
 449       if (isa<SequentialType>(*TI)) {
 450         // These should be either 32-bits or 64-bits, however, with bit
 451         // accurate types we just distinguish between less than or equal to
 452         // 32-bits or greater than 32-bits.
 453         unsigned BitWidth =
 454           cast<IntegerType>(I->getOperand(Idx)->getType())->getBitWidth();
 455         assert(BitWidth == 32 || BitWidth == 64 &&
 456                "Invalid bitwidth for GEP index");
 457         unsigned IdxId = BitWidth == 32 ? 0 : 1;
 458         Slot = (Slot << 1) | IdxId;
 459       }
 460       output_vbr(Slot);
 461     }
 462   }
 463 }
 464
 465
 466 // outputInstrVarArgsCall - Output the absurdly annoying varargs function calls.
 467 // This are more annoying than most because the signature of the call does not
 468 // tell us anything about the types of the arguments in the varargs portion.
 469 // Because of this, we encode (as type 0) all of the argument types explicitly
 470 // before the argument value.  This really sucks, but you shouldn't be using
 471 // varargs functions in your code! *death to printf*!
 472 //
 473 // Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
 474 //
 475 void BytecodeWriter::outputInstrVarArgsCall(const Instruction *I,
 476                                             unsigned Opcode,
 477                                             const SlotCalculator &Table,
 478                                             unsigned Type) {
 479   assert(isa<CallInst>(I) || isa<InvokeInst>(I));
 480   // Opcode must have top two bits clear...
 481   output_vbr(Opcode << 2);                  // Instruction Opcode ID
 482   output_typeid(Type);                      // Result type (varargs type)
 483
 484   const PointerType *PTy = cast<PointerType>(I->getOperand(0)->getType());
 485   const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
 486   unsigned NumParams = FTy->getNumParams();
 487
 488   unsigned NumFixedOperands;
 489   if (isa<CallInst>(I)) {
 490     // Output an operand for the callee and each fixed argument, then two for
 491     // each variable argument.
 492     NumFixedOperands = 1+NumParams;
 493   } else {
 494     assert(isa<InvokeInst>(I) && "Not call or invoke??");
 495     // Output an operand for the callee and destinations, then two for each
 496     // variable argument.
 497     NumFixedOperands = 3+NumParams;
 498   }
 499   output_vbr(2 * I->getNumOperands()-NumFixedOperands +
 500       unsigned(Opcode == 58 || isa<InvokeInst>(I)));
 501
 502   // The type for the function has already been emitted in the type field of the
 503   // instruction.  Just emit the slot # now.
 504   for (unsigned i = 0; i != NumFixedOperands; ++i)
 505     output_vbr(Table.getSlot(I->getOperand(i)));
 506
 507   for (unsigned i = NumFixedOperands, e = I->getNumOperands(); i != e; ++i) {
 508     // Output Arg Type ID
 509     output_typeid(Table.getTypeSlot(I->getOperand(i)->getType()));
 510
 511     // Output arg ID itself
 512     output_vbr(Table.getSlot(I->getOperand(i)));
 513   }
 514
 515   if (isa<InvokeInst>(I)) {
 516     // Emit the tail call/calling conv for invoke instructions
 517     output_vbr(cast<InvokeInst>(I)->getCallingConv());
 518   } else if (Opcode == 58) {
 519     const CallInst *CI = cast<CallInst>(I);
 520     output_vbr((CI->getCallingConv() << 1) | unsigned(CI->isTailCall()));
 521   }
 522 }
 523
 524
 525 // outputInstructionFormat1 - Output one operand instructions, knowing that no
 526 // operand index is >= 2^12.
 527 //
 528 inline void BytecodeWriter::outputInstructionFormat1(const Instruction *I,
 529                                                      unsigned Opcode,
 530                                                      unsigned *Slots,
 531                                                      unsigned Type) {
 532   // bits   Instruction format:
 533   // --------------------------
 534   // 01-00: Opcode type, fixed to 1.
 535   // 07-02: Opcode
 536   // 19-08: Resulting type plane
 537   // 31-20: Operand #1 (if set to (2^12-1), then zero operands)
 538   //
 539   output(1 | (Opcode << 2) | (Type << 8) | (Slots[0] << 20));
 540 }
 541
 542
 543 // outputInstructionFormat2 - Output two operand instructions, knowing that no
 544 // operand index is >= 2^8.
 545 //
 546 inline void BytecodeWriter::outputInstructionFormat2(const Instruction *I,
 547                                                      unsigned Opcode,
 548                                                      unsigned *Slots,
 549                                                      unsigned Type) {
 550   // bits   Instruction format:
 551   // --------------------------
 552   // 01-00: Opcode type, fixed to 2.
 553   // 07-02: Opcode
 554   // 15-08: Resulting type plane
 555   // 23-16: Operand #1
 556   // 31-24: Operand #2
 557   //
 558   output(2 | (Opcode << 2) | (Type << 8) | (Slots[0] << 16) | (Slots[1] << 24));
 559 }
 560
 561
 562 // outputInstructionFormat3 - Output three operand instructions, knowing that no
 563 // operand index is >= 2^6.
 564 //
 565 inline void BytecodeWriter::outputInstructionFormat3(const Instruction *I,
 566                                                      unsigned Opcode,
 567                                                      unsigned *Slots,
 568                                                      unsigned Type) {
 569   // bits   Instruction format:
 570   // --------------------------
 571   // 01-00: Opcode type, fixed to 3.
 572   // 07-02: Opcode
 573   // 13-08: Resulting type plane
 574   // 19-14: Operand #1
 575   // 25-20: Operand #2
 576   // 31-26: Operand #3
 577   //
 578   output(3 | (Opcode << 2) | (Type << 8) |
 579           (Slots[0] << 14) | (Slots[1] << 20) | (Slots[2] << 26));
 580 }
 581
 582 void BytecodeWriter::outputInstruction(const Instruction &I) {
 583   assert(I.getOpcode() < 57 && "Opcode too big???");
 584   unsigned Opcode = I.getOpcode();
 585   unsigned NumOperands = I.getNumOperands();
 586
 587   // Encode 'tail call' as 61, 'volatile load' as 62, and 'volatile store' as
 588   // 63.
 589   if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
 590     if (CI->getCallingConv() == CallingConv::C) {
 591       if (CI->isTailCall())
 592         Opcode = 61;   // CCC + Tail Call
 593       else
 594         ;     // Opcode = Instruction::Call
 595     } else if (CI->getCallingConv() == CallingConv::Fast) {
 596       if (CI->isTailCall())
 597         Opcode = 59;    // FastCC + TailCall
 598       else
 599         Opcode = 60;    // FastCC + Not Tail Call
 600     } else {
 601       Opcode = 58;      // Call escape sequence.
 602     }
 603   } else if (isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) {
 604     Opcode = 62;
 605   } else if (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) {
 606     Opcode = 63;
 607   }
 608
 609   // Figure out which type to encode with the instruction.  Typically we want
 610   // the type of the first parameter, as opposed to the type of the instruction
 611   // (for example, with setcc, we always know it returns bool, but the type of
 612   // the first param is actually interesting).  But if we have no arguments
 613   // we take the type of the instruction itself.
 614   //
 615   const Type *Ty;
 616   switch (I.getOpcode()) {
 617   case Instruction::Select:
 618   case Instruction::Malloc:
 619   case Instruction::Alloca:
 620     Ty = I.getType();  // These ALWAYS want to encode the return type
 621     break;
 622   case Instruction::Store:
 623     Ty = I.getOperand(1)->getType();  // Encode the pointer type...
 624     assert(isa<PointerType>(Ty) && "Store to nonpointer type!?!?");
 625     break;
 626   default:              // Otherwise use the default behavior...
 627     Ty = NumOperands ? I.getOperand(0)->getType() : I.getType();
 628     break;
 629   }
 630
 631   unsigned Type = Table.getTypeSlot(Ty);
 632
 633   // Varargs calls and invokes are encoded entirely different from any other
 634   // instructions.
 635   if (const CallInst *CI = dyn_cast<CallInst>(&I)){
 636     const PointerType *Ty =cast<PointerType>(CI->getCalledValue()->getType());
 637     if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
 638       outputInstrVarArgsCall(CI, Opcode, Table, Type);
 639       return;
 640     }
 641   } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
 642     const PointerType *Ty =cast<PointerType>(II->getCalledValue()->getType());
 643     if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
 644       outputInstrVarArgsCall(II, Opcode, Table, Type);
 645       return;
 646     }
 647   }
 648
 649   if (NumOperands <= 3) {
 650     // Make sure that we take the type number into consideration.  We don't want
 651     // to overflow the field size for the instruction format we select.
 652     //
 653     unsigned MaxOpSlot = Type;
 654     unsigned Slots[3]; Slots[0] = (1 << 12)-1;   // Marker to signify 0 operands
 655
 656     for (unsigned i = 0; i != NumOperands; ++i) {
 657       unsigned Slot = Table.getSlot(I.getOperand(i));
 658       if (Slot > MaxOpSlot) MaxOpSlot = Slot;
 659       Slots[i] = Slot;
 660     }
 661
 662     // Handle the special cases for various instructions...
 663     if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
 664       // Cast has to encode the destination type as the second argument in the
 665       // packet, or else we won't know what type to cast to!
 666       Slots[1] = Table.getTypeSlot(I.getType());
 667       if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
 668       NumOperands++;
 669     } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
 670       assert(NumOperands == 1 && "Bogus allocation!");
 671       if (AI->getAlignment()) {
 672         Slots[1] = Log2_32(AI->getAlignment())+1;
 673         if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
 674         NumOperands = 2;
 675       }
 676     } else if (isa<ICmpInst>(I) || isa<FCmpInst>(I)) {
 677       // We need to encode the compare instruction's predicate as the third
 678       // operand. Its not really a slot, but we don't want to break the
 679       // instruction format for these instructions.
 680       NumOperands++;
 681       assert(NumOperands == 3 && "CmpInst with wrong number of operands?");
 682       Slots[2] = unsigned(cast<CmpInst>(&I)->getPredicate());
 683       if (Slots[2] > MaxOpSlot)
 684         MaxOpSlot = Slots[2];
 685     } else if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
 686       // We need to encode the type of sequential type indices into their slot #
 687       unsigned Idx = 1;
 688       for (gep_type_iterator I = gep_type_begin(GEP), E = gep_type_end(GEP);
 689            I != E; ++I, ++Idx)
 690         if (isa<SequentialType>(*I)) {
 691           // These should be either 32-bits or 64-bits, however, with bit
 692           // accurate types we just distinguish between less than or equal to
 693           // 32-bits or greater than 32-bits.
 694           unsigned BitWidth =
 695             cast<IntegerType>(GEP->getOperand(Idx)->getType())->getBitWidth();
 696           assert(BitWidth == 32 || BitWidth == 64 &&
 697                  "Invalid bitwidth for GEP index");
 698           unsigned IdxId = BitWidth == 32 ? 0 : 1;
 699           Slots[Idx] = (Slots[Idx] << 1) | IdxId;
 700           if (Slots[Idx] > MaxOpSlot) MaxOpSlot = Slots[Idx];
 701         }
 702     } else if (Opcode == 58) {
 703       // If this is the escape sequence for call, emit the tailcall/cc info.
 704       const CallInst &CI = cast<CallInst>(I);
 705       ++NumOperands;
 706       if (NumOperands <= 3) {
 707         Slots[NumOperands-1] =
 708           (CI.getCallingConv() << 1)|unsigned(CI.isTailCall());
 709         if (Slots[NumOperands-1] > MaxOpSlot)
 710           MaxOpSlot = Slots[NumOperands-1];
 711       }
 712     } else if (isa<InvokeInst>(I)) {
 713       // Invoke escape seq has at least 4 operands to encode.
 714       ++NumOperands;
 715     }
 716
 717     // Decide which instruction encoding to use.  This is determined primarily
 718     // by the number of operands, and secondarily by whether or not the max
 719     // operand will fit into the instruction encoding.  More operands == fewer
 720     // bits per operand.
 721     //
 722     switch (NumOperands) {
 723     case 0:
 724     case 1:
 725       if (MaxOpSlot < (1 << 12)-1) { // -1 because we use 4095 to indicate 0 ops
 726         outputInstructionFormat1(&I, Opcode, Slots, Type);
 727         return;
 728       }
 729       break;
 730
 731     case 2:
 732       if (MaxOpSlot < (1 << 8)) {
 733         outputInstructionFormat2(&I, Opcode, Slots, Type);
 734         return;
 735       }
 736       break;
 737
 738     case 3:
 739       if (MaxOpSlot < (1 << 6)) {
 740         outputInstructionFormat3(&I, Opcode, Slots, Type);
 741         return;
 742       }
 743       break;
 744     default:
 745       break;
 746     }
 747   }
 748
 749   // If we weren't handled before here, we either have a large number of
 750   // operands or a large operand index that we are referring to.
 751   outputInstructionFormat0(&I, Opcode, Table, Type);
 752 }
 753
 754 //===----------------------------------------------------------------------===//
 755 //===                              Block Output                            ===//
 756 //===----------------------------------------------------------------------===//
 757
 758 BytecodeWriter::BytecodeWriter(std::vector<unsigned char> &o, const Module *M)
 759   : Out(o), Table(M) {
 760
 761   // Emit the signature...
 762   static const unsigned char *Sig = (const unsigned char*)"llvm";
 763   output_data(Sig, Sig+4);
 764
 765   // Emit the top level CLASS block.
 766   BytecodeBlock ModuleBlock(BytecodeFormat::ModuleBlockID, *this, false, true);
 767
 768   // Output the version identifier
 769   output_vbr(BCVersionNum);
 770
 771   // The Global type plane comes first
 772   {
 773     BytecodeBlock CPool(BytecodeFormat::GlobalTypePlaneBlockID, *this);
 774     outputTypes(Type::FirstDerivedTyID);
 775   }
 776
 777   // The ModuleInfoBlock follows directly after the type information
 778   outputModuleInfoBlock(M);
 779
 780   // Output module level constants, used for global variable initializers
 781   outputConstants();
 782
 783   // Do the whole module now! Process each function at a time...
 784   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
 785     outputFunction(I);
 786
 787   // Output the symbole table for types
 788   outputTypeSymbolTable(M->getTypeSymbolTable());
 789
 790   // Output the symbol table for values
 791   outputValueSymbolTable(M->getValueSymbolTable());
 792 }
 793
 794 void BytecodeWriter::outputTypes(unsigned TypeNum) {
 795   // Write the type plane for types first because earlier planes (e.g. for a
 796   // primitive type like float) may have constants constructed using types
 797   // coming later (e.g., via getelementptr from a pointer type).  The type
 798   // plane is needed before types can be fwd or bkwd referenced.
 799   const std::vector<const Type*>& Types = Table.getTypes();
 800   assert(!Types.empty() && "No types at all?");
 801   assert(TypeNum <= Types.size() && "Invalid TypeNo index");
 802
 803   unsigned NumEntries = Types.size() - TypeNum;
 804
 805   // Output type header: [num entries]
 806   output_vbr(NumEntries);
 807
 808   for (unsigned i = TypeNum; i < TypeNum+NumEntries; ++i)
 809     outputType(Types[i]);
 810 }
 811
 812 // Helper function for outputConstants().
 813 // Writes out all the constants in the plane Plane starting at entry StartNo.
 814 //
 815 void BytecodeWriter::outputConstantsInPlane(const std::vector<const Value*>
 816                                             &Plane, unsigned StartNo) {
 817   unsigned ValNo = StartNo;
 818
 819   // Scan through and ignore function arguments, global values, and constant
 820   // strings.
 821   for (; ValNo < Plane.size() &&
 822          (isa<Argument>(Plane[ValNo]) || isa<GlobalValue>(Plane[ValNo]) ||
 823           (isa<ConstantArray>(Plane[ValNo]) &&
 824            cast<ConstantArray>(Plane[ValNo])->isString())); ValNo++)
 825     /*empty*/;
 826
 827   unsigned NC = ValNo;              // Number of constants
 828   for (; NC < Plane.size() && (isa<Constant>(Plane[NC]) ||
 829                                isa<InlineAsm>(Plane[NC])); NC++)
 830     /*empty*/;
 831   NC -= ValNo;                      // Convert from index into count
 832   if (NC == 0) return;              // Skip empty type planes...
 833
 834   // FIXME: Most slabs only have 1 or 2 entries!  We should encode this much
 835   // more compactly.
 836
 837   // Put out type header: [num entries][type id number]
 838   //
 839   output_vbr(NC);
 840
 841   // Put out the Type ID Number.
 842   output_typeid(Table.getTypeSlot(Plane.front()->getType()));
 843
 844   for (unsigned i = ValNo; i < ValNo+NC; ++i) {
 845     const Value *V = Plane[i];
 846     if (const Constant *C = dyn_cast<Constant>(V))
 847       outputConstant(C);
 848     else
 849       outputInlineAsm(cast<InlineAsm>(V));
 850   }
 851 }
 852
 853 static inline bool hasNullValue(const Type *Ty) {
 854   return Ty != Type::LabelTy && Ty != Type::VoidTy && !isa<OpaqueType>(Ty);
 855 }
 856
 857 void BytecodeWriter::outputConstants() {
 858   BytecodeBlock CPool(BytecodeFormat::ConstantPoolBlockID, *this,
 859                       true  /* Elide block if empty */);
 860
 861   unsigned NumPlanes = Table.getNumPlanes();
 862
 863   // Output module-level string constants before any other constants.
 864   outputConstantStrings();
 865
 866   for (unsigned pno = 0; pno != NumPlanes; pno++) {
 867     const std::vector<const Value*> &Plane = Table.getPlane(pno);
 868     if (!Plane.empty()) {              // Skip empty type planes...
 869       unsigned ValNo = 0;
 870       if (hasNullValue(Plane[0]->getType())) {
 871         // Skip zero initializer
 872         ValNo = 1;
 873       }
 874
 875       // Write out constants in the plane
 876       outputConstantsInPlane(Plane, ValNo);
 877     }
 878   }
 879 }
 880
 881 static unsigned getEncodedLinkage(const GlobalValue *GV) {
 882   switch (GV->getLinkage()) {
 883   default: assert(0 && "Invalid linkage!");
 884   case GlobalValue::ExternalLinkage:     return 0;
 885   case GlobalValue::WeakLinkage:         return 1;
 886   case GlobalValue::AppendingLinkage:    return 2;
 887   case GlobalValue::InternalLinkage:     return 3;
 888   case GlobalValue::LinkOnceLinkage:     return 4;
 889   case GlobalValue::DLLImportLinkage:    return 5;
 890   case GlobalValue::DLLExportLinkage:    return 6;
 891   case GlobalValue::ExternalWeakLinkage: return 7;
 892   }
 893 }
 894
 895 static unsigned getEncodedVisibility(const GlobalValue *GV) {
 896   switch (GV->getVisibility()) {
 897   default: assert(0 && "Invalid visibility!");
 898   case GlobalValue::DefaultVisibility: return 0;
 899   case GlobalValue::HiddenVisibility:  return 1;
 900   }
 901 }
 902
 903 void BytecodeWriter::outputModuleInfoBlock(const Module *M) {
 904   BytecodeBlock ModuleInfoBlock(BytecodeFormat::ModuleGlobalInfoBlockID, *this);
 905
 906   // Give numbers to sections as we encounter them.
 907   unsigned SectionIDCounter = 0;
 908   std::vector<std::string> SectionNames;
 909   std::map<std::string, unsigned> SectionID;
 910
 911   // Output the types for the global variables in the module...
 912   for (Module::const_global_iterator I = M->global_begin(),
 913          End = M->global_end(); I != End; ++I) {
 914     unsigned Slot = Table.getTypeSlot(I->getType());
 915
 916     assert((I->hasInitializer() || !I->hasInternalLinkage()) &&
 917            "Global must have an initializer or have external linkage!");
 918
 919     // Fields: bit0 = isConstant, bit1 = hasInitializer, bit2-4=Linkage,
 920     // bit5+ = Slot # for type.
 921     bool HasExtensionWord = (I->getAlignment() != 0) ||
 922                             I->hasSection() ||
 923       (I->getVisibility() != GlobalValue::DefaultVisibility);
 924
 925     // If we need to use the extension byte, set linkage=3(internal) and
 926     // initializer = 0 (impossible!).
 927     if (!HasExtensionWord) {
 928       unsigned oSlot = (Slot << 5) | (getEncodedLinkage(I) << 2) |
 929                         (I->hasInitializer() << 1) | (unsigned)I->isConstant();
 930       output_vbr(oSlot);
 931     } else {
 932       unsigned oSlot = (Slot << 5) | (3 << 2) |
 933                         (0 << 1) | (unsigned)I->isConstant();
 934       output_vbr(oSlot);
 935
 936       // The extension word has this format: bit 0 = has initializer, bit 1-3 =
 937       // linkage, bit 4-8 = alignment (log2), bit 9 = has SectionID,
 938       // bits 10-12 = visibility, bits 13+ = future use.
 939       unsigned ExtWord = (unsigned)I->hasInitializer() |
 940                          (getEncodedLinkage(I) << 1) |
 941                          ((Log2_32(I->getAlignment())+1) << 4) |
 942                          ((unsigned)I->hasSection() << 9) |
 943                          (getEncodedVisibility(I) << 10);
 944       output_vbr(ExtWord);
 945       if (I->hasSection()) {
 946         // Give section names unique ID's.
 947         unsigned &Entry = SectionID[I->getSection()];
 948         if (Entry == 0) {
 949           Entry = ++SectionIDCounter;
 950           SectionNames.push_back(I->getSection());
 951         }
 952         output_vbr(Entry);
 953       }
 954     }
 955
 956     // If we have an initializer, output it now.
 957     if (I->hasInitializer())
 958       output_vbr(Table.getSlot((Value*)I->getInitializer()));
 959   }
 960   output_typeid(Table.getTypeSlot(Type::VoidTy));
 961
 962   // Output the types of the functions in this module.
 963   for (Module::const_iterator I = M->begin(), End = M->end(); I != End; ++I) {
 964     unsigned Slot = Table.getTypeSlot(I->getType());
 965     assert(((Slot << 6) >> 6) == Slot && "Slot # too big!");
 966     unsigned CC = I->getCallingConv()+1;
 967     unsigned ID = (Slot << 5) | (CC & 15);
 968
 969     if (I->isDeclaration())   // If external, we don't have an FunctionInfo block.
 970       ID |= 1 << 4;
 971
 972     if (I->getAlignment() || I->hasSection() || (CC & ~15) != 0 ||
 973         (I->isDeclaration() && I->hasDLLImportLinkage()) ||
 974         (I->isDeclaration() && I->hasExternalWeakLinkage())
 975        )
 976       ID |= 1 << 31;       // Do we need an extension word?
 977
 978     output_vbr(ID);
 979
 980     if (ID & (1 << 31)) {
 981       // Extension byte: bits 0-4 = alignment, bits 5-9 = top nibble of calling
 982       // convention, bit 10 = hasSectionID., bits 11-12 = external linkage type
 983       unsigned extLinkage = 0;
 984
 985       if (I->isDeclaration()) {
 986         if (I->hasDLLImportLinkage()) {
 987           extLinkage = 1;
 988         } else if (I->hasExternalWeakLinkage()) {
 989           extLinkage = 2;
 990         }
 991       }
 992
 993       ID = (Log2_32(I->getAlignment())+1) | ((CC >> 4) << 5) |
 994         (I->hasSection() << 10) |
 995         ((extLinkage & 3) << 11);
 996       output_vbr(ID);
 997
 998       // Give section names unique ID's.
 999       if (I->hasSection()) {
1000         unsigned &Entry = SectionID[I->getSection()];
1001         if (Entry == 0) {
1002           Entry = ++SectionIDCounter;
1003           SectionNames.push_back(I->getSection());
1004         }
1005         output_vbr(Entry);
1006       }
1007     }
1008   }
1009   output_vbr(Table.getTypeSlot(Type::VoidTy) << 5);
1010
1011   // Emit the list of dependent libraries for the Module.
1012   Module::lib_iterator LI = M->lib_begin();
1013   Module::lib_iterator LE = M->lib_end();
1014   output_vbr(unsigned(LE - LI));   // Emit the number of dependent libraries.
1015   for (; LI != LE; ++LI)
1016     output(*LI);
1017
1018   // Output the target triple from the module
1019   output(M->getTargetTriple());
1020
1021   // Output the data layout from the module
1022   output(M->getDataLayout());
1023
1024   // Emit the table of section names.
1025   output_vbr((unsigned)SectionNames.size());
1026   for (unsigned i = 0, e = SectionNames.size(); i != e; ++i)
1027     output(SectionNames[i]);
1028
1029   // Output the inline asm string.
1030   output(M->getModuleInlineAsm());
1031 }
1032
1033 void BytecodeWriter::outputInstructions(const Function *F) {
1034   BytecodeBlock ILBlock(BytecodeFormat::InstructionListBlockID, *this);
1035   for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
1036     for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I)
1037       outputInstruction(*I);
1038 }
1039
1040 void BytecodeWriter::outputFunction(const Function *F) {
1041   // If this is an external function, there is nothing else to emit!
1042   if (F->isDeclaration()) return;
1043
1044   BytecodeBlock FunctionBlock(BytecodeFormat::FunctionBlockID, *this);
1045   unsigned rWord = (getEncodedVisibility(F) << 16) | getEncodedLinkage(F);
1046   output_vbr(rWord);
1047
1048   // Get slot information about the function...
1049   Table.incorporateFunction(F);
1050
1051   // Output all of the instructions in the body of the function
1052   outputInstructions(F);
1053
1054   // If needed, output the symbol table for the function...
1055   outputValueSymbolTable(F->getValueSymbolTable());
1056
1057   Table.purgeFunction();
1058 }
1059
1060
1061 void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) {
1062   // Do not output the block for an empty symbol table, it just wastes
1063   // space!
1064   if (TST.empty()) return;
1065
1066   // Create a header for the symbol table
1067   BytecodeBlock SymTabBlock(BytecodeFormat::TypeSymbolTableBlockID, *this,
1068                             true/*ElideIfEmpty*/);
1069   // Write the number of types
1070   output_vbr(TST.size());
1071
1072   // Write each of the types
1073   for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end();
1074        TI != TE; ++TI) {
1075     // Symtab entry:[def slot #][name]
1076     output_typeid(Table.getTypeSlot(TI->second));
1077     output(TI->first);
1078   }
1079 }
1080
1081 void BytecodeWriter::outputValueSymbolTable(const ValueSymbolTable &VST) {
1082   // Do not output the Bytecode block for an empty symbol table, it just wastes
1083   // space!
1084   if (VST.empty()) return;
1085
1086   BytecodeBlock SymTabBlock(BytecodeFormat::ValueSymbolTableBlockID, *this,
1087                             true/*ElideIfEmpty*/);
1088
1089   // Organize the symbol table by type
1090   typedef std::pair<const std::string*, const Value*> PlaneMapEntry;
1091   typedef SmallVector<PlaneMapEntry, 8> PlaneMapVector;
1092   typedef DenseMap<const Type*, PlaneMapVector > PlaneMap;
1093   PlaneMap Planes;
1094   for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
1095        SI != SE; ++SI)
1096     Planes[SI->second->getType()]
1097       .push_back(std::make_pair(&SI->first, SI->second));
1098
1099   for (PlaneMap::iterator PI = Planes.begin(), PE = Planes.end();
1100        PI != PE; ++PI) {
1101     PlaneMapVector::const_iterator I = PI->second.begin();
1102     PlaneMapVector::const_iterator End = PI->second.end();
1103
1104     if (I == End) continue;  // Don't mess with an absent type...
1105
1106     // Write the number of values in this plane
1107     output_vbr((unsigned)PI->second.size());
1108
1109     // Write the slot number of the type for this plane
1110     output_typeid(Table.getTypeSlot(PI->first));
1111
1112     // Write each of the values in this plane
1113     for (; I != End; ++I) {
1114       // Symtab entry: [def slot #][name]
1115       output_vbr(Table.getSlot(I->second));
1116       output(*I->first);
1117     }
1118   }
1119 }
1120
1121 void llvm::WriteBytecodeToFile(const Module *M, OStream &Out,
1122                                bool compress) {
1123   assert(M && "You can't write a null module!!");
1124
1125   // Make sure that std::cout is put into binary mode for systems
1126   // that care.
1127   if (Out == cout)
1128     sys::Program::ChangeStdoutToBinary();
1129
1130   // Create a vector of unsigned char for the bytecode output. We
1131   // reserve 256KBytes of space in the vector so that we avoid doing
1132   // lots of little allocations. 256KBytes is sufficient for a large
1133   // proportion of the bytecode files we will encounter. Larger files
1134   // will be automatically doubled in size as needed (std::vector
1135   // behavior).
1136   std::vector<unsigned char> Buffer;
1137   Buffer.reserve(256 * 1024);
1138
1139   // The BytecodeWriter populates Buffer for us.
1140   BytecodeWriter BCW(Buffer, M);
1141
1142   // Keep track of how much we've written
1143   BytesWritten += Buffer.size();
1144
1145   // Determine start and end points of the Buffer
1146   const unsigned char *FirstByte = &Buffer.front();
1147
1148   // If we're supposed to compress this mess ...
1149   if (compress) {
1150
1151     // We signal compression by using an alternate magic number for the
1152     // file. The compressed bytecode file's magic number is "llvc" instead
1153     // of "llvm".
1154     char compressed_magic[4];
1155     compressed_magic[0] = 'l';
1156     compressed_magic[1] = 'l';
1157     compressed_magic[2] = 'v';
1158     compressed_magic[3] = 'c';
1159
1160     Out.stream()->write(compressed_magic,4);
1161
1162     // Compress everything after the magic number (which we altered)
1163     Compressor::compressToStream(
1164       (char*)(FirstByte+4),        // Skip the magic number
1165       Buffer.size()-4,             // Skip the magic number
1166       *Out.stream()                // Where to write compressed data
1167     );
1168
1169   } else {
1170
1171     // We're not compressing, so just write the entire block.
1172     Out.stream()->write((char*)FirstByte, Buffer.size());
1173   }
1174
1175   // make sure it hits disk now
1176   Out.stream()->flush();
1177 }