//===- Reader.cpp - Code to read bytecode files ---------------------------===//
// 
//                     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 library implements the functionality defined in llvm/Bytecode/Reader.h
//
// Note that this library should be as fast as possible, reentrant, and 
// threadsafe!!
//
// TODO: Allow passing in an option to ignore the symbol table
//
//===----------------------------------------------------------------------===//

#include "AnalyzerInternals.h"
#include "llvm/Module.h"
#include "llvm/Bytecode/Format.h"
#include "Support/StringExtras.h"
#include <iostream>
#include <sstream>

using namespace llvm;

#define PARSE_ERROR(inserters) \
  { \
    std::ostringstream errormsg; \
    errormsg << inserters; \
    if ( ! handler->handleError( errormsg.str() ) ) \
      throw std::string(errormsg.str()); \
  }

const Type *AbstractBytecodeParser::getType(unsigned ID) {
  //cerr << "Looking up Type ID: " << ID << "\n";

  if (ID < Type::FirstDerivedTyID)
    if (const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID))
      return T;   // Asked for a primitive type...

  // Otherwise, derived types need offset...
  ID -= Type::FirstDerivedTyID;

  if (!CompactionTypeTable.empty()) {
    if (ID >= CompactionTypeTable.size())
      PARSE_ERROR("Type ID out of range for compaction table!");
    return CompactionTypeTable[ID];
  }

  // Is it a module-level type?
  if (ID < ModuleTypes.size())
    return ModuleTypes[ID].get();

  // Nope, is it a function-level type?
  ID -= ModuleTypes.size();
  if (ID < FunctionTypes.size())
    return FunctionTypes[ID].get();

  PARSE_ERROR("Illegal type reference!");
  return Type::VoidTy;
}

bool AbstractBytecodeParser::ParseInstruction(BufPtr& Buf, BufPtr EndBuf,
                                      std::vector<unsigned> &Operands) {
  Operands.clear();
  unsigned iType = 0;
  unsigned Opcode = 0;
  unsigned Op = read(Buf, EndBuf);

  // bits   Instruction format:        Common to all formats
  // --------------------------
  // 01-00: Opcode type, fixed to 1.
  // 07-02: Opcode
  Opcode    = (Op >> 2) & 63;
  Operands.resize((Op >> 0) & 03);

  switch (Operands.size()) {
  case 1:
    // bits   Instruction format:
    // --------------------------
    // 19-08: Resulting type plane
    // 31-20: Operand #1 (if set to (2^12-1), then zero operands)
    //
    iType   = (Op >>  8) & 4095;
    Operands[0] = (Op >> 20) & 4095;
    if (Operands[0] == 4095)    // Handle special encoding for 0 operands...
      Operands.resize(0);
    break;
  case 2:
    // bits   Instruction format:
    // --------------------------
    // 15-08: Resulting type plane
    // 23-16: Operand #1
    // 31-24: Operand #2  
    //
    iType   = (Op >>  8) & 255;
    Operands[0] = (Op >> 16) & 255;
    Operands[1] = (Op >> 24) & 255;
    break;
  case 3:
    // bits   Instruction format:
    // --------------------------
    // 13-08: Resulting type plane
    // 19-14: Operand #1
    // 25-20: Operand #2
    // 31-26: Operand #3
    //
    iType   = (Op >>  8) & 63;
    Operands[0] = (Op >> 14) & 63;
    Operands[1] = (Op >> 20) & 63;
    Operands[2] = (Op >> 26) & 63;
    break;
  case 0:
    Buf -= 4;  // Hrm, try this again...
    Opcode = read_vbr_uint(Buf, EndBuf);
    Opcode >>= 2;
    iType = read_vbr_uint(Buf, EndBuf);

    unsigned NumOperands = read_vbr_uint(Buf, EndBuf);
    Operands.resize(NumOperands);

    if (NumOperands == 0)
      PARSE_ERROR("Zero-argument instruction found; this is invalid.");

    for (unsigned i = 0; i != NumOperands; ++i)
      Operands[i] = read_vbr_uint(Buf, EndBuf);
    align32(Buf, EndBuf);
    break;
  }

  return handler->handleInstruction(Opcode, getType(iType), Operands);
}

