From fe0bf8fbf9d401a67a1842da6cefbb58aa8975a3 Mon Sep 17 00:00:00 2001 From: "Duncan P. N. Exon Smith" Date: Tue, 19 Aug 2014 01:02:18 +0000 Subject: [PATCH] IR: Replace uses of ConstantAggrUniqueMap with ConstantUniqueMap Now that `ConstantAggrUniqueMap` and `ConstantUniqueMap` work the same way, change the aggregates to use the new one. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@215959 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/Constants.h | 18 ++-- lib/IR/ConstantsContext.h | 205 ++++++++---------------------------- lib/IR/LLVMContextImpl.h | 8 +- 3 files changed, 55 insertions(+), 176 deletions(-) diff --git a/include/llvm/IR/Constants.h b/include/llvm/IR/Constants.h index 0e72f040d3e..31a0364b4b0 100644 --- a/include/llvm/IR/Constants.h +++ b/include/llvm/IR/Constants.h @@ -37,12 +37,8 @@ class PointerType; class VectorType; class SequentialType; -template -struct ConstantCreator; -template -struct ConstantArrayCreator; -template -struct ConvertConstantType; +struct ConstantExprKeyType; +template struct ConstantAggrKeyType; //===----------------------------------------------------------------------===// /// This is the shared class of boolean and integer constants. This class @@ -338,7 +334,7 @@ public: /// ConstantArray - Constant Array Declarations /// class ConstantArray : public Constant { - friend struct ConstantArrayCreator; + friend struct ConstantAggrKeyType; ConstantArray(const ConstantArray &) LLVM_DELETED_FUNCTION; protected: ConstantArray(ArrayType *T, ArrayRef Val); @@ -376,7 +372,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantArray, Constant) // ConstantStruct - Constant Struct Declarations // class ConstantStruct : public Constant { - friend struct ConstantArrayCreator; + friend struct ConstantAggrKeyType; ConstantStruct(const ConstantStruct &) LLVM_DELETED_FUNCTION; protected: ConstantStruct(StructType *T, ArrayRef Val); @@ -435,7 +431,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantStruct, Constant) /// ConstantVector - Constant Vector Declarations /// class ConstantVector : public Constant { - friend struct ConstantArrayCreator; + friend struct ConstantAggrKeyType; ConstantVector(const ConstantVector &) LLVM_DELETED_FUNCTION; protected: ConstantVector(VectorType *T, ArrayRef Val); @@ -794,9 +790,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value) /// constant expressions. The Opcode field for the ConstantExpr class is /// maintained in the Value::SubclassData field. class ConstantExpr : public Constant { - friend struct ConstantCreator > >; - friend struct ConvertConstantType; + friend struct ConstantExprKeyType; protected: ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps) diff --git a/lib/IR/ConstantsContext.h b/lib/IR/ConstantsContext.h index bb43f55f2c7..092de718776 100644 --- a/lib/IR/ConstantsContext.h +++ b/lib/IR/ConstantsContext.h @@ -29,8 +29,6 @@ #define DEBUG_TYPE "ir" namespace llvm { -template -struct ConstantTraits; /// UnaryConstantExpr - This class is private to Constants.cpp, and is used /// behind the scenes to implement unary constant exprs. @@ -314,6 +312,7 @@ struct OperandTraits : }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value) +template struct ConstantAggrKeyType; struct InlineAsmKeyType; struct ConstantExprKeyType; @@ -326,6 +325,50 @@ template <> struct ConstantInfo { typedef InlineAsmKeyType ValType; typedef PointerType TypeClass; }; +template <> struct ConstantInfo { + typedef ConstantAggrKeyType ValType; + typedef ArrayType TypeClass; +}; +template <> struct ConstantInfo { + typedef ConstantAggrKeyType ValType; + typedef StructType TypeClass; +}; +template <> struct ConstantInfo { + typedef ConstantAggrKeyType ValType; + typedef VectorType TypeClass; +}; + +template struct ConstantAggrKeyType { + ArrayRef Operands; + ConstantAggrKeyType(ArrayRef Operands) : Operands(Operands) {} + ConstantAggrKeyType(const ConstantClass *C, + SmallVectorImpl &Storage) { + assert(Storage.empty() && "Expected empty storage"); + for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I) + Storage.push_back(C->getOperand(I)); + Operands = Storage; + } + + bool operator==(const ConstantAggrKeyType &X) const { + return Operands == X.Operands; + } + bool operator==(const ConstantClass *C) const { + if (Operands.size() != C->getNumOperands()) + return false; + for (unsigned I = 0, E = Operands.size(); I != E; ++I) + if (Operands[I] != C->getOperand(I)) + return false; + return true; + } + unsigned getHash() const { + return hash_combine_range(Operands.begin(), Operands.end()); + } + + typedef typename ConstantInfo::TypeClass TypeClass; + ConstantClass *create(TypeClass *Ty) const { + return new (Operands.size()) ConstantClass(Ty, Operands); + } +}; struct InlineAsmKeyType { StringRef AsmString; @@ -459,41 +502,6 @@ struct ConstantExprKeyType { } }; -// The number of operands for each ConstantCreator::create method is -// determined by the ConstantTraits template. -// ConstantCreator - A class that is used to create constants by -// ConstantUniqueMap*. This class should be partially specialized if there is -// something strange that needs to be done to interface to the ctor for the -// constant. -// -template -struct ConstantTraits< std::vector > { - static unsigned uses(const std::vector& v) { - return v.size(); - } -}; - -template<> -struct ConstantTraits { - static unsigned uses(Constant * const & v) { - return 1; - } -}; - -template -struct ConstantCreator { - static ConstantClass *create(TypeClass *Ty, const ValType &V) { - return new(ConstantTraits::uses(V)) ConstantClass(Ty, V); - } -}; - -template -struct ConstantArrayCreator { - static ConstantClass *create(TypeClass *Ty, ArrayRef V) { - return new(V.size()) ConstantClass(Ty, V); - } -}; - template class ConstantUniqueMap { public: typedef typename ConstantInfo::ValType ValType; @@ -589,129 +597,6 @@ public: void dump() const { DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n"); } }; -// Unique map for aggregate constants -template -class ConstantAggrUniqueMap { -public: - typedef ArrayRef Operands; - typedef std::pair LookupKey; -private: - struct MapInfo { - typedef DenseMapInfo ConstantClassInfo; - typedef DenseMapInfo ConstantInfo; - typedef DenseMapInfo TypeClassInfo; - static inline ConstantClass* getEmptyKey() { - return ConstantClassInfo::getEmptyKey(); - } - static inline ConstantClass* getTombstoneKey() { - return ConstantClassInfo::getTombstoneKey(); - } - static unsigned getHashValue(const ConstantClass *CP) { - SmallVector CPOperands; - CPOperands.reserve(CP->getNumOperands()); - for (unsigned I = 0, E = CP->getNumOperands(); I < E; ++I) - CPOperands.push_back(CP->getOperand(I)); - return getHashValue(LookupKey(CP->getType(), CPOperands)); - } - static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) { - return LHS == RHS; - } - static unsigned getHashValue(const LookupKey &Val) { - return hash_combine(Val.first, hash_combine_range(Val.second.begin(), - Val.second.end())); - } - static bool isEqual(const LookupKey &LHS, const ConstantClass *RHS) { - if (RHS == getEmptyKey() || RHS == getTombstoneKey()) - return false; - if (LHS.first != RHS->getType() - || LHS.second.size() != RHS->getNumOperands()) - return false; - for (unsigned I = 0, E = RHS->getNumOperands(); I < E; ++I) { - if (LHS.second[I] != RHS->getOperand(I)) - return false; - } - return true; - } - }; -public: - typedef DenseMap 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; - -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) { - // Asserts that use_empty(). - delete I->first; - } - } - -private: - typename MapTy::iterator findExistingElement(ConstantClass *CP) { - return Map.find(CP); - } - - ConstantClass *Create(TypeClass *Ty, Operands V, typename MapTy::iterator I) { - ConstantClass* Result = - ConstantArrayCreator::create(Ty, V); - - assert(Result->getType() == Ty && "Type specified is not correct!"); - Map[Result] = '\0'; - - return Result; - } -public: - - /// getOrCreate - Return the specified constant from the map, creating it if - /// necessary. - ConstantClass *getOrCreate(TypeClass *Ty, Operands V) { - LookupKey Lookup(Ty, V); - ConstantClass* Result = nullptr; - - typename MapTy::iterator I = Map.find_as(Lookup); - // Is it in the map? - if (I != Map.end()) - Result = I->first; - - if (!Result) { - // If no preexisting value, create one now... - Result = Create(Ty, V, I); - } - - return Result; - } - - /// Find the constant by lookup key. - typename MapTy::iterator find(LookupKey Lookup) { - return Map.find_as(Lookup); - } - - /// 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 = findExistingElement(CP); - assert(I != Map.end() && "Constant not found in constant table!"); - assert(I->first == CP && "Didn't find correct element?"); - Map.erase(I); - } - - void dump() const { - DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n"); - } -}; - } // end namespace llvm #endif diff --git a/lib/IR/LLVMContextImpl.h b/lib/IR/LLVMContextImpl.h index b6a6254ba6a..412f36db06e 100644 --- a/lib/IR/LLVMContextImpl.h +++ b/lib/IR/LLVMContextImpl.h @@ -272,13 +272,13 @@ public: DenseMap CAZConstants; - typedef ConstantAggrUniqueMap ArrayConstantsTy; + typedef ConstantUniqueMap ArrayConstantsTy; ArrayConstantsTy ArrayConstants; - typedef ConstantAggrUniqueMap StructConstantsTy; + typedef ConstantUniqueMap StructConstantsTy; StructConstantsTy StructConstants; - typedef ConstantAggrUniqueMap VectorConstantsTy; + typedef ConstantUniqueMap VectorConstantsTy; VectorConstantsTy VectorConstants; DenseMap CPNConstants; @@ -292,7 +292,7 @@ public: ConstantUniqueMap ExprConstants; ConstantUniqueMap InlineAsms; - + ConstantInt *TheTrueVal; ConstantInt *TheFalseVal; -- 2.40.0