Copy Bitwriter to generate PNaClBitwriter.

lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h

-//===-- Bitcode/Writer/ValueEnumerator.h - Number values --------*- C++ -*-===//
+//===-- Bitcode/NaCl/Writer/NaClValueEnumerator.h - ----------*- C++ -*-===//
+//      Number values.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This class gives values and types Unique ID's.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef VALUE_ENUMERATOR_H
-#define VALUE_ENUMERATOR_H
+#ifndef NACL_VALUE_ENUMERATOR_H
+#define NACL_VALUE_ENUMERATOR_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Attributes.h"
 #include <vector>
 
 namespace llvm {
 
 class Type;
 class Value;
 class Instruction;
 class BasicBlock;
 class Function;
 class Module;
 class MDNode;
 class NamedMDNode;
 class AttributeSet;
 class ValueSymbolTable;
 class MDSymbolTable;
 class raw_ostream;
 
-class ValueEnumerator {
+class NaClValueEnumerator {
 public:
   typedef std::vector<Type*> TypeList;
 
   // For each value, we remember its Value* and occurrence frequency.
   typedef std::vector<std::pair<const Value*, unsigned> > ValueList;
 private:
   typedef DenseMap<Type*, unsigned> TypeMapType;
   TypeMapType TypeMap;
   TypeList Types;
 
@@ skipping 28 matching lines @@
   /// before incorporation.
   unsigned NumModuleValues;
 
   /// When a function is incorporated, this is the size of the MDValues list
   /// before incorporation.
   unsigned NumModuleMDValues;
 
   unsigned FirstFuncConstantID;
   unsigned FirstInstID;
 
-  ValueEnumerator(const ValueEnumerator &) LLVM_DELETED_FUNCTION;
-  void operator=(const ValueEnumerator &) LLVM_DELETED_FUNCTION;
+  NaClValueEnumerator(const NaClValueEnumerator &) LLVM_DELETED_FUNCTION;
+  void operator=(const NaClValueEnumerator &) LLVM_DELETED_FUNCTION;
 public:
-  ValueEnumerator(const Module *M);
+  NaClValueEnumerator(const Module *M);
 
   void dump() const;
   void print(raw_ostream &OS, const ValueMapType &Map, const char *Name) const;
 
   unsigned getValueID(const Value *V) const;
 
   unsigned getTypeID(Type *T) const {
     TypeMapType::const_iterator I = TypeMap.find(T);
-    assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
+    assert(I != TypeMap.end() && "Type not in NaClValueEnumerator!");
     return I->second-1;
   }
 
   unsigned getInstructionID(const Instruction *I) const;
   void setInstructionID(const Instruction *I);
 
   unsigned getAttributeID(AttributeSet PAL) const {
     if (PAL.isEmpty()) return 0;  // Null maps to zero.
     AttributeMapType::const_iterator I = AttributeMap.find(PAL);
-    assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!");
+    assert(I != AttributeMap.end() && "Attribute not in NaClValueEnumerator!");
     return I->second;
   }
 
   unsigned getAttributeGroupID(AttributeSet PAL) const {
     if (PAL.isEmpty()) return 0;  // Null maps to zero.
     AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL);
-    assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!");
+    assert(I != AttributeGroupMap.end() && "Attribute not in NaClValueEnumerator!");
     return I->second;
   }
 
   /// getFunctionConstantRange - Return the range of values that corresponds to
   /// function-local constants.
   void getFunctionConstantRange(unsigned &Start, unsigned &End) const {
     Start = FirstFuncConstantID;
     End = FirstInstID;
   }
 
@@ skipping 12 matching lines @@
   const std::vector<AttributeSet> &getAttributeGroups() const {
     return AttributeGroups;
   }
 
   /// getGlobalBasicBlockID - This returns the function-specific ID for the
   /// specified basic block.  This is relatively expensive information, so it
   /// should only be used by rare constructs such as address-of-label.
   unsigned getGlobalBasicBlockID(const BasicBlock *BB) const;
 
   /// incorporateFunction/purgeFunction - If you'd like to deal with a function,
-  /// use these two methods to get its data into the ValueEnumerator!
+  /// use these two methods to get its data into the NaClValueEnumerator!
   ///
   void incorporateFunction(const Function &F);
   void purgeFunction();
 
 private:
   void OptimizeConstants(unsigned CstStart, unsigned CstEnd);
 
   void EnumerateMDNodeOperands(const MDNode *N);
   void EnumerateMetadata(const Value *MD);
   void EnumerateFunctionLocalMetadata(const MDNode *N);
   void EnumerateNamedMDNode(const NamedMDNode *NMD);
   void EnumerateValue(const Value *V);
   void EnumerateType(Type *T);
   void EnumerateOperandType(const Value *V);
   void EnumerateAttributes(AttributeSet PAL);
 
   void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
   void EnumerateNamedMetadata(const Module *M);
 };
 
 } // End llvm namespace
 
 #endif