Copy Bitwriter to generate PNaClBitwriter.

lib/Bitcode/NaCl/Writer/NaClValueEnumerator.cpp

-//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===//
+//===-- NaClValueEnumerator.cpp ------------------------------------------===//
+//     Number values and types for bitcode writer
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the ValueEnumerator class.
+// This file implements the NaClValueEnumerator class.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ValueEnumerator.h"
+#include "NaClValueEnumerator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 
 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) {
+/// NaClValueEnumerator - Enumerate module-level information.
+NaClValueEnumerator::NaClValueEnumerator(const Module *M) {
   // Enumerate the global variables.
   for (Module::const_global_iterator I = M->global_begin(),
          E = M->global_end(); I != E; ++I)
     EnumerateValue(I);
 
   // Enumerate the functions.
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
     EnumerateValue(I);
     EnumerateAttributes(cast<Function>(I)->getAttributes());
   }
@@ skipping 59 matching lines @@
           if (Scope) EnumerateMetadata(Scope);
           if (IA) EnumerateMetadata(IA);
         }
       }
   }
 
   // Optimize constant ordering.
   OptimizeConstants(FirstConstant, Values.size());
 }
 
-unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const {
+unsigned NaClValueEnumerator::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 NaClValueEnumerator::setInstructionID(const Instruction *I) {
   InstructionMap[I] = InstructionCount++;
 }
 
-unsigned ValueEnumerator::getValueID(const Value *V) const {
+unsigned NaClValueEnumerator::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!");
     return I->second-1;
   }
 
   ValueMapType::const_iterator I = ValueMap.find(V);
   assert(I != ValueMap.end() && "Value not in slotcalculator!");
   return I->second-1;
 }
 
-void ValueEnumerator::dump() const {
+void NaClValueEnumerator::dump() const {
   print(dbgs(), ValueMap, "Default");
   dbgs() << '\n';
   print(dbgs(), MDValueMap, "MetaData");
   dbgs() << '\n';
 }
 
-void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
+void NaClValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
                             const char *Name) const {
 
   OS << "Map Name: " << Name << "\n";
   OS << "Size: " << Map.size() << "\n";
   for (ValueMapType::const_iterator I = Map.begin(),
          E = Map.end(); I != E; ++I) {
 
     const Value *V = I->first;
     if (V->hasName())
       OS << "Value: " << V->getName();
@@ skipping 12 matching lines @@
         OS << " [null]";
 
     }
     OS <<  "\n\n";
   }
 }
 
 // Optimize constant ordering.
 namespace {
   struct CstSortPredicate {
-    ValueEnumerator &VE;
-    explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {}
+    NaClValueEnumerator &VE;
+    explicit CstSortPredicate(NaClValueEnumerator &ve) : VE(ve) {}
     bool operator()(const std::pair<const Value*, unsigned> &LHS,
                     const std::pair<const Value*, unsigned> &RHS) {
       // Sort by plane.
       if (LHS.first->getType() != RHS.first->getType())
         return VE.getTypeID(LHS.first->getType()) <
                VE.getTypeID(RHS.first->getType());
       // Then by frequency.
       return LHS.second > RHS.second;
     }
   };
 }
 
 /// OptimizeConstants - Reorder constant pool for denser encoding.
-void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
+void NaClValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
   if (CstStart == CstEnd || CstStart+1 == CstEnd) return;
 
   CstSortPredicate P(*this);
   std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P);
 
   // Ensure that integer and vector of integer constants are at the start of the
   // constant pool.  This is important so that GEP structure indices come before
   // gep constant exprs.
   std::partition(Values.begin()+CstStart, Values.begin()+CstEnd,
                  isIntOrIntVectorValue);
 
   // Rebuild the modified portion of ValueMap.
   for (; CstStart != CstEnd; ++CstStart)
     ValueMap[Values[CstStart].first] = CstStart+1;
 }
 
 
 /// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
 /// table into the values table.
-void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
+void NaClValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
   for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
        VI != VE; ++VI)
     EnumerateValue(VI->getValue());
 }
 
 /// EnumerateNamedMetadata - Insert all of the values referenced by
 /// named metadata in the specified module.
-void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
+void NaClValueEnumerator::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 NaClValueEnumerator::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 NaClValueEnumerator::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))
         EnumerateMetadata(V);
       else if (!isa<Instruction>(V) && !isa<Argument>(V))
         EnumerateValue(V);
     } else
       EnumerateType(Type::getVoidTy(N->getContext()));
   }
 }
 
