Copy LLVM bitcode reader to generate a PNaCl wire format reader.

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.h

-//===- BitcodeReader.h - Internal BitcodeReader impl ------------*- C++ -*-===//
+//===- NaClBitcodeReader.h ------------------------------------*- C++ -*-===//
+//     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This header defines the BitcodeReader class.
+// This header defines the NaClBitcodeReader class.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef BITCODE_READER_H
-#define BITCODE_READER_H
+#ifndef NACL_BITCODE_READER_H
+#define NACL_BITCODE_READER_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/Bitcode/BitstreamReader.h"
-#include "llvm/Bitcode/LLVMBitCodes.h"
+#include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
+#include "llvm/Bitcode/NaCl/NaClBitCodes.h"
 #include "llvm/GVMaterializer.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/ValueHandle.h"
 #include <vector>
 
 namespace llvm {
   class MemoryBuffer;
   class LLVMContext;
 
 //===----------------------------------------------------------------------===//
-//                          BitcodeReaderValueList Class
+//                          NaClBitcodeReaderValueList Class
 //===----------------------------------------------------------------------===//
 
-class BitcodeReaderValueList {
+class NaClBitcodeReaderValueList {
   std::vector<WeakVH> ValuePtrs;
 
   /// ResolveConstants - As we resolve forward-referenced constants, we add
   /// information about them to this vector.  This allows us to resolve them in
   /// bulk instead of resolving each reference at a time.  See the code in
   /// ResolveConstantForwardRefs for more information about this.
   ///
   /// The key of this vector is the placeholder constant, the value is the slot
   /// number that holds the resolved value.
   typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy;
   ResolveConstantsTy ResolveConstants;
   LLVMContext &Context;
 public:
-  BitcodeReaderValueList(LLVMContext &C) : Context(C) {}
-  ~BitcodeReaderValueList() {
+  NaClBitcodeReaderValueList(LLVMContext &C) : Context(C) {}
+  ~NaClBitcodeReaderValueList() {
     assert(ResolveConstants.empty() && "Constants not resolved?");
   }
 
   // vector compatibility methods
   unsigned size() const { return ValuePtrs.size(); }
   void resize(unsigned N) { ValuePtrs.resize(N); }
   void push_back(Value *V) {
     ValuePtrs.push_back(V);
   }
 
@@ skipping 20 matching lines @@
 
   void AssignValue(Value *V, unsigned Idx);
 
   /// ResolveConstantForwardRefs - Once all constants are read, this method bulk
   /// resolves any forward references.
   void ResolveConstantForwardRefs();
 };
 
 
 //===----------------------------------------------------------------------===//
-//                          BitcodeReaderMDValueList Class
+//                          NaClBitcodeReaderMDValueList Class
 //===----------------------------------------------------------------------===//
 
-class BitcodeReaderMDValueList {
+class NaClBitcodeReaderMDValueList {
   std::vector<WeakVH> MDValuePtrs;
 
   LLVMContext &Context;
 public:
-  BitcodeReaderMDValueList(LLVMContext& C) : Context(C) {}
+  NaClBitcodeReaderMDValueList(LLVMContext& C) : Context(C) {}
 
   // vector compatibility methods
   unsigned size() const       { return MDValuePtrs.size(); }
   void resize(unsigned N)     { MDValuePtrs.resize(N); }
   void push_back(Value *V)    { MDValuePtrs.push_back(V);  }
   void clear()                { MDValuePtrs.clear();  }
   Value *back() const         { return MDValuePtrs.back(); }
   void pop_back()             { MDValuePtrs.pop_back(); }
   bool empty() const          { return MDValuePtrs.empty(); }
 
   Value *operator[](unsigned i) const {
     assert(i < MDValuePtrs.size());
     return MDValuePtrs[i];
   }
 
   void shrinkTo(unsigned N) {
     assert(N <= size() && "Invalid shrinkTo request!");
     MDValuePtrs.resize(N);
   }
 
   Value *getValueFwdRef(unsigned Idx);
   void AssignValue(Value *V, unsigned Idx);
 };
 
-class BitcodeReader : public GVMaterializer {
+class NaClBitcodeReader : public GVMaterializer {
   LLVMContext &Context;
   Module *TheModule;
   MemoryBuffer *Buffer;
   bool BufferOwned;
-  OwningPtr<BitstreamReader> StreamFile;
-  BitstreamCursor Stream;
+  OwningPtr<NaClBitstreamReader> StreamFile;
+  NaClBitstreamCursor Stream;
   DataStreamer *LazyStreamer;
   uint64_t NextUnreadBit;
   bool SeenValueSymbolTable;
 
   const char *ErrorString;
 
   std::vector<Type*> TypeList;
-  BitcodeReaderValueList ValueList;
-  BitcodeReaderMDValueList MDValueList;
+  NaClBitcodeReaderValueList ValueList;
+  NaClBitcodeReaderMDValueList MDValueList;
   SmallVector<Instruction *, 64> InstructionList;
   SmallVector<SmallVector<uint64_t, 64>, 64> UseListRecords;
 
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
 
   /// MAttributes - The set of attributes by index.  Index zero in the
   /// file is for null, and is thus not represented here.  As such all indices
   /// are off by one.
   std::vector<AttributeSet> MAttributes;
@@ skipping 35 matching lines @@
   /// UseRelativeIDs - Indicates that we are using a new encoding for
   /// instruction operands where most operands in the current
   /// FUNCTION_BLOCK are encoded relative to the instruction number,
   /// for a more compact encoding.  Some instruction operands are not
   /// relative to the instruction ID: basic block numbers, and types.
   /// Once the old style function blocks have been phased out, we would
   /// not need this flag.
   bool UseRelativeIDs;
 
 public:
-  explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C)
+  explicit NaClBitcodeReader(MemoryBuffer *buffer, LLVMContext &C)
     : Context(C), TheModule(0), Buffer(buffer), BufferOwned(false),
       LazyStreamer(0), NextUnreadBit(0), SeenValueSymbolTable(false),
       ErrorString(0), ValueList(C), MDValueList(C),
       SeenFirstFunctionBody(false), UseRelativeIDs(false) {
   }
-  explicit BitcodeReader(DataStreamer *streamer, LLVMContext &C)
+  explicit NaClBitcodeReader(DataStreamer *streamer, LLVMContext &C)
     : Context(C), TheModule(0), Buffer(0), BufferOwned(false),
       LazyStreamer(streamer), NextUnreadBit(0), SeenValueSymbolTable(false),
       ErrorString(0), ValueList(C), MDValueList(C),
       SeenFirstFunctionBody(false), UseRelativeIDs(false) {
   }
-  ~BitcodeReader() {
+  ~NaClBitcodeReader() {
     FreeState();
   }
 
   void materializeForwardReferencedFunctions();
 
   void FreeState();
 
   /// setBufferOwned - If this is true, the reader will destroy the MemoryBuffer
   /// when the reader is destroyed.
   void setBufferOwned(bool Owned) { BufferOwned = Owned; }
@@ skipping 122 matching lines @@
   bool InitStream();
   bool InitStreamFromBuffer();
   bool InitLazyStream();
   bool FindFunctionInStream(Function *F,
          DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator);
 };
 
 } // End llvm namespace
 
 #endif