/// ParseBasicBlock - In LLVM 1.0 bytecode files, we used to output one
/// basicblock at a time.  This method reads in one of the basicblock packets.
void AbstractBytecodeParser::ParseBasicBlock(BufPtr &Buf,
                                            BufPtr EndBuf,
                                            unsigned BlockNo) {
  handler->handleBasicBlockBegin( BlockNo );

  std::vector<unsigned> Args;
  bool is_terminating = false;
  while (Buf < EndBuf)
    is_terminating = ParseInstruction(Buf, EndBuf, Args);

  if ( ! is_terminating )
    PARSE_ERROR(
      "Failed to recognize instruction as terminating at end of block");

  handler->handleBasicBlockEnd( BlockNo );
}


/// ParseInstructionList - Parse all of the BasicBlock's & Instruction's in the
/// body of a function.  In post 1.0 bytecode files, we no longer emit basic
/// block individually, in order to avoid per-basic-block overhead.
unsigned AbstractBytecodeParser::ParseInstructionList( BufPtr &Buf, BufPtr EndBuf) {
  unsigned BlockNo = 0;
  std::vector<unsigned> Args;

  while (Buf < EndBuf) {
    handler->handleBasicBlockBegin( BlockNo );

    // Read instructions into this basic block until we get to a terminator
    bool is_terminating = false;
    while (Buf < EndBuf && !is_terminating )
	is_terminating = ParseInstruction(Buf, EndBuf, Args ) ;

    if (!is_terminating)
      PARSE_ERROR( "Non-terminated basic block found!");

    handler->handleBasicBlockEnd( BlockNo );
    ++BlockNo;
  }
  return BlockNo;
}

void AbstractBytecodeParser::ParseSymbolTable(BufPtr &Buf, BufPtr EndBuf) {
  handler->handleSymbolTableBegin();

  while (Buf < EndBuf) {
    // Symtab block header: [num entries][type id number]
    unsigned NumEntries = read_vbr_uint(Buf, EndBuf);
    unsigned Typ = read_vbr_uint(Buf, EndBuf);
    const Type *Ty = getType(Typ);

    handler->handleSymbolTablePlane( Typ, NumEntries, Ty );

    for (unsigned i = 0; i != NumEntries; ++i) {
      // Symtab entry: [def slot #][name]
      unsigned slot = read_vbr_uint(Buf, EndBuf);
      std::string Name = read_str(Buf, EndBuf);

      if (Typ == Type::TypeTyID)
        handler->handleSymbolTableType( i, slot, Name );
      else
	handler->handleSymbolTableValue( i, slot, Name );
    }
  }

  if (Buf > EndBuf) 
    PARSE_ERROR("Tried to read past end of buffer while reading symbol table.");

  handler->handleSymbolTableEnd();
}

void AbstractBytecodeParser::ParseFunctionLazily(BufPtr &Buf, BufPtr EndBuf) {
  if (FunctionSignatureList.empty())
    throw std::string("FunctionSignatureList empty!");

  const Type *FType = FunctionSignatureList.back();
  FunctionSignatureList.pop_back();

  // Save the information for future reading of the function
  LazyFunctionLoadMap[FType] = LazyFunctionInfo(Buf, EndBuf);
  // Pretend we've `parsed' this function
  Buf = EndBuf;
}

void AbstractBytecodeParser::ParseNextFunction(Type* FType) {
  // Find {start, end} pointers and slot in the map. If not there, we're done.
  LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(FType);

  // Make sure we found it
  if ( Fi == LazyFunctionLoadMap.end() ) {
    PARSE_ERROR("Unrecognized function of type " << FType->getDescription());
    return;
  }

  BufPtr Buf = Fi->second.Buf;
  BufPtr EndBuf = Fi->second.EndBuf;
  assert(Fi->first == FType);

  LazyFunctionLoadMap.erase(Fi);

  this->ParseFunctionBody( FType, Buf, EndBuf );
}

