Stephen Hines | 4cc499d | 2011-08-24 19:06:17 -0700 | [diff] [blame] | 1 | //===-- Bitcode/Writer/ValueEnumerator.h - Number values --------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This class gives values and types Unique ID's. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #ifndef VALUE_ENUMERATOR_H |
| 15 | #define VALUE_ENUMERATOR_H |
| 16 | |
| 17 | #include "llvm/ADT/DenseMap.h" |
| 18 | #include "llvm/ADT/SmallVector.h" |
| 19 | #include "llvm/Attributes.h" |
| 20 | #include <vector> |
| 21 | |
| 22 | namespace llvm { |
| 23 | |
| 24 | class Type; |
| 25 | class Value; |
| 26 | class Instruction; |
| 27 | class BasicBlock; |
| 28 | class Function; |
| 29 | class Module; |
| 30 | class MDNode; |
| 31 | class NamedMDNode; |
| 32 | class AttrListPtr; |
| 33 | class ValueSymbolTable; |
| 34 | class MDSymbolTable; |
| 35 | |
| 36 | class ValueEnumerator { |
| 37 | public: |
| 38 | typedef std::vector<Type*> TypeList; |
| 39 | |
| 40 | // For each value, we remember its Value* and occurrence frequency. |
| 41 | typedef std::vector<std::pair<const Value*, unsigned> > ValueList; |
| 42 | private: |
| 43 | typedef DenseMap<Type*, unsigned> TypeMapType; |
| 44 | TypeMapType TypeMap; |
| 45 | TypeList Types; |
| 46 | |
| 47 | typedef DenseMap<const Value*, unsigned> ValueMapType; |
| 48 | ValueMapType ValueMap; |
| 49 | ValueList Values; |
| 50 | ValueList MDValues; |
| 51 | SmallVector<const MDNode *, 8> FunctionLocalMDs; |
| 52 | ValueMapType MDValueMap; |
| 53 | |
| 54 | typedef DenseMap<void*, unsigned> AttributeMapType; |
| 55 | AttributeMapType AttributeMap; |
| 56 | std::vector<AttrListPtr> Attributes; |
| 57 | |
| 58 | /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by |
| 59 | /// the "getGlobalBasicBlockID" method. |
| 60 | mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs; |
| 61 | |
| 62 | typedef DenseMap<const Instruction*, unsigned> InstructionMapType; |
| 63 | InstructionMapType InstructionMap; |
| 64 | unsigned InstructionCount; |
| 65 | |
| 66 | /// BasicBlocks - This contains all the basic blocks for the currently |
| 67 | /// incorporated function. Their reverse mapping is stored in ValueMap. |
| 68 | std::vector<const BasicBlock*> BasicBlocks; |
| 69 | |
| 70 | /// When a function is incorporated, this is the size of the Values list |
| 71 | /// before incorporation. |
| 72 | unsigned NumModuleValues; |
| 73 | |
| 74 | /// When a function is incorporated, this is the size of the MDValues list |
| 75 | /// before incorporation. |
| 76 | unsigned NumModuleMDValues; |
| 77 | |
| 78 | unsigned FirstFuncConstantID; |
| 79 | unsigned FirstInstID; |
| 80 | |
| 81 | ValueEnumerator(const ValueEnumerator &); // DO NOT IMPLEMENT |
| 82 | void operator=(const ValueEnumerator &); // DO NOT IMPLEMENT |
| 83 | public: |
| 84 | ValueEnumerator(const Module *M); |
| 85 | |
| 86 | unsigned getValueID(const Value *V) const; |
| 87 | |
| 88 | unsigned getTypeID(Type *T) const { |
| 89 | TypeMapType::const_iterator I = TypeMap.find(T); |
| 90 | assert(I != TypeMap.end() && "Type not in ValueEnumerator!"); |
| 91 | return I->second-1; |
| 92 | } |
| 93 | |
| 94 | unsigned getInstructionID(const Instruction *I) const; |
| 95 | void setInstructionID(const Instruction *I); |
| 96 | |
| 97 | unsigned getAttributeID(const AttrListPtr &PAL) const { |
| 98 | if (PAL.isEmpty()) return 0; // Null maps to zero. |
| 99 | AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer()); |
| 100 | assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!"); |
| 101 | return I->second; |
| 102 | } |
| 103 | |
| 104 | /// getFunctionConstantRange - Return the range of values that corresponds to |
| 105 | /// function-local constants. |
| 106 | void getFunctionConstantRange(unsigned &Start, unsigned &End) const { |
| 107 | Start = FirstFuncConstantID; |
| 108 | End = FirstInstID; |
| 109 | } |
| 110 | |
| 111 | const ValueList &getValues() const { return Values; } |
| 112 | const ValueList &getMDValues() const { return MDValues; } |
| 113 | const SmallVector<const MDNode *, 8> &getFunctionLocalMDValues() const { |
| 114 | return FunctionLocalMDs; |
| 115 | } |
| 116 | const TypeList &getTypes() const { return Types; } |
| 117 | const std::vector<const BasicBlock*> &getBasicBlocks() const { |
| 118 | return BasicBlocks; |
| 119 | } |
| 120 | const std::vector<AttrListPtr> &getAttributes() const { |
| 121 | return Attributes; |
| 122 | } |
| 123 | |
| 124 | /// getGlobalBasicBlockID - This returns the function-specific ID for the |
| 125 | /// specified basic block. This is relatively expensive information, so it |
| 126 | /// should only be used by rare constructs such as address-of-label. |
| 127 | unsigned getGlobalBasicBlockID(const BasicBlock *BB) const; |
| 128 | |
| 129 | /// incorporateFunction/purgeFunction - If you'd like to deal with a function, |
| 130 | /// use these two methods to get its data into the ValueEnumerator! |
| 131 | /// |
| 132 | void incorporateFunction(const Function &F); |
| 133 | void purgeFunction(); |
| 134 | |
| 135 | private: |
| 136 | void OptimizeConstants(unsigned CstStart, unsigned CstEnd); |
| 137 | |
| 138 | void EnumerateMDNodeOperands(const MDNode *N); |
| 139 | void EnumerateMetadata(const Value *MD); |
| 140 | void EnumerateFunctionLocalMetadata(const MDNode *N); |
| 141 | void EnumerateNamedMDNode(const NamedMDNode *NMD); |
| 142 | void EnumerateValue(const Value *V); |
| 143 | void EnumerateType(Type *T); |
| 144 | void EnumerateOperandType(const Value *V); |
| 145 | void EnumerateAttributes(const AttrListPtr &PAL); |
| 146 | |
| 147 | void EnumerateValueSymbolTable(const ValueSymbolTable &ST); |
| 148 | void EnumerateNamedMetadata(const Module *M); |
| 149 | }; |
| 150 | |
| 151 | } // End llvm namespace |
| 152 | |
| 153 | #endif |