Remove files no longer needed. ConstantReader and InstructionReader were

integrated into Reader. Parser.* was just a bad idea. AnalyzerInternals.h
is no longer needed. ReaderPrimitives.h was integrated into Reader.h and
Reader.cpp. Dumper.cpp was integrated into Analyzer.cpp. ReaderInternals.h
became Reader.h. AnalyzerWrappers.cpp was integerated into
ReaderWrappers.cpp


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

9 files changed, 0 insertions, 3404 deletions

diff --git a/lib/Bytecode/Reader/AnalyzerInternals.h b/lib/Bytecode/Reader/AnalyzerInternals.h
deleted file mode 100644
index d7733c7176..0000000000
--- a/lib/Bytecode/Reader/AnalyzerInternals.h
+++ /dev/null
@@ -1,51 +0,0 @@
-//===-- ReaderInternals.h - Definitions internal to the reader --*- C++ -*-===//
-// 
-//                     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 header file defines various stuff that is used by the bytecode reader.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ANALYZER_INTERNALS_H
-#define ANALYZER_INTERNALS_H
-
-#include "Parser.h"
-#include "llvm/Bytecode/Analyzer.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-
-
-namespace llvm {
-
-class BytecodeAnalyzer {
-  BytecodeAnalyzer(const BytecodeAnalyzer &);  // DO NOT IMPLEMENT
-  void operator=(const BytecodeAnalyzer &);  // DO NOT IMPLEMENT
-public:
-  BytecodeAnalyzer() { }
-  ~BytecodeAnalyzer() { }
-
-  void AnalyzeBytecode(
-    const unsigned char *Buf, 
-    unsigned Length,
-    BytecodeAnalysis& bca,
-    const std::string &ModuleID
-  );
-
-  void DumpBytecode(
-    const unsigned char *Buf, 
-    unsigned Length,
-    BytecodeAnalysis& bca,
-    const std::string &ModuleID
-  );
-};
-
-} // End llvm namespace
-
-#endif
-
-// vim: sw=2
diff --git a/lib/Bytecode/Reader/AnalyzerWrappers.cpp b/lib/Bytecode/Reader/AnalyzerWrappers.cpp
deleted file mode 100644
index f8493170fa..0000000000
--- a/lib/Bytecode/Reader/AnalyzerWrappers.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-//===- AnalyzerWrappers.cpp - Analyze bytecode from file or buffer  -------===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// This file implements loading and analysis of a bytecode file and analyzing a
-// bytecode buffer.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bytecode/Analyzer.h"
-#include "AnalyzerInternals.h"
-#include "Support/FileUtilities.h"
-#include "Support/StringExtras.h"
-#include "Config/unistd.h"
-#include <cerrno>
-#include <iomanip>
-
-using namespace llvm;
-
-//===----------------------------------------------------------------------===//
-// BytecodeFileAnalyzer - Analyze from an mmap'able file descriptor.
-//
-
-namespace {
-  /// BytecodeFileAnalyzer - parses a bytecode file from a file
-  class BytecodeFileAnalyzer : public BytecodeAnalyzer {
-  private:
-    unsigned char *Buffer;
-    unsigned Length;
-
-    BytecodeFileAnalyzer(const BytecodeFileAnalyzer&); // Do not implement
-    void operator=(const BytecodeFileAnalyzer &BFR); // Do not implement
-
-  public:
-    BytecodeFileAnalyzer(const std::string &Filename, BytecodeAnalysis& bca);
-    ~BytecodeFileAnalyzer();
-  };
-}
-
-static std::string ErrnoMessage (int savedErrNum, std::string descr) {
-   return ::strerror(savedErrNum) + std::string(", while trying to ") + descr;
-}
-
-BytecodeFileAnalyzer::BytecodeFileAnalyzer(const std::string &Filename, 
-                                           BytecodeAnalysis& bca) {
-  Buffer = (unsigned char*)ReadFileIntoAddressSpace(Filename, Length);
-  if (Buffer == 0)
-    throw "Error reading file '" + Filename + "'.";
-
-  try {
-    // Parse the bytecode we mmapped in
-    if ( bca.dumpBytecode ) 
-      DumpBytecode(Buffer, Length, bca, Filename);
-    AnalyzeBytecode(Buffer, Length, bca, Filename);
-  } catch (...) {
-    UnmapFileFromAddressSpace(Buffer, Length);
-    throw;
-  }
-}
-
-BytecodeFileAnalyzer::~BytecodeFileAnalyzer() {
-  // Unmmap the bytecode...
-  UnmapFileFromAddressSpace(Buffer, Length);
-}
-
-//===----------------------------------------------------------------------===//
-// BytecodeBufferAnalyzer - Read from a memory buffer
-//
-
-namespace {
-  /// BytecodeBufferAnalyzer - parses a bytecode file from a buffer
-  ///
-  class BytecodeBufferAnalyzer : public BytecodeAnalyzer {
-  private:
-    const unsigned char *Buffer;
-    bool MustDelete;
-
-    BytecodeBufferAnalyzer(const BytecodeBufferAnalyzer&); // Do not implement
-    void operator=(const BytecodeBufferAnalyzer &BFR);   // Do not implement
-
-  public:
-    BytecodeBufferAnalyzer(const unsigned char *Buf, unsigned Length,
-                           BytecodeAnalysis& bca, const std::string &ModuleID);
-    ~BytecodeBufferAnalyzer();
-
-  };
-}
-
-BytecodeBufferAnalyzer::BytecodeBufferAnalyzer(const unsigned char *Buf,
-                                               unsigned Length,
-                                               BytecodeAnalysis& bca,
-                                               const std::string &ModuleID) {
-  // If not aligned, allocate a new buffer to hold the bytecode...
-  const unsigned char *ParseBegin = 0;
-  if ((intptr_t)Buf & 3) {
-    Buffer = new unsigned char[Length+4];
-    unsigned Offset = 4 - ((intptr_t)Buffer & 3);   // Make sure it's aligned
-    ParseBegin = Buffer + Offset;
-    memcpy((unsigned char*)ParseBegin, Buf, Length);    // Copy it over
-    MustDelete = true;
-  } else {
-    // If we don't need to copy it over, just use the caller's copy
-    ParseBegin = Buffer = Buf;
-    MustDelete = false;
-  }
-  try {
-    if ( bca.dumpBytecode ) 
-      DumpBytecode(ParseBegin, Length, bca, ModuleID);
-    AnalyzeBytecode(ParseBegin, Length, bca, ModuleID);
-  } catch (...) {
-    if (MustDelete) delete [] Buffer;
-    throw;
-  }
-}
-
-BytecodeBufferAnalyzer::~BytecodeBufferAnalyzer() {
-  if (MustDelete) delete [] Buffer;
-}
-
-//===----------------------------------------------------------------------===//
-//  BytecodeStdinAnalyzer - Read bytecode from Standard Input
-//
-
-namespace {
-  /// BytecodeStdinAnalyzer - parses a bytecode file from stdin
-  /// 
-  class BytecodeStdinAnalyzer : public BytecodeAnalyzer {
-  private:
-    std::vector<unsigned char> FileData;
-    unsigned char *FileBuf;
-
-    BytecodeStdinAnalyzer(const BytecodeStdinAnalyzer&); // Do not implement
-    void operator=(const BytecodeStdinAnalyzer &BFR);  // Do not implement
-
-  public:
-    BytecodeStdinAnalyzer(BytecodeAnalysis& bca);
-  };
-}
-
-BytecodeStdinAnalyzer::BytecodeStdinAnalyzer(BytecodeAnalysis& bca ) {
-  int BlockSize;
-  unsigned char Buffer[4096*4];
-
-  // Read in all of the data from stdin, we cannot mmap stdin...
-  while ((BlockSize = ::read(0 /*stdin*/, Buffer, 4096*4))) {
-    if (BlockSize == -1)
-      throw ErrnoMessage(errno, "read from standard input");
-    
-    FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
-  }
-
-  if (FileData.empty())
-    throw std::string("Standard Input empty!");
-
-  FileBuf = &FileData[0];
-  if (bca.dumpBytecode)
-    DumpBytecode(&FileData[0], FileData.size(), bca, "<stdin>");
-  AnalyzeBytecode(FileBuf, FileData.size(), bca, "<stdin>");
-}
-
-//===----------------------------------------------------------------------===//
-// Wrapper functions
-//===----------------------------------------------------------------------===//
-
-// AnalyzeBytecodeFile - analyze one file
-void llvm::AnalyzeBytecodeFile(const std::string &Filename, 
-                               BytecodeAnalysis& bca,
-                               std::string *ErrorStr) 
-{
-  try {
-    if ( Filename != "-" )
-      BytecodeFileAnalyzer bfa(Filename,bca);
-    else
-      BytecodeStdinAnalyzer bsa(bca);
-  } catch (std::string &err) {
-    if (ErrorStr) *ErrorStr = err;
-  }
-}
-
-// AnalyzeBytecodeBuffer - analyze a buffer
-void llvm::AnalyzeBytecodeBuffer(
-       const unsigned char* Buffer, ///< Pointer to start of bytecode buffer
-       unsigned BufferSize,         ///< Size of the bytecode buffer
-       BytecodeAnalysis& Results,   ///< The results of the analysis
-       std::string* ErrorStr        ///< Errors, if any.
-     ) 
-{
-  try {
-    BytecodeBufferAnalyzer(Buffer, BufferSize, Results, "<buffer>" );
-  } catch (std::string& err ) {
-    if ( ErrorStr) *ErrorStr = err;
-  }
-}
-
-
-/// This function prints the contents of rhe BytecodeAnalysis structure in
-/// a human legible form.
-/// @brief Print BytecodeAnalysis structure to an ostream
-namespace {
-inline static void print(std::ostream& Out, const char*title, 
-  unsigned val, bool nl = true ) {
-  Out << std::setw(30) << std::right << title 
-      << std::setw(0) << ": "
-      << std::setw(9) << val << "\n";
-}
-
-inline static void print(std::ostream&Out, const char*title, 
-  double val ) {
-  Out << std::setw(30) << std::right << title 
-      << std::setw(0) << ": "
-      << std::setw(9) << std::setprecision(6) << val << "\n" ;
-}
-
-inline static void print(std::ostream&Out, const char*title, 
-  double top, double bot ) {
-  Out << std::setw(30) << std::right << title 
-      << std::setw(0) << ": "
-      << std::setw(9) << std::setprecision(6) << top 
-      << " (" << std::left << std::setw(0) << std::setprecision(4) 
-      << (top/bot)*100.0 << "%)\n";
-}
-inline static void print(std::ostream&Out, const char*title, 
-  std::string val, bool nl = true) {
-  Out << std::setw(30) << std::right << title 
-      << std::setw(0) << ": "
-      << std::left << val << (nl ? "\n" : "");
-}
-
-}
-
-void llvm::PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out )
-{
-  print(Out, "Bytecode Analysis Of Module",     bca.ModuleId);
-  print(Out, "File Size",                       bca.byteSize);
-  print(Out, "Bytecode Compression Index",std::string("TBD"));
-  print(Out, "Number Of Bytecode Blocks",       bca.numBlocks);
-  print(Out, "Number Of Types",                 bca.numTypes);
-  print(Out, "Number Of Values",                bca.numValues);
-  print(Out, "Number Of Constants",             bca.numConstants);
-  print(Out, "Number Of Global Variables",      bca.numGlobalVars);
-  print(Out, "Number Of Functions",             bca.numFunctions);
-  print(Out, "Number Of Basic Blocks",          bca.numBasicBlocks);
-  print(Out, "Number Of Instructions",          bca.numInstructions);
-  print(Out, "Number Of Operands",              bca.numOperands);
-  print(Out, "Number Of Compaction Tables",     bca.numCmpctnTables);
-  print(Out, "Number Of Symbol Tables",         bca.numSymTab);
-  print(Out, "Long Instructions", bca.longInstructions);
-  print(Out, "Instruction Size", bca.instructionSize);
-  print(Out, "Average Instruction Size", 
-    double(bca.instructionSize)/double(bca.numInstructions));
-  print(Out, "Maximum Type Slot Number",        bca.maxTypeSlot);
-  print(Out, "Maximum Value Slot Number",       bca.maxValueSlot);
-  print(Out, "Bytes Thrown To Alignment",       double(bca.numAlignment), 
-    double(bca.byteSize));
-  print(Out, "File Density (bytes/def)",        bca.fileDensity);
-  print(Out, "Globals Density (bytes/def)",     bca.globalsDensity);
-  print(Out, "Function Density (bytes/func)",   bca.functionDensity);
-  print(Out, "Number of VBR 32-bit Integers",   bca.vbrCount32);
-  print(Out, "Number of VBR 64-bit Integers",   bca.vbrCount64);
-  print(Out, "Number of VBR Compressed Bytes",  bca.vbrCompBytes);
-  print(Out, "Number of VBR Expanded Bytes",    bca.vbrExpdBytes);
-  print(Out, "VBR Savings", 
-    double(bca.vbrExpdBytes)-double(bca.vbrCompBytes),
-    double(bca.byteSize));
-
-  if ( bca.detailedResults ) {
-    print(Out, "Module Bytes",
-        double(bca.BlockSizes[BytecodeFormat::Module]),
-        double(bca.byteSize));
-    print(Out, "Function Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::Function]),
-        double(bca.byteSize));
-    print(Out, "Constant Pool Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::ConstantPool]),
-        double(bca.byteSize));
-    print(Out, "Symbol Table Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::SymbolTable]),
-        double(bca.byteSize));
-    print(Out, "Module Global Info Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::ModuleGlobalInfo]),
-        double(bca.byteSize));
-    print(Out, "Global Type Plane Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::GlobalTypePlane]),
-        double(bca.byteSize));
-    print(Out, "Basic Block Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::BasicBlock]),
-        double(bca.byteSize));
-    print(Out, "Instruction List Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::InstructionList]),
-        double(bca.byteSize));
-    print(Out, "Compaction Table Bytes", 
-        double(bca.BlockSizes[BytecodeFormat::CompactionTable]),
-        double(bca.byteSize));
-
-    std::map<const Function*,BytecodeAnalysis::BytecodeFunctionInfo>::iterator I = 
-      bca.FunctionInfo.begin();
-    std::map<const Function*,BytecodeAnalysis::BytecodeFunctionInfo>::iterator E = 
-      bca.FunctionInfo.end();
-
-    while ( I != E ) {
-      Out << std::left << std::setw(0);
-      Out << "Function: " << I->second.name << "\n";
-      print(Out, "Type:", I->second.description);
-      print(Out, "Byte Size", I->second.byteSize);
-      print(Out, "Instructions", I->second.numInstructions);
-      print(Out, "Long Instructions", I->second.longInstructions);
-      print(Out, "Instruction Size", I->second.instructionSize);
-      print(Out, "Average Instruction Size", 
-        double(I->second.instructionSize)/double(I->second.numInstructions));
-      print(Out, "Basic Blocks", I->second.numBasicBlocks);
-      print(Out, "Operand", I->second.numOperands);
-      print(Out, "Function Density", I->second.density);
-      print(Out, "Number of VBR 32-bit Integers",   I->second.vbrCount32);
-      print(Out, "Number of VBR 64-bit Integers",   I->second.vbrCount64);
-      print(Out, "Number of VBR Compressed Bytes",  I->second.vbrCompBytes);
-      print(Out, "Number of VBR Expanded Bytes",    I->second.vbrExpdBytes);
-      print(Out, "VBR Savings", 
-        double(I->second.vbrExpdBytes)-double(I->second.vbrCompBytes),
-        double(I->second.byteSize));
-      ++I;
-    }
-  }
-
-  if ( bca.dumpBytecode )
-    Out << bca.BytecodeDump;
-}
-// vim: sw=2
diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp
deleted file mode 100644
index 72d8caed67..0000000000
--- a/lib/Bytecode/Reader/ConstantReader.cpp
+++ /dev/null
@@ -1,362 +0,0 @@
-//===- ConstantReader.cpp - Code to constants and types ====---------------===//
-// 
-//                     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 functionality to deserialize constants and types from
-// bytecode files.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ReaderInternals.h"
-#include "llvm/Module.h"
-#include "llvm/Constants.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include <algorithm>
-using namespace llvm;
-
-const Type *BytecodeParser::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::TypeID)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();
-
-    return FunctionType::get(RetType, Params, isVarArg);
-  }
-  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");
-    return ArrayType::get(ElementType, NumElements);
-  }
-  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);
-    }
-
-    return StructType::get(Elements);
-  }
-  case Type::PointerTyID: {
-    unsigned ElTyp = read_vbr_uint(Buf, EndBuf);
-    BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
-    return PointerType::get(getType(ElTyp));
-  }
-
-  case Type::OpaqueTyID: {
-    return OpaqueType::get();
-  }
-
-  default:
-    std::cerr << __FILE__ << ":" << __LINE__
-              << ": 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 BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
-                                        const unsigned char *EndBuf,
-					TypeValuesListTy &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");
-  }
-}
-
-
-Constant *BytecodeParser::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) {
-    // FIXME: Encoding of constant exprs could be much more compact!
-    std::vector<Constant*> ArgVec;
-    ArgVec.reserve(isExprNumArgs);
-    unsigned Opcode = read_vbr_uint(Buf, EndBuf);
-    
-    // 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(getConstantValue(ArgTypeSlot, ArgValSlot));
-    }
-    
-    // Construct a ConstantExpr of the appropriate kind
-    if (isExprNumArgs == 1) {           // All one-operand expressions
-      assert(Opcode == Instruction::Cast);
-      return ConstantExpr::getCast(ArgVec[0], getType(TypeID));
-    } else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
-      std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
-
-      if (hasRestrictedGEPTypes) {
-        const Type *BaseTy = ArgVec[0]->getType();
-        generic_gep_type_iterator<std::vector<Constant*>::iterator>
-          GTI = gep_type_begin(BaseTy, IdxList.begin(), IdxList.end()),
-          E = gep_type_end(BaseTy, IdxList.begin(), IdxList.end());
-        for (unsigned i = 0; GTI != E; ++GTI, ++i)
-          if (isa<StructType>(*GTI)) {
-            if (IdxList[i]->getType() != Type::UByteTy)
-              throw std::string("Invalid index for getelementptr!");
-            IdxList[i] = ConstantExpr::getCast(IdxList[i], Type::UIntTy);
-          }
-      }
-
-      return ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
-    } else if (Opcode == Instruction::Select) {
-      assert(ArgVec.size() == 3);
-      return ConstantExpr::getSelect(ArgVec[0], ArgVec[1], ArgVec[2]);
-    } else {                            // All other 2-operand expressions
-      return ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
-    }
-  }
-  
-  // Ok, not an ConstantExpr.  We now know how to read the given type...
-  const Type *Ty = getType(TypeID);
-  switch (Ty->getTypeID()) {
-  case Type::BoolTyID: {
-    unsigned Val = read_vbr_uint(Buf, EndBuf);
-    if (Val != 0 && Val != 1) throw std::string("Invalid boolean value read.");
-    return ConstantBool::get(Val == 1);
-  }
-
-  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.");
-    return ConstantUInt::get(Ty, Val);
-  }
-
-  case Type::ULongTyID: {
-    return ConstantUInt::get(Ty, read_vbr_uint64(Buf, EndBuf));
-  }
-
-  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.");
-    return ConstantSInt::get(Ty, Val);
-  }
-
-  case Type::FloatTyID: {
-    float F;
-    input_data(Buf, EndBuf, &F, &F+1);
-    return ConstantFP::get(Ty, F);
-  }
-
-  case Type::DoubleTyID: {
-    double Val;
-    input_data(Buf, EndBuf, &Val, &Val+1);
-    return ConstantFP::get(Ty, Val);
-  }
-
-  case Type::TypeTyID:
-    throw std::string("Type constants shouldn't live in constant table!");
-
-  case Type::ArrayTyID: {
-    const ArrayType *AT = cast<ArrayType>(Ty);
-    unsigned NumElements = AT->getNumElements();
-    unsigned TypeSlot = getTypeSlot(AT->getElementType());
-    std::vector<Constant*> Elements;
-    Elements.reserve(NumElements);
-    while (NumElements--)     // Read all of the elements of the constant.
-      Elements.push_back(getConstantValue(TypeSlot,
-                                          read_vbr_uint(Buf, EndBuf)));
-    return ConstantArray::get(AT, Elements);
-  }
-
-  case Type::StructTyID: {
-    const StructType *ST = cast<StructType>(Ty);
-
-    std::vector<Constant *> Elements;
-    Elements.reserve(ST->getNumElements());
-    for (unsigned i = 0; i != ST->getNumElements(); ++i)
-      Elements.push_back(getConstantValue(ST->getElementType(i),
-                                          read_vbr_uint(Buf, EndBuf)));
-
-    return ConstantStruct::get(ST, Elements);
-  }    
-
-  case Type::PointerTyID: {  // ConstantPointerRef value...
-    const PointerType *PT = cast<PointerType>(Ty);
-    unsigned Slot = read_vbr_uint(Buf, EndBuf);
-    BCR_TRACE(4, "CPR: Type: '" << Ty << "'  slot: " << Slot << "\n");
-    
-    // Check to see if we have already read this global variable...
-    Value *Val = getValue(TypeID, Slot, false);
-    GlobalValue *GV;
-    if (Val) {
-      if (!(GV = dyn_cast<GlobalValue>(Val))) 
-        throw std::string("Value of ConstantPointerRef not in ValueTable!");
-      BCR_TRACE(5, "Value Found in ValueTable!\n");
-    } else {
-      throw std::string("Forward references are not allowed here.");
-    }
-    
-    return ConstantPointerRef::get(GV);
-  }
-
-  default:
-    throw std::string("Don't know how to deserialize constant value of type '"+
-                      Ty->getDescription());
-  }
-}
-
-void BytecodeParser::ParseGlobalTypes(const unsigned char *&Buf,
-                                      const unsigned char *EndBuf) {
-  ValueTable T;
-  ParseConstantPool(Buf, EndBuf, T, ModuleTypeValues);
-}
-
-void BytecodeParser::parseStringConstants(const unsigned char *&Buf,
-                                          const unsigned char *EndBuf,
-                                          unsigned NumEntries, ValueTable &Tab){
-  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.
-    Constant *C = ConstantArray::get(ATy, Elements);
-    unsigned Slot = insertValue(C, Typ, Tab);
-    ResolveReferencesToConstant(C, Slot);
-  }
-}
-
-
-void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
-                                       const unsigned char *EndBuf,
-                                       ValueTable &Tab, 
-                                       TypeValuesListTy &TypeTab) {
-  while (Buf < EndBuf) {
-    unsigned NumEntries = read_vbr_uint(Buf, EndBuf);
-    unsigned Typ = read_vbr_uint(Buf, EndBuf);
-    if (Typ == Type::TypeTyID) {
-      BCR_TRACE(3, "Type: 'type'  NumEntries: " << NumEntries << "\n");
-      parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
-    } else if (Typ == Type::VoidTyID) {
-      assert(&Tab == &ModuleValues && "Cannot read strings in functions!");
-      parseStringConstants(Buf, EndBuf, NumEntries, Tab);
-    } else {
-      BCR_TRACE(3, "Type: '" << *getType(Typ) << "'  NumEntries: "
-                << NumEntries << "\n");
-
-      for (unsigned i = 0; i < NumEntries; ++i) {
-        Constant *C = parseConstantValue(Buf, EndBuf, Typ);
-        assert(C && "parseConstantValue returned NULL!");
-        BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
-        unsigned Slot = insertValue(C, Typ, Tab);
-
-        // If we are reading a function constant table, make sure that we adjust
-        // the slot number to be the real global constant number.
-        //
-        if (&Tab != &ModuleValues && Typ < ModuleValues.size() &&
-            ModuleValues[Typ])
-          Slot += ModuleValues[Typ]->size();
-        ResolveReferencesToConstant(C, Slot);
-      }
-    }
-  }
-  
-  if (Buf > EndBuf) throw std::string("Read past end of buffer.");
-}
diff --git a/lib/Bytecode/Reader/Dumper.cpp b/lib/Bytecode/Reader/Dumper.cpp
deleted file mode 100644
index 280a12ba73..0000000000
--- a/lib/Bytecode/Reader/Dumper.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-//===-- BytecodeDumper.cpp - Parsing Handler --------------------*- C++ -*-===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Reid Spencer and is distributed under the 
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-//  This header file defines the BytecodeDumper class that gets called by the
-//  AbstractBytecodeParser when parsing events occur. It merely dumps the
-//  information presented to it from the parser.
-//
-//===----------------------------------------------------------------------===//
-
-#include "AnalyzerInternals.h"
-#include "llvm/Constant.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Instruction.h"
-#include "llvm/Type.h"
-
-using namespace llvm;
-
-namespace {
-
-class BytecodeDumper : public llvm::BytecodeHandler {
-public:
-
-  virtual bool handleError(const std::string& str )
-  {
-    std::cout << "ERROR: " << str << "\n";
-    return true;
-  }
-
-  virtual void handleStart()
-  {
-    std::cout << "Bytecode {\n";
-  }
-
-  virtual void handleFinish()
-  {
-    std::cout << "} End Bytecode\n";
-  }
-
-  virtual void handleModuleBegin(const std::string& id)
-  {
-    std::cout << "  Module " << id << " {\n";
-  }
-
-  virtual void handleModuleEnd(const std::string& id)
-  {
-    std::cout << "  } End Module " << id << "\n";
-  }
-
-  virtual void handleVersionInfo(
-    unsigned char RevisionNum,        ///< Byte code revision number
-    Module::Endianness Endianness,    ///< Endianness indicator
-    Module::PointerSize PointerSize   ///< PointerSize indicator
-  )
-  {
-    std::cout << "    RevisionNum: " << int(RevisionNum) 
-	      << " Endianness: " << Endianness
-	      << " PointerSize: " << PointerSize << "\n";
-  }
-
-  virtual void handleModuleGlobalsBegin()
-  {
-    std::cout << "    BLOCK: ModuleGlobalInfo {\n";
-  }
-
-  virtual void handleGlobalVariable( 
-    const Type* ElemType,     ///< The type of the global variable
-    bool isConstant,          ///< Whether the GV is constant or not
-    GlobalValue::LinkageTypes Linkage ///< The linkage type of the GV
-  )
-  {
-    std::cout << "      GV: Uninitialized, " 
-	     << ( isConstant? "Constant, " : "Variable, ")
-	     << " Linkage=" << Linkage << " Type=" 
-	     << ElemType->getDescription() << "\n"; 
-  }
-
-  virtual void handleInitializedGV( 
-    const Type* ElemType,     ///< The type of the global variable
-    bool isConstant,          ///< Whether the GV is constant or not
-    GlobalValue::LinkageTypes Linkage,///< The linkage type of the GV
-    unsigned initSlot         ///< Slot number of GV's initializer
-  )
-  {
-    std::cout << "      GV: Initialized, " 
-	     << ( isConstant? "Constant, " : "Variable, ")
-	     << " Linkage=" << Linkage << " Type=" 
-	     << ElemType->getDescription()
-	     << " InitializerSlot=" << initSlot << "\n"; 
-  }
-
-  virtual void handleType( const Type* Ty ) {
-    std::cout << "      Type: " << Ty->getDescription() << "\n";
-  }
-
-  virtual void handleFunctionDeclaration( 
-    Function* Func,
-    const FunctionType* FuncType) {
-    std::cout << "      Function: " << FuncType->getDescription() << "\n";
-  }
-
-  virtual void handleModuleGlobalsEnd() {
-    std::cout << "    } END BLOCK: ModuleGlobalInfo\n";
-  }
-
-  virtual void handleCompactionTableBegin() {
-    std::cout << "    BLOCK: CompactionTable {\n";
-  }
-
-  virtual void handleCompactionTablePlane( unsigned Ty, unsigned NumEntries ) {
-    std::cout << "      Plane: Ty=" << Ty << " Size=" << NumEntries << "\n";
-  }
-
-  virtual void handleCompactionTableType( 
-    unsigned i, 
-    unsigned TypSlot, 
-    const Type* Ty) {