lib/Bitcode/Writer/BitcodeWriter.cpp

   1 //===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Chris Lattner and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Bitcode writer implementation.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Bitcode/ReaderWriter.h"
  15 #include "llvm/Bitcode/BitstreamWriter.h"
  16 #include "llvm/Bitcode/LLVMBitCodes.h"
  17 #include "ValueEnumerator.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/Module.h"
  22 #include "llvm/ParameterAttributes.h"
  23 #include "llvm/TypeSymbolTable.h"
  24 #include "llvm/ValueSymbolTable.h"
  25 #include "llvm/Support/MathExtras.h"
  26 using namespace llvm;
  27
  28 /// These are manifest constants used by the bitcode writer. They do not need to
  29 /// be kept in sync with the reader, but need to be consistent within this file.
  30 enum {
  31   CurVersion = 0,
  32
  33   // VALUE_SYMTAB_BLOCK abbrev id's.
  34   VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
  35   VST_ENTRY_7_ABBREV,
  36   VST_ENTRY_6_ABBREV,
  37   VST_BBENTRY_6_ABBREV,
  38
  39   // CONSTANTS_BLOCK abbrev id's.
  40   CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
  41   CONSTANTS_INTEGER_ABBREV,
  42   CONSTANTS_CE_CAST_Abbrev,
  43   CONSTANTS_NULL_Abbrev
  44 };
  45
  46
  47 static unsigned GetEncodedCastOpcode(unsigned Opcode) {
  48   switch (Opcode) {
  49   default: assert(0 && "Unknown cast instruction!");
  50   case Instruction::Trunc   : return bitc::CAST_TRUNC;
  51   case Instruction::ZExt    : return bitc::CAST_ZEXT;
  52   case Instruction::SExt    : return bitc::CAST_SEXT;
  53   case Instruction::FPToUI  : return bitc::CAST_FPTOUI;
  54   case Instruction::FPToSI  : return bitc::CAST_FPTOSI;
  55   case Instruction::UIToFP  : return bitc::CAST_UITOFP;
  56   case Instruction::SIToFP  : return bitc::CAST_SITOFP;
  57   case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
  58   case Instruction::FPExt   : return bitc::CAST_FPEXT;
  59   case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
  60   case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
  61   case Instruction::BitCast : return bitc::CAST_BITCAST;
  62   }
  63 }
  64
  65 static unsigned GetEncodedBinaryOpcode(unsigned Opcode) {
  66   switch (Opcode) {
  67   default: assert(0 && "Unknown binary instruction!");
  68   case Instruction::Add:  return bitc::BINOP_ADD;
  69   case Instruction::Sub:  return bitc::BINOP_SUB;
  70   case Instruction::Mul:  return bitc::BINOP_MUL;
  71   case Instruction::UDiv: return bitc::BINOP_UDIV;
  72   case Instruction::FDiv:
  73   case Instruction::SDiv: return bitc::BINOP_SDIV;
  74   case Instruction::URem: return bitc::BINOP_UREM;
  75   case Instruction::FRem:
  76   case Instruction::SRem: return bitc::BINOP_SREM;
  77   case Instruction::Shl:  return bitc::BINOP_SHL;
  78   case Instruction::LShr: return bitc::BINOP_LSHR;
  79   case Instruction::AShr: return bitc::BINOP_ASHR;
  80   case Instruction::And:  return bitc::BINOP_AND;
  81   case Instruction::Or:   return bitc::BINOP_OR;
  82   case Instruction::Xor:  return bitc::BINOP_XOR;
  83   }
  84 }
  85
  86
  87
  88 static void WriteStringRecord(unsigned Code, const std::string &Str,
  89                               unsigned AbbrevToUse, BitstreamWriter &Stream) {
  90   SmallVector<unsigned, 64> Vals;
  91
  92   // Code: [strchar x N]
  93   for (unsigned i = 0, e = Str.size(); i != e; ++i)
  94     Vals.push_back(Str[i]);
  95
  96   // Emit the finished record.
  97   Stream.EmitRecord(Code, Vals, AbbrevToUse);
  98 }
  99
 100 // Emit information about parameter attributes.
 101 static void WriteParamAttrTable(const ValueEnumerator &VE,
 102                                 BitstreamWriter &Stream) {
 103   const std::vector<const ParamAttrsList*> &Attrs = VE.getParamAttrs();
 104   if (Attrs.empty()) return;
 105
 106   Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
 107
 108   SmallVector<uint64_t, 64> Record;
 109   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
 110     const ParamAttrsList *A = Attrs[i];
 111     for (unsigned op = 0, e = A->size(); op != e; ++op) {
 112       Record.push_back(A->getParamIndex(op));
 113       Record.push_back(A->getParamAttrsAtIndex(op));
 114     }
 115
 116     Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
 117     Record.clear();
 118   }
 119
 120   Stream.ExitBlock();
 121 }
 122
 123 /// WriteTypeTable - Write out the type table for a module.
 124 static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
 125   const ValueEnumerator::TypeList &TypeList = VE.getTypes();
 126
 127   Stream.EnterSubblock(bitc::TYPE_BLOCK_ID, 4 /*count from # abbrevs */);
 128   SmallVector<uint64_t, 64> TypeVals;
 129
 130   // Abbrev for TYPE_CODE_POINTER.
 131   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 132   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));
 133   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 134                             Log2_32_Ceil(VE.getTypes().size()+1)));
 135   unsigned PtrAbbrev = Stream.EmitAbbrev(Abbv);
 136
 137   // Abbrev for TYPE_CODE_FUNCTION.
 138   Abbv = new BitCodeAbbrev();
 139   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));
 140   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // isvararg
 141   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 142                             Log2_32_Ceil(VE.getParamAttrs().size()+1)));
 143   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 144   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 145                             Log2_32_Ceil(VE.getTypes().size()+1)));
 146   unsigned FunctionAbbrev = Stream.EmitAbbrev(Abbv);
 147
 148   // Abbrev for TYPE_CODE_STRUCT.
 149   Abbv = new BitCodeAbbrev();
 150   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT));
 151   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // ispacked
 152   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 153   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 154                             Log2_32_Ceil(VE.getTypes().size()+1)));
 155   unsigned StructAbbrev = Stream.EmitAbbrev(Abbv);
 156
 157   // Abbrev for TYPE_CODE_ARRAY.
 158   Abbv = new BitCodeAbbrev();
 159   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
 160   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // size
 161   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 162                             Log2_32_Ceil(VE.getTypes().size()+1)));
 163   unsigned ArrayAbbrev = Stream.EmitAbbrev(Abbv);
 164
 165   // Emit an entry count so the reader can reserve space.
 166   TypeVals.push_back(TypeList.size());
 167   Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
 168   TypeVals.clear();
 169
 170   // Loop over all of the types, emitting each in turn.
 171   for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
 172     const Type *T = TypeList[i].first;
 173     int AbbrevToUse = 0;
 174     unsigned Code = 0;
 175
 176     switch (T->getTypeID()) {
 177     case Type::PackedStructTyID: // FIXME: Delete Type::PackedStructTyID.
 178     default: assert(0 && "Unknown type!");
 179     case Type::VoidTyID:   Code = bitc::TYPE_CODE_VOID;   break;
 180     case Type::FloatTyID:  Code = bitc::TYPE_CODE_FLOAT;  break;
 181     case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
 182     case Type::LabelTyID:  Code = bitc::TYPE_CODE_LABEL;  break;
 183     case Type::OpaqueTyID: Code = bitc::TYPE_CODE_OPAQUE; break;
 184     case Type::IntegerTyID:
 185       // INTEGER: [width]
 186       Code = bitc::TYPE_CODE_INTEGER;
 187       TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
 188       break;
 189     case Type::PointerTyID:
 190       // POINTER: [pointee type]
 191       Code = bitc::TYPE_CODE_POINTER;
 192       TypeVals.push_back(VE.getTypeID(cast<PointerType>(T)->getElementType()));
 193       AbbrevToUse = PtrAbbrev;
 194       break;
 195
 196     case Type::FunctionTyID: {
 197       const FunctionType *FT = cast<FunctionType>(T);
 198       // FUNCTION: [isvararg, attrid, retty, paramty x N]
 199       Code = bitc::TYPE_CODE_FUNCTION;
 200       TypeVals.push_back(FT->isVarArg());
 201       TypeVals.push_back(VE.getParamAttrID(FT->getParamAttrs()));
 202       TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
 203       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
 204         TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
 205       AbbrevToUse = FunctionAbbrev;
 206       break;
 207     }
 208     case Type::StructTyID: {
 209       const StructType *ST = cast<StructType>(T);
 210       // STRUCT: [ispacked, eltty x N]
 211       Code = bitc::TYPE_CODE_STRUCT;
 212       TypeVals.push_back(ST->isPacked());
 213       // Output all of the element types.
 214       for (StructType::element_iterator I = ST->element_begin(),
 215            E = ST->element_end(); I != E; ++I)
 216         TypeVals.push_back(VE.getTypeID(*I));
 217       AbbrevToUse = StructAbbrev;
 218       break;
 219     }
 220     case Type::ArrayTyID: {
 221       const ArrayType *AT = cast<ArrayType>(T);
 222       // ARRAY: [numelts, eltty]
 223       Code = bitc::TYPE_CODE_ARRAY;
 224       TypeVals.push_back(AT->getNumElements());
 225       TypeVals.push_back(VE.getTypeID(AT->getElementType()));
 226       AbbrevToUse = ArrayAbbrev;
 227       break;
 228     }
 229     case Type::VectorTyID: {
 230       const VectorType *VT = cast<VectorType>(T);
 231       // VECTOR [numelts, eltty]
 232       Code = bitc::TYPE_CODE_VECTOR;
 233       TypeVals.push_back(VT->getNumElements());
 234       TypeVals.push_back(VE.getTypeID(VT->getElementType()));
 235       break;
 236     }
 237     }
 238
 239     // Emit the finished record.
 240     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
 241     TypeVals.clear();
 242   }
 243
 244   Stream.ExitBlock();
 245 }
 246
 247 static unsigned getEncodedLinkage(const GlobalValue *GV) {
 248   switch (GV->getLinkage()) {
 249   default: assert(0 && "Invalid linkage!");
 250   case GlobalValue::ExternalLinkage:     return 0;
 251   case GlobalValue::WeakLinkage:         return 1;
 252   case GlobalValue::AppendingLinkage:    return 2;
 253   case GlobalValue::InternalLinkage:     return 3;
 254   case GlobalValue::LinkOnceLinkage:     return 4;
 255   case GlobalValue::DLLImportLinkage:    return 5;
 256   case GlobalValue::DLLExportLinkage:    return 6;
 257   case GlobalValue::ExternalWeakLinkage: return 7;
 258   }
 259 }
 260
 261 static unsigned getEncodedVisibility(const GlobalValue *GV) {
 262   switch (GV->getVisibility()) {
 263   default: assert(0 && "Invalid visibility!");
 264   case GlobalValue::DefaultVisibility:   return 0;
 265   case GlobalValue::HiddenVisibility:    return 1;
 266   case GlobalValue::ProtectedVisibility: return 2;
 267   }
 268 }
 269
 270 // Emit top-level description of module, including target triple, inline asm,
 271 // descriptors for global variables, and function prototype info.
 272 static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
 273                             BitstreamWriter &Stream) {
 274   // Emit the list of dependent libraries for the Module.
 275   for (Module::lib_iterator I = M->lib_begin(), E = M->lib_end(); I != E; ++I)
 276     WriteStringRecord(bitc::MODULE_CODE_DEPLIB, *I, 0/*TODO*/, Stream);
 277
 278   // Emit various pieces of data attached to a module.
 279   if (!M->getTargetTriple().empty())
 280     WriteStringRecord(bitc::MODULE_CODE_TRIPLE, M->getTargetTriple(),
 281                       0/*TODO*/, Stream);
 282   if (!M->getDataLayout().empty())
 283     WriteStringRecord(bitc::MODULE_CODE_DATALAYOUT, M->getDataLayout(),
 284                       0/*TODO*/, Stream);
 285   if (!M->getModuleInlineAsm().empty())
 286     WriteStringRecord(bitc::MODULE_CODE_ASM, M->getModuleInlineAsm(),
 287                       0/*TODO*/, Stream);
 288
 289   // Emit information about sections, computing how many there are.  Also
 290   // compute the maximum alignment value.
 291   std::map<std::string, unsigned> SectionMap;
 292   unsigned MaxAlignment = 0;
 293   unsigned MaxGlobalType = 0;
 294   for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
 295        GV != E; ++GV) {
 296     MaxAlignment = std::max(MaxAlignment, GV->getAlignment());
 297     MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV->getType()));
 298
 299     if (!GV->hasSection()) continue;
 300     // Give section names unique ID's.
 301     unsigned &Entry = SectionMap[GV->getSection()];
 302     if (Entry != 0) continue;
 303     WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, GV->getSection(),
 304                       0/*TODO*/, Stream);
 305     Entry = SectionMap.size();
 306   }
 307   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
 308     MaxAlignment = std::max(MaxAlignment, F->getAlignment());
 309     if (!F->hasSection()) continue;
 310     // Give section names unique ID's.
 311     unsigned &Entry = SectionMap[F->getSection()];
 312     if (Entry != 0) continue;
 313     WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, F->getSection(),
 314                       0/*TODO*/, Stream);
 315     Entry = SectionMap.size();
 316   }
 317
 318   // Emit abbrev for globals, now that we know # sections and max alignment.
 319   unsigned SimpleGVarAbbrev = 0;
 320   if (!M->global_empty()) {
 321     // Add an abbrev for common globals with no visibility or thread localness.
 322     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 323     Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
 324     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 325                               Log2_32_Ceil(MaxGlobalType+1)));
 326     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));      // Constant.
 327     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));        // Initializer.
 328     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));      // Linkage.
 329     if (MaxAlignment == 0)                                      // Alignment.
 330       Abbv->Add(BitCodeAbbrevOp(0));
 331     else {
 332       unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
 333       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 334                                Log2_32_Ceil(MaxEncAlignment+1)));
 335     }
 336     if (SectionMap.empty())                                    // Section.
 337       Abbv->Add(BitCodeAbbrevOp(0));
 338     else
 339       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 340                                Log2_32_Ceil(SectionMap.size()+1)));
 341     // Don't bother emitting vis + thread local.
 342     SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
 343   }
 344
 345   // Emit the global variable information.
 346   SmallVector<unsigned, 64> Vals;
 347   for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
 348        GV != E; ++GV) {
 349     unsigned AbbrevToUse = 0;
 350
 351     // GLOBALVAR: [type, isconst, initid,
 352     //             linkage, alignment, section, visibility, threadlocal]
 353     Vals.push_back(VE.getTypeID(GV->getType()));
 354     Vals.push_back(GV->isConstant());
 355     Vals.push_back(GV->isDeclaration() ? 0 :
 356                    (VE.getValueID(GV->getInitializer()) + 1));
 357     Vals.push_back(getEncodedLinkage(GV));
 358     Vals.push_back(Log2_32(GV->getAlignment())+1);
 359     Vals.push_back(GV->hasSection() ? SectionMap[GV->getSection()] : 0);
 360     if (GV->isThreadLocal() ||
 361         GV->getVisibility() != GlobalValue::DefaultVisibility) {
 362       Vals.push_back(getEncodedVisibility(GV));
 363       Vals.push_back(GV->isThreadLocal());
 364     } else {
 365       AbbrevToUse = SimpleGVarAbbrev;
 366     }
 367
 368     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
 369     Vals.clear();
 370   }
 371
 372   // Emit the function proto information.
 373   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
 374     // FUNCTION:  [type, callingconv, isproto, linkage, alignment, section,
 375     //             visibility]
 376     Vals.push_back(VE.getTypeID(F->getType()));
 377     Vals.push_back(F->getCallingConv());
 378     Vals.push_back(F->isDeclaration());
 379     Vals.push_back(getEncodedLinkage(F));
 380     Vals.push_back(Log2_32(F->getAlignment())+1);
 381     Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
 382     Vals.push_back(getEncodedVisibility(F));
 383
 384     unsigned AbbrevToUse = 0;
 385     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
 386     Vals.clear();
 387   }
 388
 389
 390   // Emit the alias information.
 391   for (Module::const_alias_iterator AI = M->alias_begin(), E = M->alias_end();
 392        AI != E; ++AI) {
 393     Vals.push_back(VE.getTypeID(AI->getType()));
 394     Vals.push_back(VE.getValueID(AI->getAliasee()));
 395     Vals.push_back(getEncodedLinkage(AI));
 396     unsigned AbbrevToUse = 0;
 397     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
 398     Vals.clear();
 399   }
 400 }
 401
 402
 403 static void WriteConstants(unsigned FirstVal, unsigned LastVal,
 404                            const ValueEnumerator &VE,
 405                            BitstreamWriter &Stream, bool isGlobal) {
 406   if (FirstVal == LastVal) return;
 407
 408   Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);
 409
 410   unsigned AggregateAbbrev = 0;
 411   unsigned GEPAbbrev = 0;
 412   // If this is a constant pool for the module, emit module-specific abbrevs.
 413   if (isGlobal) {
 414     // Abbrev for CST_CODE_AGGREGATE.
 415     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 416     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));
 417     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 418     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));
 419     AggregateAbbrev = Stream.EmitAbbrev(Abbv);
 420   }
 421
 422   // FIXME: Install and use abbrevs to reduce size.  Install them globally so
 423   // they don't need to be reemitted for each function body.
 424
 425   SmallVector<uint64_t, 64> Record;
 426
 427   const ValueEnumerator::ValueList &Vals = VE.getValues();
 428   const Type *LastTy = 0;
 429   for (unsigned i = FirstVal; i != LastVal; ++i) {
 430     const Value *V = Vals[i].first;
 431     // If we need to switch types, do so now.
 432     if (V->getType() != LastTy) {
 433       LastTy = V->getType();
 434       Record.push_back(VE.getTypeID(LastTy));
 435       Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
 436                         CONSTANTS_SETTYPE_ABBREV);
 437       Record.clear();
 438     }
 439
 440     if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
 441       assert(0 && IA && "FIXME: Inline asm writing unimp!");
 442       continue;
 443     }
 444     const Constant *C = cast<Constant>(V);
 445     unsigned Code = -1U;
 446     unsigned AbbrevToUse = 0;
 447     if (C->isNullValue()) {
 448       Code = bitc::CST_CODE_NULL;
 449     } else if (isa<UndefValue>(C)) {
 450       Code = bitc::CST_CODE_UNDEF;
 451     } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
 452       if (IV->getBitWidth() <= 64) {
 453         int64_t V = IV->getSExtValue();
 454         if (V >= 0)
 455           Record.push_back(V << 1);
 456         else
 457           Record.push_back((-V << 1) | 1);
 458         Code = bitc::CST_CODE_INTEGER;
 459         AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
 460       } else {                             // Wide integers, > 64 bits in size.
 461         // We have an arbitrary precision integer value to write whose
 462         // bit width is > 64. However, in canonical unsigned integer
 463         // format it is likely that the high bits are going to be zero.
 464         // So, we only write the number of active words.
 465         unsigned NWords = IV->getValue().getActiveWords();
 466         const uint64_t *RawWords = IV->getValue().getRawData();
 467         for (unsigned i = 0; i != NWords; ++i) {
 468           int64_t V = RawWords[i];
 469           if (V >= 0)
 470             Record.push_back(V << 1);
 471           else
 472             Record.push_back((-V << 1) | 1);
 473         }
 474         Code = bitc::CST_CODE_WIDE_INTEGER;
 475       }
 476     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
 477       Code = bitc::CST_CODE_FLOAT;
 478       if (CFP->getType() == Type::FloatTy) {
 479         Record.push_back(FloatToBits((float)CFP->getValue()));
 480       } else {
 481         assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
 482         Record.push_back(DoubleToBits((double)CFP->getValue()));
 483       }
 484     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
 485                isa<ConstantVector>(V)) {
 486       Code = bitc::CST_CODE_AGGREGATE;
 487       for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
 488         Record.push_back(VE.getValueID(C->getOperand(i)));
 489       AbbrevToUse = AggregateAbbrev;
 490     } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
 491       switch (CE->getOpcode()) {
 492       default:
 493         if (Instruction::isCast(CE->getOpcode())) {
 494           Code = bitc::CST_CODE_CE_CAST;
 495           Record.push_back(GetEncodedCastOpcode(CE->getOpcode()));
 496           Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
 497           Record.push_back(VE.getValueID(C->getOperand(0)));
 498           AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
 499         } else {
 500           assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
 501           Code = bitc::CST_CODE_CE_BINOP;
 502           Record.push_back(GetEncodedBinaryOpcode(CE->getOpcode()));
 503           Record.push_back(VE.getValueID(C->getOperand(0)));
 504           Record.push_back(VE.getValueID(C->getOperand(1)));
 505         }
 506         break;
 507       case Instruction::GetElementPtr:
 508         Code = bitc::CST_CODE_CE_GEP;
 509         for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
 510           Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
 511           Record.push_back(VE.getValueID(C->getOperand(i)));
 512         }
 513         AbbrevToUse = GEPAbbrev;
 514         break;
 515       case Instruction::Select:
 516         Code = bitc::CST_CODE_CE_SELECT;
 517         Record.push_back(VE.getValueID(C->getOperand(0)));
 518         Record.push_back(VE.getValueID(C->getOperand(1)));
 519         Record.push_back(VE.getValueID(C->getOperand(2)));
 520         break;
 521       case Instruction::ExtractElement:
 522         Code = bitc::CST_CODE_CE_EXTRACTELT;
 523         Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
 524         Record.push_back(VE.getValueID(C->getOperand(0)));
 525         Record.push_back(VE.getValueID(C->getOperand(1)));
 526         break;
 527       case Instruction::InsertElement:
 528         Code = bitc::CST_CODE_CE_INSERTELT;
 529         Record.push_back(VE.getValueID(C->getOperand(0)));
 530         Record.push_back(VE.getValueID(C->getOperand(1)));
 531         Record.push_back(VE.getValueID(C->getOperand(2)));
 532         break;
 533       case Instruction::ShuffleVector:
 534         Code = bitc::CST_CODE_CE_SHUFFLEVEC;
 535         Record.push_back(VE.getValueID(C->getOperand(0)));
 536         Record.push_back(VE.getValueID(C->getOperand(1)));
 537         Record.push_back(VE.getValueID(C->getOperand(2)));
 538         break;
 539       case Instruction::ICmp:
 540       case Instruction::FCmp:
 541         Code = bitc::CST_CODE_CE_CMP;
 542         Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
 543         Record.push_back(VE.getValueID(C->getOperand(0)));
 544         Record.push_back(VE.getValueID(C->getOperand(1)));
 545         Record.push_back(CE->getPredicate());
 546         break;
 547       }
 548     } else {
 549       assert(0 && "Unknown constant!");
 550     }
 551     Stream.EmitRecord(Code, Record, AbbrevToUse);
 552     Record.clear();
 553   }
 554
 555   Stream.ExitBlock();
 556 }
 557
 558 static void WriteModuleConstants(const ValueEnumerator &VE,
 559                                  BitstreamWriter &Stream) {
 560   const ValueEnumerator::ValueList &Vals = VE.getValues();
 561
 562   // Find the first constant to emit, which is the first non-globalvalue value.
 563   // We know globalvalues have been emitted by WriteModuleInfo.
 564   for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
 565     if (!isa<GlobalValue>(Vals[i].first)) {
 566       WriteConstants(i, Vals.size(), VE, Stream, true);
 567       return;
 568     }
 569   }
 570 }
 571
 572 /// WriteInstruction - Emit an instruction to the specified stream.
 573 static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
 574                              BitstreamWriter &Stream,
 575                              SmallVector<unsigned, 64> &Vals) {
 576   unsigned Code = 0;
 577   unsigned AbbrevToUse = 0;
 578   switch (I.getOpcode()) {
 579   default:
 580     if (Instruction::isCast(I.getOpcode())) {
 581       Code = bitc::FUNC_CODE_INST_CAST;
 582       Vals.push_back(GetEncodedCastOpcode(I.getOpcode()));
 583       Vals.push_back(VE.getTypeID(I.getType()));
 584       Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 585       Vals.push_back(VE.getValueID(I.getOperand(0)));
 586     } else {
 587       assert(isa<BinaryOperator>(I) && "Unknown instruction!");
 588       Code = bitc::FUNC_CODE_INST_BINOP;
 589       Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode()));
 590       Vals.push_back(VE.getTypeID(I.getType()));
 591       Vals.push_back(VE.getValueID(I.getOperand(0)));
 592       Vals.push_back(VE.getValueID(I.getOperand(1)));
 593     }
 594     break;
 595
 596   case Instruction::GetElementPtr:
 597     Code = bitc::FUNC_CODE_INST_GEP;
 598     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
 599       Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
 600       Vals.push_back(VE.getValueID(I.getOperand(i)));
 601     }
 602     break;
 603   case Instruction::Select:
 604     Code = bitc::FUNC_CODE_INST_SELECT;
 605     Vals.push_back(VE.getTypeID(I.getType()));
 606     Vals.push_back(VE.getValueID(I.getOperand(0)));
 607     Vals.push_back(VE.getValueID(I.getOperand(1)));
 608     Vals.push_back(VE.getValueID(I.getOperand(2)));
 609     break;
 610   case Instruction::ExtractElement:
 611     Code = bitc::FUNC_CODE_INST_EXTRACTELT;
 612     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 613     Vals.push_back(VE.getValueID(I.getOperand(0)));
 614     Vals.push_back(VE.getValueID(I.getOperand(1)));
 615     break;
 616   case Instruction::InsertElement:
 617     Code = bitc::FUNC_CODE_INST_INSERTELT;
 618     Vals.push_back(VE.getTypeID(I.getType()));
 619     Vals.push_back(VE.getValueID(I.getOperand(0)));
 620     Vals.push_back(VE.getValueID(I.getOperand(1)));
 621     Vals.push_back(VE.getValueID(I.getOperand(2)));
 622     break;
 623   case Instruction::ShuffleVector:
 624     Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;
 625     Vals.push_back(VE.getTypeID(I.getType()));
 626     Vals.push_back(VE.getValueID(I.getOperand(0)));
 627     Vals.push_back(VE.getValueID(I.getOperand(1)));
 628     Vals.push_back(VE.getValueID(I.getOperand(2)));
 629     break;
 630   case Instruction::ICmp:
 631   case Instruction::FCmp:
 632     Code = bitc::FUNC_CODE_INST_CMP;
 633     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 634     Vals.push_back(VE.getValueID(I.getOperand(0)));
 635     Vals.push_back(VE.getValueID(I.getOperand(1)));
 636     Vals.push_back(cast<CmpInst>(I).getPredicate());
 637     break;
 638
 639   case Instruction::Ret:
 640     Code = bitc::FUNC_CODE_INST_RET;
 641     if (I.getNumOperands()) {
 642       Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 643       Vals.push_back(VE.getValueID(I.getOperand(0)));
 644     }
 645     break;
 646   case Instruction::Br:
 647     Code = bitc::FUNC_CODE_INST_BR;
 648     Vals.push_back(VE.getValueID(I.getOperand(0)));
 649     if (cast<BranchInst>(I).isConditional()) {
 650       Vals.push_back(VE.getValueID(I.getOperand(1)));
 651       Vals.push_back(VE.getValueID(I.getOperand(2)));
 652     }
 653     break;
 654   case Instruction::Switch:
 655     Code = bitc::FUNC_CODE_INST_SWITCH;
 656     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 657     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
 658       Vals.push_back(VE.getValueID(I.getOperand(i)));
 659     break;
 660   case Instruction::Invoke: {
 661     Code = bitc::FUNC_CODE_INST_INVOKE;
 662     Vals.push_back(cast<InvokeInst>(I).getCallingConv());
 663     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 664     Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
 665     Vals.push_back(VE.getValueID(I.getOperand(1)));  // normal
 666     Vals.push_back(VE.getValueID(I.getOperand(2)));  // unwind
 667
 668     // Emit value #'s for the fixed parameters.
 669     const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
 670     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
 671     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
 672       Vals.push_back(VE.getValueID(I.getOperand(i+3)));  // fixed param.
 673
 674     // Emit type/value pairs for varargs params.
 675     if (FTy->isVarArg()) {
 676       unsigned NumVarargs = I.getNumOperands()-3-FTy->getNumParams();
 677       for (unsigned i = I.getNumOperands()-NumVarargs, e = I.getNumOperands();
 678            i != e; ++i) {
 679         Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
 680         Vals.push_back(VE.getValueID(I.getOperand(i)));
 681       }
 682     }
 683     break;
 684   }
 685   case Instruction::Unwind:
 686     Code = bitc::FUNC_CODE_INST_UNWIND;
 687     break;
 688   case Instruction::Unreachable:
 689     Code = bitc::FUNC_CODE_INST_UNREACHABLE;
 690     break;
 691
 692   case Instruction::PHI:
 693     Code = bitc::FUNC_CODE_INST_PHI;
 694     Vals.push_back(VE.getTypeID(I.getType()));
 695     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
 696       Vals.push_back(VE.getValueID(I.getOperand(i)));
 697     break;
 698
 699   case Instruction::Malloc:
 700     Code = bitc::FUNC_CODE_INST_MALLOC;
 701     Vals.push_back(VE.getTypeID(I.getType()));
 702     Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
 703     Vals.push_back(Log2_32(cast<MallocInst>(I).getAlignment())+1);
 704     break;
 705
 706   case Instruction::Free:
 707     Code = bitc::FUNC_CODE_INST_FREE;
 708     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 709     Vals.push_back(VE.getValueID(I.getOperand(0)));
 710     break;
 711
 712   case Instruction::Alloca:
 713     Code = bitc::FUNC_CODE_INST_ALLOCA;
 714     Vals.push_back(VE.getTypeID(I.getType()));
 715     Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
 716     Vals.push_back(Log2_32(cast<AllocaInst>(I).getAlignment())+1);
 717     break;
 718
 719   case Instruction::Load:
 720     Code = bitc::FUNC_CODE_INST_LOAD;
 721     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 722     Vals.push_back(VE.getValueID(I.getOperand(0))); // ptr.
 723     Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
 724     Vals.push_back(cast<LoadInst>(I).isVolatile());
 725     break;
 726   case Instruction::Store:
 727     Code = bitc::FUNC_CODE_INST_STORE;
 728     Vals.push_back(VE.getTypeID(I.getOperand(1)->getType()));   // Pointer
 729     Vals.push_back(VE.getValueID(I.getOperand(0))); // val.
 730     Vals.push_back(VE.getValueID(I.getOperand(1))); // ptr.
 731     Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
 732     Vals.push_back(cast<StoreInst>(I).isVolatile());
 733     break;
 734   case Instruction::Call: {
 735     Code = bitc::FUNC_CODE_INST_CALL;
 736     Vals.push_back((cast<CallInst>(I).getCallingConv() << 1) |
 737                    cast<CallInst>(I).isTailCall());
 738     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
 739     Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
 740
 741     // Emit value #'s for the fixed parameters.
 742     const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
 743     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
 744     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
 745       Vals.push_back(VE.getValueID(I.getOperand(i+1)));  // fixed param.
 746
 747     // Emit type/value pairs for varargs params.
 748     if (FTy->isVarArg()) {
 749       unsigned NumVarargs = I.getNumOperands()-1-FTy->getNumParams();
 750       for (unsigned i = I.getNumOperands()-NumVarargs, e = I.getNumOperands();
 751            i != e; ++i) {
 752         Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
 753         Vals.push_back(VE.getValueID(I.getOperand(i)));
 754       }
 755     }
 756     break;
 757   }
 758   case Instruction::VAArg:
 759     Code = bitc::FUNC_CODE_INST_VAARG;
 760     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));   // valistty
 761     Vals.push_back(VE.getValueID(I.getOperand(0))); // valist.
 762     Vals.push_back(VE.getTypeID(I.getType())); // restype.
 763     break;
 764   }
 765
 766   Stream.EmitRecord(Code, Vals, AbbrevToUse);
 767   Vals.clear();
 768 }
 769
 770 // Emit names for globals/functions etc.
 771 static void WriteValueSymbolTable(const ValueSymbolTable &VST,
 772                                   const ValueEnumerator &VE,
 773                                   BitstreamWriter &Stream) {
 774   if (VST.empty()) return;
 775   Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
 776
 777   // FIXME: Set up the abbrev, we know how many values there are!
 778   // FIXME: We know if the type names can use 7-bit ascii.
 779   SmallVector<unsigned, 64> NameVals;
 780
 781   for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
 782        SI != SE; ++SI) {
 783
 784     const ValueName &Name = *SI;
 785
 786     // Figure out the encoding to use for the name.
 787     bool is7Bit = true;
 788     bool isChar6 = true;
 789     for (const char *C = Name.getKeyData(), *E = C+Name.getKeyLength();
 790          C != E; ++C) {
 791       if (isChar6)
 792         isChar6 = BitCodeAbbrevOp::isChar6(*C);
 793       if ((unsigned char)*C & 128) {
 794         is7Bit = false;
 795         break;  // don't bother scanning the rest.
 796       }
 797     }
 798
 799     unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
 800
 801     // VST_ENTRY:   [valueid, namechar x N]
 802     // VST_BBENTRY: [bbid, namechar x N]
 803     unsigned Code;
 804     if (isa<BasicBlock>(SI->getValue())) {
 805       Code = bitc::VST_CODE_BBENTRY;
 806       if (isChar6)
 807         AbbrevToUse = VST_BBENTRY_6_ABBREV;
 808     } else {
 809       Code = bitc::VST_CODE_ENTRY;
 810       if (isChar6)
 811         AbbrevToUse = VST_ENTRY_6_ABBREV;
 812       else if (is7Bit)
 813         AbbrevToUse = VST_ENTRY_7_ABBREV;
 814     }
 815
 816     NameVals.push_back(VE.getValueID(SI->getValue()));
 817     for (const char *P = Name.getKeyData(),
 818          *E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P)
 819       NameVals.push_back((unsigned char)*P);
 820
 821     // Emit the finished record.
 822     Stream.EmitRecord(Code, NameVals, AbbrevToUse);
 823     NameVals.clear();
 824   }
 825   Stream.ExitBlock();
 826 }
 827
 828 /// WriteFunction - Emit a function body to the module stream.
 829 static void WriteFunction(const Function &F, ValueEnumerator &VE,
 830                           BitstreamWriter &Stream) {
 831   Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 3);
 832   VE.incorporateFunction(F);
 833
 834   SmallVector<unsigned, 64> Vals;
 835
 836   // Emit the number of basic blocks, so the reader can create them ahead of
 837   // time.
 838   Vals.push_back(VE.getBasicBlocks().size());
 839   Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);
 840   Vals.clear();
 841
 842   // FIXME: Function attributes?
 843
 844   // If there are function-local constants, emit them now.
 845   unsigned CstStart, CstEnd;
 846   VE.getFunctionConstantRange(CstStart, CstEnd);
 847   WriteConstants(CstStart, CstEnd, VE, Stream, false);
 848
 849   // Finally, emit all the instructions, in order.
 850   for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
 851     for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
 852       WriteInstruction(*I, VE, Stream, Vals);
 853
 854   // Emit names for all the instructions etc.
 855   WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
 856
 857   VE.purgeFunction();
 858   Stream.ExitBlock();
 859 }
 860
 861 /// WriteTypeSymbolTable - Emit a block for the specified type symtab.
 862 static void WriteTypeSymbolTable(const TypeSymbolTable &TST,
 863                                  const ValueEnumerator &VE,
 864                                  BitstreamWriter &Stream) {
 865   if (TST.empty()) return;
 866
 867   Stream.EnterSubblock(bitc::TYPE_SYMTAB_BLOCK_ID, 3);
 868
 869   // 7-bit fixed width VST_CODE_ENTRY strings.
 870   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 871   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
 872   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 873                             Log2_32_Ceil(VE.getTypes().size()+1)));
 874   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 875   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
 876   unsigned V7Abbrev = Stream.EmitAbbrev(Abbv);
 877
 878   SmallVector<unsigned, 64> NameVals;
 879
 880   for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end();
 881        TI != TE; ++TI) {
 882     // TST_ENTRY: [typeid, namechar x N]
 883     NameVals.push_back(VE.getTypeID(TI->second));
 884
 885     const std::string &Str = TI->first;
 886     bool is7Bit = true;
 887     for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 888       NameVals.push_back((unsigned char)Str[i]);
 889       if (Str[i] & 128)
 890         is7Bit = false;
 891     }
 892
 893     // Emit the finished record.
 894     Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, is7Bit ? V7Abbrev : 0);
 895     NameVals.clear();
 896   }
 897
 898   Stream.ExitBlock();
 899 }
 900
 901 // Emit blockinfo, which defines the standard abbreviations etc.
 902 static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) {
 903   // We only want to emit block info records for blocks that have multiple
 904   // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.  Other
 905   // blocks can defined their abbrevs inline.
 906   Stream.EnterBlockInfoBlock(2);
 907
 908   { // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings.
 909     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 910     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
 911     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 912     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 913     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
 914     if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
 915                                    Abbv) != VST_ENTRY_8_ABBREV)
 916       assert(0 && "Unexpected abbrev ordering!");
 917   }
 918
 919   { // 7-bit fixed width VST_ENTRY strings.
 920     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 921     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
 922     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 923     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 924     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
 925     if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
 926                                    Abbv) != VST_ENTRY_7_ABBREV)
 927       assert(0 && "Unexpected abbrev ordering!");
 928   }
 929   { // 6-bit char6 VST_ENTRY strings.
 930     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 931     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
 932     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 933     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 934     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 935     if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
 936                                    Abbv) != VST_ENTRY_6_ABBREV)
 937       assert(0 && "Unexpected abbrev ordering!");
 938   }
 939   { // 6-bit char6 VST_BBENTRY strings.
 940     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 941     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
 942     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 943     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 944     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 945     if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
 946                                    Abbv) != VST_BBENTRY_6_ABBREV)
 947       assert(0 && "Unexpected abbrev ordering!");
 948   }
 949
 950   { // SETTYPE abbrev for CONSTANTS_BLOCK.
 951     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 952     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));
 953     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 954                               Log2_32_Ceil(VE.getTypes().size()+1)));
 955     if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
 956                                    Abbv) != CONSTANTS_SETTYPE_ABBREV)
 957       assert(0 && "Unexpected abbrev ordering!");
 958   }
 959
 960   { // INTEGER abbrev for CONSTANTS_BLOCK.
 961     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 962     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));
 963     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 964     if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
 965                                    Abbv) != CONSTANTS_INTEGER_ABBREV)
 966       assert(0 && "Unexpected abbrev ordering!");
 967   }
 968
 969   { // CE_CAST abbrev for CONSTANTS_BLOCK.
 970     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 971     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));
 972     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));  // cast opc
 973     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,       // typeid
 974                               Log2_32_Ceil(VE.getTypes().size()+1)));
 975     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));    // value id
 976
 977     if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
 978                                    Abbv) != CONSTANTS_CE_CAST_Abbrev)
 979       assert(0 && "Unexpected abbrev ordering!");
 980   }
 981   { // NULL abbrev for CONSTANTS_BLOCK.
 982     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
 983     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));
 984     if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
 985                                    Abbv) != CONSTANTS_NULL_Abbrev)
 986       assert(0 && "Unexpected abbrev ordering!");
 987   }
 988
 989   Stream.ExitBlock();
 990 }
 991
 992
 993 /// WriteModule - Emit the specified module to the bitstream.
 994 static void WriteModule(const Module *M, BitstreamWriter &Stream) {
 995   Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
 996
 997   // Emit the version number if it is non-zero.
 998   if (CurVersion) {
 999     SmallVector<unsigned, 1> Vals;
1000     Vals.push_back(CurVersion);
1001     Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
1002   }
1003
1004   // Analyze the module, enumerating globals, functions, etc.
1005   ValueEnumerator VE(M);
1006
1007   // Emit blockinfo, which defines the standard abbreviations etc.
1008   WriteBlockInfo(VE, Stream);
1009
1010   // Emit information about parameter attributes.
1011   WriteParamAttrTable(VE, Stream);
1012
1013   // Emit information describing all of the types in the module.
1014   WriteTypeTable(VE, Stream);
1015
1016   // Emit top-level description of module, including target triple, inline asm,
1017   // descriptors for global variables, and function prototype info.
1018   WriteModuleInfo(M, VE, Stream);
1019
1020   // Emit constants.
1021   WriteModuleConstants(VE, Stream);
1022
1023   // If we have any aggregate values in the value table, purge them - these can
1024   // only be used to initialize global variables.  Doing so makes the value
1025   // namespace smaller for code in functions.
1026   int NumNonAggregates = VE.PurgeAggregateValues();
1027   if (NumNonAggregates != -1) {
1028     SmallVector<unsigned, 1> Vals;
1029     Vals.push_back(NumNonAggregates);
1030     Stream.EmitRecord(bitc::MODULE_CODE_PURGEVALS, Vals);
1031   }
1032
1033   // Emit function bodies.
1034   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
1035     if (!I->isDeclaration())
1036       WriteFunction(*I, VE, Stream);
1037
1038   // Emit the type symbol table information.
1039   WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream);
1040
1041   // Emit names for globals/functions etc.
1042   WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
1043
1044   Stream.ExitBlock();
1045 }
1046
1047
1048 /// WriteBitcodeToFile - Write the specified module to the specified output
1049 /// stream.
1050 void llvm::WriteBitcodeToFile(const Module *M, std::ostream &Out) {
1051   std::vector<unsigned char> Buffer;
1052   BitstreamWriter Stream(Buffer);
1053
1054   Buffer.reserve(256*1024);
1055
1056   // Emit the file header.
1057   Stream.Emit((unsigned)'B', 8);
1058   Stream.Emit((unsigned)'C', 8);
1059   Stream.Emit(0x0, 4);
1060   Stream.Emit(0xC, 4);
1061   Stream.Emit(0xE, 4);
1062   Stream.Emit(0xD, 4);
1063
1064   // Emit the module.
1065   WriteModule(M, Stream);
1066
1067   // Write the generated bitstream to "Out".
1068   Out.write((char*)&Buffer.front(), Buffer.size());
1069 }