void AbstractBytecodeParser::ParseFunctionBody(const Type* FType, 
                                               BufPtr &Buf, BufPtr EndBuf ) {

  GlobalValue::LinkageTypes Linkage = GlobalValue::ExternalLinkage;

  unsigned LinkageType = read_vbr_uint(Buf, EndBuf);
  switch (LinkageType) {
  case 0: Linkage = GlobalValue::ExternalLinkage; break;
  case 1: Linkage = GlobalValue::WeakLinkage; break;
  case 2: Linkage = GlobalValue::AppendingLinkage; break;
  case 3: Linkage = GlobalValue::InternalLinkage; break;
  case 4: Linkage = GlobalValue::LinkOnceLinkage; break;
  default:
    PARSE_ERROR("Invalid linkage type for Function.");
    Linkage = GlobalValue::InternalLinkage;
    break;
  }

  handler->handleFunctionBegin(FType,Linkage);

  // Keep track of how many basic blocks we have read in...
  unsigned BlockNum = 0;
  bool InsertedArguments = false;

  while (Buf < EndBuf) {
    unsigned Type, Size;
    BufPtr OldBuf = Buf;
    readBlock(Buf, EndBuf, Type, Size);

    switch (Type) {
    case BytecodeFormat::ConstantPool:
      ParseConstantPool(Buf, Buf+Size, FunctionTypes );
      break;

    case BytecodeFormat::CompactionTable:
      ParseCompactionTable(Buf, Buf+Size);
      break;

    case BytecodeFormat::BasicBlock:
      ParseBasicBlock(Buf, Buf+Size, BlockNum++);
      break;

    case BytecodeFormat::InstructionList:
      if (BlockNum) 
	PARSE_ERROR("InstructionList must come before basic blocks!");
      BlockNum = ParseInstructionList(Buf, Buf+Size);
      break;

    case BytecodeFormat::SymbolTable:
      ParseSymbolTable(Buf, Buf+Size );
      break;

    default:
      Buf += Size;
      if (OldBuf > Buf)
	PARSE_ERROR("Wrapped around reading bytecode");
      break;
    }

    // Malformed bc file if read past end of block.
    align32(Buf, EndBuf);
  }

  handler->handleFunctionEnd(FType);

  // Clear out function-level types...
  FunctionTypes.clear();
  CompactionTypeTable.clear();
}

void AbstractBytecodeParser::ParseAllFunctionBodies() {
  LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.begin();
  LazyFunctionMap::iterator Fe = LazyFunctionLoadMap.end();

  while ( Fi != Fe ) {
    const Type* FType = Fi->first;
    this->ParseFunctionBody(FType, Fi->second.Buf, Fi->second.EndBuf);
  }
}

void AbstractBytecodeParser::ParseCompactionTable(BufPtr &Buf, BufPtr End) {

  handler->handleCompactionTableBegin();

  while (Buf != End) {
    unsigned NumEntries = read_vbr_uint(Buf, End);
    unsigned Ty;

    if ((NumEntries & 3) == 3) {
      NumEntries >>= 2;
      Ty = read_vbr_uint(Buf, End);
    } else {
      Ty = NumEntries >> 2;
      NumEntries &= 3;
    }

    handler->handleCompactionTablePlane( Ty, NumEntries );

    if (Ty == Type::TypeTyID) {
      for (unsigned i = 0; i != NumEntries; ++i) {
	unsigned TypeSlot = read_vbr_uint(Buf,End);
        const Type *Typ = getGlobalTableType(TypeSlot);
	handler->handleCompactionTableType( i, TypeSlot, Typ );
      }
    } else {
      const Type *Typ = getType(Ty);
      // Push the implicit zero
      for (unsigned i = 0; i != NumEntries; ++i) {
	unsigned ValSlot = read_vbr_uint(Buf, End);
	handler->handleCompactionTableValue( i, ValSlot, Typ );
      }
    }
  }
  handler->handleCompactionTableEnd();
}

