From 2ae250c36a5e4a5305b0d0b6774eaa3270d61736 Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Fri, 9 May 2014 00:08:36 +0000 Subject: Use auto to avoid duplicating the type. llvm-svn: 208374 --- clang/lib/CodeGen/CodeGenModule.cpp | 157 +++++++++++++++++------------------- 1 file changed, 74 insertions(+), 83 deletions(-) (limited to 'clang/lib/CodeGen/CodeGenModule.cpp') diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index cdd240e..d474c1b 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -200,13 +200,13 @@ void CodeGenModule::applyReplacements() { llvm::GlobalValue *Entry = GetGlobalValue(MangledName); if (!Entry) continue; - llvm::Function *OldF = cast(Entry); - llvm::Function *NewF = dyn_cast(Replacement); + auto *OldF = cast(Entry); + auto *NewF = dyn_cast(Replacement); if (!NewF) { - if (llvm::GlobalAlias *Alias = dyn_cast(Replacement)) { + if (auto *Alias = dyn_cast(Replacement)) { NewF = dyn_cast(Alias->getAliasedGlobal()); } else { - llvm::ConstantExpr *CE = cast(Replacement); + auto *CE = cast(Replacement); assert(CE->getOpcode() == llvm::Instruction::BitCast || CE->getOpcode() == llvm::Instruction::GetElementPtr); NewF = dyn_cast(CE->getOperand(0)); @@ -232,11 +232,11 @@ void CodeGenModule::checkAliases() { for (std::vector::iterator I = Aliases.begin(), E = Aliases.end(); I != E; ++I) { const GlobalDecl &GD = *I; - const ValueDecl *D = cast(GD.getDecl()); + const auto *D = cast(GD.getDecl()); const AliasAttr *AA = D->getAttr(); StringRef MangledName = getMangledName(GD); llvm::GlobalValue *Entry = GetGlobalValue(MangledName); - llvm::GlobalAlias *Alias = cast(Entry); + auto *Alias = cast(Entry); llvm::GlobalValue *GV = Alias->getAliasedGlobal(); if (!GV) { Error = true; @@ -287,7 +287,7 @@ void CodeGenModule::checkAliases() { const GlobalDecl &GD = *I; StringRef MangledName = getMangledName(GD); llvm::GlobalValue *Entry = GetGlobalValue(MangledName); - llvm::GlobalAlias *Alias = cast(Entry); + auto *Alias = cast(Entry); Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType())); Alias->eraseFromParent(); } @@ -483,7 +483,7 @@ void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV, } StringRef CodeGenModule::getMangledName(GlobalDecl GD) { - const NamedDecl *ND = cast(GD.getDecl()); + const auto *ND = cast(GD.getDecl()); StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; if (!Str.empty()) @@ -499,9 +499,9 @@ StringRef CodeGenModule::getMangledName(GlobalDecl GD) { SmallString<256> Buffer; llvm::raw_svector_ostream Out(Buffer); - if (const CXXConstructorDecl *D = dyn_cast(ND)) + if (const auto *D = dyn_cast(ND)) getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); - else if (const CXXDestructorDecl *D = dyn_cast(ND)) + else if (const auto *D = dyn_cast(ND)) getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); else getCXXABI().getMangleContext().mangleName(ND, Out); @@ -525,9 +525,9 @@ void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, if (D == 0) MangleCtx.mangleGlobalBlock(BD, dyn_cast_or_null(initializedGlobalDecl.getDecl()), Out); - else if (const CXXConstructorDecl *CD = dyn_cast(D)) + else if (const auto *CD = dyn_cast(D)) MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); - else if (const CXXDestructorDecl *DD = dyn_cast(D)) + else if (const auto *DD = dyn_cast(D)) MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); else MangleCtx.mangleBlock(cast(D), BD, Out); @@ -581,7 +581,7 @@ void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { llvm::GlobalValue::LinkageTypes CodeGenModule::getFunctionLinkage(GlobalDecl GD) { - const FunctionDecl *D = cast(GD.getDecl()); + const auto *D = cast(GD.getDecl()); GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); @@ -700,7 +700,7 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, if (isa(D) || isa(D)) F->setUnnamedAddr(true); - else if (const CXXMethodDecl *MD = dyn_cast(D)) + else if (const auto *MD = dyn_cast(D)) if (MD->isVirtual()) F->setUnnamedAddr(true); @@ -715,7 +715,7 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, void CodeGenModule::SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV) { - if (const NamedDecl *ND = dyn_cast(D)) + if (const auto *ND = dyn_cast(D)) setGlobalVisibility(GV, ND); else GV->setVisibility(llvm::GlobalValue::DefaultVisibility); @@ -782,7 +782,7 @@ void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, return; } - const FunctionDecl *FD = cast(GD.getDecl()); + const auto *FD = cast(GD.getDecl()); if (!IsIncompleteFunction) SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); @@ -846,11 +846,9 @@ static void emitUsed(CodeGenModule &CGM, StringRef Name, return; llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size()); - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(CGM.getModule(), ATy, false, - llvm::GlobalValue::AppendingLinkage, - llvm::ConstantArray::get(ATy, UsedArray), - Name); + auto *GV = new llvm::GlobalVariable( + CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage, + llvm::ConstantArray::get(ATy, UsedArray), Name); GV->setSection("llvm.metadata"); } @@ -1031,9 +1029,9 @@ void CodeGenModule::EmitGlobalAnnotations() { // Create a new global variable for the ConstantStruct in the Module. llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( Annotations[0]->getType(), Annotations.size()), Annotations); - llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), - Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, - "llvm.global.annotations"); + auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false, + llvm::GlobalValue::AppendingLinkage, + Array, "llvm.global.annotations"); gv->setSection(AnnotationSection); } @@ -1044,8 +1042,9 @@ llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { // Not found yet, create a new global. llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); - llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), - true, llvm::GlobalValue::PrivateLinkage, s, ".str"); + auto *gv = + new llvm::GlobalVariable(getModule(), s->getType(), true, + llvm::GlobalValue::PrivateLinkage, s, ".str"); gv->setSection(AnnotationSection); gv->setUnnamedAddr(true); AStr = gv; @@ -1117,7 +1116,7 @@ llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor( llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType()); assert(Init && "failed to initialize as constant"); - llvm::GlobalVariable *GV = new llvm::GlobalVariable( + auto *GV = new llvm::GlobalVariable( getModule(), Init->getType(), /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name); return GV; @@ -1145,7 +1144,7 @@ llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), llvm::PointerType::getUnqual(DeclTy), 0); - llvm::GlobalValue* F = cast(Aliasee); + auto *F = cast(Aliasee); F->setLinkage(llvm::Function::ExternalWeakLinkage); WeakRefReferences.insert(F); @@ -1153,7 +1152,7 @@ llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { } void CodeGenModule::EmitGlobal(GlobalDecl GD) { - const ValueDecl *Global = cast(GD.getDecl()); + const auto *Global = cast(GD.getDecl()); // Weak references don't produce any output by themselves. if (Global->hasAttr()) @@ -1182,7 +1181,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) { } // Ignore declarations, they will be emitted on their first use. - if (const FunctionDecl *FD = dyn_cast(Global)) { + if (const auto *FD = dyn_cast(Global)) { // Forward declarations are emitted lazily on first use. if (!FD->doesThisDeclarationHaveABody()) { if (!FD->doesDeclarationForceExternallyVisibleDefinition()) @@ -1199,7 +1198,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) { return; } } else { - const VarDecl *VD = cast(Global); + const auto *VD = cast(Global); assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); if (VD->isThisDeclarationADefinition() != VarDecl::Definition) @@ -1294,7 +1293,7 @@ bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) { if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage) return true; - const FunctionDecl *F = cast(GD.getDecl()); + const auto *F = cast(GD.getDecl()); if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr()) return false; // PR9614. Avoid cases where the source code is lying to us. An available @@ -1316,14 +1315,13 @@ void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) { if (CGDebugInfo *DI = getModuleDebugInfo()) if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { - const PointerType *ThisPtr = - cast(D->getThisType(getContext())); + const auto *ThisPtr = cast(D->getThisType(getContext())); DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation()); } } void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { - const ValueDecl *D = cast(GD.getDecl()); + const auto *D = cast(GD.getDecl()); PrettyStackTraceDecl CrashInfo(const_cast(D), D->getLocation(), Context.getSourceManager(), @@ -1335,13 +1333,13 @@ void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { if (!shouldEmitFunction(GD)) return; - if (const CXXMethodDecl *Method = dyn_cast(D)) { + if (const auto *Method = dyn_cast(D)) { CompleteDIClassType(Method); // Make sure to emit the definition(s) before we emit the thunks. // This is necessary for the generation of certain thunks. - if (const CXXConstructorDecl *CD = dyn_cast(Method)) + if (const auto *CD = dyn_cast(Method)) EmitCXXConstructor(CD, GD.getCtorType()); - else if (const CXXDestructorDecl *DD =dyn_cast(Method)) + else if (const auto *DD = dyn_cast(Method)) EmitCXXDestructor(DD, GD.getDtorType()); else EmitGlobalFunctionDefinition(GD, GV); @@ -1354,8 +1352,8 @@ void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { return EmitGlobalFunctionDefinition(GD, GV); } - - if (const VarDecl *VD = dyn_cast(D)) + + if (const auto *VD = dyn_cast(D)) return EmitGlobalVarDefinition(VD); llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); @@ -1460,7 +1458,7 @@ CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, // in a vtable, unless it's already marked as used. } else if (getLangOpts().CPlusPlus && D) { // Look for a declaration that's lexically in a record. - const FunctionDecl *FD = cast(D); + const auto *FD = cast(D); FD = FD->getMostRecentDecl(); do { if (isa(FD->getLexicalDeclContext())) { @@ -1515,7 +1513,7 @@ CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, llvm::Constant *C = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, /*DontDefer=*/false, ExtraAttrs); - if (llvm::Function *F = dyn_cast(C)) + if (auto *F = dyn_cast(C)) if (F->empty()) F->setCallingConv(getRuntimeCC()); return C; @@ -1587,11 +1585,10 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, } unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, - llvm::GlobalValue::ExternalLinkage, - 0, MangledName, 0, - llvm::GlobalVariable::NotThreadLocal, AddrSpace); + auto *GV = new llvm::GlobalVariable( + getModule(), Ty->getElementType(), false, + llvm::GlobalValue::ExternalLinkage, 0, MangledName, 0, + llvm::GlobalVariable::NotThreadLocal, AddrSpace); // This is the first use or definition of a mangled name. If there is a // deferred decl with this name, remember that we need to emit it at the end @@ -1828,7 +1825,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); // Strip off a bitcast if we got one back. - if (llvm::ConstantExpr *CE = dyn_cast(Entry)) { + if (auto *CE = dyn_cast(Entry)) { assert(CE->getOpcode() == llvm::Instruction::BitCast || CE->getOpcode() == llvm::Instruction::AddrSpaceCast || // All zero index gep. @@ -1837,7 +1834,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { } // Entry is now either a Function or GlobalVariable. - llvm::GlobalVariable *GV = dyn_cast(Entry); + auto *GV = dyn_cast(Entry); // We have a definition after a declaration with the wrong type. // We must make a new GlobalVariable* and update everything that used OldGV @@ -2050,7 +2047,7 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old, // Recognize and replace uses of bitcasts. Most calls to // unprototyped functions will use bitcasts. - if (llvm::ConstantExpr *bitcast = dyn_cast(user)) { + if (auto *bitcast = dyn_cast(user)) { if (bitcast->getOpcode() == llvm::Instruction::BitCast) replaceUsesOfNonProtoConstant(bitcast, newFn); continue; @@ -2114,8 +2111,7 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old, newCall = llvm::CallInst::Create(newFn, newArgs, "", callSite.getInstruction()); } else { - llvm::InvokeInst *oldInvoke = - cast(callSite.getInstruction()); + auto *oldInvoke = cast(callSite.getInstruction()); newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(), @@ -2170,7 +2166,7 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { - const FunctionDecl *D = cast(GD.getDecl()); + const auto *D = cast(GD.getDecl()); // Compute the function info and LLVM type. const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); @@ -2182,7 +2178,7 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer*/ true); // Strip off a bitcast if we got one back. - if (llvm::ConstantExpr *CE = dyn_cast(C)) { + if (auto *CE = dyn_cast(C)) { assert(CE->getOpcode() == llvm::Instruction::BitCast); GV = cast(CE->getOperand(0)); } else { @@ -2239,7 +2235,7 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, // generating code for it because various parts of IR generation // want to propagate this information down (e.g. to local static // declarations). - llvm::Function *Fn = cast(GV); + auto *Fn = cast(GV); setFunctionLinkage(GD, Fn); // FIXME: this is redundant with part of setFunctionDefinitionAttributes @@ -2261,7 +2257,7 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, } void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { - const ValueDecl *D = cast(GD.getDecl()); + const auto *D = cast(GD.getDecl()); const AliasAttr *AA = D->getAttr(); assert(AA && "Not an alias?"); @@ -2288,10 +2284,9 @@ void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { llvm::PointerType::getUnqual(DeclTy), 0); // Create the new alias itself, but don't set a name yet. - llvm::GlobalValue *GA = - new llvm::GlobalAlias(Aliasee->getType(), - llvm::Function::ExternalLinkage, - "", Aliasee, &getModule()); + auto *GA = + new llvm::GlobalAlias(Aliasee->getType(), llvm::Function::ExternalLinkage, + "", Aliasee, &getModule()); if (Entry) { assert(Entry->isDeclaration()); @@ -2316,7 +2311,7 @@ void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { // specialization of the attributes which may be set on a global // variable/function. if (D->hasAttr()) { - if (const FunctionDecl *FD = dyn_cast(D)) { + if (const auto *FD = dyn_cast(D)) { // The dllexport attribute is ignored for undefined symbols. if (FD->hasBody()) GA->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); @@ -2414,8 +2409,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { QualType CFTy = getContext().getCFConstantStringType(); - llvm::StructType *STy = - cast(getTypes().ConvertType(CFTy)); + auto *STy = cast(getTypes().ConvertType(CFTy)); llvm::Constant *Fields[4]; @@ -2441,7 +2435,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { // Note: -fwritable-strings doesn't make the backing store strings of // CFStrings writable. (See ) - llvm::GlobalVariable *GV = + auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str"); GV->setUnnamedAddr(true); @@ -2567,10 +2561,9 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { bool isConstant; Linkage = llvm::GlobalValue::PrivateLinkage; isConstant = !LangOpts.WritableStrings; - - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, - ".str"); + + auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), isConstant, + Linkage, C, ".str"); GV->setUnnamedAddr(true); // Don't enforce the target's minimum global alignment, since the only use // of the string is via this class initializer. @@ -2646,9 +2639,8 @@ CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { Str.resize(CAT->getSize().getZExtValue()); return llvm::ConstantDataArray::getString(VMContext, Str, false); } - - llvm::ArrayType *AType = - cast(getTypes().ConvertType(E->getType())); + + auto *AType = cast(getTypes().ConvertType(E->getType())); llvm::Type *ElemTy = AType->getElementType(); unsigned NumElements = AType->getNumElements(); @@ -2769,7 +2761,7 @@ static llvm::GlobalVariable *GenerateStringLiteral(StringRef str, AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant); // Create a global variable for this string - llvm::GlobalVariable *GV = new llvm::GlobalVariable( + auto *GV = new llvm::GlobalVariable( CGM.getModule(), C->getType(), constant, llvm::GlobalValue::PrivateLinkage, C, GlobalName, 0, llvm::GlobalVariable::NotThreadLocal, AddrSpace); @@ -2832,7 +2824,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( const MaterializeTemporaryExpr *E, const Expr *Init) { assert((E->getStorageDuration() == SD_Static || E->getStorageDuration() == SD_Thread) && "not a global temporary"); - const VarDecl *VD = cast(E->getExtendingDecl()); + const auto *VD = cast(E->getExtendingDecl()); // If we're not materializing a subobject of the temporary, keep the // cv-qualifiers from the type of the MaterializeTemporaryExpr. @@ -2893,7 +2885,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( Linkage = llvm::GlobalVariable::PrivateLinkage; unsigned AddrSpace = GetGlobalVarAddressSpace( VD, getContext().getTargetAddressSpace(MaterializedType)); - llvm::GlobalVariable *GV = new llvm::GlobalVariable( + auto *GV = new llvm::GlobalVariable( getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(), /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace); @@ -3096,7 +3088,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::ObjCProtocol: { - ObjCProtocolDecl *Proto = cast(D); + auto *Proto = cast(D); if (Proto->isThisDeclarationADefinition()) ObjCRuntime->GenerateProtocol(Proto); break; @@ -3109,7 +3101,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::ObjCImplementation: { - ObjCImplementationDecl *OMD = cast(D); + auto *OMD = cast(D); EmitObjCPropertyImplementations(OMD); EmitObjCIvarInitializations(OMD); ObjCRuntime->GenerateClass(OMD); @@ -3121,7 +3113,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; } case Decl::ObjCMethod: { - ObjCMethodDecl *OMD = cast(D); + auto *OMD = cast(D); // If this is not a prototype, emit the body. if (OMD->getBody()) CodeGenFunction(*this).GenerateObjCMethod(OMD); @@ -3136,7 +3128,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::FileScopeAsm: { - FileScopeAsmDecl *AD = cast(D); + auto *AD = cast(D); StringRef AsmString = AD->getAsmString()->getString(); const std::string &S = getModule().getModuleInlineAsm(); @@ -3150,7 +3142,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { } case Decl::Import: { - ImportDecl *Import = cast(D); + auto *Import = cast(D); // Ignore import declarations that come from imported modules. if (clang::Module *Owner = Import->getOwningModule()) { @@ -3164,8 +3156,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { } case Decl::ClassTemplateSpecialization: { - const ClassTemplateSpecializationDecl *Spec = - cast(D); + const auto *Spec = cast(D); if (DebugInfo && Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition) DebugInfo->completeTemplateDefinition(*Spec); @@ -3256,10 +3247,10 @@ void CodeGenFunction::EmitDeclMetadata() { const Decl *D = I->first; llvm::Value *Addr = I->second; - if (llvm::AllocaInst *Alloca = dyn_cast(Addr)) { + if (auto *Alloca = dyn_cast(Addr)) { llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); - } else if (llvm::GlobalValue *GV = dyn_cast(Addr)) { + } else if (auto *GV = dyn_cast(Addr)) { GlobalDecl GD = GlobalDecl(cast(D)); EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); } -- cgit v1.1