Copy Bitwriter to generate PNaClBitwriter.

lib/Bitcode/PNaCl/Writer/PNaClValueEnumerator.cpp

Index: lib/Bitcode/PNaCl/Writer/PNaClValueEnumerator.cpp
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/PNaCl/Writer/PNaClValueEnumerator.cpp
similarity index 91%
copy from lib/Bitcode/Writer/ValueEnumerator.cpp
copy to lib/Bitcode/PNaCl/Writer/PNaClValueEnumerator.cpp
index 4f19dd00e63966cebe2ce1057e90b23011540cff..3fd58788388651e5bf95a0aa63de90683b010bea 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/PNaCl/Writer/PNaClValueEnumerator.cpp
@@ -7,11 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the ValueEnumerator class.
+// This file implements the PNaClValueEnumerator class.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ValueEnumerator.h"
+#include "PNaClValueEnumerator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Constants.h"
@@ -28,8 +28,8 @@ static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) {
   return V.first->getType()->isIntOrIntVectorTy();
 }
 
-/// ValueEnumerator - Enumerate module-level information.
-ValueEnumerator::ValueEnumerator(const Module *M) {
+/// PNaClValueEnumerator - Enumerate module-level information.
+PNaClValueEnumerator::PNaClValueEnumerator(const Module *M) {
   // Enumerate the global variables.
   for (Module::const_global_iterator I = M->global_begin(),
          E = M->global_end(); I != E; ++I)
@@ -109,17 +109,17 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   OptimizeConstants(FirstConstant, Values.size());
 }
 
-unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const {
+unsigned PNaClValueEnumerator::getInstructionID(const Instruction *Inst) const {
   InstructionMapType::const_iterator I = InstructionMap.find(Inst);
   assert(I != InstructionMap.end() && "Instruction is not mapped!");
   return I->second;
 }
 
-void ValueEnumerator::setInstructionID(const Instruction *I) {
+void PNaClValueEnumerator::setInstructionID(const Instruction *I) {
   InstructionMap[I] = InstructionCount++;
 }
 
-unsigned ValueEnumerator::getValueID(const Value *V) const {
+unsigned PNaClValueEnumerator::getValueID(const Value *V) const {
   if (isa<MDNode>(V) || isa<MDString>(V)) {
     ValueMapType::const_iterator I = MDValueMap.find(V);
     assert(I != MDValueMap.end() && "Value not in slotcalculator!");
@@ -131,14 +131,14 @@ unsigned ValueEnumerator::getValueID(const Value *V) const {
   return I->second-1;
 }
 
-void ValueEnumerator::dump() const {
+void PNaClValueEnumerator::dump() const {
   print(dbgs(), ValueMap, "Default");
   dbgs() << '\n';
   print(dbgs(), MDValueMap, "MetaData");
   dbgs() << '\n';
 }
 
-void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
+void PNaClValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
                             const char *Name) const {
 
   OS << "Map Name: " << Name << "\n";
@@ -171,8 +171,8 @@ void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
 // Optimize constant ordering.
 namespace {
   struct CstSortPredicate {
-    ValueEnumerator &VE;
-    explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {}
+    PNaClValueEnumerator &VE;
+    explicit CstSortPredicate(PNaClValueEnumerator &ve) : VE(ve) {}
     bool operator()(const std::pair<const Value*, unsigned> &LHS,
                     const std::pair<const Value*, unsigned> &RHS) {
       // Sort by plane.
@@ -186,7 +186,7 @@ namespace {
 }
 
 /// OptimizeConstants - Reorder constant pool for denser encoding.
-void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
+void PNaClValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
   if (CstStart == CstEnd || CstStart+1 == CstEnd) return;
 
   CstSortPredicate P(*this);
@@ -206,7 +206,7 @@ void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
 
 /// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
 /// table into the values table.
-void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
+void PNaClValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
   for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
        VI != VE; ++VI)
     EnumerateValue(VI->getValue());
@@ -214,20 +214,20 @@ void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
 
 /// EnumerateNamedMetadata - Insert all of the values referenced by
 /// named metadata in the specified module.
-void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
+void PNaClValueEnumerator::EnumerateNamedMetadata(const Module *M) {
   for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
        E = M->named_metadata_end(); I != E; ++I)
     EnumerateNamedMDNode(I);
 }
 
-void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {
+void PNaClValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {
   for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i)
     EnumerateMetadata(MD->getOperand(i));
 }
 
 /// EnumerateMDNodeOperands - Enumerate all non-function-local values
 /// and types referenced by the given MDNode.
-void ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) {
+void PNaClValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) {
   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
     if (Value *V = N->getOperand(i)) {
       if (isa<MDNode>(V) || isa<MDString>(V))
@@ -239,7 +239,7 @@ void ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) {
   }
 }
 
-void ValueEnumerator::EnumerateMetadata(const Value *MD) {
+void PNaClValueEnumerator::EnumerateMetadata(const Value *MD) {
   assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind");
 
   // Enumerate the type of this value.
@@ -271,7 +271,7 @@ void ValueEnumerator::EnumerateMetadata(const Value *MD) {
 
 /// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata
 /// information reachable from the given MDNode.
-void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
+void PNaClValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
   assert(N->isFunctionLocal() && N->getFunction() &&
          "EnumerateFunctionLocalMetadata called on non-function-local mdnode!");
 
@@ -303,7 +303,7 @@ void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
   FunctionLocalMDs.push_back(N);
 }
 
-void ValueEnumerator::EnumerateValue(const Value *V) {
+void PNaClValueEnumerator::EnumerateValue(const Value *V) {
   assert(!V->getType()->isVoidTy() && "Can't insert void values!");
   assert(!isa<MDNode>(V) && !isa<MDString>(V) &&
          "EnumerateValue doesn't handle Metadata!");
@@ -350,7 +350,7 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
 }
 
 
-void ValueEnumerator::EnumerateType(Type *Ty) {
+void PNaClValueEnumerator::EnumerateType(Type *Ty) {
   unsigned *TypeID = &TypeMap[Ty];
 
   // We've already seen this type.
@@ -389,7 +389,7 @@ void ValueEnumerator::EnumerateType(Type *Ty) {
 
 // Enumerate the types for the specified value.  If the value is a constant,
 // walk through it, enumerating the types of the constant.
-void ValueEnumerator::EnumerateOperandType(const Value *V) {
+void PNaClValueEnumerator::EnumerateOperandType(const Value *V) {
   EnumerateType(V->getType());
 
   if (const Constant *C = dyn_cast<Constant>(V)) {
@@ -418,7 +418,7 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) {
     EnumerateMetadata(V);
 }
 
-void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
+void PNaClValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
   if (PAL.isEmpty()) return;  // null is always 0.
 
   // Do a lookup.
@@ -440,7 +440,7 @@ void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
   }
 }
 
-void ValueEnumerator::incorporateFunction(const Function &F) {
+void PNaClValueEnumerator::incorporateFunction(const Function &F) {
   InstructionCount = 0;
   NumModuleValues = Values.size();
   NumModuleMDValues = MDValues.size();
@@ -504,7 +504,7 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
     EnumerateFunctionLocalMetadata(FnLocalMDVector[i]);
 }
 
-void ValueEnumerator::purgeFunction() {
+void PNaClValueEnumerator::purgeFunction() {
   /// Remove purged values from the ValueMap.
   for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i)
     ValueMap.erase(Values[i].first);
@@ -529,7 +529,7 @@ static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
 /// 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 ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
+unsigned PNaClValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
   unsigned &Idx = GlobalBasicBlockIDs[BB];
   if (Idx != 0)
     return Idx-1;