//===-- Bitcode/Writer/ValueEnumerator.h - Number values --------*- C++ -*-===// // // 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 VALUE_ENUMERATOR_H #define VALUE_ENUMERATOR_H #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/UniqueVector.h" #include "llvm/IR/Attributes.h" #include <vector> namespace llvm { class Type; class Value; class Instruction; class BasicBlock; class Comdat; class Function; class Module; class MDNode; class NamedMDNode; class AttributeSet; class ValueSymbolTable; class MDSymbolTable; class raw_ostream; class ValueEnumerator { 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: typedef DenseMap<Type*, unsigned> TypeMapType; TypeMapType TypeMap; TypeList Types; typedef DenseMap<const Value*, unsigned> ValueMapType; ValueMapType ValueMap; ValueList Values; typedef UniqueVector<const Comdat *> ComdatSetType; ComdatSetType Comdats; ValueList MDValues; SmallVector<const MDNode *, 8> FunctionLocalMDs; ValueMapType MDValueMap; typedef DenseMap<AttributeSet, unsigned> AttributeGroupMapType; AttributeGroupMapType AttributeGroupMap; std::vector<AttributeSet> AttributeGroups; typedef DenseMap<AttributeSet, unsigned> AttributeMapType; AttributeMapType AttributeMap; std::vector<AttributeSet> Attribute; /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by /// the "getGlobalBasicBlockID" method. mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs; 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; /// When a function is incorporated, this is the size of the MDValues list /// before incorporation. unsigned NumModuleMDValues; unsigned FirstFuncConstantID; unsigned FirstInstID; ValueEnumerator(const ValueEnumerator &) LLVM_DELETED_FUNCTION; void operator=(const ValueEnumerator &) LLVM_DELETED_FUNCTION; public: ValueEnumerator(const Module *M); void dump() const; void print(raw_ostream &OS, const ValueMapType &Map, const char *Name) const; unsigned getValueID(const Value *V) const; unsigned getTypeID(Type *T) const { TypeMapType::const_iterator I = TypeMap.find(T); assert(I != TypeMap.end() && "Type not in ValueEnumerator!"); return I->second-1; } unsigned getInstructionID(const Instruction *I) const; void setInstructionID(const Instruction *I); unsigned getAttributeID(AttributeSet PAL) const { if (PAL.isEmpty()) return 0; // Null maps to zero. AttributeMapType::const_iterator I = AttributeMap.find(PAL); assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!"); return I->second; } unsigned getAttributeGroupID(AttributeSet PAL) const { if (PAL.isEmpty()) return 0; // Null maps to zero. AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL); assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!"); return I->second; } /// getFunctionConstantRange - Return the range of values that corresponds to /// function-local constants. void getFunctionConstantRange(unsigned &Start, unsigned &End) const { Start = FirstFuncConstantID; End = FirstInstID; } const ValueList &getValues() const { return Values; } const ValueList &getMDValues() const { return MDValues; } const SmallVectorImpl<const MDNode *> &getFunctionLocalMDValues() const { return FunctionLocalMDs; } const TypeList &getTypes() const { return Types; } const std::vector<const BasicBlock*> &getBasicBlocks() const { return BasicBlocks; } const std::vector<AttributeSet> &getAttributes() const { return Attribute; } const std::vector<AttributeSet> &getAttributeGroups() const { return AttributeGroups; } const ComdatSetType &getComdats() const { return Comdats; } unsigned getComdatID(const Comdat *C) const; /// 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 getGlobalBasicBlockID(const BasicBlock *BB) const; /// incorporateFunction/purgeFunction - If you'd like to deal with a function, /// use these two methods to get its data into the ValueEnumerator! /// void incorporateFunction(const Function &F); void purgeFunction(); private: void OptimizeConstants(unsigned CstStart, unsigned CstEnd); void EnumerateMDNodeOperands(const MDNode *N); void EnumerateMetadata(const Value *MD); void EnumerateFunctionLocalMetadata(const MDNode *N); void EnumerateNamedMDNode(const NamedMDNode *NMD); void EnumerateValue(const Value *V); void EnumerateType(Type *T); void EnumerateOperandType(const Value *V); void EnumerateAttributes(AttributeSet PAL); void EnumerateValueSymbolTable(const ValueSymbolTable &ST); void EnumerateNamedMetadata(const Module *M); }; } // End llvm namespace #endif