bug 263:

- encode/decode target triple and dependent libraries
bug 401:
- fix encoding/decoding of FP values to be little-endian only
bug 402:
- initial (compatible) cut at 24-bit types instead of 32-bit
- reduce size of block headers by 50%
Other:
- cleanup Writer by consolidating to one compilation unit, rem. other files
- use a std::vector instead of std::deque so the buffer can be allocated
  in multiples of 64KByte chunks rather than in multiples of some smaller
  (default) number.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15210 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 832 insertions, 783 deletions

diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp
deleted file mode 100644
index 7aa8febda3..0000000000
--- a/lib/Bytecode/Writer/ConstantWriter.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-//===-- ConstantWriter.cpp - Functions for writing constants --------------===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// This file implements the routines for encoding constants to a bytecode 
-// stream.
-//
-//===----------------------------------------------------------------------===//
-
-#include "WriterInternals.h"
-#include "llvm/Constants.h"
-#include "llvm/SymbolTable.h"
-#include "llvm/DerivedTypes.h"
-#include "Support/Statistic.h"
-using namespace llvm;
-
-void BytecodeWriter::outputType(const Type *T) {
-  output_vbr((unsigned)T->getTypeID(), Out);
-  
-  // That's all there is to handling primitive types...
-  if (T->isPrimitiveType()) {
-    return;     // We might do this if we alias a prim type: %x = type int
-  }
-
-  switch (T->getTypeID()) {   // Handle derived types now.
-  case Type::FunctionTyID: {
-    const FunctionType *MT = cast<FunctionType>(T);
-    int Slot = Table.getSlot(MT->getReturnType());
-    assert(Slot != -1 && "Type used but not available!!");
-    output_vbr((unsigned)Slot, Out);
-
-    // Output the number of arguments to function (+1 if varargs):
-    output_vbr((unsigned)MT->getNumParams()+MT->isVarArg(), Out);
-
-    // Output all of the arguments...
-    FunctionType::param_iterator I = MT->param_begin();
-    for (; I != MT->param_end(); ++I) {
-      Slot = Table.getSlot(*I);
-      assert(Slot != -1 && "Type used but not available!!");
-      output_vbr((unsigned)Slot, Out);
-    }
-
-    // Terminate list with VoidTy if we are a varargs function...
-    if (MT->isVarArg())
-      output_vbr((unsigned)Type::VoidTyID, Out);
-    break;
-  }
-
-  case Type::ArrayTyID: {
-    const ArrayType *AT = cast<ArrayType>(T);
-    int Slot = Table.getSlot(AT->getElementType());
-    assert(Slot != -1 && "Type used but not available!!");
-    output_vbr((unsigned)Slot, Out);
-    //std::cerr << "Type slot = " << Slot << " Type = " << T->getName() << endl;
-
-    output_vbr(AT->getNumElements(), Out);
-    break;
-  }
-
-  case Type::StructTyID: {
-    const StructType *ST = cast<StructType>(T);
-
-    // Output all of the element types...
-    for (StructType::element_iterator I = ST->element_begin(),
-           E = ST->element_end(); I != E; ++I) {
-      int Slot = Table.getSlot(*I);
-      assert(Slot != -1 && "Type used but not available!!");
-      output_vbr((unsigned)Slot, Out);
-    }
-
-    // Terminate list with VoidTy
-    output_vbr((unsigned)Type::VoidTyID, Out);
-    break;
-  }
-
-  case Type::PointerTyID: {
-    const PointerType *PT = cast<PointerType>(T);
-    int Slot = Table.getSlot(PT->getElementType());
-    assert(Slot != -1 && "Type used but not available!!");
-    output_vbr((unsigned)Slot, Out);
-    break;
-  }
-
-  case Type::OpaqueTyID: {
-    // No need to emit anything, just the count of opaque types is enough.
-    break;
-  }
-
-  //case Type::PackedTyID:
-  default:
-    std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
-              << " Type '" << T->getDescription() << "'\n";
-    break;
-  }
-}
-
-void BytecodeWriter::outputConstant(const Constant *CPV) {
-  assert((CPV->getType()->isPrimitiveType() || !CPV->isNullValue()) &&
-         "Shouldn't output null constants!");
-
-  // We must check for a ConstantExpr before switching by type because
-  // a ConstantExpr can be of any type, and has no explicit value.
-  // 
-  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
-    // FIXME: Encoding of constant exprs could be much more compact!
-    assert(CE->getNumOperands() > 0 && "ConstantExpr with 0 operands");
-    output_vbr(CE->getNumOperands(), Out);   // flags as an expr
-    output_vbr(CE->getOpcode(), Out);        // flags as an expr
-    
-    for (User::const_op_iterator OI = CE->op_begin(); OI != CE->op_end(); ++OI){
-      int Slot = Table.getSlot(*OI);
-      assert(Slot != -1 && "Unknown constant used in ConstantExpr!!");
-      output_vbr((unsigned)Slot, Out);
-      Slot = Table.getSlot((*OI)->getType());
-      output_vbr((unsigned)Slot, Out);
-    }
-    return;
-  } else {
-    output_vbr(0U, Out);       // flag as not a ConstantExpr
-  }
-  
-  switch (CPV->getType()->getTypeID()) {
-  case Type::BoolTyID:    // Boolean Types
-    if (cast<ConstantBool>(CPV)->getValue())
-      output_vbr(1U, Out);
-    else
-      output_vbr(0U, Out);
-    break;
-
-  case Type::UByteTyID:   // Unsigned integer types...
-  case Type::UShortTyID:
-  case Type::UIntTyID:
-  case Type::ULongTyID:
-    output_vbr(cast<ConstantUInt>(CPV)->getValue(), Out);
-    break;
-
-  case Type::SByteTyID:   // Signed integer types...
-  case Type::ShortTyID:
-  case Type::IntTyID:
-  case Type::LongTyID:
-    output_vbr(cast<ConstantSInt>(CPV)->getValue(), Out);
-    break;
-
-  case Type::ArrayTyID: {
-    const ConstantArray *CPA = cast<ConstantArray>(CPV);
-    assert(!CPA->isString() && "Constant strings should be handled specially!");
-
-    for (unsigned i = 0; i != CPA->getNumOperands(); ++i) {
-      int Slot = Table.getSlot(CPA->getOperand(i));
-      assert(Slot != -1 && "Constant used but not available!!");
-      output_vbr((unsigned)Slot, Out);
-    }
-    break;
-  }
-
-  case Type::StructTyID: {
-    const ConstantStruct *CPS = cast<ConstantStruct>(CPV);
-    const std::vector<Use> &Vals = CPS->getValues();
-
-    for (unsigned i = 0; i < Vals.size(); ++i) {
-      int Slot = Table.getSlot(Vals[i]);
-      assert(Slot != -1 && "Constant used but not available!!");
-      output_vbr((unsigned)Slot, Out);
-    }
-    break;
-  }
-
-  case Type::PointerTyID:
-    assert(0 && "No non-null, non-constant-expr constants allowed!");
-    abort();
-
-  case Type::FloatTyID: {   // Floating point types...
-    float Tmp = (float)cast<ConstantFP>(CPV)->getValue();
-    output_float(Tmp, Out);
-    break;
-  }
-  case Type::DoubleTyID: {
-    double Tmp = cast<ConstantFP>(CPV)->getValue();
-    output_double(Tmp, Out);
-    break;
-  }
-
-  case Type::VoidTyID: 
-  case Type::LabelTyID:
-  default:
-    std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
-              << " type '" << *CPV->getType() << "'\n";
-    break;
-  }
-  return;
-}
-
-void BytecodeWriter::outputConstantStrings() {
-  SlotCalculator::string_iterator I = Table.string_begin();
-  SlotCalculator::string_iterator E = Table.string_end();
-  if (I == E) return;  // No strings to emit
-
-  // If we have != 0 strings to emit, output them now.  Strings are emitted into
-  // the 'void' type plane.
-  output_vbr(unsigned(E-I), Out);
-  output_vbr(Type::VoidTyID, Out);
-    
-  // Emit all of the strings.
-  for (I = Table.string_begin(); I != E; ++I) {
-    const ConstantArray *Str = *I;
-    int Slot = Table.getSlot(Str->getType());
-    assert(Slot != -1 && "Constant string of unknown type?");
-    output_vbr((unsigned)Slot, Out);
-    
-    // Now that we emitted the type (which indicates the size of the string),
-    // emit all of the characters.
-    std::string Val = Str->getAsString();
-    output_data(Val.c_str(), Val.c_str()+Val.size(), Out);
-  }
-}
diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
deleted file mode 100644
index 188136718d..0000000000
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-//===-- InstructionWriter.cpp - Functions for writing instructions --------===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// This file implements the routines for encoding instruction opcodes to a 
-// bytecode stream.
-//
-//===----------------------------------------------------------------------===//
-
-#include "WriterInternals.h"
-#include "llvm/Module.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Instructions.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "Support/Statistic.h"
-#include <algorithm>
-using namespace llvm;
-
-typedef unsigned char uchar;
-
-// outputInstructionFormat0 - Output those wierd instructions that have a large
-// number of operands or have large operands themselves...
-//
-// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
-//
-static void outputInstructionFormat0(const Instruction *I, unsigned Opcode,
-				     const SlotCalculator &Table,
-				     unsigned Type, std::deque<uchar> &Out) {
-  // Opcode must have top two bits clear...
-  output_vbr(Opcode << 2, Out);                  // Instruction Opcode ID
-  output_vbr(Type, Out);                         // Result type
-
-  unsigned NumArgs = I->getNumOperands();
-  output_vbr(NumArgs + (isa<CastInst>(I) || isa<VANextInst>(I) ||
-                        isa<VAArgInst>(I)), Out);
-
-  if (!isa<GetElementPtrInst>(&I)) {
-    for (unsigned i = 0; i < NumArgs; ++i) {
-      int Slot = Table.getSlot(I->getOperand(i));
-      assert(Slot >= 0 && "No slot number for value!?!?");      
-      output_vbr((unsigned)Slot, Out);
-    }
-
-    if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
-      int Slot = Table.getSlot(I->getType());
-      assert(Slot != -1 && "Cast return type unknown?");
-      output_vbr((unsigned)Slot, Out);
-    } else if (const VANextInst *VAI = dyn_cast<VANextInst>(I)) {
-      int Slot = Table.getSlot(VAI->getArgType());
-      assert(Slot != -1 && "VarArg argument type unknown?");
-      output_vbr((unsigned)Slot, Out);
-    }
-
-  } else {
-    int Slot = Table.getSlot(I->getOperand(0));
-    assert(Slot >= 0 && "No slot number for value!?!?");      
-    output_vbr(unsigned(Slot), Out);
-
-    // We need to encode the type of sequential type indices into their slot #
-    unsigned Idx = 1;
-    for (gep_type_iterator TI = gep_type_begin(I), E = gep_type_end(I);
-         Idx != NumArgs; ++TI, ++Idx) {
-      Slot = Table.getSlot(I->getOperand(Idx));
-      assert(Slot >= 0 && "No slot number for value!?!?");      
-    
-      if (isa<SequentialType>(*TI)) {
-        unsigned IdxId;
-        switch (I->getOperand(Idx)->getType()->getTypeID()) {
-        default: assert(0 && "Unknown index type!");
-        case Type::UIntTyID:  IdxId = 0; break;
-        case Type::IntTyID:   IdxId = 1; break;
-        case Type::ULongTyID: IdxId = 2; break;
-        case Type::LongTyID:  IdxId = 3; break;
-        }
-        Slot = (Slot << 2) | IdxId;
-      }
-      output_vbr(unsigned(Slot), Out);
-    }
-  }
-
-  align32(Out);    // We must maintain correct alignment!
-}
-
-
-// outputInstrVarArgsCall - Output the absurdly annoying varargs function calls.
-// This are more annoying than most because the signature of the call does not
-// tell us anything about the types of the arguments in the varargs portion.
-// Because of this, we encode (as type 0) all of the argument types explicitly
-// before the argument value.  This really sucks, but you shouldn't be using
-// varargs functions in your code! *death to printf*!
-//
-// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
-//
-static void outputInstrVarArgsCall(const Instruction *I, unsigned Opcode,
-				   const SlotCalculator &Table, unsigned Type,
-				   std::deque<uchar> &Out) {
-  assert(isa<CallInst>(I) || isa<InvokeInst>(I));
-  // Opcode must have top two bits clear...
-  output_vbr(Opcode << 2, Out);                  // Instruction Opcode ID
-  output_vbr(Type, Out);                         // Result type (varargs type)
-
-  const PointerType *PTy = cast<PointerType>(I->getOperand(0)->getType());
-  const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
-  unsigned NumParams = FTy->getNumParams();
-
-  unsigned NumFixedOperands;
-  if (isa<CallInst>(I)) {
-    // Output an operand for the callee and each fixed argument, then two for
-    // each variable argument.
-    NumFixedOperands = 1+NumParams;
-  } else {
-    assert(isa<InvokeInst>(I) && "Not call or invoke??");
-    // Output an operand for the callee and destinations, then two for each
-    // variable argument.
-    NumFixedOperands = 3+NumParams;
-  }
-  output_vbr(2 * I->getNumOperands()-NumFixedOperands, Out);
-
-  // The type for the function has already been emitted in the type field of the
-  // instruction.  Just emit the slot # now.
-  for (unsigned i = 0; i != NumFixedOperands; ++i) {
-    int Slot = Table.getSlot(I->getOperand(i));
-    assert(Slot >= 0 && "No slot number for value!?!?");      
-    output_vbr((unsigned)Slot, Out);
-  }
-
-  for (unsigned i = NumFixedOperands, e = I->getNumOperands(); i != e; ++i) {
-    // Output Arg Type ID
-    int Slot = Table.getSlot(I->getOperand(i)->getType());
-    assert(Slot >= 0 && "No slot number for value!?!?");      
-    output_vbr((unsigned)Slot, Out);
-    
-    // Output arg ID itself
-    Slot = Table.getSlot(I->getOperand(i));
-    assert(Slot >= 0 && "No slot number for value!?!?");      
-    output_vbr((unsigned)Slot, Out);
-  }
-  align32(Out);    // We must maintain correct alignment!
-}
-
-
-// outputInstructionFormat1 - Output one operand instructions, knowing that no
-// operand index is >= 2^12.
-//
-static void outputInstructionFormat1(const Instruction *I, unsigned Opcode,
-				     const SlotCalculator &Table,
-                                     unsigned *Slots, unsigned Type, 
-                                     std::deque<uchar> &Out) {
-  // bits   Instruction format:
-  // --------------------------
-  // 01-00: Opcode type, fixed to 1.
-  // 07-02: Opcode
-  // 19-08: Resulting type plane
-  // 31-20: Operand #1 (if set to (2^12-1), then zero operands)
-  //
-  unsigned Bits = 1 | (Opcode << 2) | (Type << 8) | (Slots[0] << 20);
-  //  cerr << "1 " << IType << " " << Type << " " << Slots[0] << endl;
-  output(Bits, Out);
-}
-
-
-// outputInstructionFormat2 - Output two operand instructions, knowing that no
-// operand index is >= 2^8.
-//
-static void outputInstructionFormat2(const Instruction *I, unsigned Opcode,
-				     const SlotCalculator &Table,
-                                     unsigned *Slots, unsigned Type, 
-                                     std::deque<uchar> &Out) {
-  // bits   Instruction format:
-  // --------------------------
-  // 01-00: Opcode type, fixed to 2.
-  // 07-02: Opcode
-  // 15-08: Resulting type plane
-  // 23-16: Operand #1
-  // 31-24: Operand #2  
-  //
-  unsigned Bits = 2 | (Opcode << 2) | (Type << 8) |
-                    (Slots[0] << 16) | (Slots[1] << 24);
-  //  cerr << "2 " << IType << " " << Type << " " << Slots[0] << " " 
-  //       << Slots[1] << endl;
-  output(Bits, Out);
-}
-
-
-// outputInstructionFormat3 - Output three operand instructions, knowing that no
-// operand index is >= 2^6.
-//
-static void outputInstructionFormat3(const Instruction *I, unsigned Opcode,
-				     const SlotCalculator &Table,
-                                     unsigned *Slots, unsigned Type,
-                                     std::deque<uchar> &Out) {
-  // bits   Instruction format:
-  // --------------------------
-  // 01-00: Opcode type, fixed to 3.
-  // 07-02: Opcode
-  // 13-08: Resulting type plane
-  // 19-14: Operand #1
-  // 25-20: Operand #2
-  // 31-26: Operand #3
-  //
-  unsigned Bits = 3 | (Opcode << 2) | (Type << 8) |
-          (Slots[0] << 14) | (Slots[1] << 20) | (Slots[2] << 26);
-  //cerr << "3 " << IType << " " << Type << " " << Slots[0] << " " 
-  //     << Slots[1] << " " << Slots[2] << endl;
-  output(Bits, Out);
-}
-
-void BytecodeWriter::outputInstruction(const Instruction &I) {
-  assert(I.getOpcode() < 62 && "Opcode too big???");
-  unsigned Opcode = I.getOpcode();
-  unsigned NumOperands = I.getNumOperands();
-
-  // Encode 'volatile load' as 62 and 'volatile store' as 63.
-  if (isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile())
-    Opcode = 62;
-  if (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())
-    Opcode = 63;
-
-  // Figure out which type to encode with the instruction.  Typically we want
-  // the type of the first parameter, as opposed to the type of the instruction
-  // (for example, with setcc, we always know it returns bool, but the type of
-  // the first param is actually interesting).  But if we have no arguments
-  // we take the type of the instruction itself.  
-  //
-  const Type *Ty;
-  switch (I.getOpcode()) {
-  case Instruction::Select:
-  case Instruction::Malloc:
-  case Instruction::Alloca:
-    Ty = I.getType();  // These ALWAYS want to encode the return type
-    break;
-  case Instruction::Store:
-    Ty = I.getOperand(1)->getType();  // Encode the pointer type...
-    assert(isa<PointerType>(Ty) && "Store to nonpointer type!?!?");
-    break;
-  default:              // Otherwise use the default behavior...
-    Ty = NumOperands ? I.getOperand(0)->getType() : I.getType();
-    break;
-  }
-
-  unsigned Type;
-  int Slot = Table.getSlot(Ty);
-  assert(Slot != -1 && "Type not available!!?!");
-  Type = (unsigned)Slot;
-
-  // Varargs calls and invokes are encoded entirely different from any other
-  // instructions.
-  if (const CallInst *CI = dyn_cast<CallInst>(&I)){
-    const PointerType *Ty =cast<PointerType>(CI->getCalledValue()->getType());
-    if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
-      outputInstrVarArgsCall(CI, Opcode, Table, Type, Out);
-      return;
-    }
-  } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
-    const PointerType *Ty =cast<PointerType>(II->getCalledValue()->getType());
-    if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
-      outputInstrVarArgsCall(II, Opcode, Table, Type, Out);
-      return;
-    }
-  }
-
-  if (NumOperands <= 3) {
-    // Make sure that we take the type number into consideration.  We don't want
-    // to overflow the field size for the instruction format we select.
-    //
-    unsigned MaxOpSlot = Type;
-    unsigned Slots[3]; Slots[0] = (1 << 12)-1;   // Marker to signify 0 operands
-    
-    for (unsigned i = 0; i != NumOperands; ++i) {
-      int slot = Table.getSlot(I.getOperand(i));
-      assert(slot != -1 && "Broken bytecode!");
-      if (unsigned(slot) > MaxOpSlot) MaxOpSlot = unsigned(slot);
-      Slots[i] = unsigned(slot);
-    }
-
-    // Handle the special cases for various instructions...
-    if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
-      // Cast has to encode the destination type as the second argument in the
-      // packet, or else we won't know what type to cast to!
-      Slots[1] = Table.getSlot(I.getType());
-      assert(Slots[1] != ~0U && "Cast return type unknown?");
-      if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
-      NumOperands++;
-    } else if (const VANextInst *VANI = dyn_cast<VANextInst>(&I)) {
-      Slots[1] = Table.getSlot(VANI->getArgType());
-      assert(Slots[1] != ~0U && "va_next return type unknown?");
-      if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
-      NumOperands++;
-    } else if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
-      // We need to encode the type of sequential type indices into their slot #
-      unsigned Idx = 1;
-      for (gep_type_iterator I = gep_type_begin(GEP), E = gep_type_end(GEP);
-           I != E; ++I, ++Idx)
-        if (isa<SequentialType>(*I)) {
-          unsigned IdxId;
-          switch (GEP->getOperand(Idx)->getType()->getTypeID()) {
-          default: assert(0 && "Unknown index type!");
-          case Type::UIntTyID:  IdxId = 0; break;
-          case Type::IntTyID:   IdxId = 1; break;
-          case Type::ULongTyID: IdxId = 2; break;
-          case Type::LongTyID:  IdxId = 3; break;
-          }
-          Slots[Idx] = (Slots[Idx] << 2) | IdxId;
-          if (Slots[Idx] > MaxOpSlot) MaxOpSlot = Slots[Idx];
-        }
-    }
-
-    // Decide which instruction encoding to use.  This is determined primarily
-    // by the number of operands, and secondarily by whether or not the max
-    // operand will fit into the instruction encoding.  More operands == fewer
-    // bits per operand.
-    //
-    switch (NumOperands) {
-    case 0:
-    case 1:
-      if (MaxOpSlot < (1 << 12)-1) { // -1 because we use 4095 to indicate 0 ops
-        outputInstructionFormat1(&I, Opcode, Table, Slots, Type, Out);
-        return;
-      }
-      break;
-
-    case 2:
-      if (MaxOpSlot < (1 << 8)) {
-        outputInstructionFormat2(&I, Opcode, Table, Slots, Type, Out);
-        return;
-      }
-      break;
-
-    case 3:
-      if (MaxOpSlot < (1 << 6)) {
-        outputInstructionFormat3(&I, Opcode, Table, Slots, Type, Out);
-        return;
-      }
-      break;
-    default:
-      break;
-    }
-  }
-
-  // If we weren't handled before here, we either have a large number of
-  // operands or a large operand index that we are referring to.
-  outputInstructionFormat0(&I, Opcode, Table, Type, Out);
-}
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 395386d662..9bc5ce600a 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -10,24 +10,21 @@
 // This library implements the functionality defined in llvm/Bytecode/Writer.h
 //
 // Note that this file uses an unusual technique of outputting all the bytecode
