maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

rename TypeHolderMap to TypeCache, which more aptly describes what it is. 

llvm-svn: 46804
This commit is contained in:
Chris Lattner 2008-02-06 05:21:55 +00:00
parent ee9fafd533
commit 56096f3020
2 changed files with 20 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
clang/CodeGen/CodeGenTypes.cpp
View File

@ -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.

16
clang/CodeGen/CodeGenTypes.h
View File

@ -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);