ValueEnumerator.h revision bc5201f8371f9041e79efcca3b158335da5c2604
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/Attributes.h" 19#include <vector> 20 21namespace llvm { 22 23class Type; 24class Value; 25class Instruction; 26class BasicBlock; 27class Function; 28class Module; 29class MetadataBase; 30class NamedMDNode; 31class AttrListPtr; 32class TypeSymbolTable; 33class ValueSymbolTable; 34class MDSymbolTable; 35 36class ValueEnumerator { 37public: 38 // For each type, we remember its Type* and occurrence frequency. 39 typedef std::vector<std::pair<const Type*, unsigned> > TypeList; 40 41 // For each value, we remember its Value* and occurrence frequency. 42 typedef std::vector<std::pair<const Value*, unsigned> > ValueList; 43private: 44 typedef DenseMap<const Type*, unsigned> TypeMapType; 45 TypeMapType TypeMap; 46 TypeList Types; 47 48 typedef DenseMap<const Value*, unsigned> ValueMapType; 49 ValueMapType ValueMap; 50 ValueList Values; 51 ValueList MDValues; 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 unsigned FirstFuncConstantID; 74 unsigned FirstInstID; 75 76 ValueEnumerator(const ValueEnumerator &); // DO NOT IMPLEMENT 77 void operator=(const ValueEnumerator &); // DO NOT IMPLEMENT 78public: 79 ValueEnumerator(const Module *M); 80 81 unsigned getValueID(const Value *V) const; 82 83 unsigned getTypeID(const Type *T) const { 84 TypeMapType::const_iterator I = TypeMap.find(T); 85 assert(I != TypeMap.end() && "Type not in ValueEnumerator!"); 86 return I->second-1; 87 } 88 89 unsigned getInstructionID(const Instruction *I) const; 90 void setInstructionID(const Instruction *I); 91 92 unsigned getAttributeID(const AttrListPtr &PAL) const { 93 if (PAL.isEmpty()) return 0; // Null maps to zero. 94 AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer()); 95 assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!"); 96 return I->second; 97 } 98 99 /// getFunctionConstantRange - Return the range of values that corresponds to 100 /// function-local constants. 101 void getFunctionConstantRange(unsigned &Start, unsigned &End) const { 102 Start = FirstFuncConstantID; 103 End = FirstInstID; 104 } 105 106 const ValueList &getValues() const { return Values; } 107 const ValueList &getMDValues() const { return MDValues; } 108 const TypeList &getTypes() const { return Types; } 109 const std::vector<const BasicBlock*> &getBasicBlocks() const { 110 return BasicBlocks; 111 } 112 const std::vector<AttrListPtr> &getAttributes() const { 113 return Attributes; 114 } 115 116 /// getGlobalBasicBlockID - This returns the function-specific ID for the 117 /// specified basic block. This is relatively expensive information, so it 118 /// should only be used by rare constructs such as address-of-label. 119 unsigned getGlobalBasicBlockID(const BasicBlock *BB) const; 120 121 /// incorporateFunction/purgeFunction - If you'd like to deal with a function, 122 /// use these two methods to get its data into the ValueEnumerator! 123 /// 124 void incorporateFunction(const Function &F); 125 void purgeFunction(); 126 127private: 128 void OptimizeConstants(unsigned CstStart, unsigned CstEnd); 129 130 void EnumerateMetadata(const Value *MD); 131 void EnumerateNamedMDNode(const NamedMDNode *NMD); 132 void EnumerateValue(const Value *V); 133 void EnumerateType(const Type *T); 134 void EnumerateOperandType(const Value *V); 135 void EnumerateAttributes(const AttrListPtr &PAL); 136 137 void EnumerateTypeSymbolTable(const TypeSymbolTable &ST); 138 void EnumerateValueSymbolTable(const ValueSymbolTable &ST); 139 void EnumerateMDSymbolTable(const MDSymbolTable &ST); 140}; 141 142} // End llvm namespace 143 144#endif 145