const Type *AbstractBytecodeParser::ParseTypeConstant(const unsigned char *&Buf,
					      const unsigned char *EndBuf) {
  unsigned PrimType = read_vbr_uint(Buf, EndBuf);

  const Type *Val = 0;
  if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
    return Val;
  
  switch (PrimType) {
  case Type::FunctionTyID: {
    const Type *RetType = getType(read_vbr_uint(Buf, EndBuf));

    unsigned NumParams = read_vbr_uint(Buf, EndBuf);

    std::vector<const Type*> Params;
    while (NumParams--)
      Params.push_back(getType(read_vbr_uint(Buf, EndBuf)));

    bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
    if (isVarArg) Params.pop_back();

    Type* result = FunctionType::get(RetType, Params, isVarArg);
    handler->handleType( result );
    return result;
  }
  case Type::ArrayTyID: {
    unsigned ElTyp = read_vbr_uint(Buf, EndBuf);
    const Type *ElementType = getType(ElTyp);

    unsigned NumElements = read_vbr_uint(Buf, EndBuf);

    BCR_TRACE(5, "Array Type Constant #" << ElTyp << " size=" 
              << NumElements << "\n");
    Type* result =  ArrayType::get(ElementType, NumElements);
    handler->handleType( result );
    return result;
  }
  case Type::StructTyID: {
    std::vector<const Type*> Elements;
    unsigned Typ = read_vbr_uint(Buf, EndBuf);
    while (Typ) {         // List is terminated by void/0 typeid
      Elements.push_back(getType(Typ));
      Typ = read_vbr_uint(Buf, EndBuf);
    }

    Type* result = StructType::get(Elements);
    handler->handleType( result );
    return result;
  }
  case Type::PointerTyID: {
    unsigned ElTyp = read_vbr_uint(Buf, EndBuf);
    BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
    Type* result = PointerType::get(getType(ElTyp));
    handler->handleType( result );
    return result;
  }

  case Type::OpaqueTyID: {
    Type* result = OpaqueType::get();
    handler->handleType( result );
    return result;
  }

  default:
    PARSE_ERROR("Don't know how to deserialize primitive type" << PrimType << "\n");
    return Val;
  }
}

// ParseTypeConstants - We have to use this weird code to handle recursive
// types.  We know that recursive types will only reference the current slab of
// values in the type plane, but they can forward reference types before they
// have been read.  For example, Type #0 might be '{ Ty#1 }' and Type #1 might
// be 'Ty#0*'.  When reading Type #0, type number one doesn't exist.  To fix
// this ugly problem, we pessimistically insert an opaque type for each type we
// are about to read.  This means that forward references will resolve to
// something and when we reread the type later, we can replace the opaque type
// with a new resolved concrete type.
//
void AbstractBytecodeParser::ParseTypeConstants(const unsigned char *&Buf,
                                        const unsigned char *EndBuf,
					TypeListTy &Tab,
					unsigned NumEntries) {
  assert(Tab.size() == 0 && "should not have read type constants in before!");

  // Insert a bunch of opaque types to be resolved later...
  Tab.reserve(NumEntries);
  for (unsigned i = 0; i != NumEntries; ++i)
    Tab.push_back(OpaqueType::get());

  // Loop through reading all of the types.  Forward types will make use of the
  // opaque types just inserted.
  //
  for (unsigned i = 0; i != NumEntries; ++i) {
    const Type *NewTy = ParseTypeConstant(Buf, EndBuf), *OldTy = Tab[i].get();
    if (NewTy == 0) throw std::string("Couldn't parse type!");
    BCR_TRACE(4, "#" << i << ": Read Type Constant: '" << NewTy <<
              "' Replacing: " << OldTy << "\n");

    // Don't insertValue the new type... instead we want to replace the opaque
    // type with the new concrete value...
    //

    // Refine the abstract type to the new type.  This causes all uses of the
    // abstract type to use NewTy.  This also will cause the opaque type to be
    // deleted...
    //
    cast<DerivedType>(const_cast<Type*>(OldTy))->refineAbstractTypeTo(NewTy);

    // This should have replace the old opaque type with the new type in the
    // value table... or with a preexisting type that was already in the system
    assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
  }

  BCR_TRACE(5, "Resulting types:\n");
  for (unsigned i = 0; i < NumEntries; ++i) {
    BCR_TRACE(5, (void*)Tab[i].get() << " - " << Tab[i].get() << "\n");
  }
}


