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

diff --git a/CodeGen/CodeGenTypes.cpp b/CodeGen/CodeGenTypes.cpp
index 62781cae1a0c808c8516e8d19a8dae4304c44a72..c81f00f76a392a0e7359b12611a8e3631d211ea6 100644 (file)
--- 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<Type *, llvm::PATypeHolder>::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 166d10300b2ce141936aa192b7cad305fd239746..e68d97b1d7fd1c0a1bb73b4e45da3300d004d8eb 100644 (file)
--- a/CodeGen/CodeGenTypes.h
+++ b/CodeGen/CodeGenTypes.h
@@ -100,11 +100,11 @@ public:
 private:
   llvm::DenseMap<const FieldDecl *, BitFieldInfo> 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<Type *, llvm::PATypeHolder> TypeHolderMap;
+  llvm::DenseMap<Type *, llvm::PATypeHolder> 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);