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