void AbstractBytecodeParser::ParseConstantValue(const unsigned char *&Buf,
                                             const unsigned char *EndBuf,
                                             unsigned TypeID) {

  // We must check for a ConstantExpr before switching by type because
  // a ConstantExpr can be of any type, and has no explicit value.
  // 
  // 0 if not expr; numArgs if is expr
  unsigned isExprNumArgs = read_vbr_uint(Buf, EndBuf);
  
  if (isExprNumArgs) {
    unsigned Opcode = read_vbr_uint(Buf, EndBuf);
    const Type* Typ = getType(TypeID);
    
    // FIXME: Encoding of constant exprs could be much more compact!
    std::vector<std::pair<const Type*,unsigned> > ArgVec;
    ArgVec.reserve(isExprNumArgs);

    // Read the slot number and types of each of the arguments
    for (unsigned i = 0; i != isExprNumArgs; ++i) {
      unsigned ArgValSlot = read_vbr_uint(Buf, EndBuf);
      unsigned ArgTypeSlot = read_vbr_uint(Buf, EndBuf);
      BCR_TRACE(4, "CE Arg " << i << ": Type: '" << *getType(ArgTypeSlot)
                << "'  slot: " << ArgValSlot << "\n");
      
      // Get the arg value from its slot if it exists, otherwise a placeholder
      ArgVec.push_back(std::make_pair(getType(ArgTypeSlot), ArgValSlot));
    }

    handler->handleConstantExpression( Opcode, Typ, ArgVec );
    return;
  }
  
  // Ok, not an ConstantExpr.  We now know how to read the given type...
  const Type *Ty = getType(TypeID);
  switch (Ty->getPrimitiveID()) {
  case Type::BoolTyID: {
    unsigned Val = read_vbr_uint(Buf, EndBuf);
    if (Val != 0 && Val != 1) 
      PARSE_ERROR("Invalid boolean value read.");

    handler->handleConstantValue( ConstantBool::get(Val == 1));
    break;
  }

  case Type::UByteTyID:   // Unsigned integer types...
  case Type::UShortTyID:
  case Type::UIntTyID: {
    unsigned Val = read_vbr_uint(Buf, EndBuf);
    if (!ConstantUInt::isValueValidForType(Ty, Val)) 
      throw std::string("Invalid unsigned byte/short/int read.");
    handler->handleConstantValue( ConstantUInt::get(Ty, Val) );
    break;
  }

  case Type::ULongTyID: {
    handler->handleConstantValue( ConstantUInt::get(Ty, read_vbr_uint64(Buf, EndBuf)) );
    break;
  }

  case Type::SByteTyID:   // Signed integer types...
  case Type::ShortTyID:
  case Type::IntTyID: {
  case Type::LongTyID:
    int64_t Val = read_vbr_int64(Buf, EndBuf);
    if (!ConstantSInt::isValueValidForType(Ty, Val)) 
      throw std::string("Invalid signed byte/short/int/long read.");
    handler->handleConstantValue(  ConstantSInt::get(Ty, Val) );
    break;
  }

  case Type::FloatTyID: {
    float F;
    input_data(Buf, EndBuf, &F, &F+1);
    handler->handleConstantValue( ConstantFP::get(Ty, F) );
    break;
  }

  case Type::DoubleTyID: {
    double Val;
    input_data(Buf, EndBuf, &Val, &Val+1);
    handler->handleConstantValue( ConstantFP::get(Ty, Val) );
    break;
  }

  case Type::TypeTyID:
    PARSE_ERROR("Type constants shouldn't live in constant table!");
    break;

  case Type::ArrayTyID: {
    const ArrayType *AT = cast<ArrayType>(Ty);
    unsigned NumElements = AT->getNumElements();
    std::vector<unsigned> Elements;
    Elements.reserve(NumElements);
    while (NumElements--)     // Read all of the elements of the constant.
      Elements.push_back(read_vbr_uint(Buf, EndBuf));

    handler->handleConstantArray( AT, Elements );
    break;
  }

  case Type::StructTyID: {
    const StructType *ST = cast<StructType>(Ty);
    std::vector<unsigned> Elements;
    Elements.reserve(ST->getNumElements());
    for (unsigned i = 0; i != ST->getNumElements(); ++i)
      Elements.push_back(read_vbr_uint(Buf, EndBuf));

    handler->handleConstantStruct( ST, Elements );
  }    

  case Type::PointerTyID: {  // ConstantPointerRef value...
    const PointerType *PT = cast<PointerType>(Ty);
    unsigned Slot = read_vbr_uint(Buf, EndBuf);
    handler->handleConstantPointer( PT, Slot );
  }

  default:
    PARSE_ERROR("Don't know how to deserialize constant value of type '"+
                      Ty->getDescription());
  }
}

