From 4581fff8af09a156a9dcc4de62587385c5da9574 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 6 Feb 2008 05:21:55 +0000 Subject: [PATCH] rename TypeHolderMap to TypeCache, which more aptly describes what it is. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@46804 91177308-0d34-0410-b5e6-96231b3b80d8 --- CodeGen/CodeGenTypes.cpp | 27 +++++++++++++-------------- CodeGen/CodeGenTypes.h | 16 +++++++--------- 2 files changed, 20 insertions(+), 23 deletions(-) diff --git a/CodeGen/CodeGenTypes.cpp b/CodeGen/CodeGenTypes.cpp index 62781cae1a..c81f00f76a 100644 --- a/CodeGen/CodeGenTypes.cpp +++ b/CodeGen/CodeGenTypes.cpp @@ -95,23 +95,22 @@ CodeGenTypes::~CodeGenTypes() { const llvm::Type *CodeGenTypes::ConvertType(QualType T) { // See if type is already cached. llvm::DenseMap::iterator - I = TypeHolderMap.find(T.getTypePtr()); + I = TypeCache.find(T.getTypePtr()); // If type is found in map and this is not a definition for a opaque // place holder type then use it. Otherwise convert type T. - if (I != TypeHolderMap.end()) + if (I != TypeCache.end()) return I->second.get(); const llvm::Type *ResultType = ConvertNewType(T); - TypeHolderMap.insert(std::make_pair(T.getTypePtr(), - llvm::PATypeHolder(ResultType))); + TypeCache.insert(std::make_pair(T.getTypePtr(), + llvm::PATypeHolder(ResultType))); return ResultType; } -/// ConvertTypeForMem - Convert type T into a llvm::Type. Maintain and use -/// type cache through TypeHolderMap. This differs from ConvertType in that -/// it is used to convert to the memory representation for a type. For -/// example, the scalar representation for _Bool is i1, but the memory -/// representation is usually i8 or i32, depending on the target. +/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from +/// ConvertType in that it is used to convert to the memory representation for +/// a type. For example, the scalar representation for _Bool is i1, but the +/// memory representation is usually i8 or i32, depending on the target. const llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { const llvm::Type *R = ConvertType(T); @@ -251,8 +250,8 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { const llvm::Type *RType = llvm::PointerType::get(ResultType, FP.getResultType().getAddressSpace()); QualType RTy = Context.getPointerType(FP.getResultType()); - TypeHolderMap.insert(std::make_pair(RTy.getTypePtr(), - llvm::PATypeHolder(RType))); + TypeCache.insert(std::make_pair(RTy.getTypePtr(), + llvm::PATypeHolder(RType))); ArgTys.push_back(RType); ResultType = llvm::Type::VoidTy; @@ -302,8 +301,8 @@ void CodeGenTypes::DecodeArgumentTypes(const FunctionTypeProto &FTP, QualType PTy = Context.getPointerType(ATy); unsigned AS = ATy.getAddressSpace(); const llvm::Type *PtrTy = llvm::PointerType::get(Ty, AS); - TypeHolderMap.insert(std::make_pair(PTy.getTypePtr(), - llvm::PATypeHolder(PtrTy))); + TypeCache.insert(std::make_pair(PTy.getTypePtr(), + llvm::PATypeHolder(PtrTy))); ArgTys.push_back(PtrTy); } @@ -342,7 +341,7 @@ const llvm::Type *CodeGenTypes::ConvertTagDeclType(QualType T, // type. This will later be refined to the actual type. ResultType = llvm::OpaqueType::get(); TagDeclTypes.insert(std::make_pair(TD, ResultType)); - TypeHolderMap.insert(std::make_pair(T.getTypePtr(), ResultType)); + TypeCache.insert(std::make_pair(T.getTypePtr(), ResultType)); } // Layout fields. diff --git a/CodeGen/CodeGenTypes.h b/CodeGen/CodeGenTypes.h index 166d10300b..e68d97b1d7 100644 --- a/CodeGen/CodeGenTypes.h +++ b/CodeGen/CodeGenTypes.h @@ -100,11 +100,11 @@ public: private: llvm::DenseMap BitFields; - /// TypeHolderMap - This map keeps cache of llvm::Types (through PATypeHolder) + /// TypeCache - This map keeps cache of llvm::Types (through PATypeHolder) /// and maps llvm::Types to corresponding clang::Type. llvm::PATypeHolder is /// used instead of llvm::Type because it allows us to bypass potential /// dangling type pointers due to type refinement on llvm side. - llvm::DenseMap TypeHolderMap; + llvm::DenseMap TypeCache; /// ConvertNewType - Convert type T into a llvm::Type. Do not use this /// method directly because it does not do any type caching. This method @@ -119,15 +119,13 @@ public: TargetInfo &getTarget() const { return Target; } ASTContext &getContext() const { return Context; } - /// ConvertType - Convert type T into a llvm::Type. Maintain and use - /// type cache through TypeHolderMap. + /// ConvertType - Convert type T into a llvm::Type. const llvm::Type *ConvertType(QualType T); - /// ConvertTypeForMem - Convert type T into a llvm::Type. Maintain and use - /// type cache through TypeHolderMap. This differs from ConvertType in that - /// it is used to convert to the memory representation for a type. For - /// example, the scalar representation for _Bool is i1, but the memory - /// representation is usually i8 or i32, depending on the target. + /// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from + /// ConvertType in that it is used to convert to the memory representation for + /// a type. For example, the scalar representation for _Bool is i1, but the + /// memory representation is usually i8 or i32, depending on the target. const llvm::Type *ConvertTypeForMem(QualType T); -- 2.40.0