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

1 files changed, 0 insertions, 348 deletions

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);
-}