void AbstractBytecodeParser::ParseGlobalTypes(const unsigned char *&Buf,
                                      const unsigned char *EndBuf) {
  ParseConstantPool(Buf, EndBuf, ModuleTypes);
}

void AbstractBytecodeParser::ParseStringConstants(const unsigned char *&Buf,
                                          const unsigned char *EndBuf,
                                          unsigned NumEntries ){
  for (; NumEntries; --NumEntries) {
    unsigned Typ = read_vbr_uint(Buf, EndBuf);
    const Type *Ty = getType(Typ);
    if (!isa<ArrayType>(Ty))
      throw std::string("String constant data invalid!");
    
    const ArrayType *ATy = cast<ArrayType>(Ty);
    if (ATy->getElementType() != Type::SByteTy &&
        ATy->getElementType() != Type::UByteTy)
      throw std::string("String constant data invalid!");
    
    // Read character data.  The type tells us how long the string is.
    char Data[ATy->getNumElements()];
    input_data(Buf, EndBuf, Data, Data+ATy->getNumElements());

    std::vector<Constant*> Elements(ATy->getNumElements());
    if (ATy->getElementType() == Type::SByteTy)
      for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
        Elements[i] = ConstantSInt::get(Type::SByteTy, (signed char)Data[i]);
    else
      for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
        Elements[i] = ConstantUInt::get(Type::UByteTy, (unsigned char)Data[i]);

    // Create the constant, inserting it as needed.
    ConstantArray *C = cast<ConstantArray>( ConstantArray::get(ATy, Elements) );
    handler->handleConstantString( C );
  }
}


void AbstractBytecodeParser::ParseConstantPool(const unsigned char *&Buf,
                                       const unsigned char *EndBuf,
                                       TypeListTy &TypeTab) {
  while (Buf < EndBuf) {
    unsigned NumEntries = read_vbr_uint(Buf, EndBuf);
    unsigned Typ = read_vbr_uint(Buf, EndBuf);
    if (Typ == Type::TypeTyID) {
      ParseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
    } else if (Typ == Type::VoidTyID) {
      ParseStringConstants(Buf, EndBuf, NumEntries);
    } else {
      BCR_TRACE(3, "Type: '" << *getType(Typ) << "'  NumEntries: "
                << NumEntries << "\n");

      for (unsigned i = 0; i < NumEntries; ++i) {
        ParseConstantValue(Buf, EndBuf, Typ);
      }
    }
  }
  
  if (Buf > EndBuf) PARSE_ERROR("Read past end of buffer.");
}

