Rebased PNaCl localmods in LLVM to 223109

lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h

Index: lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h
diff --git a/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h b/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..46080df2a574a07264426452074b2eb8856dd57a
--- /dev/null
+++ b/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.h
@@ -0,0 +1,169 @@
+//===-- 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 NACL_VALUE_ENUMERATOR_H
+#define NACL_VALUE_ENUMERATOR_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
+#include <vector>
+
+namespace llvm {
+
+class Type;
+class Value;
+class Instruction;
+class BasicBlock;
+class Function;
+class Module;
+class ValueSymbolTable;
+class raw_ostream;
+
+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:
+  // Defines unique ID's for each type.
+  typedef DenseMap<Type*, unsigned> TypeMapType;
+  TypeMapType TypeMap;
+  // Defines the number of references to each type. If defined,
+  // we are in the first pass of collecting types, and reference counts
+  // should be added to the map. If undefined, we are in the second pass
+  // that actually assigns type IDs, based on frequency counts found in
+  // the first pass.
+  typedef TypeMapType TypeCountMapType;
+  TypeCountMapType* TypeCountMap;
+
+  TypeList Types;
+
+  typedef DenseMap<const Value*, unsigned> ValueMapType;
+  ValueMapType ValueMap;
+  ValueList Values;
+
+  typedef DenseMap<const Instruction*, unsigned> InstructionMapType;
+  InstructionMapType InstructionMap;
+  unsigned InstructionCount;
+
+  /// BasicBlocks - This contains all the basic blocks for the currently
+  /// incorporated function.  Their reverse mapping is stored in ValueMap.
+  std::vector<const BasicBlock*> BasicBlocks;
+
+  /// When a function is incorporated, this is the size of the Values list
+  /// before incorporation.
+  unsigned NumModuleValues;
+
+  unsigned FirstFuncConstantID;
+  unsigned FirstInstID;
+
+  /// Holds values that have been forward referenced within a function.
+  /// Used to make sure we don't generate more forward reference declarations
+  /// than necessary.
+  SmallSet<unsigned, 32> FnForwardTypeRefs;
+
+  // The index of the first global variable ID in the bitcode file.
+  unsigned FirstGlobalVarID;
+  // The number of global variable IDs defined in the bitcode file.
+  unsigned NumGlobalVarIDs;
+
+  /// \brief Integer type use for PNaCl conversion of pointers.
+  Type *IntPtrType;
+
+  NaClValueEnumerator(const NaClValueEnumerator &) LLVM_DELETED_FUNCTION;
+  void operator=(const NaClValueEnumerator &) LLVM_DELETED_FUNCTION;
+public:
+  NaClValueEnumerator(const Module *M);
+
+  void dump() const;
+  void print(raw_ostream &OS, const ValueMapType &Map, const char *Name) const;
+
+  unsigned getFirstGlobalVarID() const {
+    return FirstGlobalVarID;
+  }
+
+  unsigned getNumGlobalVarIDs() const {
+    return NumGlobalVarIDs;
+  }
+
+  unsigned getValueID(const Value *V) const;
+
+  unsigned getTypeID(Type *T) const {
+    TypeMapType::const_iterator I = TypeMap.find(NormalizeType(T));
+    assert(I != TypeMap.end() && "Type not in NaClValueEnumerator!");
+    return I->second-1;
+  }
+
+  unsigned getInstructionID(const Instruction *I) const;
+  void setInstructionID(const Instruction *I);
+
+  /// getFunctionConstantRange - Return the range of values that corresponds to
+  /// function-local constants.
+  void getFunctionConstantRange(unsigned &Start, unsigned &End) const {
+    Start = FirstFuncConstantID;
+    End = FirstInstID;
+  }
+
+  /// \brief Inserts the give value into the set of known function forward
+  /// value type refs. Returns true if the value id is added to the set.
+  bool InsertFnForwardTypeRef(unsigned ValID) {
+    return FnForwardTypeRefs.insert(ValID).second;
+  }
+
+  const ValueList &getValues() const { return Values; }
+  const TypeList &getTypes() const { return Types; }
+  const std::vector<const BasicBlock*> &getBasicBlocks() const {
+    return BasicBlocks;
+  }
+
+  /// incorporateFunction/purgeFunction - If you'd like to deal with a function,
+  /// use these two methods to get its data into the NaClValueEnumerator!
+  ///
+  void incorporateFunction(const Function &F);
+  void purgeFunction();
+
+  /// \brief Returns the value after elided (cast) operations have been
+  /// removed. Returns V if unable to elide the cast.
+  const Value *ElideCasts(const Value *V) const;
+
+  /// \brief Returns true if value V is an elided (cast) operation.
+  bool IsElidedCast(const Value *V) const {
+    return V != ElideCasts(V);
+  }
+
+  /// \brief Returns true if the type of V is the integer used to
+  /// model pointers in PNaCl.
+  bool IsIntPtrType(Type *T) const {
+    return T == IntPtrType;
+  }
+
+  Type *NormalizeType(Type *Ty) const;
+
+private:
+  void OptimizeTypes(const Module *M);
+  void OptimizeConstants(unsigned CstStart, unsigned CstEnd);
+
+  void EnumerateValue(const Value *V);
+  void EnumerateType(Type *T, bool InsideOptimizeTypes=false);
+  void EnumerateOperandType(const Value *V);
+
+  void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
+};
+
+} // End llvm namespace
+
+#endif