-void ValueEnumerator::EnumerateMetadata(const Value *MD) {
+void NaClValueEnumerator::EnumerateMetadata(const Value *MD) {
   assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind");
 
   // Enumerate the type of this value.
   EnumerateType(MD->getType());
 
   const MDNode *N = dyn_cast<MDNode>(MD);
 
   // In the module-level pass, skip function-local nodes themselves, but
   // do walk their operands.
   if (N && N->isFunctionLocal() && N->getFunction()) {
@@ skipping 11 matching lines @@
   MDValues.push_back(std::make_pair(MD, 1U));
   MDValueID = MDValues.size();
 
   // Enumerate all non-function-local operands.
   if (N)
     EnumerateMDNodeOperands(N);
 }
 
 /// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata
 /// information reachable from the given MDNode.
-void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
+void NaClValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
   assert(N->isFunctionLocal() && N->getFunction() &&
          "EnumerateFunctionLocalMetadata called on non-function-local mdnode!");
 
   // Enumerate the type of this value.
   EnumerateType(N->getType());
 
   // Check to see if it's already in!
   unsigned &MDValueID = MDValueMap[N];
   if (MDValueID) {
     // Increment use count.
@@ skipping 11 matching lines @@
         if (O->isFunctionLocal() && O->getFunction())
           EnumerateFunctionLocalMetadata(O);
       } else if (isa<Instruction>(V) || isa<Argument>(V))
         EnumerateValue(V);
     }
 
   // Also, collect all function-local MDNodes for easy access.
   FunctionLocalMDs.push_back(N);
 }
 
-void ValueEnumerator::EnumerateValue(const Value *V) {
+void NaClValueEnumerator::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!");
 
   // Check to see if it's already in!
   unsigned &ValueID = ValueMap[V];
   if (ValueID) {
     // Increment use count.
     Values[ValueID-1].second++;
     return;
@@ skipping 26 matching lines @@
       return;
     }
   }
 
   // Add the value.
   Values.push_back(std::make_pair(V, 1U));
   ValueID = Values.size();
 }
 
 
-void ValueEnumerator::EnumerateType(Type *Ty) {
+void NaClValueEnumerator::EnumerateType(Type *Ty) {
   unsigned *TypeID = &TypeMap[Ty];
 
   // We've already seen this type.
   if (*TypeID)
     return;
 
   // If it is a non-anonymous struct, mark the type as being visited so that we
   // don't recursively visit it.  This is safe because we allow forward
   // references of these in the bitcode reader.
   if (StructType *STy = dyn_cast<StructType>(Ty))
@@ skipping 18 matching lines @@
     return;
 
   // Add this type now that its contents are all happily enumerated.
   Types.push_back(Ty);
 
   *TypeID = Types.size();
 }
 
 // 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 NaClValueEnumerator::EnumerateOperandType(const Value *V) {
   EnumerateType(V->getType());
 
   if (const Constant *C = dyn_cast<Constant>(V)) {
     // If this constant is already enumerated, ignore it, we know its type must
     // be enumerated.
     if (ValueMap.count(V)) return;
 
     // This constant may have operands, make sure to enumerate the types in
     // them.
     for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
       const Value *Op = C->getOperand(i);
 
       // Don't enumerate basic blocks here, this happens as operands to
       // blockaddress.
       if (isa<BasicBlock>(Op)) continue;
 
       EnumerateOperandType(Op);
     }
 
     if (const MDNode *N = dyn_cast<MDNode>(V)) {
       for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
         if (Value *Elem = N->getOperand(i))
           EnumerateOperandType(Elem);
     }
   } else if (isa<MDString>(V) || isa<MDNode>(V))
     EnumerateMetadata(V);
 }
 
-void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
+void NaClValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
   if (PAL.isEmpty()) return;  // null is always 0.
 
   // Do a lookup.
   unsigned &Entry = AttributeMap[PAL];
   if (Entry == 0) {
     // Never saw this before, add it.
     Attribute.push_back(PAL);
     Entry = Attribute.size();
   }
 
   // Do lookups for all attribute groups.
   for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) {
     AttributeSet AS = PAL.getSlotAttributes(i);
     unsigned &Entry = AttributeGroupMap[AS];
     if (Entry == 0) {
       AttributeGroups.push_back(AS);
       Entry = AttributeGroups.size();
     }
   }
 }
 
-void ValueEnumerator::incorporateFunction(const Function &F) {
+void NaClValueEnumerator::incorporateFunction(const Function &F) {
   InstructionCount = 0;
   NumModuleValues = Values.size();
   NumModuleMDValues = MDValues.size();
 
   // Adding function arguments to the value table.
   for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end();
        I != E; ++I)
     EnumerateValue(I);
 
   FirstFuncConstantID = Values.size();
@@ skipping 43 matching lines @@
       if (!I->getType()->isVoidTy())
         EnumerateValue(I);
     }
   }
 
   // Add all of the function-local metadata.
   for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i)
     EnumerateFunctionLocalMetadata(FnLocalMDVector[i]);
 }
 
-void ValueEnumerator::purgeFunction() {
+void NaClValueEnumerator::purgeFunction() {
   /// Remove purged values from the ValueMap.
   for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i)
     ValueMap.erase(Values[i].first);
   for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i)
     MDValueMap.erase(MDValues[i].first);
   for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i)
     ValueMap.erase(BasicBlocks[i]);
 
   Values.resize(NumModuleValues);
   MDValues.resize(NumModuleMDValues);
   BasicBlocks.clear();
   FunctionLocalMDs.clear();
 }
 
 static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
                                  DenseMap<const BasicBlock*, unsigned> &IDMap) {
   unsigned Counter = 0;
   for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
     IDMap[BB] = ++Counter;
 }
 
 /// 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 NaClValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
   unsigned &Idx = GlobalBasicBlockIDs[BB];
   if (Idx != 0)
     return Idx-1;
 
   IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs);
   return getGlobalBasicBlockID(BB);
 }