void AbstractBytecodeParser::ParseModuleGlobalInfo(BufPtr &Buf, BufPtr End) {

  handler->handleModuleGlobalsBegin();

  // Read global variables...
  unsigned VarType = read_vbr_uint(Buf, End);
  while (VarType != Type::VoidTyID) { // List is terminated by Void
    // VarType Fields: bit0 = isConstant, bit1 = hasInitializer, bit2,3,4 =
    // Linkage, bit4+ = slot#
    unsigned SlotNo = VarType >> 5;
    unsigned LinkageID = (VarType >> 2) & 7;
    bool isConstant = VarType & 1;
    bool hasInitializer = VarType & 2;
    GlobalValue::LinkageTypes Linkage;

    switch (LinkageID) {
    case 0: Linkage = GlobalValue::ExternalLinkage;  break;
    case 1: Linkage = GlobalValue::WeakLinkage;      break;
    case 2: Linkage = GlobalValue::AppendingLinkage; break;
    case 3: Linkage = GlobalValue::InternalLinkage;  break;
    case 4: Linkage = GlobalValue::LinkOnceLinkage;  break;
    default: 
      PARSE_ERROR("Unknown linkage type: " << LinkageID);
      Linkage = GlobalValue::InternalLinkage;
      break;
    }

    const Type *Ty = getType(SlotNo);
    if ( !Ty ) {
      PARSE_ERROR("Global has no type! SlotNo=" << SlotNo);
    }

    if ( !isa<PointerType>(Ty)) {
      PARSE_ERROR("Global not a pointer type! Ty= " << Ty->getDescription());
    }

    const Type *ElTy = cast<PointerType>(Ty)->getElementType();

    // Create the global variable...
    if (hasInitializer)
      handler->handleGlobalVariable( ElTy, isConstant, Linkage );
    else {
      unsigned initSlot = read_vbr_uint(Buf,End);
      handler->handleInitializedGV( ElTy, isConstant, Linkage, initSlot );
    }

    // Get next item
    VarType = read_vbr_uint(Buf, End);
  }

  // Read the function objects for all of the functions that are coming
  unsigned FnSignature = read_vbr_uint(Buf, End);
  while (FnSignature != Type::VoidTyID) { // List is terminated by Void
    const Type *Ty = getType(FnSignature);
    if (!isa<PointerType>(Ty) ||
        !isa<FunctionType>(cast<PointerType>(Ty)->getElementType())) {
      PARSE_ERROR( "Function not a pointer to function type! Ty = " +
                        Ty->getDescription());
      // FIXME: what should Ty be if handler continues?
    }

    // We create functions by passing the underlying FunctionType to create...
    Ty = cast<PointerType>(Ty)->getElementType();

    // Save this for later so we know type of lazily instantiated functions
    FunctionSignatureList.push_back(Ty);

    handler->handleFunctionDeclaration(Ty);

    // Get Next function signature
    FnSignature = read_vbr_uint(Buf, End);
  }

  if (hasInconsistentModuleGlobalInfo)
    align32(Buf, End);

  // This is for future proofing... in the future extra fields may be added that
  // we don't understand, so we transparently ignore them.
  //
  Buf = End;

  handler->handleModuleGlobalsEnd();
}

