X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FBitcode%2FWriter%2FValueEnumerator.h;h=9fb8325150e933bf0c8d1820c384e23a48b5e404;hp=dc40d016dcaaef94e7d203ab095f7d48a5ad9087;hb=8a32dc47d61f3c12f95f5cf7dd1d67ed7c6c00cd;hpb=58d74910c6b82e622ecbb57d6644d48fec5a5c0f diff --git a/lib/Bitcode/Writer/ValueEnumerator.h b/lib/Bitcode/Writer/ValueEnumerator.h index dc40d016dca..9fb8325150e 100644 --- a/lib/Bitcode/Writer/ValueEnumerator.h +++ b/lib/Bitcode/Writer/ValueEnumerator.h @@ -11,75 +11,142 @@ // //===----------------------------------------------------------------------===// -#ifndef VALUE_ENUMERATOR_H -#define VALUE_ENUMERATOR_H +#ifndef LLVM_LIB_BITCODE_WRITER_VALUEENUMERATOR_H +#define LLVM_LIB_BITCODE_WRITER_VALUEENUMERATOR_H #include "llvm/ADT/DenseMap.h" -#include "llvm/ParameterAttributes.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/UniqueVector.h" +#include "llvm/IR/Attributes.h" +#include "llvm/IR/UseListOrder.h" #include namespace llvm { class Type; class Value; +class Instruction; class BasicBlock; +class Comdat; class Function; class Module; -class PAListPtr; -class TypeSymbolTable; +class Metadata; +class LocalAsMetadata; +class MDNode; +class NamedMDNode; +class AttributeSet; class ValueSymbolTable; +class MDSymbolTable; +class raw_ostream; class ValueEnumerator { public: - // For each type, we remember its Type* and occurrence frequency. - typedef std::vector > TypeList; + typedef std::vector TypeList; // For each value, we remember its Value* and occurrence frequency. typedef std::vector > ValueList; + + UseListOrderStack UseListOrders; + private: - typedef DenseMap TypeMapType; + typedef DenseMap TypeMapType; TypeMapType TypeMap; TypeList Types; typedef DenseMap ValueMapType; ValueMapType ValueMap; ValueList Values; - - typedef DenseMap ParamAttrMapType; - ParamAttrMapType ParamAttrMap; - std::vector ParamAttrs; - + + typedef UniqueVector ComdatSetType; + ComdatSetType Comdats; + + std::vector MDs; + SmallVector FunctionLocalMDs; + typedef DenseMap MetadataMapType; + MetadataMapType MetadataMap; + bool HasMDString; + bool HasDILocation; + bool HasGenericDINode; + bool ShouldPreserveUseListOrder; + + typedef DenseMap AttributeGroupMapType; + AttributeGroupMapType AttributeGroupMap; + std::vector AttributeGroups; + + typedef DenseMap AttributeMapType; + AttributeMapType AttributeMap; + std::vector Attribute; + + /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by + /// the "getGlobalBasicBlockID" method. + mutable DenseMap GlobalBasicBlockIDs; + + typedef DenseMap 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 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 Metadatas list + /// before incorporation. + unsigned NumModuleMDs; + unsigned FirstFuncConstantID; unsigned FirstInstID; - - ValueEnumerator(const ValueEnumerator &); // DO NOT IMPLEMENT - void operator=(const ValueEnumerator &); // DO NOT IMPLEMENT + + ValueEnumerator(const ValueEnumerator &) = delete; + void operator=(const ValueEnumerator &) = delete; public: - ValueEnumerator(const Module *M); + ValueEnumerator(const Module &M, bool ShouldPreserveUseListOrder); - unsigned getValueID(const Value *V) const { - ValueMapType::const_iterator I = ValueMap.find(V); - assert(I != ValueMap.end() && "Value not in slotcalculator!"); - return I->second-1; + void dump() const; + void print(raw_ostream &OS, const ValueMapType &Map, const char *Name) const; + void print(raw_ostream &OS, const MetadataMapType &Map, + const char *Name) const; + + unsigned getValueID(const Value *V) const; + unsigned getMetadataID(const Metadata *MD) const { + auto ID = getMetadataOrNullID(MD); + assert(ID != 0 && "Metadata not in slotcalculator!"); + return ID - 1; + } + unsigned getMetadataOrNullID(const Metadata *MD) const { + return MetadataMap.lookup(MD); } - - unsigned getTypeID(const Type *T) const { + unsigned numMDs() const { return MDs.size(); } + + bool hasMDString() const { return HasMDString; } + bool hasDILocation() const { return HasDILocation; } + bool hasGenericDINode() const { return HasGenericDINode; } + + bool shouldPreserveUseListOrder() const { return ShouldPreserveUseListOrder; } + + 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 getParamAttrID(const PAListPtr &PAL) const { + + 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. - ParamAttrMapType::const_iterator I = ParamAttrMap.find(PAL.getRawPointer()); - assert(I != ParamAttrMap.end() && "ParamAttr not in ValueEnumerator!"); + AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL); + assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!"); return I->second; } @@ -89,37 +156,52 @@ public: Start = FirstFuncConstantID; End = FirstInstID; } - + const ValueList &getValues() const { return Values; } + const std::vector &getMDs() const { return MDs; } + const SmallVectorImpl &getFunctionLocalMDs() const { + return FunctionLocalMDs; + } const TypeList &getTypes() const { return Types; } const std::vector &getBasicBlocks() const { - return BasicBlocks; + return BasicBlocks; + } + const std::vector &getAttributes() const { + return Attribute; } - const std::vector &getParamAttrs() const { - return ParamAttrs; + const std::vector &getAttributeGroups() const { + return AttributeGroups; } - /// PurgeAggregateValues - If there are any aggregate values at the end of the - /// value list, remove them and return the count of the remaining values. If - /// there are none, return -1. - int PurgeAggregateValues(); - + 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(); + uint64_t computeBitsRequiredForTypeIndicies() const; private: void OptimizeConstants(unsigned CstStart, unsigned CstEnd); - + + void EnumerateMDNodeOperands(const MDNode *N); + void EnumerateMetadata(const Metadata *MD); + void EnumerateFunctionLocalMetadata(const LocalAsMetadata *Local); + void EnumerateNamedMDNode(const NamedMDNode *NMD); void EnumerateValue(const Value *V); - void EnumerateType(const Type *T); + void EnumerateType(Type *T); void EnumerateOperandType(const Value *V); - void EnumerateParamAttrs(const PAListPtr &PAL); - - void EnumerateTypeSymbolTable(const TypeSymbolTable &ST); + void EnumerateAttributes(AttributeSet PAL); + void EnumerateValueSymbolTable(const ValueSymbolTable &ST); + void EnumerateNamedMetadata(const Module &M); }; } // End llvm namespace