-// to a deque of unsigned char, then copies the deque to an ostream.  The
+// to a vector of unsigned char, then copies the vector to an ostream.  The
 // reason for this is that we must do "seeking" in the stream to do back-
 // patching, and some very important ostreams that we want to support (like
 // pipes) do not support seeking.  :( :( :(
 //
-// The choice of the deque data structure is influenced by the extremely fast
-// "append" speed, plus the free "seek"/replace in the middle of the stream. I
-// didn't use a vector because the stream could end up very large and copying
-// the whole thing to reallocate would be kinda silly.
-//
 //===----------------------------------------------------------------------===//
 
 #include "WriterInternals.h"
 #include "llvm/Bytecode/WriteBytecodePass.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "Support/STLExtras.h"
 #include "Support/Statistic.h"
 #include <cstring>
@@ -39,15 +36,720 @@ static RegisterPass<WriteBytecodePass> X("emitbytecode", "Bytecode Writer");
 static Statistic<> 
 BytesWritten("bytecodewriter", "Number of bytecode bytes written");
 
-BytecodeWriter::BytecodeWriter(std::deque<unsigned char> &o, const Module *M) 
+//===----------------------------------------------------------------------===//
+//===                           Output Primitives                          ===//
+//===----------------------------------------------------------------------===//
+
+// output - If a position is specified, it must be in the valid portion of the
+// string... note that this should be inlined always so only the relevant IF 
+// body should be included.
+inline void BytecodeWriter::output(unsigned i, int pos) {
+  if (pos == -1) { // Be endian clean, little endian is our friend
+    Out.push_back((unsigned char)i); 
+    Out.push_back((unsigned char)(i >> 8));
+    Out.push_back((unsigned char)(i >> 16));
+    Out.push_back((unsigned char)(i >> 24));
+  } else {
+    Out[pos  ] = (unsigned char)i;
+    Out[pos+1] = (unsigned char)(i >> 8);
+    Out[pos+2] = (unsigned char)(i >> 16);
+    Out[pos+3] = (unsigned char)(i >> 24);
+  }
+}
+
+inline void BytecodeWriter::output(int i) {
+  output((unsigned)i);
+}
+
+/// output_vbr - Output an unsigned value, by using the least number of bytes
+/// possible.  This is useful because many of our "infinite" values are really
+/// very small most of the time; but can be large a few times.
+/// Data format used:  If you read a byte with the high bit set, use the low 
+/// seven bits as data and then read another byte. Note that using this may 
+/// cause the output buffer to become unaligned.
+inline void BytecodeWriter::output_vbr(uint64_t i) {
+  while (1) {
+    if (i < 0x80) { // done?
+      Out.push_back((unsigned char)i);   // We know the high bit is clear...
+      return;
+    }
+    
+    // Nope, we are bigger than a character, output the next 7 bits and set the
+    // high bit to say that there is more coming...
+    Out.push_back(0x80 | ((unsigned char)i & 0x7F));
+    i >>= 7;  // Shift out 7 bits now...
+  }
+}
+
+inline void BytecodeWriter::output_vbr(unsigned i) {
+  while (1) {
+    if (i < 0x80) { // done?
+      Out.push_back((unsigned char)i);   // We know the high bit is clear...
+      return;
+    }
+    
+    // Nope, we are bigger than a character, output the next 7 bits and set the
+    // high bit to say that there is more coming...
+    Out.push_back(0x80 | ((unsigned char)i & 0x7F));
+    i >>= 7;  // Shift out 7 bits now...
+  }
+}
+
+inline void BytecodeWriter::output_typeid(unsigned i) {
+  if (i <= 0x00FFFFFF)
+    this->output_vbr(i);
+  else {
+    this->output_vbr(0x00FFFFFF);
+    this->output_vbr(i);
+  }
+}
+
+inline void BytecodeWriter::output_vbr(int64_t i) {
+  if (i < 0) 
+    output_vbr(((uint64_t)(-i) << 1) | 1); // Set low order sign bit...
+  else
+    output_vbr((uint64_t)i << 1);          // Low order bit is clear.
+}
+
+
+inline void BytecodeWriter::output_vbr(int i) {
+  if (i < 0) 
+    output_vbr(((unsigned)(-i) << 1) | 1); // Set low order sign bit...
+  else
+    output_vbr((unsigned)i << 1);          // Low order bit is clear.
+}
+
+// align32 - emit the minimal number of bytes that will bring us to 32 bit 
+// alignment...
+//
+inline void BytecodeWriter::align32() {
+  int NumPads = (4-(Out.size() & 3)) & 3; // Bytes to get padding to 32 bits
+  while (NumPads--) Out.push_back((unsigned char)0xAB);
+}
+
+inline void BytecodeWriter::output(const std::string &s, bool Aligned ) {
+  unsigned Len = s.length();
+  output_vbr(Len );             // Strings may have an arbitrary length...
+  Out.insert(Out.end(), s.begin(), s.end());
+
+  if (Aligned)
+    align32();                   // Make sure we are now aligned...
+}
+
+inline void BytecodeWriter::output_data(const void *Ptr, const void *End) {
+  Out.insert(Out.end(), (const unsigned char*)Ptr, (const unsigned char*)End);
+}
+
+inline void BytecodeWriter::output_float(float& FloatVal) {
+  /// FIXME: This isn't optimal, it has size problems on some platforms
+  /// where FP is not IEEE.
+  union {
+    float f;
+    uint32_t i;
+  } FloatUnion;
+  FloatUnion.f = FloatVal;
+  Out.push_back( static_cast<unsigned char>( (FloatUnion.i & 0xFF )));
+  Out.push_back( static_cast<unsigned char>( (FloatUnion.i >> 8) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (FloatUnion.i >> 16) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (FloatUnion.i >> 24) & 0xFF));
+}
+
+inline void BytecodeWriter::output_double(double& DoubleVal) {
+  /// FIXME: This isn't optimal, it has size problems on some platforms
+  /// where FP is not IEEE.
+  union {
+    double d;
+    uint64_t i;
+  } DoubleUnion;
+  DoubleUnion.d = DoubleVal;
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i & 0xFF )));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 8) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 16) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 24) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 32) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 40) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 48) & 0xFF));
+  Out.push_back( static_cast<unsigned char>( (DoubleUnion.i >> 56) & 0xFF));
+}
+
+inline BytecodeBlock::BytecodeBlock(unsigned ID, BytecodeWriter& w,
+		     bool elideIfEmpty, bool hasLongFormat )
+  : Id(ID), Writer(w), ElideIfEmpty(elideIfEmpty), HasLongFormat(hasLongFormat){
+
+  if (HasLongFormat) {
+    w.output(ID);
+    w.output(0U); // For length in long format
+  } else {
+    w.output(0U); /// Place holder for ID and length for this block
+  }
+  Loc = w.size();
+}
+
+inline BytecodeBlock::~BytecodeBlock() {           // Do backpatch when block goes out
+				    // of scope...
+  if (Loc == Writer.size() && ElideIfEmpty) {
+    // If the block is empty, and we are allowed to, do not emit the block at
+    // all!
+    Writer.resize(Writer.size()-(HasLongFormat?8:4));
+    return;
+  }
+
+  //cerr << "OldLoc = " << Loc << " NewLoc = " << NewLoc << " diff = "
+  //     << (NewLoc-Loc) << endl;
+  if (HasLongFormat)
+    Writer.output(unsigned(Writer.size()-Loc), int(Loc-4));
+  else
+    Writer.output(unsigned(Writer.size()-Loc) << 5 | (Id & 0x1F), int(Loc-4));
+  Writer.align32();  // Blocks must ALWAYS be aligned
+}
+
+//===----------------------------------------------------------------------===//
+//===                           Constant Output                            ===//
+//===----------------------------------------------------------------------===//
+
+void BytecodeWriter::outputType(const Type *T) {
+  output_vbr((unsigned)T->getTypeID());
+  
+  // That's all there is to handling primitive types...
+  if (T->isPrimitiveType()) {
+    return;     // We might do this if we alias a prim type: %x = type int
+  }
+
+  switch (T->getTypeID()) {   // Handle derived types now.
+  case Type::FunctionTyID: {
+    const FunctionType *MT = cast<FunctionType>(T);
+    int Slot = Table.getSlot(MT->getReturnType());
+    assert(Slot != -1 && "Type used but not available!!");
+    output_typeid((unsigned)Slot);
+
+    // Output the number of arguments to function (+1 if varargs):
+    output_vbr((unsigned)MT->getNumParams()+MT->isVarArg());
+
+    // Output all of the arguments...
+    FunctionType::param_iterator I = MT->param_begin();
+    for (; I != MT->param_end(); ++I) {
+      Slot = Table.getSlot(*I);
+      assert(Slot != -1 && "Type used but not available!!");
+      output_typeid((unsigned)Slot);
+    }
+
+    // Terminate list with VoidTy if we are a varargs function...
+    if (MT->isVarArg())
+      output_typeid((unsigned)Type::VoidTyID);
+    break;
+  }
+
+  case Type::ArrayTyID: {
+    const ArrayType *AT = cast<ArrayType>(T);
+    int Slot = Table.getSlot(AT->getElementType());
+    assert(Slot != -1 && "Type used but not available!!");
+    output_typeid((unsigned)Slot);
+    //std::cerr << "Type slot = " << Slot << " Type = " << T->getName() << endl;
+
+    output_vbr(AT->getNumElements());
+    break;
+  }
+
+  case Type::StructTyID: {
+    const StructType *ST = cast<StructType>(T);
+
+    // Output all of the element types...
+    for (StructType::element_iterator I = ST->element_begin(),
+           E = ST->element_end(); I != E; ++I) {
+      int Slot = Table.getSlot(*I);
+      assert(Slot != -1 && "Type used but not available!!");
+      output_typeid((unsigned)Slot);
+    }
+
+    // Terminate list with VoidTy
+    output_typeid((unsigned)Type::VoidTyID);
+    break;
+  }
+
+  case Type::PointerTyID: {
+    const PointerType *PT = cast<PointerType>(T);
+    int Slot = Table.getSlot(PT->getElementType());
+    assert(Slot != -1 && "Type used but not available!!");
+    output_typeid((unsigned)Slot);
+    break;
+  }
+
+  case Type::OpaqueTyID: {
+    // No need to emit anything, just the count of opaque types is enough.
+    break;
+  }
+
+  //case Type::PackedTyID:
+  default:
+    std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
+              << " Type '" << T->getDescription() << "'\n";
+    break;
+  }
+}
+
+void BytecodeWriter::outputConstant(const Constant *CPV) {
+  assert((CPV->getType()->isPrimitiveType() || !CPV->isNullValue()) &&
+         "Shouldn't output null constants!");
+
+  // We must check for a ConstantExpr before switching by type because
+  // a ConstantExpr can be of any type, and has no explicit value.
+  // 
+  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
+    // FIXME: Encoding of constant exprs could be much more compact!
+    assert(CE->getNumOperands() > 0 && "ConstantExpr with 0 operands");
+    output_vbr(CE->getNumOperands());   // flags as an expr
+    output_vbr(CE->getOpcode());        // flags as an expr
+    
+    for (User::const_op_iterator OI = CE->op_begin(); OI != CE->op_end(); ++OI){
+      int Slot = Table.getSlot(*OI);
+      assert(Slot != -1 && "Unknown constant used in ConstantExpr!!");
+      output_vbr((unsigned)Slot);
+      Slot = Table.getSlot((*OI)->getType());
+      output_typeid((unsigned)Slot);
+    }
+    return;
+  } el