void AbstractBytecodeParser::ParseVersionInfo(BufPtr &Buf, BufPtr EndBuf) {
  unsigned Version = read_vbr_uint(Buf, EndBuf);

  // Unpack version number: low four bits are for flags, top bits = version
  Module::Endianness  Endianness;
  Module::PointerSize PointerSize;
  Endianness  = (Version & 1) ? Module::BigEndian : Module::LittleEndian;
  PointerSize = (Version & 2) ? Module::Pointer64 : Module::Pointer32;

  bool hasNoEndianness = Version & 4;
  bool hasNoPointerSize = Version & 8;
  
  RevisionNum = Version >> 4;

  // Default values for the current bytecode version
  hasInconsistentModuleGlobalInfo = false;
  hasExplicitPrimitiveZeros = false;
  hasRestrictedGEPTypes = false;

  switch (RevisionNum) {
  case 0:               //  LLVM 1.0, 1.1 release version
    // Base LLVM 1.0 bytecode format.
    hasInconsistentModuleGlobalInfo = true;
    hasExplicitPrimitiveZeros = true;
    // FALL THROUGH
  case 1:               // LLVM 1.2 release version
    // LLVM 1.2 added explicit support for emitting strings efficiently.

    // Also, it fixed the problem where the size of the ModuleGlobalInfo block
    // included the size for the alignment at the end, where the rest of the
    // blocks did not.

    // LLVM 1.2 and before required that GEP indices be ubyte constants for
    // structures and longs for sequential types.
    hasRestrictedGEPTypes = true;

    // FALL THROUGH
  case 2:               // LLVM 1.3 release version
    break;

  default:
    PARSE_ERROR("Unknown bytecode version number: " << RevisionNum);
  }

  if (hasNoEndianness) Endianness  = Module::AnyEndianness;
  if (hasNoPointerSize) PointerSize = Module::AnyPointerSize;

  handler->handleVersionInfo(RevisionNum, Endianness, PointerSize );
}

void AbstractBytecodeParser::ParseModule(BufPtr &Buf, BufPtr EndBuf ) {
  unsigned Type, Size;
  readBlock(Buf, EndBuf, Type, Size);
  if (Type != BytecodeFormat::Module || Buf+Size != EndBuf)
    // Hrm, not a class?
    PARSE_ERROR("Expected Module block! B: " << unsigned(intptr_t(Buf)) <<
        ", S: " << Size << " E: " << unsigned(intptr_t(EndBuf))); 

  // Read into instance variables...
  ParseVersionInfo(Buf, EndBuf);
  align32(Buf, EndBuf);

  bool SeenModuleGlobalInfo = false;
  bool SeenGlobalTypePlane = false;
  while (Buf < EndBuf) {
    BufPtr OldBuf = Buf;
    readBlock(Buf, EndBuf, Type, Size);

    switch (Type) {

    case BytecodeFormat::GlobalTypePlane:
      if ( SeenGlobalTypePlane )
	PARSE_ERROR("Two GlobalTypePlane Blocks Encountered!");

      ParseGlobalTypes(Buf, Buf+Size);
      SeenGlobalTypePlane = true;
      break;

    case BytecodeFormat::ModuleGlobalInfo: 
      if ( SeenModuleGlobalInfo )
	PARSE_ERROR("Two ModuleGlobalInfo Blocks Encountered!");
      ParseModuleGlobalInfo(Buf, Buf+Size);
      SeenModuleGlobalInfo = true;
      break;

    case BytecodeFormat::ConstantPool:
      ParseConstantPool(Buf, Buf+Size, ModuleTypes);
      break;

    case BytecodeFormat::Function:
      ParseFunctionLazily(Buf, Buf+Size);
      break;

    case BytecodeFormat::SymbolTable:
      ParseSymbolTable(Buf, Buf+Size );
      break;

    default:
      Buf += Size;
      if (OldBuf > Buf) 
      {
	PARSE_ERROR("Unexpected Block of Type" << Type << "encountered!" );
      }
      break;
    }
    align32(Buf, EndBuf);
  }
}

void AbstractBytecodeParser::ParseBytecode(
       BufPtr Buf, unsigned Length,
       const std::string &ModuleID) {

  handler->handleStart();
  unsigned char *EndBuf = (unsigned char*)(Buf + Length);

  // Read and check signature...
  unsigned Sig = read(Buf, EndBuf);
  if (Sig != ('l' | ('l' << 8) | ('v' << 16) | ('m' << 24))) {
    PARSE_ERROR("Invalid bytecode signature: " << Sig);
  }

  handler->handleModuleBegin(ModuleID);

  this->ParseModule(Buf, EndBuf);

  handler->handleModuleEnd(ModuleID);

  handler->handleFinish();
}

// vim: sw=2