[llvm] r215957 - IR: Rewrite ConstantUniqueMap
Rafael Espíndola
rafael.espindola at gmail.com
Mon Aug 18 20:47:12 PDT 2014
This is awesome, thanks!
On 18 August 2014 20:42, Duncan P. N. Exon Smith <dexonsmith at apple.com> wrote:
> Author: dexonsmith
> Date: Mon Aug 18 19:42:32 2014
> New Revision: 215957
>
> URL: http://llvm.org/viewvc/llvm-project?rev=215957&view=rev
> Log:
> IR: Rewrite ConstantUniqueMap
>
> Rewrite `ConstantUniqueMap` to be more similar to
> `ConstantAggrUniqueMap`.
>
> - Use a `DenseMap` with custom MapInfo instead of a `std::map` with
> linear lookups and deletion.
> - Don't waste memory explicitly storing (heavyweight) keys.
>
> Only `ConstantExpr` and `InlineAsm` actually use this data structure, so
> I also updated them to use it.
>
> This code cleanup is a precursor to reducing RAUW traffic on
> `ConstantExpr` -- I felt badly adding a new (linear) call to
> `ConstantUniqueMap::FindExistingKey`, so this designs away the concern.
>
> A follow-up commit will transition the users of `ConstantAggrUniqueMap`
> over.
>
> Modified:
> llvm/trunk/include/llvm/IR/InlineAsm.h
> llvm/trunk/lib/IR/Constants.cpp
> llvm/trunk/lib/IR/ConstantsContext.h
> llvm/trunk/lib/IR/LLVMContextImpl.cpp
> llvm/trunk/lib/IR/LLVMContextImpl.h
>
> Modified: llvm/trunk/include/llvm/IR/InlineAsm.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/InlineAsm.h?rev=215957&r1=215956&r2=215957&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/IR/InlineAsm.h (original)
> +++ llvm/trunk/include/llvm/IR/InlineAsm.h Mon Aug 18 19:42:32 2014
> @@ -25,12 +25,9 @@ namespace llvm {
> class PointerType;
> class FunctionType;
> class Module;
> +
> struct InlineAsmKeyType;
> -template<class ValType, class ValRefType, class TypeClass, class ConstantClass,
> - bool HasLargeKey>
> -class ConstantUniqueMap;
> -template<class ConstantClass, class TypeClass, class ValType>
> -struct ConstantCreator;
> +template <class ConstantClass> class ConstantUniqueMap;
>
> class InlineAsm : public Value {
> public:
> @@ -40,9 +37,8 @@ public:
> };
>
> private:
> - friend struct ConstantCreator<InlineAsm, PointerType, InlineAsmKeyType>;
> - friend class ConstantUniqueMap<InlineAsmKeyType, const InlineAsmKeyType&,
> - PointerType, InlineAsm, false>;
> + friend struct InlineAsmKeyType;
> + friend class ConstantUniqueMap<InlineAsm>;
>
> InlineAsm(const InlineAsm &) LLVM_DELETED_FUNCTION;
> void operator=(const InlineAsm&) LLVM_DELETED_FUNCTION;
>
> Modified: llvm/trunk/lib/IR/Constants.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Constants.cpp?rev=215957&r1=215956&r2=215957&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/Constants.cpp (original)
> +++ llvm/trunk/lib/IR/Constants.cpp Mon Aug 18 19:42:32 2014
> @@ -1507,7 +1507,7 @@ static inline Constant *getFoldedCast(
> LLVMContextImpl *pImpl = Ty->getContext().pImpl;
>
> // Look up the constant in the table first to ensure uniqueness.
> - ExprMapKeyType Key(opc, C);
> + ConstantExprKeyType Key(opc, C);
>
> return pImpl->ExprConstants.getOrCreate(Ty, Key);
> }
> @@ -1842,7 +1842,7 @@ Constant *ConstantExpr::get(unsigned Opc
> return FC; // Fold a few common cases.
>
> Constant *ArgVec[] = { C1, C2 };
> - ExprMapKeyType Key(Opcode, ArgVec, 0, Flags);
> + ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
>
> LLVMContextImpl *pImpl = C1->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
> @@ -1919,7 +1919,7 @@ Constant *ConstantExpr::getSelect(Consta
> return SC; // Fold common cases
>
> Constant *ArgVec[] = { C, V1, V2 };
> - ExprMapKeyType Key(Instruction::Select, ArgVec);
> + ConstantExprKeyType Key(Instruction::Select, ArgVec);
>
> LLVMContextImpl *pImpl = C->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
> @@ -1954,8 +1954,8 @@ Constant *ConstantExpr::getGetElementPtr
> "getelementptr index type missmatch");
> ArgVec.push_back(cast<Constant>(Idxs[i]));
> }
> - const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
> - InBounds ? GEPOperator::IsInBounds : 0);
> + const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
> + InBounds ? GEPOperator::IsInBounds : 0);
>
> LLVMContextImpl *pImpl = C->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
> @@ -1973,7 +1973,7 @@ ConstantExpr::getICmp(unsigned short pre
> // Look up the constant in the table first to ensure uniqueness
> Constant *ArgVec[] = { LHS, RHS };
> // Get the key type with both the opcode and predicate
> - const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
> + const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, pred);
>
> Type *ResultTy = Type::getInt1Ty(LHS->getContext());
> if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
> @@ -1994,7 +1994,7 @@ ConstantExpr::getFCmp(unsigned short pre
> // Look up the constant in the table first to ensure uniqueness
> Constant *ArgVec[] = { LHS, RHS };
> // Get the key type with both the opcode and predicate
> - const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
> + const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, pred);
>
> Type *ResultTy = Type::getInt1Ty(LHS->getContext());
> if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
> @@ -2015,7 +2015,7 @@ Constant *ConstantExpr::getExtractElemen
>
> // Look up the constant in the table first to ensure uniqueness
> Constant *ArgVec[] = { Val, Idx };
> - const ExprMapKeyType Key(Instruction::ExtractElement, ArgVec);
> + const ConstantExprKeyType Key(Instruction::ExtractElement, ArgVec);
>
> LLVMContextImpl *pImpl = Val->getContext().pImpl;
> Type *ReqTy = Val->getType()->getVectorElementType();
> @@ -2035,7 +2035,7 @@ Constant *ConstantExpr::getInsertElement
> return FC; // Fold a few common cases.
> // Look up the constant in the table first to ensure uniqueness
> Constant *ArgVec[] = { Val, Elt, Idx };
> - const ExprMapKeyType Key(Instruction::InsertElement, ArgVec);
> + const ConstantExprKeyType Key(Instruction::InsertElement, ArgVec);
>
> LLVMContextImpl *pImpl = Val->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
> @@ -2055,7 +2055,7 @@ Constant *ConstantExpr::getShuffleVector
>
> // Look up the constant in the table first to ensure uniqueness
> Constant *ArgVec[] = { V1, V2, Mask };
> - const ExprMapKeyType Key(Instruction::ShuffleVector, ArgVec);
> + const ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec);
>
> LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
> @@ -2075,7 +2075,7 @@ Constant *ConstantExpr::getInsertValue(C
> return FC;
>
> Constant *ArgVec[] = { Agg, Val };
> - const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
> + const ConstantExprKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
>
> LLVMContextImpl *pImpl = Agg->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
> @@ -2096,7 +2096,7 @@ Constant *ConstantExpr::getExtractValue(
> return FC;
>
> Constant *ArgVec[] = { Agg };
> - const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
> + const ConstantExprKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
>
> LLVMContextImpl *pImpl = Agg->getContext().pImpl;
> return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
>
> Modified: llvm/trunk/lib/IR/ConstantsContext.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/ConstantsContext.h?rev=215957&r1=215956&r2=215957&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/ConstantsContext.h (original)
> +++ llvm/trunk/lib/IR/ConstantsContext.h Mon Aug 18 19:42:32 2014
> @@ -314,66 +314,148 @@ struct OperandTraits<CompareConstantExpr
> };
> DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value)
>
> -struct ExprMapKeyType {
> - ExprMapKeyType(unsigned opc,
> - ArrayRef<Constant*> ops,
> - unsigned short flags = 0,
> - unsigned short optionalflags = 0,
> - ArrayRef<unsigned> inds = None)
> - : opcode(opc), subclassoptionaldata(optionalflags), subclassdata(flags),
> - operands(ops.begin(), ops.end()), indices(inds.begin(), inds.end()) {}
> - uint8_t opcode;
> - uint8_t subclassoptionaldata;
> - uint16_t subclassdata;
> - std::vector<Constant*> operands;
> - SmallVector<unsigned, 4> indices;
> - bool operator==(const ExprMapKeyType& that) const {
> - return this->opcode == that.opcode &&
> - this->subclassdata == that.subclassdata &&
> - this->subclassoptionaldata == that.subclassoptionaldata &&
> - this->operands == that.operands &&
> - this->indices == that.indices;
> - }
> - bool operator<(const ExprMapKeyType & that) const {
> - return std::tie(opcode, operands, subclassdata, subclassoptionaldata,
> - indices) <
> - std::tie(that.opcode, that.operands, that.subclassdata,
> - that.subclassoptionaldata, that.indices);
> - }
> +struct InlineAsmKeyType;
> +struct ConstantExprKeyType;
>
> - bool operator!=(const ExprMapKeyType& that) const {
> - return !(*this == that);
> - }
> +template <class ConstantClass> struct ConstantInfo;
> +template <> struct ConstantInfo<ConstantExpr> {
> + typedef ConstantExprKeyType ValType;
> + typedef Type TypeClass;
> +};
> +template <> struct ConstantInfo<InlineAsm> {
> + typedef InlineAsmKeyType ValType;
> + typedef PointerType TypeClass;
> };
>
> struct InlineAsmKeyType {
> - InlineAsmKeyType(StringRef AsmString,
> - StringRef Constraints, bool hasSideEffects,
> - bool isAlignStack, InlineAsm::AsmDialect asmDialect)
> - : asm_string(AsmString), constraints(Constraints),
> - has_side_effects(hasSideEffects), is_align_stack(isAlignStack),
> - asm_dialect(asmDialect) {}
> - std::string asm_string;
> - std::string constraints;
> - bool has_side_effects;
> - bool is_align_stack;
> - InlineAsm::AsmDialect asm_dialect;
> - bool operator==(const InlineAsmKeyType& that) const {
> - return this->asm_string == that.asm_string &&
> - this->constraints == that.constraints &&
> - this->has_side_effects == that.has_side_effects &&
> - this->is_align_stack == that.is_align_stack &&
> - this->asm_dialect == that.asm_dialect;
> - }
> - bool operator<(const InlineAsmKeyType& that) const {
> - return std::tie(asm_string, constraints, has_side_effects, is_align_stack,
> - asm_dialect) <
> - std::tie(that.asm_string, that.constraints, that.has_side_effects,
> - that.is_align_stack, that.asm_dialect);
> - }
> -
> - bool operator!=(const InlineAsmKeyType& that) const {
> - return !(*this == that);
> + StringRef AsmString;
> + StringRef Constraints;
> + bool HasSideEffects;
> + bool IsAlignStack;
> + InlineAsm::AsmDialect AsmDialect;
> +
> + InlineAsmKeyType(StringRef AsmString, StringRef Constraints,
> + bool HasSideEffects, bool IsAlignStack,
> + InlineAsm::AsmDialect AsmDialect)
> + : AsmString(AsmString), Constraints(Constraints),
> + HasSideEffects(HasSideEffects), IsAlignStack(IsAlignStack),
> + AsmDialect(AsmDialect) {}
> + InlineAsmKeyType(const InlineAsm *Asm, SmallVectorImpl<Constant *> &)
> + : AsmString(Asm->getAsmString()), Constraints(Asm->getConstraintString()),
> + HasSideEffects(Asm->hasSideEffects()),
> + IsAlignStack(Asm->isAlignStack()), AsmDialect(Asm->getDialect()) {}
> +
> + bool operator==(const InlineAsmKeyType &X) const {
> + return HasSideEffects == X.HasSideEffects &&
> + IsAlignStack == X.IsAlignStack && AsmDialect == X.AsmDialect &&
> + AsmString == X.AsmString && Constraints == X.Constraints;
> + }
> + bool operator==(const InlineAsm *Asm) const {
> + return HasSideEffects == Asm->hasSideEffects() &&
> + IsAlignStack == Asm->isAlignStack() &&
> + AsmDialect == Asm->getDialect() &&
> + AsmString == Asm->getAsmString() &&
> + Constraints == Asm->getConstraintString();
> + }
> + unsigned getHash() const {
> + return hash_combine(AsmString, Constraints, HasSideEffects, IsAlignStack,
> + AsmDialect);
> + }
> +
> + typedef typename ConstantInfo<InlineAsm>::TypeClass TypeClass;
> + InlineAsm *create(TypeClass *Ty) const {
> + return new InlineAsm(Ty, AsmString, Constraints, HasSideEffects,
> + IsAlignStack, AsmDialect);
> + }
> +};
> +
> +struct ConstantExprKeyType {
> + uint8_t Opcode;
> + uint8_t SubclassOptionalData;
> + uint16_t SubclassData;
> + ArrayRef<Constant *> Ops;
> + ArrayRef<unsigned> Indexes;
> +
> + ConstantExprKeyType(unsigned Opcode, ArrayRef<Constant *> Ops,
> + unsigned short SubclassData = 0,
> + unsigned short SubclassOptionalData = 0,
> + ArrayRef<unsigned> Indexes = None)
> + : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
> + SubclassData(SubclassData), Ops(Ops), Indexes(Indexes) {}
> + ConstantExprKeyType(const ConstantExpr *CE,
> + SmallVectorImpl<Constant *> &Storage)
> + : Opcode(CE->getOpcode()),
> + SubclassOptionalData(CE->getRawSubclassOptionalData()),
> + SubclassData(CE->isCompare() ? CE->getPredicate() : 0),
> + Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {
> + assert(Storage.empty() && "Expected empty storage");
> + for (unsigned I = 0, E = CE->getNumOperands(); I != E; ++I)
> + Storage.push_back(CE->getOperand(I));
> + Ops = Storage;
> + }
> +
> + bool operator==(const ConstantExprKeyType &X) const {
> + return Opcode == X.Opcode && SubclassData == X.SubclassData &&
> + SubclassOptionalData == X.SubclassOptionalData && Ops == X.Ops &&
> + Indexes == X.Indexes;
> + }
> +
> + bool operator==(const ConstantExpr *CE) const {
> + if (Opcode != CE->getOpcode())
> + return false;
> + if (SubclassOptionalData != CE->getRawSubclassOptionalData())
> + return false;
> + if (Ops.size() != CE->getNumOperands())
> + return false;
> + if (SubclassData != (CE->isCompare() ? CE->getPredicate() : 0))
> + return false;
> + for (unsigned I = 0, E = Ops.size(); I != E; ++I)
> + if (Ops[I] != CE->getOperand(I))
> + return false;
> + if (Indexes != (CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()))
> + return false;
> + return true;
> + }
> +
> + unsigned getHash() const {
> + return hash_combine(Opcode, SubclassOptionalData, SubclassData,
> + hash_combine_range(Ops.begin(), Ops.end()),
> + hash_combine_range(Indexes.begin(), Indexes.end()));
> + }
> +
> + typedef typename ConstantInfo<ConstantExpr>::TypeClass TypeClass;
> + ConstantExpr *create(TypeClass *Ty) const {
> + switch (Opcode) {
> + default:
> + if (Instruction::isCast(Opcode))
> + return new UnaryConstantExpr(Opcode, Ops[0], Ty);
> + if ((Opcode >= Instruction::BinaryOpsBegin &&
> + Opcode < Instruction::BinaryOpsEnd))
> + return new BinaryConstantExpr(Opcode, Ops[0], Ops[1],
> + SubclassOptionalData);
> + llvm_unreachable("Invalid ConstantExpr!");
> + case Instruction::Select:
> + return new SelectConstantExpr(Ops[0], Ops[1], Ops[2]);
> + case Instruction::ExtractElement:
> + return new ExtractElementConstantExpr(Ops[0], Ops[1]);
> + case Instruction::InsertElement:
> + return new InsertElementConstantExpr(Ops[0], Ops[1], Ops[2]);
> + case Instruction::ShuffleVector:
> + return new ShuffleVectorConstantExpr(Ops[0], Ops[1], Ops[2]);
> + case Instruction::InsertValue:
> + return new InsertValueConstantExpr(Ops[0], Ops[1], Indexes, Ty);
> + case Instruction::ExtractValue:
> + return new ExtractValueConstantExpr(Ops[0], Indexes, Ty);
> + case Instruction::GetElementPtr:
> + return GetElementPtrConstantExpr::Create(Ops[0], Ops.slice(1), Ty,
> + SubclassOptionalData);
> + case Instruction::ICmp:
> + return new CompareConstantExpr(Ty, Instruction::ICmp, SubclassData,
> + Ops[0], Ops[1]);
> + case Instruction::FCmp:
> + return new CompareConstantExpr(Ty, Instruction::FCmp, SubclassData,
> + Ops[0], Ops[1]);
> + }
> }
> };
>
> @@ -412,228 +494,99 @@ struct ConstantArrayCreator {
> }
> };
>
> -template<class ConstantClass>
> -struct ConstantKeyData {
> - typedef void ValType;
> - static ValType getValType(ConstantClass *C) {
> - llvm_unreachable("Unknown Constant type!");
> - }
> -};
> +template <class ConstantClass> class ConstantUniqueMap {
> +public:
> + typedef typename ConstantInfo<ConstantClass>::ValType ValType;
> + typedef typename ConstantInfo<ConstantClass>::TypeClass TypeClass;
> + typedef std::pair<TypeClass *, ValType> LookupKey;
>
> -template<>
> -struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
> - static ConstantExpr *create(Type *Ty, const ExprMapKeyType &V,
> - unsigned short pred = 0) {
> - if (Instruction::isCast(V.opcode))
> - return new UnaryConstantExpr(V.opcode, V.operands[0], Ty);
> - if ((V.opcode >= Instruction::BinaryOpsBegin &&
> - V.opcode < Instruction::BinaryOpsEnd))
> - return new BinaryConstantExpr(V.opcode, V.operands[0], V.operands[1],
> - V.subclassoptionaldata);
> - if (V.opcode == Instruction::Select)
> - return new SelectConstantExpr(V.operands[0], V.operands[1],
> - V.operands[2]);
> - if (V.opcode == Instruction::ExtractElement)
> - return new ExtractElementConstantExpr(V.operands[0], V.operands[1]);
> - if (V.opcode == Instruction::InsertElement)
> - return new InsertElementConstantExpr(V.operands[0], V.operands[1],
> - V.operands[2]);
> - if (V.opcode == Instruction::ShuffleVector)
> - return new ShuffleVectorConstantExpr(V.operands[0], V.operands[1],
> - V.operands[2]);
> - if (V.opcode == Instruction::InsertValue)
> - return new InsertValueConstantExpr(V.operands[0], V.operands[1],
> - V.indices, Ty);
> - if (V.opcode == Instruction::ExtractValue)
> - return new ExtractValueConstantExpr(V.operands[0], V.indices, Ty);
> - if (V.opcode == Instruction::GetElementPtr) {
> - std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end());
> - return GetElementPtrConstantExpr::Create(V.operands[0], IdxList, Ty,
> - V.subclassoptionaldata);
> +private:
> + struct MapInfo {
> + typedef DenseMapInfo<ConstantClass *> ConstantClassInfo;
> + static inline ConstantClass *getEmptyKey() {
> + return ConstantClassInfo::getEmptyKey();
> }
> + static inline ConstantClass *getTombstoneKey() {
> + return ConstantClassInfo::getTombstoneKey();
> + }
> + static unsigned getHashValue(const ConstantClass *CP) {
> + SmallVector<Constant *, 8> Storage;
> + return getHashValue(LookupKey(CP->getType(), ValType(CP, Storage)));
> + }
> + static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
> + return LHS == RHS;
> + }
> + static unsigned getHashValue(const LookupKey &Val) {
> + return hash_combine(Val.first, Val.second.getHash());
> + }
> + static bool isEqual(const LookupKey &LHS, const ConstantClass *RHS) {
> + if (RHS == getEmptyKey() || RHS == getTombstoneKey())
> + return false;
> + if (LHS.first != RHS->getType())
> + return false;
> + return LHS.second == RHS;
> + }
> + };
>
> - // The compare instructions are weird. We have to encode the predicate
> - // value and it is combined with the instruction opcode by multiplying
> - // the opcode by one hundred. We must decode this to get the predicate.
> - if (V.opcode == Instruction::ICmp)
> - return new CompareConstantExpr(Ty, Instruction::ICmp, V.subclassdata,
> - V.operands[0], V.operands[1]);
> - if (V.opcode == Instruction::FCmp)
> - return new CompareConstantExpr(Ty, Instruction::FCmp, V.subclassdata,
> - V.operands[0], V.operands[1]);
> - llvm_unreachable("Invalid ConstantExpr!");
> - }
> -};
> -
> -template<>
> -struct ConstantKeyData<ConstantExpr> {
> - typedef ExprMapKeyType ValType;
> - static ValType getValType(ConstantExpr *CE) {
> - std::vector<Constant*> Operands;
> - Operands.reserve(CE->getNumOperands());
> - for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
> - Operands.push_back(cast<Constant>(CE->getOperand(i)));
> - return ExprMapKeyType(CE->getOpcode(), Operands,
> - CE->isCompare() ? CE->getPredicate() : 0,
> - CE->getRawSubclassOptionalData(),
> - CE->hasIndices() ?
> - CE->getIndices() : ArrayRef<unsigned>());
> - }
> -};
> -
> -template<>
> -struct ConstantCreator<InlineAsm, PointerType, InlineAsmKeyType> {
> - static InlineAsm *create(PointerType *Ty, const InlineAsmKeyType &Key) {
> - return new InlineAsm(Ty, Key.asm_string, Key.constraints,
> - Key.has_side_effects, Key.is_align_stack,
> - Key.asm_dialect);
> - }
> -};
> -
> -template<>
> -struct ConstantKeyData<InlineAsm> {
> - typedef InlineAsmKeyType ValType;
> - static ValType getValType(InlineAsm *Asm) {
> - return InlineAsmKeyType(Asm->getAsmString(), Asm->getConstraintString(),
> - Asm->hasSideEffects(), Asm->isAlignStack(),
> - Asm->getDialect());
> - }
> -};
> -
> -template<class ValType, class ValRefType, class TypeClass, class ConstantClass,
> - bool HasLargeKey = false /*true for arrays and structs*/ >
> -class ConstantUniqueMap {
> public:
> - typedef std::pair<TypeClass*, ValType> MapKey;
> - typedef std::map<MapKey, ConstantClass *> MapTy;
> - typedef std::map<ConstantClass *, typename MapTy::iterator> InverseMapTy;
> + typedef DenseMap<ConstantClass *, char, MapInfo> MapTy;
> +
> private:
> - /// Map - This is the main map from the element descriptor to the Constants.
> - /// This is the primary way we avoid creating two of the same shape
> - /// constant.
> MapTy Map;
> -
> - /// InverseMap - If "HasLargeKey" is true, this contains an inverse mapping
> - /// from the constants to their element in Map. This is important for
> - /// removal of constants from the array, which would otherwise have to scan
> - /// through the map with very large keys.
> - InverseMapTy InverseMap;
>
> public:
> typename MapTy::iterator map_begin() { return Map.begin(); }
> typename MapTy::iterator map_end() { return Map.end(); }
>
> void freeConstants() {
> - for (typename MapTy::iterator I=Map.begin(), E=Map.end();
> - I != E; ++I) {
> + for (auto &I : Map)
> // Asserts that use_empty().
> - delete I->second;
> - }
> - }
> -
> - /// InsertOrGetItem - Return an iterator for the specified element.
> - /// If the element exists in the map, the returned iterator points to the
> - /// entry and Exists=true. If not, the iterator points to the newly
> - /// inserted entry and returns Exists=false. Newly inserted entries have
> - /// I->second == 0, and should be filled in.
> - typename MapTy::iterator InsertOrGetItem(std::pair<MapKey, ConstantClass *>
> - &InsertVal,
> - bool &Exists) {
> - std::pair<typename MapTy::iterator, bool> IP = Map.insert(InsertVal);
> - Exists = !IP.second;
> - return IP.first;
> - }
> -
> -private:
> - typename MapTy::iterator FindExistingElement(ConstantClass *CP) {
> - if (HasLargeKey) {
> - typename InverseMapTy::iterator IMI = InverseMap.find(CP);
> - assert(IMI != InverseMap.end() && IMI->second != Map.end() &&
> - IMI->second->second == CP &&
> - "InverseMap corrupt!");
> - return IMI->second;
> - }
> -
> - typename MapTy::iterator I =
> - Map.find(MapKey(static_cast<TypeClass*>(CP->getType()),
> - ConstantKeyData<ConstantClass>::getValType(CP)));
> - if (I == Map.end() || I->second != CP) {
> - // FIXME: This should not use a linear scan. If this gets to be a
> - // performance problem, someone should look at this.
> - for (I = Map.begin(); I != Map.end() && I->second != CP; ++I)
> - /* empty */;
> - }
> - return I;
> + delete I.first;
> }
>
> - ConstantClass *Create(TypeClass *Ty, ValRefType V,
> - typename MapTy::iterator I) {
> - ConstantClass* Result =
> - ConstantCreator<ConstantClass,TypeClass,ValType>::create(Ty, V);
> +private:
> + ConstantClass *create(TypeClass *Ty, ValType V) {
> + ConstantClass *Result = V.create(Ty);
>
> assert(Result->getType() == Ty && "Type specified is not correct!");
> - I = Map.insert(I, std::make_pair(MapKey(Ty, V), Result));
> -
> - if (HasLargeKey) // Remember the reverse mapping if needed.
> - InverseMap.insert(std::make_pair(Result, I));
> + insert(Result);
>
> return Result;
> }
> +
> public:
> -
> - /// getOrCreate - Return the specified constant from the map, creating it if
> - /// necessary.
> - ConstantClass *getOrCreate(TypeClass *Ty, ValRefType V) {
> - MapKey Lookup(Ty, V);
> - ConstantClass* Result = nullptr;
> -
> - typename MapTy::iterator I = Map.find(Lookup);
> - // Is it in the map?
> - if (I != Map.end())
> - Result = I->second;
> -
> - if (!Result) {
> - // If no preexisting value, create one now...
> - Result = Create(Ty, V, I);
> - }
> -
> + /// Return the specified constant from the map, creating it if necessary.
> + ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
> + LookupKey Lookup(Ty, V);
> + ConstantClass *Result = nullptr;
> +
> + auto I = find(Lookup);
> + if (I == Map.end())
> + Result = create(Ty, V);
> + else
> + Result = I->first;
> + assert(Result && "Unexpected nullptr");
> +
> return Result;
> }
>
> - void remove(ConstantClass *CP) {
> - typename MapTy::iterator I = FindExistingElement(CP);
> - assert(I != Map.end() && "Constant not found in constant table!");
> - assert(I->second == CP && "Didn't find correct element?");
> + /// Find the constant by lookup key.
> + typename MapTy::iterator find(LookupKey Lookup) {
> + return Map.find_as(Lookup);
> + }
>
> - if (HasLargeKey) // Remember the reverse mapping if needed.
> - InverseMap.erase(CP);
> + /// Insert the constant into its proper slot.
> + void insert(ConstantClass *CP) { Map[CP] = '\0'; }
>
> + /// Remove this constant from the map
> + void remove(ConstantClass *CP) {
> + typename MapTy::iterator I = Map.find(CP);
> + assert(I != Map.end() && "Constant not found in constant table!");
> + assert(I->first == CP && "Didn't find correct element?");
> Map.erase(I);
> }
>
> - /// MoveConstantToNewSlot - If we are about to change C to be the element
> - /// specified by I, update our internal data structures to reflect this
> - /// fact.
> - void MoveConstantToNewSlot(ConstantClass *C, typename MapTy::iterator I) {
> - // First, remove the old location of the specified constant in the map.
> - typename MapTy::iterator OldI = FindExistingElement(C);
> - assert(OldI != Map.end() && "Constant not found in constant table!");
> - assert(OldI->second == C && "Didn't find correct element?");
> -
> - // Remove the old entry from the map.
> - Map.erase(OldI);
> -
> - // Update the inverse map so that we know that this constant is now
> - // located at descriptor I.
> - if (HasLargeKey) {
> - assert(I->second == C && "Bad inversemap entry!");
> - InverseMap[C] = I;
> - }
> - }
> -
> - void dump() const {
> - DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n");
> - }
> + void dump() const { DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n"); }
> };
>
> // Unique map for aggregate constants
>
> Modified: llvm/trunk/lib/IR/LLVMContextImpl.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/LLVMContextImpl.cpp?rev=215957&r1=215956&r2=215957&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/LLVMContextImpl.cpp (original)
> +++ llvm/trunk/lib/IR/LLVMContextImpl.cpp Mon Aug 18 19:42:32 2014
> @@ -75,7 +75,7 @@ LLVMContextImpl::~LLVMContextImpl() {
> // Free the constants. This is important to do here to ensure that they are
> // freed before the LeakDetector is torn down.
> std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
> - DropReferences());
> + DropFirst());
> std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
> DropFirst());
> std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
>
> Modified: llvm/trunk/lib/IR/LLVMContextImpl.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/LLVMContextImpl.h?rev=215957&r1=215956&r2=215957&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/LLVMContextImpl.h (original)
> +++ llvm/trunk/lib/IR/LLVMContextImpl.h Mon Aug 18 19:42:32 2014
> @@ -289,11 +289,9 @@ public:
>
> DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
> BlockAddresses;
> - ConstantUniqueMap<ExprMapKeyType, const ExprMapKeyType&, Type, ConstantExpr>
> - ExprConstants;
> + ConstantUniqueMap<ConstantExpr> ExprConstants;
>
> - ConstantUniqueMap<InlineAsmKeyType, const InlineAsmKeyType&, PointerType,
> - InlineAsm> InlineAsms;
> + ConstantUniqueMap<InlineAsm> InlineAsms;
>
> ConstantInt *TheTrueVal;
> ConstantInt *TheFalseVal;
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list