CodeGenModule.cpp revision b37a73d5c6a0c8bb1f6e363d3b53980e4fa0cead
1//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This coordinates the per-module state used while generating code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenModule.h" 15#include "CGCUDARuntime.h" 16#include "CGCXXABI.h" 17#include "CGCall.h" 18#include "CGDebugInfo.h" 19#include "CGObjCRuntime.h" 20#include "CGOpenCLRuntime.h" 21#include "CodeGenFunction.h" 22#include "CodeGenTBAA.h" 23#include "TargetInfo.h" 24#include "clang/AST/ASTContext.h" 25#include "clang/AST/CharUnits.h" 26#include "clang/AST/DeclCXX.h" 27#include "clang/AST/DeclObjC.h" 28#include "clang/AST/DeclTemplate.h" 29#include "clang/AST/Mangle.h" 30#include "clang/AST/RecordLayout.h" 31#include "clang/AST/RecursiveASTVisitor.h" 32#include "clang/Basic/Builtins.h" 33#include "clang/Basic/CharInfo.h" 34#include "clang/Basic/Diagnostic.h" 35#include "clang/Basic/Module.h" 36#include "clang/Basic/SourceManager.h" 37#include "clang/Basic/TargetInfo.h" 38#include "clang/Basic/TargetOptions.h" 39#include "clang/Frontend/CodeGenOptions.h" 40#include "llvm/ADT/APSInt.h" 41#include "llvm/ADT/Triple.h" 42#include "llvm/IR/CallingConv.h" 43#include "llvm/IR/DataLayout.h" 44#include "llvm/IR/Intrinsics.h" 45#include "llvm/IR/LLVMContext.h" 46#include "llvm/IR/Module.h" 47#include "llvm/Support/CallSite.h" 48#include "llvm/Support/ConvertUTF.h" 49#include "llvm/Support/ErrorHandling.h" 50#include "llvm/Target/Mangler.h" 51 52using namespace clang; 53using namespace CodeGen; 54 55static const char AnnotationSection[] = "llvm.metadata"; 56 57static CGCXXABI &createCXXABI(CodeGenModule &CGM) { 58 switch (CGM.getContext().getTargetInfo().getCXXABI().getKind()) { 59 case TargetCXXABI::GenericAArch64: 60 case TargetCXXABI::GenericARM: 61 case TargetCXXABI::iOS: 62 case TargetCXXABI::GenericItanium: 63 return *CreateItaniumCXXABI(CGM); 64 case TargetCXXABI::Microsoft: 65 return *CreateMicrosoftCXXABI(CGM); 66 } 67 68 llvm_unreachable("invalid C++ ABI kind"); 69} 70 71 72CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, 73 const TargetOptions &TO, llvm::Module &M, 74 const llvm::DataLayout &TD, 75 DiagnosticsEngine &diags) 76 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TargetOpts(TO), 77 TheModule(M), TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags), 78 ABI(createCXXABI(*this)), 79 Types(*this), 80 TBAA(0), 81 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0), 82 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0), 83 RRData(0), CFConstantStringClassRef(0), 84 ConstantStringClassRef(0), NSConstantStringType(0), 85 VMContext(M.getContext()), 86 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), 87 BlockObjectAssign(0), BlockObjectDispose(0), 88 BlockDescriptorType(0), GenericBlockLiteralType(0), 89 LifetimeStartFn(0), LifetimeEndFn(0), 90 SanitizerBlacklist(CGO.SanitizerBlacklistFile), 91 SanOpts(SanitizerBlacklist.isIn(M) ? 92 SanitizerOptions::Disabled : LangOpts.Sanitize) { 93 94 // Initialize the type cache. 95 llvm::LLVMContext &LLVMContext = M.getContext(); 96 VoidTy = llvm::Type::getVoidTy(LLVMContext); 97 Int8Ty = llvm::Type::getInt8Ty(LLVMContext); 98 Int16Ty = llvm::Type::getInt16Ty(LLVMContext); 99 Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 100 Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 101 FloatTy = llvm::Type::getFloatTy(LLVMContext); 102 DoubleTy = llvm::Type::getDoubleTy(LLVMContext); 103 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0); 104 PointerAlignInBytes = 105 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity(); 106 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth()); 107 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits); 108 Int8PtrTy = Int8Ty->getPointerTo(0); 109 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); 110 111 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC(); 112 113 if (LangOpts.ObjC1) 114 createObjCRuntime(); 115 if (LangOpts.OpenCL) 116 createOpenCLRuntime(); 117 if (LangOpts.CUDA) 118 createCUDARuntime(); 119 120 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. 121 if (SanOpts.Thread || 122 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) 123 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(), 124 ABI.getMangleContext()); 125 126 // If debug info or coverage generation is enabled, create the CGDebugInfo 127 // object. 128 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo || 129 CodeGenOpts.EmitGcovArcs || 130 CodeGenOpts.EmitGcovNotes) 131 DebugInfo = new CGDebugInfo(*this); 132 133 Block.GlobalUniqueCount = 0; 134 135 if (C.getLangOpts().ObjCAutoRefCount) 136 ARCData = new ARCEntrypoints(); 137 RRData = new RREntrypoints(); 138} 139 140CodeGenModule::~CodeGenModule() { 141 delete ObjCRuntime; 142 delete OpenCLRuntime; 143 delete CUDARuntime; 144 delete TheTargetCodeGenInfo; 145 delete &ABI; 146 delete TBAA; 147 delete DebugInfo; 148 delete ARCData; 149 delete RRData; 150} 151 152void CodeGenModule::createObjCRuntime() { 153 // This is just isGNUFamily(), but we want to force implementors of 154 // new ABIs to decide how best to do this. 155 switch (LangOpts.ObjCRuntime.getKind()) { 156 case ObjCRuntime::GNUstep: 157 case ObjCRuntime::GCC: 158 case ObjCRuntime::ObjFW: 159 ObjCRuntime = CreateGNUObjCRuntime(*this); 160 return; 161 162 case ObjCRuntime::FragileMacOSX: 163 case ObjCRuntime::MacOSX: 164 case ObjCRuntime::iOS: 165 ObjCRuntime = CreateMacObjCRuntime(*this); 166 return; 167 } 168 llvm_unreachable("bad runtime kind"); 169} 170 171void CodeGenModule::createOpenCLRuntime() { 172 OpenCLRuntime = new CGOpenCLRuntime(*this); 173} 174 175void CodeGenModule::createCUDARuntime() { 176 CUDARuntime = CreateNVCUDARuntime(*this); 177} 178 179void CodeGenModule::Release() { 180 EmitDeferred(); 181 EmitCXXGlobalInitFunc(); 182 EmitCXXGlobalDtorFunc(); 183 if (ObjCRuntime) 184 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) 185 AddGlobalCtor(ObjCInitFunction); 186 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 187 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 188 EmitGlobalAnnotations(); 189 EmitLLVMUsed(); 190 191 if (CodeGenOpts.ModulesAutolink) { 192 EmitModuleLinkOptions(); 193 } 194 195 SimplifyPersonality(); 196 197 if (getCodeGenOpts().EmitDeclMetadata) 198 EmitDeclMetadata(); 199 200 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes) 201 EmitCoverageFile(); 202 203 if (DebugInfo) 204 DebugInfo->finalize(); 205} 206 207void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { 208 // Make sure that this type is translated. 209 Types.UpdateCompletedType(TD); 210} 211 212llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { 213 if (!TBAA) 214 return 0; 215 return TBAA->getTBAAInfo(QTy); 216} 217 218llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() { 219 if (!TBAA) 220 return 0; 221 return TBAA->getTBAAInfoForVTablePtr(); 222} 223 224llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { 225 if (!TBAA) 226 return 0; 227 return TBAA->getTBAAStructInfo(QTy); 228} 229 230llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) { 231 if (!TBAA) 232 return 0; 233 return TBAA->getTBAAStructTypeInfo(QTy); 234} 235 236llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy, 237 llvm::MDNode *AccessN, 238 uint64_t O) { 239 if (!TBAA) 240 return 0; 241 return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O); 242} 243 244void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, 245 llvm::MDNode *TBAAInfo) { 246 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); 247} 248 249bool CodeGenModule::isTargetDarwin() const { 250 return getContext().getTargetInfo().getTriple().isOSDarwin(); 251} 252 253void CodeGenModule::Error(SourceLocation loc, StringRef error) { 254 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error); 255 getDiags().Report(Context.getFullLoc(loc), diagID); 256} 257 258/// ErrorUnsupported - Print out an error that codegen doesn't support the 259/// specified stmt yet. 260void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 261 bool OmitOnError) { 262 if (OmitOnError && getDiags().hasErrorOccurred()) 263 return; 264 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 265 "cannot compile this %0 yet"); 266 std::string Msg = Type; 267 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 268 << Msg << S->getSourceRange(); 269} 270 271/// ErrorUnsupported - Print out an error that codegen doesn't support the 272/// specified decl yet. 273void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 274 bool OmitOnError) { 275 if (OmitOnError && getDiags().hasErrorOccurred()) 276 return; 277 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 278 "cannot compile this %0 yet"); 279 std::string Msg = Type; 280 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 281} 282 283llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) { 284 return llvm::ConstantInt::get(SizeTy, size.getQuantity()); 285} 286 287void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 288 const NamedDecl *D) const { 289 // Internal definitions always have default visibility. 290 if (GV->hasLocalLinkage()) { 291 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 292 return; 293 } 294 295 // Set visibility for definitions. 296 LinkageInfo LV = D->getLinkageAndVisibility(); 297 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage()) 298 GV->setVisibility(GetLLVMVisibility(LV.getVisibility())); 299} 300 301static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) { 302 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S) 303 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel) 304 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel) 305 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel) 306 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel); 307} 308 309static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel( 310 CodeGenOptions::TLSModel M) { 311 switch (M) { 312 case CodeGenOptions::GeneralDynamicTLSModel: 313 return llvm::GlobalVariable::GeneralDynamicTLSModel; 314 case CodeGenOptions::LocalDynamicTLSModel: 315 return llvm::GlobalVariable::LocalDynamicTLSModel; 316 case CodeGenOptions::InitialExecTLSModel: 317 return llvm::GlobalVariable::InitialExecTLSModel; 318 case CodeGenOptions::LocalExecTLSModel: 319 return llvm::GlobalVariable::LocalExecTLSModel; 320 } 321 llvm_unreachable("Invalid TLS model!"); 322} 323 324void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV, 325 const VarDecl &D) const { 326 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!"); 327 328 llvm::GlobalVariable::ThreadLocalMode TLM; 329 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel()); 330 331 // Override the TLS model if it is explicitly specified. 332 if (D.hasAttr<TLSModelAttr>()) { 333 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>(); 334 TLM = GetLLVMTLSModel(Attr->getModel()); 335 } 336 337 GV->setThreadLocalMode(TLM); 338} 339 340/// Set the symbol visibility of type information (vtable and RTTI) 341/// associated with the given type. 342void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV, 343 const CXXRecordDecl *RD, 344 TypeVisibilityKind TVK) const { 345 setGlobalVisibility(GV, RD); 346 347 if (!CodeGenOpts.HiddenWeakVTables) 348 return; 349 350 // We never want to drop the visibility for RTTI names. 351 if (TVK == TVK_ForRTTIName) 352 return; 353 354 // We want to drop the visibility to hidden for weak type symbols. 355 // This isn't possible if there might be unresolved references 356 // elsewhere that rely on this symbol being visible. 357 358 // This should be kept roughly in sync with setThunkVisibility 359 // in CGVTables.cpp. 360 361 // Preconditions. 362 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage || 363 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility) 364 return; 365 366 // Don't override an explicit visibility attribute. 367 if (RD->getExplicitVisibility(NamedDecl::VisibilityForType)) 368 return; 369 370 switch (RD->getTemplateSpecializationKind()) { 371 // We have to disable the optimization if this is an EI definition 372 // because there might be EI declarations in other shared objects. 373 case TSK_ExplicitInstantiationDefinition: 374 case TSK_ExplicitInstantiationDeclaration: 375 return; 376 377 // Every use of a non-template class's type information has to emit it. 378 case TSK_Undeclared: 379 break; 380 381 // In theory, implicit instantiations can ignore the possibility of 382 // an explicit instantiation declaration because there necessarily 383 // must be an EI definition somewhere with default visibility. In 384 // practice, it's possible to have an explicit instantiation for 385 // an arbitrary template class, and linkers aren't necessarily able 386 // to deal with mixed-visibility symbols. 387 case TSK_ExplicitSpecialization: 388 case TSK_ImplicitInstantiation: 389 return; 390 } 391 392 // If there's a key function, there may be translation units 393 // that don't have the key function's definition. But ignore 394 // this if we're emitting RTTI under -fno-rtti. 395 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) { 396 // FIXME: what should we do if we "lose" the key function during 397 // the emission of the file? 398 if (Context.getCurrentKeyFunction(RD)) 399 return; 400 } 401 402 // Otherwise, drop the visibility to hidden. 403 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 404 GV->setUnnamedAddr(true); 405} 406 407StringRef CodeGenModule::getMangledName(GlobalDecl GD) { 408 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); 409 410 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; 411 if (!Str.empty()) 412 return Str; 413 414 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { 415 IdentifierInfo *II = ND->getIdentifier(); 416 assert(II && "Attempt to mangle unnamed decl."); 417 418 Str = II->getName(); 419 return Str; 420 } 421 422 SmallString<256> Buffer; 423 llvm::raw_svector_ostream Out(Buffer); 424 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 425 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); 426 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 427 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); 428 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND)) 429 getCXXABI().getMangleContext().mangleBlock(BD, Out, 430 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl())); 431 else 432 getCXXABI().getMangleContext().mangleName(ND, Out); 433 434 // Allocate space for the mangled name. 435 Out.flush(); 436 size_t Length = Buffer.size(); 437 char *Name = MangledNamesAllocator.Allocate<char>(Length); 438 std::copy(Buffer.begin(), Buffer.end(), Name); 439 440 Str = StringRef(Name, Length); 441 442 return Str; 443} 444 445void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, 446 const BlockDecl *BD) { 447 MangleContext &MangleCtx = getCXXABI().getMangleContext(); 448 const Decl *D = GD.getDecl(); 449 llvm::raw_svector_ostream Out(Buffer.getBuffer()); 450 if (D == 0) 451 MangleCtx.mangleGlobalBlock(BD, 452 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out); 453 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 454 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); 455 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 456 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); 457 else 458 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); 459} 460 461llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { 462 return getModule().getNamedValue(Name); 463} 464 465/// AddGlobalCtor - Add a function to the list that will be called before 466/// main() runs. 467void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 468 // FIXME: Type coercion of void()* types. 469 GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 470} 471 472/// AddGlobalDtor - Add a function to the list that will be called 473/// when the module is unloaded. 474void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 475 // FIXME: Type coercion of void()* types. 476 GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 477} 478 479void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 480 // Ctor function type is void()*. 481 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); 482 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 483 484 // Get the type of a ctor entry, { i32, void ()* }. 485 llvm::StructType *CtorStructTy = 486 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL); 487 488 // Construct the constructor and destructor arrays. 489 SmallVector<llvm::Constant*, 8> Ctors; 490 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 491 llvm::Constant *S[] = { 492 llvm::ConstantInt::get(Int32Ty, I->second, false), 493 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy) 494 }; 495 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 496 } 497 498 if (!Ctors.empty()) { 499 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 500 new llvm::GlobalVariable(TheModule, AT, false, 501 llvm::GlobalValue::AppendingLinkage, 502 llvm::ConstantArray::get(AT, Ctors), 503 GlobalName); 504 } 505} 506 507llvm::GlobalValue::LinkageTypes 508CodeGenModule::getFunctionLinkage(const FunctionDecl *D) { 509 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); 510 511 if (Linkage == GVA_Internal) 512 return llvm::Function::InternalLinkage; 513 514 if (D->hasAttr<DLLExportAttr>()) 515 return llvm::Function::DLLExportLinkage; 516 517 if (D->hasAttr<WeakAttr>()) 518 return llvm::Function::WeakAnyLinkage; 519 520 // In C99 mode, 'inline' functions are guaranteed to have a strong 521 // definition somewhere else, so we can use available_externally linkage. 522 if (Linkage == GVA_C99Inline) 523 return llvm::Function::AvailableExternallyLinkage; 524 525 // Note that Apple's kernel linker doesn't support symbol 526 // coalescing, so we need to avoid linkonce and weak linkages there. 527 // Normally, this means we just map to internal, but for explicit 528 // instantiations we'll map to external. 529 530 // In C++, the compiler has to emit a definition in every translation unit 531 // that references the function. We should use linkonce_odr because 532 // a) if all references in this translation unit are optimized away, we 533 // don't need to codegen it. b) if the function persists, it needs to be 534 // merged with other definitions. c) C++ has the ODR, so we know the 535 // definition is dependable. 536 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 537 return !Context.getLangOpts().AppleKext 538 ? llvm::Function::LinkOnceODRLinkage 539 : llvm::Function::InternalLinkage; 540 541 // An explicit instantiation of a template has weak linkage, since 542 // explicit instantiations can occur in multiple translation units 543 // and must all be equivalent. However, we are not allowed to 544 // throw away these explicit instantiations. 545 if (Linkage == GVA_ExplicitTemplateInstantiation) 546 return !Context.getLangOpts().AppleKext 547 ? llvm::Function::WeakODRLinkage 548 : llvm::Function::ExternalLinkage; 549 550 // Otherwise, we have strong external linkage. 551 assert(Linkage == GVA_StrongExternal); 552 return llvm::Function::ExternalLinkage; 553} 554 555 556/// SetFunctionDefinitionAttributes - Set attributes for a global. 557/// 558/// FIXME: This is currently only done for aliases and functions, but not for 559/// variables (these details are set in EmitGlobalVarDefinition for variables). 560void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 561 llvm::GlobalValue *GV) { 562 SetCommonAttributes(D, GV); 563} 564 565void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 566 const CGFunctionInfo &Info, 567 llvm::Function *F) { 568 unsigned CallingConv; 569 AttributeListType AttributeList; 570 ConstructAttributeList(Info, D, AttributeList, CallingConv, false); 571 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList)); 572 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 573} 574 575/// Determines whether the language options require us to model 576/// unwind exceptions. We treat -fexceptions as mandating this 577/// except under the fragile ObjC ABI with only ObjC exceptions 578/// enabled. This means, for example, that C with -fexceptions 579/// enables this. 580static bool hasUnwindExceptions(const LangOptions &LangOpts) { 581 // If exceptions are completely disabled, obviously this is false. 582 if (!LangOpts.Exceptions) return false; 583 584 // If C++ exceptions are enabled, this is true. 585 if (LangOpts.CXXExceptions) return true; 586 587 // If ObjC exceptions are enabled, this depends on the ABI. 588 if (LangOpts.ObjCExceptions) { 589 return LangOpts.ObjCRuntime.hasUnwindExceptions(); 590 } 591 592 return true; 593} 594 595void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 596 llvm::Function *F) { 597 if (CodeGenOpts.UnwindTables) 598 F->setHasUWTable(); 599 600 if (!hasUnwindExceptions(LangOpts)) 601 F->addFnAttr(llvm::Attribute::NoUnwind); 602 603 if (D->hasAttr<NakedAttr>()) { 604 // Naked implies noinline: we should not be inlining such functions. 605 F->addFnAttr(llvm::Attribute::Naked); 606 F->addFnAttr(llvm::Attribute::NoInline); 607 } 608 609 if (D->hasAttr<NoInlineAttr>()) 610 F->addFnAttr(llvm::Attribute::NoInline); 611 612 // (noinline wins over always_inline, and we can't specify both in IR) 613 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) && 614 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex, 615 llvm::Attribute::NoInline)) 616 F->addFnAttr(llvm::Attribute::AlwaysInline); 617 618 // FIXME: Communicate hot and cold attributes to LLVM more directly. 619 if (D->hasAttr<ColdAttr>()) 620 F->addFnAttr(llvm::Attribute::OptimizeForSize); 621 622 if (D->hasAttr<MinSizeAttr>()) 623 F->addFnAttr(llvm::Attribute::MinSize); 624 625 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) 626 F->setUnnamedAddr(true); 627 628 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) 629 if (MD->isVirtual()) 630 F->setUnnamedAddr(true); 631 632 if (LangOpts.getStackProtector() == LangOptions::SSPOn) 633 F->addFnAttr(llvm::Attribute::StackProtect); 634 else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 635 F->addFnAttr(llvm::Attribute::StackProtectReq); 636 637 // Add sanitizer attributes if function is not blacklisted. 638 if (!SanitizerBlacklist.isIn(*F)) { 639 // When AddressSanitizer is enabled, set SanitizeAddress attribute 640 // unless __attribute__((no_sanitize_address)) is used. 641 if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>()) 642 F->addFnAttr(llvm::Attribute::SanitizeAddress); 643 // Same for ThreadSanitizer and __attribute__((no_sanitize_thread)) 644 if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) { 645 F->addFnAttr(llvm::Attribute::SanitizeThread); 646 } 647 // Same for MemorySanitizer and __attribute__((no_sanitize_memory)) 648 if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>()) 649 F->addFnAttr(llvm::Attribute::SanitizeMemory); 650 } 651 652 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth(); 653 if (alignment) 654 F->setAlignment(alignment); 655 656 // C++ ABI requires 2-byte alignment for member functions. 657 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D)) 658 F->setAlignment(2); 659} 660 661void CodeGenModule::SetCommonAttributes(const Decl *D, 662 llvm::GlobalValue *GV) { 663 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 664 setGlobalVisibility(GV, ND); 665 else 666 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 667 668 if (D->hasAttr<UsedAttr>()) 669 AddUsedGlobal(GV); 670 671 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 672 GV->setSection(SA->getName()); 673 674 // Alias cannot have attributes. Filter them here. 675 if (!isa<llvm::GlobalAlias>(GV)) 676 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); 677} 678 679void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 680 llvm::Function *F, 681 const CGFunctionInfo &FI) { 682 SetLLVMFunctionAttributes(D, FI, F); 683 SetLLVMFunctionAttributesForDefinition(D, F); 684 685 F->setLinkage(llvm::Function::InternalLinkage); 686 687 SetCommonAttributes(D, F); 688} 689 690void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, 691 llvm::Function *F, 692 bool IsIncompleteFunction) { 693 if (unsigned IID = F->getIntrinsicID()) { 694 // If this is an intrinsic function, set the function's attributes 695 // to the intrinsic's attributes. 696 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), 697 (llvm::Intrinsic::ID)IID)); 698 return; 699 } 700 701 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 702 703 if (!IsIncompleteFunction) 704 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); 705 706 // Only a few attributes are set on declarations; these may later be 707 // overridden by a definition. 708 709 if (FD->hasAttr<DLLImportAttr>()) { 710 F->setLinkage(llvm::Function::DLLImportLinkage); 711 } else if (FD->hasAttr<WeakAttr>() || 712 FD->isWeakImported()) { 713 // "extern_weak" is overloaded in LLVM; we probably should have 714 // separate linkage types for this. 715 F->setLinkage(llvm::Function::ExternalWeakLinkage); 716 } else { 717 F->setLinkage(llvm::Function::ExternalLinkage); 718 719 LinkageInfo LV = FD->getLinkageAndVisibility(); 720 if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) { 721 F->setVisibility(GetLLVMVisibility(LV.getVisibility())); 722 } 723 } 724 725 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 726 F->setSection(SA->getName()); 727} 728 729void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 730 assert(!GV->isDeclaration() && 731 "Only globals with definition can force usage."); 732 LLVMUsed.push_back(GV); 733} 734 735void CodeGenModule::EmitLLVMUsed() { 736 // Don't create llvm.used if there is no need. 737 if (LLVMUsed.empty()) 738 return; 739 740 // Convert LLVMUsed to what ConstantArray needs. 741 SmallVector<llvm::Constant*, 8> UsedArray; 742 UsedArray.resize(LLVMUsed.size()); 743 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 744 UsedArray[i] = 745 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 746 Int8PtrTy); 747 } 748 749 if (UsedArray.empty()) 750 return; 751 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size()); 752 753 llvm::GlobalVariable *GV = 754 new llvm::GlobalVariable(getModule(), ATy, false, 755 llvm::GlobalValue::AppendingLinkage, 756 llvm::ConstantArray::get(ATy, UsedArray), 757 "llvm.used"); 758 759 GV->setSection("llvm.metadata"); 760} 761 762/// \brief Add link options implied by the given module, including modules 763/// it depends on, using a postorder walk. 764static void addLinkOptionsPostorder(llvm::LLVMContext &Context, 765 Module *Mod, 766 SmallVectorImpl<llvm::Value *> &Metadata, 767 llvm::SmallPtrSet<Module *, 16> &Visited) { 768 // Import this module's parent. 769 if (Mod->Parent && Visited.insert(Mod->Parent)) { 770 addLinkOptionsPostorder(Context, Mod->Parent, Metadata, Visited); 771 } 772 773 // Import this module's dependencies. 774 for (unsigned I = Mod->Imports.size(); I > 0; --I) { 775 if (Visited.insert(Mod->Imports[I-1])) 776 addLinkOptionsPostorder(Context, Mod->Imports[I-1], Metadata, Visited); 777 } 778 779 // Add linker options to link against the libraries/frameworks 780 // described by this module. 781 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) { 782 // FIXME: -lfoo is Unix-centric and -framework Foo is Darwin-centric. 783 // We need to know more about the linker to know how to encode these 784 // options propertly. 785 786 // Link against a framework. 787 if (Mod->LinkLibraries[I-1].IsFramework) { 788 llvm::Value *Args[2] = { 789 llvm::MDString::get(Context, "-framework"), 790 llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library) 791 }; 792 793 Metadata.push_back(llvm::MDNode::get(Context, Args)); 794 continue; 795 } 796 797 // Link against a library. 798 llvm::Value *OptString 799 = llvm::MDString::get(Context, 800 "-l" + Mod->LinkLibraries[I-1].Library); 801 Metadata.push_back(llvm::MDNode::get(Context, OptString)); 802 } 803} 804 805void CodeGenModule::EmitModuleLinkOptions() { 806 // Collect the set of all of the modules we want to visit to emit link 807 // options, which is essentially the imported modules and all of their 808 // non-explicit child modules. 809 llvm::SetVector<clang::Module *> LinkModules; 810 llvm::SmallPtrSet<clang::Module *, 16> Visited; 811 SmallVector<clang::Module *, 16> Stack; 812 813 // Seed the stack with imported modules. 814 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(), 815 MEnd = ImportedModules.end(); 816 M != MEnd; ++M) { 817 if (Visited.insert(*M)) 818 Stack.push_back(*M); 819 } 820 821 // Find all of the modules to import, making a little effort to prune 822 // non-leaf modules. 823 while (!Stack.empty()) { 824 clang::Module *Mod = Stack.back(); 825 Stack.pop_back(); 826 827 bool AnyChildren = false; 828 829 // Visit the submodules of this module. 830 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(), 831 SubEnd = Mod->submodule_end(); 832 Sub != SubEnd; ++Sub) { 833 // Skip explicit children; they need to be explicitly imported to be 834 // linked against. 835 if ((*Sub)->IsExplicit) 836 continue; 837 838 if (Visited.insert(*Sub)) { 839 Stack.push_back(*Sub); 840 AnyChildren = true; 841 } 842 } 843 844 // We didn't find any children, so add this module to the list of 845 // modules to link against. 846 if (!AnyChildren) { 847 LinkModules.insert(Mod); 848 } 849 } 850 851 // Add link options for all of the imported modules in reverse topological 852 // order. 853 SmallVector<llvm::Value *, 16> MetadataArgs; 854 Visited.clear(); 855 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(), 856 MEnd = LinkModules.end(); 857 M != MEnd; ++M) { 858 if (Visited.insert(*M)) 859 addLinkOptionsPostorder(getLLVMContext(), *M, MetadataArgs, Visited); 860 } 861 std::reverse(MetadataArgs.begin(), MetadataArgs.end()); 862 863 // Add the linker options metadata flag. 864 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options", 865 llvm::MDNode::get(getLLVMContext(), MetadataArgs)); 866} 867 868void CodeGenModule::EmitDeferred() { 869 // Emit code for any potentially referenced deferred decls. Since a 870 // previously unused static decl may become used during the generation of code 871 // for a static function, iterate until no changes are made. 872 873 while (true) { 874 if (!DeferredVTables.empty()) { 875 EmitDeferredVTables(); 876 877 // Emitting a v-table doesn't directly cause more v-tables to 878 // become deferred, although it can cause functions to be 879 // emitted that then need those v-tables. 880 assert(DeferredVTables.empty()); 881 } 882 883 // Stop if we're out of both deferred v-tables and deferred declarations. 884 if (DeferredDeclsToEmit.empty()) break; 885 886 GlobalDecl D = DeferredDeclsToEmit.back(); 887 DeferredDeclsToEmit.pop_back(); 888 889 // Check to see if we've already emitted this. This is necessary 890 // for a couple of reasons: first, decls can end up in the 891 // deferred-decls queue multiple times, and second, decls can end 892 // up with definitions in unusual ways (e.g. by an extern inline 893 // function acquiring a strong function redefinition). Just 894 // ignore these cases. 895 // 896 // TODO: That said, looking this up multiple times is very wasteful. 897 StringRef Name = getMangledName(D); 898 llvm::GlobalValue *CGRef = GetGlobalValue(Name); 899 assert(CGRef && "Deferred decl wasn't referenced?"); 900 901 if (!CGRef->isDeclaration()) 902 continue; 903 904 // GlobalAlias::isDeclaration() defers to the aliasee, but for our 905 // purposes an alias counts as a definition. 906 if (isa<llvm::GlobalAlias>(CGRef)) 907 continue; 908 909 // Otherwise, emit the definition and move on to the next one. 910 EmitGlobalDefinition(D); 911 } 912} 913 914void CodeGenModule::EmitGlobalAnnotations() { 915 if (Annotations.empty()) 916 return; 917 918 // Create a new global variable for the ConstantStruct in the Module. 919 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( 920 Annotations[0]->getType(), Annotations.size()), Annotations); 921 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), 922 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, 923 "llvm.global.annotations"); 924 gv->setSection(AnnotationSection); 925} 926 927llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { 928 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str); 929 if (i != AnnotationStrings.end()) 930 return i->second; 931 932 // Not found yet, create a new global. 933 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); 934 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), 935 true, llvm::GlobalValue::PrivateLinkage, s, ".str"); 936 gv->setSection(AnnotationSection); 937 gv->setUnnamedAddr(true); 938 AnnotationStrings[Str] = gv; 939 return gv; 940} 941 942llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) { 943 SourceManager &SM = getContext().getSourceManager(); 944 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 945 if (PLoc.isValid()) 946 return EmitAnnotationString(PLoc.getFilename()); 947 return EmitAnnotationString(SM.getBufferName(Loc)); 948} 949 950llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) { 951 SourceManager &SM = getContext().getSourceManager(); 952 PresumedLoc PLoc = SM.getPresumedLoc(L); 953 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() : 954 SM.getExpansionLineNumber(L); 955 return llvm::ConstantInt::get(Int32Ty, LineNo); 956} 957 958llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 959 const AnnotateAttr *AA, 960 SourceLocation L) { 961 // Get the globals for file name, annotation, and the line number. 962 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()), 963 *UnitGV = EmitAnnotationUnit(L), 964 *LineNoCst = EmitAnnotationLineNo(L); 965 966 // Create the ConstantStruct for the global annotation. 967 llvm::Constant *Fields[4] = { 968 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy), 969 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy), 970 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy), 971 LineNoCst 972 }; 973 return llvm::ConstantStruct::getAnon(Fields); 974} 975 976void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, 977 llvm::GlobalValue *GV) { 978 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 979 // Get the struct elements for these annotations. 980 for (specific_attr_iterator<AnnotateAttr> 981 ai = D->specific_attr_begin<AnnotateAttr>(), 982 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 983 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation())); 984} 985 986bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 987 // Never defer when EmitAllDecls is specified. 988 if (LangOpts.EmitAllDecls) 989 return false; 990 991 return !getContext().DeclMustBeEmitted(Global); 992} 993 994llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor( 995 const CXXUuidofExpr* E) { 996 // Sema has verified that IIDSource has a __declspec(uuid()), and that its 997 // well-formed. 998 StringRef Uuid; 999 if (E->isTypeOperand()) 1000 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid(); 1001 else { 1002 // Special case: __uuidof(0) means an all-zero GUID. 1003 Expr *Op = E->getExprOperand(); 1004 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 1005 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid(); 1006 else 1007 Uuid = "00000000-0000-0000-0000-000000000000"; 1008 } 1009 std::string Name = "__uuid_" + Uuid.str(); 1010 1011 // Look for an existing global. 1012 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name)) 1013 return GV; 1014 1015 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType()); 1016 assert(Init && "failed to initialize as constant"); 1017 1018 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the 1019 // first field is declared as "long", which for many targets is 8 bytes. 1020 // Those architectures are not supported. (With the MS abi, long is always 4 1021 // bytes.) 1022 llvm::Type *GuidType = getTypes().ConvertType(E->getType()); 1023 if (Init->getType() != GuidType) { 1024 DiagnosticsEngine &Diags = getDiags(); 1025 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1026 "__uuidof codegen is not supported on this architecture"); 1027 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange(); 1028 Init = llvm::UndefValue::get(GuidType); 1029 } 1030 1031 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType, 1032 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name); 1033 GV->setUnnamedAddr(true); 1034 return GV; 1035} 1036 1037llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { 1038 const AliasAttr *AA = VD->getAttr<AliasAttr>(); 1039 assert(AA && "No alias?"); 1040 1041 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType()); 1042 1043 // See if there is already something with the target's name in the module. 1044 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee()); 1045 if (Entry) { 1046 unsigned AS = getContext().getTargetAddressSpace(VD->getType()); 1047 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS)); 1048 } 1049 1050 llvm::Constant *Aliasee; 1051 if (isa<llvm::FunctionType>(DeclTy)) 1052 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, 1053 GlobalDecl(cast<FunctionDecl>(VD)), 1054 /*ForVTable=*/false); 1055 else 1056 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 1057 llvm::PointerType::getUnqual(DeclTy), 0); 1058 1059 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); 1060 F->setLinkage(llvm::Function::ExternalWeakLinkage); 1061 WeakRefReferences.insert(F); 1062 1063 return Aliasee; 1064} 1065 1066void CodeGenModule::EmitGlobal(GlobalDecl GD) { 1067 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); 1068 1069 // Weak references don't produce any output by themselves. 1070 if (Global->hasAttr<WeakRefAttr>()) 1071 return; 1072 1073 // If this is an alias definition (which otherwise looks like a declaration) 1074 // emit it now. 1075 if (Global->hasAttr<AliasAttr>()) 1076 return EmitAliasDefinition(GD); 1077 1078 // If this is CUDA, be selective about which declarations we emit. 1079 if (LangOpts.CUDA) { 1080 if (CodeGenOpts.CUDAIsDevice) { 1081 if (!Global->hasAttr<CUDADeviceAttr>() && 1082 !Global->hasAttr<CUDAGlobalAttr>() && 1083 !Global->hasAttr<CUDAConstantAttr>() && 1084 !Global->hasAttr<CUDASharedAttr>()) 1085 return; 1086 } else { 1087 if (!Global->hasAttr<CUDAHostAttr>() && ( 1088 Global->hasAttr<CUDADeviceAttr>() || 1089 Global->hasAttr<CUDAConstantAttr>() || 1090 Global->hasAttr<CUDASharedAttr>())) 1091 return; 1092 } 1093 } 1094 1095 // Ignore declarations, they will be emitted on their first use. 1096 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 1097 // Forward declarations are emitted lazily on first use. 1098 if (!FD->doesThisDeclarationHaveABody()) { 1099 if (!FD->doesDeclarationForceExternallyVisibleDefinition()) 1100 return; 1101 1102 const FunctionDecl *InlineDefinition = 0; 1103 FD->getBody(InlineDefinition); 1104 1105 StringRef MangledName = getMangledName(GD); 1106 DeferredDecls.erase(MangledName); 1107 EmitGlobalDefinition(InlineDefinition); 1108 return; 1109 } 1110 } else { 1111 const VarDecl *VD = cast<VarDecl>(Global); 1112 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 1113 1114 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) 1115 return; 1116 } 1117 1118 // Defer code generation when possible if this is a static definition, inline 1119 // function etc. These we only want to emit if they are used. 1120 if (!MayDeferGeneration(Global)) { 1121 // Emit the definition if it can't be deferred. 1122 EmitGlobalDefinition(GD); 1123 return; 1124 } 1125 1126 // If we're deferring emission of a C++ variable with an 1127 // initializer, remember the order in which it appeared in the file. 1128 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && 1129 cast<VarDecl>(Global)->hasInit()) { 1130 DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); 1131 CXXGlobalInits.push_back(0); 1132 } 1133 1134 // If the value has already been used, add it directly to the 1135 // DeferredDeclsToEmit list. 1136 StringRef MangledName = getMangledName(GD); 1137 if (GetGlobalValue(MangledName)) 1138 DeferredDeclsToEmit.push_back(GD); 1139 else { 1140 // Otherwise, remember that we saw a deferred decl with this name. The 1141 // first use of the mangled name will cause it to move into 1142 // DeferredDeclsToEmit. 1143 DeferredDecls[MangledName] = GD; 1144 } 1145} 1146 1147namespace { 1148 struct FunctionIsDirectlyRecursive : 1149 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> { 1150 const StringRef Name; 1151 const Builtin::Context &BI; 1152 bool Result; 1153 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) : 1154 Name(N), BI(C), Result(false) { 1155 } 1156 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base; 1157 1158 bool TraverseCallExpr(CallExpr *E) { 1159 const FunctionDecl *FD = E->getDirectCallee(); 1160 if (!FD) 1161 return true; 1162 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1163 if (Attr && Name == Attr->getLabel()) { 1164 Result = true; 1165 return false; 1166 } 1167 unsigned BuiltinID = FD->getBuiltinID(); 1168 if (!BuiltinID) 1169 return true; 1170 StringRef BuiltinName = BI.GetName(BuiltinID); 1171 if (BuiltinName.startswith("__builtin_") && 1172 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) { 1173 Result = true; 1174 return false; 1175 } 1176 return true; 1177 } 1178 }; 1179} 1180 1181// isTriviallyRecursive - Check if this function calls another 1182// decl that, because of the asm attribute or the other decl being a builtin, 1183// ends up pointing to itself. 1184bool 1185CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) { 1186 StringRef Name; 1187 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) { 1188 // asm labels are a special kind of mangling we have to support. 1189 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>(); 1190 if (!Attr) 1191 return false; 1192 Name = Attr->getLabel(); 1193 } else { 1194 Name = FD->getName(); 1195 } 1196 1197 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo); 1198 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD)); 1199 return Walker.Result; 1200} 1201 1202bool 1203CodeGenModule::shouldEmitFunction(const FunctionDecl *F) { 1204 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage) 1205 return true; 1206 if (CodeGenOpts.OptimizationLevel == 0 && 1207 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>()) 1208 return false; 1209 // PR9614. Avoid cases where the source code is lying to us. An available 1210 // externally function should have an equivalent function somewhere else, 1211 // but a function that calls itself is clearly not equivalent to the real 1212 // implementation. 1213 // This happens in glibc's btowc and in some configure checks. 1214 return !isTriviallyRecursive(F); 1215} 1216 1217void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 1218 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 1219 1220 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), 1221 Context.getSourceManager(), 1222 "Generating code for declaration"); 1223 1224 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1225 // At -O0, don't generate IR for functions with available_externally 1226 // linkage. 1227 if (!shouldEmitFunction(Function)) 1228 return; 1229 1230 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 1231 // Make sure to emit the definition(s) before we emit the thunks. 1232 // This is necessary for the generation of certain thunks. 1233 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) 1234 EmitCXXConstructor(CD, GD.getCtorType()); 1235 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method)) 1236 EmitCXXDestructor(DD, GD.getDtorType()); 1237 else 1238 EmitGlobalFunctionDefinition(GD); 1239 1240 if (Method->isVirtual()) 1241 getVTables().EmitThunks(GD); 1242 1243 return; 1244 } 1245 1246 return EmitGlobalFunctionDefinition(GD); 1247 } 1248 1249 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 1250 return EmitGlobalVarDefinition(VD); 1251 1252 llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); 1253} 1254 1255/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 1256/// module, create and return an llvm Function with the specified type. If there 1257/// is something in the module with the specified name, return it potentially 1258/// bitcasted to the right type. 1259/// 1260/// If D is non-null, it specifies a decl that correspond to this. This is used 1261/// to set the attributes on the function when it is first created. 1262llvm::Constant * 1263CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, 1264 llvm::Type *Ty, 1265 GlobalDecl D, bool ForVTable, 1266 llvm::AttributeSet ExtraAttrs) { 1267 // Lookup the entry, lazily creating it if necessary. 1268 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1269 if (Entry) { 1270 if (WeakRefReferences.erase(Entry)) { 1271 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl()); 1272 if (FD && !FD->hasAttr<WeakAttr>()) 1273 Entry->setLinkage(llvm::Function::ExternalLinkage); 1274 } 1275 1276 if (Entry->getType()->getElementType() == Ty) 1277 return Entry; 1278 1279 // Make sure the result is of the correct type. 1280 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); 1281 } 1282 1283 // This function doesn't have a complete type (for example, the return 1284 // type is an incomplete struct). Use a fake type instead, and make 1285 // sure not to try to set attributes. 1286 bool IsIncompleteFunction = false; 1287 1288 llvm::FunctionType *FTy; 1289 if (isa<llvm::FunctionType>(Ty)) { 1290 FTy = cast<llvm::FunctionType>(Ty); 1291 } else { 1292 FTy = llvm::FunctionType::get(VoidTy, false); 1293 IsIncompleteFunction = true; 1294 } 1295 1296 llvm::Function *F = llvm::Function::Create(FTy, 1297 llvm::Function::ExternalLinkage, 1298 MangledName, &getModule()); 1299 assert(F->getName() == MangledName && "name was uniqued!"); 1300 if (D.getDecl()) 1301 SetFunctionAttributes(D, F, IsIncompleteFunction); 1302 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) { 1303 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex); 1304 F->addAttributes(llvm::AttributeSet::FunctionIndex, 1305 llvm::AttributeSet::get(VMContext, 1306 llvm::AttributeSet::FunctionIndex, 1307 B)); 1308 } 1309 1310 // This is the first use or definition of a mangled name. If there is a 1311 // deferred decl with this name, remember that we need to emit it at the end 1312 // of the file. 1313 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1314 if (DDI != DeferredDecls.end()) { 1315 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1316 // list, and remove it from DeferredDecls (since we don't need it anymore). 1317 DeferredDeclsToEmit.push_back(DDI->second); 1318 DeferredDecls.erase(DDI); 1319 1320 // Otherwise, there are cases we have to worry about where we're 1321 // using a declaration for which we must emit a definition but where 1322 // we might not find a top-level definition: 1323 // - member functions defined inline in their classes 1324 // - friend functions defined inline in some class 1325 // - special member functions with implicit definitions 1326 // If we ever change our AST traversal to walk into class methods, 1327 // this will be unnecessary. 1328 // 1329 // We also don't emit a definition for a function if it's going to be an entry 1330 // in a vtable, unless it's already marked as used. 1331 } else if (getLangOpts().CPlusPlus && D.getDecl()) { 1332 // Look for a declaration that's lexically in a record. 1333 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl()); 1334 FD = FD->getMostRecentDecl(); 1335 do { 1336 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { 1337 if (FD->isImplicit() && !ForVTable) { 1338 assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); 1339 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1340 break; 1341 } else if (FD->doesThisDeclarationHaveABody()) { 1342 DeferredDeclsToEmit.push_back(D.getWithDecl(FD)); 1343 break; 1344 } 1345 } 1346 FD = FD->getPreviousDecl(); 1347 } while (FD); 1348 } 1349 1350 // Make sure the result is of the requested type. 1351 if (!IsIncompleteFunction) { 1352 assert(F->getType()->getElementType() == Ty); 1353 return F; 1354 } 1355 1356 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 1357 return llvm::ConstantExpr::getBitCast(F, PTy); 1358} 1359 1360/// GetAddrOfFunction - Return the address of the given function. If Ty is 1361/// non-null, then this function will use the specified type if it has to 1362/// create it (this occurs when we see a definition of the function). 1363llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 1364 llvm::Type *Ty, 1365 bool ForVTable) { 1366 // If there was no specific requested type, just convert it now. 1367 if (!Ty) 1368 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); 1369 1370 StringRef MangledName = getMangledName(GD); 1371 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); 1372} 1373 1374/// CreateRuntimeFunction - Create a new runtime function with the specified 1375/// type and name. 1376llvm::Constant * 1377CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, 1378 StringRef Name, 1379 llvm::AttributeSet ExtraAttrs) { 1380 llvm::Constant *C 1381 = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, 1382 ExtraAttrs); 1383 if (llvm::Function *F = dyn_cast<llvm::Function>(C)) 1384 if (F->empty()) 1385 F->setCallingConv(getRuntimeCC()); 1386 return C; 1387} 1388 1389/// isTypeConstant - Determine whether an object of this type can be emitted 1390/// as a constant. 1391/// 1392/// If ExcludeCtor is true, the duration when the object's constructor runs 1393/// will not be considered. The caller will need to verify that the object is 1394/// not written to during its construction. 1395bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { 1396 if (!Ty.isConstant(Context) && !Ty->isReferenceType()) 1397 return false; 1398 1399 if (Context.getLangOpts().CPlusPlus) { 1400 if (const CXXRecordDecl *Record 1401 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl()) 1402 return ExcludeCtor && !Record->hasMutableFields() && 1403 Record->hasTrivialDestructor(); 1404 } 1405 1406 return true; 1407} 1408 1409/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 1410/// create and return an llvm GlobalVariable with the specified type. If there 1411/// is something in the module with the specified name, return it potentially 1412/// bitcasted to the right type. 1413/// 1414/// If D is non-null, it specifies a decl that correspond to this. This is used 1415/// to set the attributes on the global when it is first created. 1416llvm::Constant * 1417CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, 1418 llvm::PointerType *Ty, 1419 const VarDecl *D, 1420 bool UnnamedAddr) { 1421 // Lookup the entry, lazily creating it if necessary. 1422 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 1423 if (Entry) { 1424 if (WeakRefReferences.erase(Entry)) { 1425 if (D && !D->hasAttr<WeakAttr>()) 1426 Entry->setLinkage(llvm::Function::ExternalLinkage); 1427 } 1428 1429 if (UnnamedAddr) 1430 Entry->setUnnamedAddr(true); 1431 1432 if (Entry->getType() == Ty) 1433 return Entry; 1434 1435 // Make sure the result is of the correct type. 1436 return llvm::ConstantExpr::getBitCast(Entry, Ty); 1437 } 1438 1439 // This is the first use or definition of a mangled name. If there is a 1440 // deferred decl with this name, remember that we need to emit it at the end 1441 // of the file. 1442 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); 1443 if (DDI != DeferredDecls.end()) { 1444 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 1445 // list, and remove it from DeferredDecls (since we don't need it anymore). 1446 DeferredDeclsToEmit.push_back(DDI->second); 1447 DeferredDecls.erase(DDI); 1448 } 1449 1450 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); 1451 llvm::GlobalVariable *GV = 1452 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 1453 llvm::GlobalValue::ExternalLinkage, 1454 0, MangledName, 0, 1455 llvm::GlobalVariable::NotThreadLocal, AddrSpace); 1456 1457 // Handle things which are present even on external declarations. 1458 if (D) { 1459 // FIXME: This code is overly simple and should be merged with other global 1460 // handling. 1461 GV->setConstant(isTypeConstant(D->getType(), false)); 1462 1463 // Set linkage and visibility in case we never see a definition. 1464 LinkageInfo LV = D->getLinkageAndVisibility(); 1465 if (LV.getLinkage() != ExternalLinkage) { 1466 // Don't set internal linkage on declarations. 1467 } else { 1468 if (D->hasAttr<DLLImportAttr>()) 1469 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); 1470 else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) 1471 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 1472 1473 // Set visibility on a declaration only if it's explicit. 1474 if (LV.isVisibilityExplicit()) 1475 GV->setVisibility(GetLLVMVisibility(LV.getVisibility())); 1476 } 1477 1478 if (D->isThreadSpecified()) 1479 setTLSMode(GV, *D); 1480 } 1481 1482 if (AddrSpace != Ty->getAddressSpace()) 1483 return llvm::ConstantExpr::getBitCast(GV, Ty); 1484 else 1485 return GV; 1486} 1487 1488 1489llvm::GlobalVariable * 1490CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, 1491 llvm::Type *Ty, 1492 llvm::GlobalValue::LinkageTypes Linkage) { 1493 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); 1494 llvm::GlobalVariable *OldGV = 0; 1495 1496 1497 if (GV) { 1498 // Check if the variable has the right type. 1499 if (GV->getType()->getElementType() == Ty) 1500 return GV; 1501 1502 // Because C++ name mangling, the only way we can end up with an already 1503 // existing global with the same name is if it has been declared extern "C". 1504 assert(GV->isDeclaration() && "Declaration has wrong type!"); 1505 OldGV = GV; 1506 } 1507 1508 // Create a new variable. 1509 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, 1510 Linkage, 0, Name); 1511 1512 if (OldGV) { 1513 // Replace occurrences of the old variable if needed. 1514 GV->takeName(OldGV); 1515 1516 if (!OldGV->use_empty()) { 1517 llvm::Constant *NewPtrForOldDecl = 1518 llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); 1519 OldGV->replaceAllUsesWith(NewPtrForOldDecl); 1520 } 1521 1522 OldGV->eraseFromParent(); 1523 } 1524 1525 return GV; 1526} 1527 1528/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 1529/// given global variable. If Ty is non-null and if the global doesn't exist, 1530/// then it will be created with the specified type instead of whatever the 1531/// normal requested type would be. 1532llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 1533 llvm::Type *Ty) { 1534 assert(D->hasGlobalStorage() && "Not a global variable"); 1535 QualType ASTTy = D->getType(); 1536 if (Ty == 0) 1537 Ty = getTypes().ConvertTypeForMem(ASTTy); 1538 1539 llvm::PointerType *PTy = 1540 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); 1541 1542 StringRef MangledName = getMangledName(D); 1543 return GetOrCreateLLVMGlobal(MangledName, PTy, D); 1544} 1545 1546/// CreateRuntimeVariable - Create a new runtime global variable with the 1547/// specified type and name. 1548llvm::Constant * 1549CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, 1550 StringRef Name) { 1551 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, 1552 true); 1553} 1554 1555void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 1556 assert(!D->getInit() && "Cannot emit definite definitions here!"); 1557 1558 if (MayDeferGeneration(D)) { 1559 // If we have not seen a reference to this variable yet, place it 1560 // into the deferred declarations table to be emitted if needed 1561 // later. 1562 StringRef MangledName = getMangledName(D); 1563 if (!GetGlobalValue(MangledName)) { 1564 DeferredDecls[MangledName] = D; 1565 return; 1566 } 1567 } 1568 1569 // The tentative definition is the only definition. 1570 EmitGlobalVarDefinition(D); 1571} 1572 1573CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const { 1574 return Context.toCharUnitsFromBits( 1575 TheDataLayout.getTypeStoreSizeInBits(Ty)); 1576} 1577 1578llvm::Constant * 1579CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D, 1580 const Expr *rawInit) { 1581 ArrayRef<ExprWithCleanups::CleanupObject> cleanups; 1582 if (const ExprWithCleanups *withCleanups = 1583 dyn_cast<ExprWithCleanups>(rawInit)) { 1584 cleanups = withCleanups->getObjects(); 1585 rawInit = withCleanups->getSubExpr(); 1586 } 1587 1588 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit); 1589 if (!init || !init->initializesStdInitializerList() || 1590 init->getNumInits() == 0) 1591 return 0; 1592 1593 ASTContext &ctx = getContext(); 1594 unsigned numInits = init->getNumInits(); 1595 // FIXME: This check is here because we would otherwise silently miscompile 1596 // nested global std::initializer_lists. Better would be to have a real 1597 // implementation. 1598 for (unsigned i = 0; i < numInits; ++i) { 1599 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i)); 1600 if (inner && inner->initializesStdInitializerList()) { 1601 ErrorUnsupported(inner, "nested global std::initializer_list"); 1602 return 0; 1603 } 1604 } 1605 1606 // Synthesize a fake VarDecl for the array and initialize that. 1607 QualType elementType = init->getInit(0)->getType(); 1608 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits); 1609 QualType arrayType = ctx.getConstantArrayType(elementType, numElements, 1610 ArrayType::Normal, 0); 1611 1612 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist"); 1613 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo( 1614 arrayType, D->getLocation()); 1615 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>( 1616 D->getDeclContext()), 1617 D->getLocStart(), D->getLocation(), 1618 name, arrayType, sourceInfo, 1619 SC_Static); 1620 1621 // Now clone the InitListExpr to initialize the array instead. 1622 // Incredible hack: we want to use the existing InitListExpr here, so we need 1623 // to tell it that it no longer initializes a std::initializer_list. 1624 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(), 1625 init->getNumInits()); 1626 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits, 1627 init->getRBraceLoc()); 1628 arrayInit->setType(arrayType); 1629 1630 if (!cleanups.empty()) 1631 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups); 1632 1633 backingArray->setInit(arrayInit); 1634 1635 // Emit the definition of the array. 1636 EmitGlobalVarDefinition(backingArray); 1637 1638 // Inspect the initializer list to validate it and determine its type. 1639 // FIXME: doing this every time is probably inefficient; caching would be nice 1640 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl(); 1641 RecordDecl::field_iterator field = record->field_begin(); 1642 if (field == record->field_end()) { 1643 ErrorUnsupported(D, "weird std::initializer_list"); 1644 return 0; 1645 } 1646 QualType elementPtr = ctx.getPointerType(elementType.withConst()); 1647 // Start pointer. 1648 if (!ctx.hasSameType(field->getType(), elementPtr)) { 1649 ErrorUnsupported(D, "weird std::initializer_list"); 1650 return 0; 1651 } 1652 ++field; 1653 if (field == record->field_end()) { 1654 ErrorUnsupported(D, "weird std::initializer_list"); 1655 return 0; 1656 } 1657 bool isStartEnd = false; 1658 if (ctx.hasSameType(field->getType(), elementPtr)) { 1659 // End pointer. 1660 isStartEnd = true; 1661 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) { 1662 ErrorUnsupported(D, "weird std::initializer_list"); 1663 return 0; 1664 } 1665 1666 // Now build an APValue representing the std::initializer_list. 1667 APValue initListValue(APValue::UninitStruct(), 0, 2); 1668 APValue &startField = initListValue.getStructField(0); 1669 APValue::LValuePathEntry startOffsetPathEntry; 1670 startOffsetPathEntry.ArrayIndex = 0; 1671 startField = APValue(APValue::LValueBase(backingArray), 1672 CharUnits::fromQuantity(0), 1673 llvm::makeArrayRef(startOffsetPathEntry), 1674 /*IsOnePastTheEnd=*/false, 0); 1675 1676 if (isStartEnd) { 1677 APValue &endField = initListValue.getStructField(1); 1678 APValue::LValuePathEntry endOffsetPathEntry; 1679 endOffsetPathEntry.ArrayIndex = numInits; 1680 endField = APValue(APValue::LValueBase(backingArray), 1681 ctx.getTypeSizeInChars(elementType) * numInits, 1682 llvm::makeArrayRef(endOffsetPathEntry), 1683 /*IsOnePastTheEnd=*/true, 0); 1684 } else { 1685 APValue &sizeField = initListValue.getStructField(1); 1686 sizeField = APValue(llvm::APSInt(numElements)); 1687 } 1688 1689 // Emit the constant for the initializer_list. 1690 llvm::Constant *llvmInit = 1691 EmitConstantValueForMemory(initListValue, D->getType()); 1692 assert(llvmInit && "failed to initialize as constant"); 1693 return llvmInit; 1694} 1695 1696unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D, 1697 unsigned AddrSpace) { 1698 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) { 1699 if (D->hasAttr<CUDAConstantAttr>()) 1700 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant); 1701 else if (D->hasAttr<CUDASharedAttr>()) 1702 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared); 1703 else 1704 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device); 1705 } 1706 1707 return AddrSpace; 1708} 1709 1710void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 1711 llvm::Constant *Init = 0; 1712 QualType ASTTy = D->getType(); 1713 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 1714 bool NeedsGlobalCtor = false; 1715 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor(); 1716 1717 const VarDecl *InitDecl; 1718 const Expr *InitExpr = D->getAnyInitializer(InitDecl); 1719 1720 if (!InitExpr) { 1721 // This is a tentative definition; tentative definitions are 1722 // implicitly initialized with { 0 }. 1723 // 1724 // Note that tentative definitions are only emitted at the end of 1725 // a translation unit, so they should never have incomplete 1726 // type. In addition, EmitTentativeDefinition makes sure that we 1727 // never attempt to emit a tentative definition if a real one 1728 // exists. A use may still exists, however, so we still may need 1729 // to do a RAUW. 1730 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 1731 Init = EmitNullConstant(D->getType()); 1732 } else { 1733 // If this is a std::initializer_list, emit the special initializer. 1734 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr); 1735 // An empty init list will perform zero-initialization, which happens 1736 // to be exactly what we want. 1737 // FIXME: It does so in a global constructor, which is *not* what we 1738 // want. 1739 1740 if (!Init) { 1741 initializedGlobalDecl = GlobalDecl(D); 1742 Init = EmitConstantInit(*InitDecl); 1743 } 1744 if (!Init) { 1745 QualType T = InitExpr->getType(); 1746 if (D->getType()->isReferenceType()) 1747 T = D->getType(); 1748 1749 if (getLangOpts().CPlusPlus) { 1750 Init = EmitNullConstant(T); 1751 NeedsGlobalCtor = true; 1752 } else { 1753 ErrorUnsupported(D, "static initializer"); 1754 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 1755 } 1756 } else { 1757 // We don't need an initializer, so remove the entry for the delayed 1758 // initializer position (just in case this entry was delayed) if we 1759 // also don't need to register a destructor. 1760 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor) 1761 DelayedCXXInitPosition.erase(D); 1762 } 1763 } 1764 1765 llvm::Type* InitType = Init->getType(); 1766 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 1767 1768 // Strip off a bitcast if we got one back. 1769 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1770 assert(CE->getOpcode() == llvm::Instruction::BitCast || 1771 // all zero index gep. 1772 CE->getOpcode() == llvm::Instruction::GetElementPtr); 1773 Entry = CE->getOperand(0); 1774 } 1775 1776 // Entry is now either a Function or GlobalVariable. 1777 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 1778 1779 // We have a definition after a declaration with the wrong type. 1780 // We must make a new GlobalVariable* and update everything that used OldGV 1781 // (a declaration or tentative definition) with the new GlobalVariable* 1782 // (which will be a definition). 1783 // 1784 // This happens if there is a prototype for a global (e.g. 1785 // "extern int x[];") and then a definition of a different type (e.g. 1786 // "int x[10];"). This also happens when an initializer has a different type 1787 // from the type of the global (this happens with unions). 1788 if (GV == 0 || 1789 GV->getType()->getElementType() != InitType || 1790 GV->getType()->getAddressSpace() != 1791 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) { 1792 1793 // Move the old entry aside so that we'll create a new one. 1794 Entry->setName(StringRef()); 1795 1796 // Make a new global with the correct type, this is now guaranteed to work. 1797 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 1798 1799 // Replace all uses of the old global with the new global 1800 llvm::Constant *NewPtrForOldDecl = 1801 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1802 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1803 1804 // Erase the old global, since it is no longer used. 1805 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1806 } 1807 1808 if (D->hasAttr<AnnotateAttr>()) 1809 AddGlobalAnnotations(D, GV); 1810 1811 GV->setInitializer(Init); 1812 1813 // If it is safe to mark the global 'constant', do so now. 1814 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor && 1815 isTypeConstant(D->getType(), true)); 1816 1817 GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); 1818 1819 // Set the llvm linkage type as appropriate. 1820 llvm::GlobalValue::LinkageTypes Linkage = 1821 GetLLVMLinkageVarDefinition(D, GV); 1822 GV->setLinkage(Linkage); 1823 if (Linkage == llvm::GlobalVariable::CommonLinkage) 1824 // common vars aren't constant even if declared const. 1825 GV->setConstant(false); 1826 1827 SetCommonAttributes(D, GV); 1828 1829 // Emit the initializer function if necessary. 1830 if (NeedsGlobalCtor || NeedsGlobalDtor) 1831 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); 1832 1833 // If we are compiling with ASan, add metadata indicating dynamically 1834 // initialized globals. 1835 if (SanOpts.Address && NeedsGlobalCtor) { 1836 llvm::Module &M = getModule(); 1837 1838 llvm::NamedMDNode *DynamicInitializers = 1839 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals"); 1840 llvm::Value *GlobalToAdd[] = { GV }; 1841 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd); 1842 DynamicInitializers->addOperand(ThisGlobal); 1843 } 1844 1845 // Emit global variable debug information. 1846 if (CGDebugInfo *DI = getModuleDebugInfo()) 1847 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 1848 DI->EmitGlobalVariable(GV, D); 1849} 1850 1851llvm::GlobalValue::LinkageTypes 1852CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, 1853 llvm::GlobalVariable *GV) { 1854 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); 1855 if (Linkage == GVA_Internal) 1856 return llvm::Function::InternalLinkage; 1857 else if (D->hasAttr<DLLImportAttr>()) 1858 return llvm::Function::DLLImportLinkage; 1859 else if (D->hasAttr<DLLExportAttr>()) 1860 return llvm::Function::DLLExportLinkage; 1861 else if (D->hasAttr<WeakAttr>()) { 1862 if (GV->isConstant()) 1863 return llvm::GlobalVariable::WeakODRLinkage; 1864 else 1865 return llvm::GlobalVariable::WeakAnyLinkage; 1866 } else if (Linkage == GVA_TemplateInstantiation || 1867 Linkage == GVA_ExplicitTemplateInstantiation) 1868 return llvm::GlobalVariable::WeakODRLinkage; 1869 else if (!getLangOpts().CPlusPlus && 1870 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || 1871 D->getAttr<CommonAttr>()) && 1872 !D->hasExternalStorage() && !D->getInit() && 1873 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() && 1874 !D->getAttr<WeakImportAttr>()) { 1875 // Thread local vars aren't considered common linkage. 1876 return llvm::GlobalVariable::CommonLinkage; 1877 } 1878 return llvm::GlobalVariable::ExternalLinkage; 1879} 1880 1881/// Replace the uses of a function that was declared with a non-proto type. 1882/// We want to silently drop extra arguments from call sites 1883static void replaceUsesOfNonProtoConstant(llvm::Constant *old, 1884 llvm::Function *newFn) { 1885 // Fast path. 1886 if (old->use_empty()) return; 1887 1888 llvm::Type *newRetTy = newFn->getReturnType(); 1889 SmallVector<llvm::Value*, 4> newArgs; 1890 1891 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end(); 1892 ui != ue; ) { 1893 llvm::Value::use_iterator use = ui++; // Increment before the use is erased. 1894 llvm::User *user = *use; 1895 1896 // Recognize and replace uses of bitcasts. Most calls to 1897 // unprototyped functions will use bitcasts. 1898 if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) { 1899 if (bitcast->getOpcode() == llvm::Instruction::BitCast) 1900 replaceUsesOfNonProtoConstant(bitcast, newFn); 1901 continue; 1902 } 1903 1904 // Recognize calls to the function. 1905 llvm::CallSite callSite(user); 1906 if (!callSite) continue; 1907 if (!callSite.isCallee(use)) continue; 1908 1909 // If the return types don't match exactly, then we can't 1910 // transform this call unless it's dead. 1911 if (callSite->getType() != newRetTy && !callSite->use_empty()) 1912 continue; 1913 1914 // Get the call site's attribute list. 1915 SmallVector<llvm::AttributeSet, 8> newAttrs; 1916 llvm::AttributeSet oldAttrs = callSite.getAttributes(); 1917 1918 // Collect any return attributes from the call. 1919 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex)) 1920 newAttrs.push_back( 1921 llvm::AttributeSet::get(newFn->getContext(), 1922 oldAttrs.getRetAttributes())); 1923 1924 // If the function was passed too few arguments, don't transform. 1925 unsigned newNumArgs = newFn->arg_size(); 1926 if (callSite.arg_size() < newNumArgs) continue; 1927 1928 // If extra arguments were passed, we silently drop them. 1929 // If any of the types mismatch, we don't transform. 1930 unsigned argNo = 0; 1931 bool dontTransform = false; 1932 for (llvm::Function::arg_iterator ai = newFn->arg_begin(), 1933 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) { 1934 if (callSite.getArgument(argNo)->getType() != ai->getType()) { 1935 dontTransform = true; 1936 break; 1937 } 1938 1939 // Add any parameter attributes. 1940 if (oldAttrs.hasAttributes(argNo + 1)) 1941 newAttrs. 1942 push_back(llvm:: 1943 AttributeSet::get(newFn->getContext(), 1944 oldAttrs.getParamAttributes(argNo + 1))); 1945 } 1946 if (dontTransform) 1947 continue; 1948 1949 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) 1950 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(), 1951 oldAttrs.getFnAttributes())); 1952 1953 // Okay, we can transform this. Create the new call instruction and copy 1954 // over the required information. 1955 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo); 1956 1957 llvm::CallSite newCall; 1958 if (callSite.isCall()) { 1959 newCall = llvm::CallInst::Create(newFn, newArgs, "", 1960 callSite.getInstruction()); 1961 } else { 1962 llvm::InvokeInst *oldInvoke = 1963 cast<llvm::InvokeInst>(callSite.getInstruction()); 1964 newCall = llvm::InvokeInst::Create(newFn, 1965 oldInvoke->getNormalDest(), 1966 oldInvoke->getUnwindDest(), 1967 newArgs, "", 1968 callSite.getInstruction()); 1969 } 1970 newArgs.clear(); // for the next iteration 1971 1972 if (!newCall->getType()->isVoidTy()) 1973 newCall->takeName(callSite.getInstruction()); 1974 newCall.setAttributes( 1975 llvm::AttributeSet::get(newFn->getContext(), newAttrs)); 1976 newCall.setCallingConv(callSite.getCallingConv()); 1977 1978 // Finally, remove the old call, replacing any uses with the new one. 1979 if (!callSite->use_empty()) 1980 callSite->replaceAllUsesWith(newCall.getInstruction()); 1981 1982 // Copy debug location attached to CI. 1983 if (!callSite->getDebugLoc().isUnknown()) 1984 newCall->setDebugLoc(callSite->getDebugLoc()); 1985 callSite->eraseFromParent(); 1986 } 1987} 1988 1989/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1990/// implement a function with no prototype, e.g. "int foo() {}". If there are 1991/// existing call uses of the old function in the module, this adjusts them to 1992/// call the new function directly. 1993/// 1994/// This is not just a cleanup: the always_inline pass requires direct calls to 1995/// functions to be able to inline them. If there is a bitcast in the way, it 1996/// won't inline them. Instcombine normally deletes these calls, but it isn't 1997/// run at -O0. 1998static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1999 llvm::Function *NewFn) { 2000 // If we're redefining a global as a function, don't transform it. 2001 if (!isa<llvm::Function>(Old)) return; 2002 2003 replaceUsesOfNonProtoConstant(Old, NewFn); 2004} 2005 2006void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 2007 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind(); 2008 // If we have a definition, this might be a deferred decl. If the 2009 // instantiation is explicit, make sure we emit it at the end. 2010 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition) 2011 GetAddrOfGlobalVar(VD); 2012 2013 EmitTopLevelDecl(VD); 2014} 2015 2016void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 2017 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 2018 2019 // Compute the function info and LLVM type. 2020 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); 2021 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); 2022 2023 // Get or create the prototype for the function. 2024 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 2025 2026 // Strip off a bitcast if we got one back. 2027 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 2028 assert(CE->getOpcode() == llvm::Instruction::BitCast); 2029 Entry = CE->getOperand(0); 2030 } 2031 2032 2033 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 2034 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 2035 2036 // If the types mismatch then we have to rewrite the definition. 2037 assert(OldFn->isDeclaration() && 2038 "Shouldn't replace non-declaration"); 2039 2040 // F is the Function* for the one with the wrong type, we must make a new 2041 // Function* and update everything that used F (a declaration) with the new 2042 // Function* (which will be a definition). 2043 // 2044 // This happens if there is a prototype for a function 2045 // (e.g. "int f()") and then a definition of a different type 2046 // (e.g. "int f(int x)"). Move the old function aside so that it 2047 // doesn't interfere with GetAddrOfFunction. 2048 OldFn->setName(StringRef()); 2049 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 2050 2051 // This might be an implementation of a function without a 2052 // prototype, in which case, try to do special replacement of 2053 // calls which match the new prototype. The really key thing here 2054 // is that we also potentially drop arguments from the call site 2055 // so as to make a direct call, which makes the inliner happier 2056 // and suppresses a number of optimizer warnings (!) about 2057 // dropping arguments. 2058 if (!OldFn->use_empty()) { 2059 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 2060 OldFn->removeDeadConstantUsers(); 2061 } 2062 2063 // Replace uses of F with the Function we will endow with a body. 2064 if (!Entry->use_empty()) { 2065 llvm::Constant *NewPtrForOldDecl = 2066 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 2067 Entry->replaceAllUsesWith(NewPtrForOldDecl); 2068 } 2069 2070 // Ok, delete the old function now, which is dead. 2071 OldFn->eraseFromParent(); 2072 2073 Entry = NewFn; 2074 } 2075 2076 // We need to set linkage and visibility on the function before 2077 // generating code for it because various parts of IR generation 2078 // want to propagate this information down (e.g. to local static 2079 // declarations). 2080 llvm::Function *Fn = cast<llvm::Function>(Entry); 2081 setFunctionLinkage(D, Fn); 2082 2083 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes 2084 setGlobalVisibility(Fn, D); 2085 2086 CodeGenFunction(*this).GenerateCode(D, Fn, FI); 2087 2088 SetFunctionDefinitionAttributes(D, Fn); 2089 SetLLVMFunctionAttributesForDefinition(D, Fn); 2090 2091 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 2092 AddGlobalCtor(Fn, CA->getPriority()); 2093 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 2094 AddGlobalDtor(Fn, DA->getPriority()); 2095 if (D->hasAttr<AnnotateAttr>()) 2096 AddGlobalAnnotations(D, Fn); 2097} 2098 2099void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { 2100 const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); 2101 const AliasAttr *AA = D->getAttr<AliasAttr>(); 2102 assert(AA && "Not an alias?"); 2103 2104 StringRef MangledName = getMangledName(GD); 2105 2106 // If there is a definition in the module, then it wins over the alias. 2107 // This is dubious, but allow it to be safe. Just ignore the alias. 2108 llvm::GlobalValue *Entry = GetGlobalValue(MangledName); 2109 if (Entry && !Entry->isDeclaration()) 2110 return; 2111 2112 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 2113 2114 // Create a reference to the named value. This ensures that it is emitted 2115 // if a deferred decl. 2116 llvm::Constant *Aliasee; 2117 if (isa<llvm::FunctionType>(DeclTy)) 2118 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD, 2119 /*ForVTable=*/false); 2120 else 2121 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), 2122 llvm::PointerType::getUnqual(DeclTy), 0); 2123 2124 // Create the new alias itself, but don't set a name yet. 2125 llvm::GlobalValue *GA = 2126 new llvm::GlobalAlias(Aliasee->getType(), 2127 llvm::Function::ExternalLinkage, 2128 "", Aliasee, &getModule()); 2129 2130 if (Entry) { 2131 assert(Entry->isDeclaration()); 2132 2133 // If there is a declaration in the module, then we had an extern followed 2134 // by the alias, as in: 2135 // extern int test6(); 2136 // ... 2137 // int test6() __attribute__((alias("test7"))); 2138 // 2139 // Remove it and replace uses of it with the alias. 2140 GA->takeName(Entry); 2141 2142 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 2143 Entry->getType())); 2144 Entry->eraseFromParent(); 2145 } else { 2146 GA->setName(MangledName); 2147 } 2148 2149 // Set attributes which are particular to an alias; this is a 2150 // specialization of the attributes which may be set on a global 2151 // variable/function. 2152 if (D->hasAttr<DLLExportAttr>()) { 2153 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2154 // The dllexport attribute is ignored for undefined symbols. 2155 if (FD->hasBody()) 2156 GA->setLinkage(llvm::Function::DLLExportLinkage); 2157 } else { 2158 GA->setLinkage(llvm::Function::DLLExportLinkage); 2159 } 2160 } else if (D->hasAttr<WeakAttr>() || 2161 D->hasAttr<WeakRefAttr>() || 2162 D->isWeakImported()) { 2163 GA->setLinkage(llvm::Function::WeakAnyLinkage); 2164 } 2165 2166 SetCommonAttributes(D, GA); 2167} 2168 2169llvm::Function *CodeGenModule::getIntrinsic(unsigned IID, 2170 ArrayRef<llvm::Type*> Tys) { 2171 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID, 2172 Tys); 2173} 2174 2175static llvm::StringMapEntry<llvm::Constant*> & 2176GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2177 const StringLiteral *Literal, 2178 bool TargetIsLSB, 2179 bool &IsUTF16, 2180 unsigned &StringLength) { 2181 StringRef String = Literal->getString(); 2182 unsigned NumBytes = String.size(); 2183 2184 // Check for simple case. 2185 if (!Literal->containsNonAsciiOrNull()) { 2186 StringLength = NumBytes; 2187 return Map.GetOrCreateValue(String); 2188 } 2189 2190 // Otherwise, convert the UTF8 literals into a string of shorts. 2191 IsUTF16 = true; 2192 2193 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls. 2194 const UTF8 *FromPtr = (const UTF8 *)String.data(); 2195 UTF16 *ToPtr = &ToBuf[0]; 2196 2197 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 2198 &ToPtr, ToPtr + NumBytes, 2199 strictConversion); 2200 2201 // ConvertUTF8toUTF16 returns the length in ToPtr. 2202 StringLength = ToPtr - &ToBuf[0]; 2203 2204 // Add an explicit null. 2205 *ToPtr = 0; 2206 return Map. 2207 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()), 2208 (StringLength + 1) * 2)); 2209} 2210 2211static llvm::StringMapEntry<llvm::Constant*> & 2212GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map, 2213 const StringLiteral *Literal, 2214 unsigned &StringLength) { 2215 StringRef String = Literal->getString(); 2216 StringLength = String.size(); 2217 return Map.GetOrCreateValue(String); 2218} 2219 2220llvm::Constant * 2221CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 2222 unsigned StringLength = 0; 2223 bool isUTF16 = false; 2224 llvm::StringMapEntry<llvm::Constant*> &Entry = 2225 GetConstantCFStringEntry(CFConstantStringMap, Literal, 2226 getDataLayout().isLittleEndian(), 2227 isUTF16, StringLength); 2228 2229 if (llvm::Constant *C = Entry.getValue()) 2230 return C; 2231 2232 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2233 llvm::Constant *Zeros[] = { Zero, Zero }; 2234 2235 // If we don't already have it, get __CFConstantStringClassReference. 2236 if (!CFConstantStringClassRef) { 2237 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2238 Ty = llvm::ArrayType::get(Ty, 0); 2239 llvm::Constant *GV = CreateRuntimeVariable(Ty, 2240 "__CFConstantStringClassReference"); 2241 // Decay array -> ptr 2242 CFConstantStringClassRef = 2243 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2244 } 2245 2246 QualType CFTy = getContext().getCFConstantStringType(); 2247 2248 llvm::StructType *STy = 2249 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 2250 2251 llvm::Constant *Fields[4]; 2252 2253 // Class pointer. 2254 Fields[0] = CFConstantStringClassRef; 2255 2256 // Flags. 2257 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2258 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 2259 llvm::ConstantInt::get(Ty, 0x07C8); 2260 2261 // String pointer. 2262 llvm::Constant *C = 0; 2263 if (isUTF16) { 2264 ArrayRef<uint16_t> Arr = 2265 llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>( 2266 const_cast<char *>(Entry.getKey().data())), 2267 Entry.getKey().size() / 2); 2268 C = llvm::ConstantDataArray::get(VMContext, Arr); 2269 } else { 2270 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2271 } 2272 2273 llvm::GlobalValue::LinkageTypes Linkage; 2274 if (isUTF16) 2275 // FIXME: why do utf strings get "_" labels instead of "L" labels? 2276 Linkage = llvm::GlobalValue::InternalLinkage; 2277 else 2278 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error 2279 // when using private linkage. It is not clear if this is a bug in ld 2280 // or a reasonable new restriction. 2281 Linkage = llvm::GlobalValue::LinkerPrivateLinkage; 2282 2283 // Note: -fwritable-strings doesn't make the backing store strings of 2284 // CFStrings writable. (See <rdar://problem/10657500>) 2285 llvm::GlobalVariable *GV = 2286 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, 2287 Linkage, C, ".str"); 2288 GV->setUnnamedAddr(true); 2289 if (isUTF16) { 2290 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); 2291 GV->setAlignment(Align.getQuantity()); 2292 } else { 2293 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2294 GV->setAlignment(Align.getQuantity()); 2295 } 2296 2297 // String. 2298 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2299 2300 if (isUTF16) 2301 // Cast the UTF16 string to the correct type. 2302 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy); 2303 2304 // String length. 2305 Ty = getTypes().ConvertType(getContext().LongTy); 2306 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 2307 2308 // The struct. 2309 C = llvm::ConstantStruct::get(STy, Fields); 2310 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2311 llvm::GlobalVariable::PrivateLinkage, C, 2312 "_unnamed_cfstring_"); 2313 if (const char *Sect = getContext().getTargetInfo().getCFStringSection()) 2314 GV->setSection(Sect); 2315 Entry.setValue(GV); 2316 2317 return GV; 2318} 2319 2320static RecordDecl * 2321CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 2322 DeclContext *DC, IdentifierInfo *Id) { 2323 SourceLocation Loc; 2324 if (Ctx.getLangOpts().CPlusPlus) 2325 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2326 else 2327 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 2328} 2329 2330llvm::Constant * 2331CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { 2332 unsigned StringLength = 0; 2333 llvm::StringMapEntry<llvm::Constant*> &Entry = 2334 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength); 2335 2336 if (llvm::Constant *C = Entry.getValue()) 2337 return C; 2338 2339 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty); 2340 llvm::Constant *Zeros[] = { Zero, Zero }; 2341 2342 // If we don't already have it, get _NSConstantStringClassReference. 2343 if (!ConstantStringClassRef) { 2344 std::string StringClass(getLangOpts().ObjCConstantStringClass); 2345 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 2346 llvm::Constant *GV; 2347 if (LangOpts.ObjCRuntime.isNonFragile()) { 2348 std::string str = 2349 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 2350 : "OBJC_CLASS_$_" + StringClass; 2351 GV = getObjCRuntime().GetClassGlobal(str); 2352 // Make sure the result is of the correct type. 2353 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 2354 ConstantStringClassRef = 2355 llvm::ConstantExpr::getBitCast(GV, PTy); 2356 } else { 2357 std::string str = 2358 StringClass.empty() ? "_NSConstantStringClassReference" 2359 : "_" + StringClass + "ClassReference"; 2360 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0); 2361 GV = CreateRuntimeVariable(PTy, str); 2362 // Decay array -> ptr 2363 ConstantStringClassRef = 2364 llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2365 } 2366 } 2367 2368 if (!NSConstantStringType) { 2369 // Construct the type for a constant NSString. 2370 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2371 Context.getTranslationUnitDecl(), 2372 &Context.Idents.get("__builtin_NSString")); 2373 D->startDefinition(); 2374 2375 QualType FieldTypes[3]; 2376 2377 // const int *isa; 2378 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst()); 2379 // const char *str; 2380 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst()); 2381 // unsigned int length; 2382 FieldTypes[2] = Context.UnsignedIntTy; 2383 2384 // Create fields 2385 for (unsigned i = 0; i < 3; ++i) { 2386 FieldDecl *Field = FieldDecl::Create(Context, D, 2387 SourceLocation(), 2388 SourceLocation(), 0, 2389 FieldTypes[i], /*TInfo=*/0, 2390 /*BitWidth=*/0, 2391 /*Mutable=*/false, 2392 ICIS_NoInit); 2393 Field->setAccess(AS_public); 2394 D->addDecl(Field); 2395 } 2396 2397 D->completeDefinition(); 2398 QualType NSTy = Context.getTagDeclType(D); 2399 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy)); 2400 } 2401 2402 llvm::Constant *Fields[3]; 2403 2404 // Class pointer. 2405 Fields[0] = ConstantStringClassRef; 2406 2407 // String pointer. 2408 llvm::Constant *C = 2409 llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); 2410 2411 llvm::GlobalValue::LinkageTypes Linkage; 2412 bool isConstant; 2413 Linkage = llvm::GlobalValue::PrivateLinkage; 2414 isConstant = !LangOpts.WritableStrings; 2415 2416 llvm::GlobalVariable *GV = 2417 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, 2418 ".str"); 2419 GV->setUnnamedAddr(true); 2420 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); 2421 GV->setAlignment(Align.getQuantity()); 2422 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros); 2423 2424 // String length. 2425 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 2426 Fields[2] = llvm::ConstantInt::get(Ty, StringLength); 2427 2428 // The struct. 2429 C = llvm::ConstantStruct::get(NSConstantStringType, Fields); 2430 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 2431 llvm::GlobalVariable::PrivateLinkage, C, 2432 "_unnamed_nsstring_"); 2433 // FIXME. Fix section. 2434 if (const char *Sect = 2435 LangOpts.ObjCRuntime.isNonFragile() 2436 ? getContext().getTargetInfo().getNSStringNonFragileABISection() 2437 : getContext().getTargetInfo().getNSStringSection()) 2438 GV->setSection(Sect); 2439 Entry.setValue(GV); 2440 2441 return GV; 2442} 2443 2444QualType CodeGenModule::getObjCFastEnumerationStateType() { 2445 if (ObjCFastEnumerationStateType.isNull()) { 2446 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, 2447 Context.getTranslationUnitDecl(), 2448 &Context.Idents.get("__objcFastEnumerationState")); 2449 D->startDefinition(); 2450 2451 QualType FieldTypes[] = { 2452 Context.UnsignedLongTy, 2453 Context.getPointerType(Context.getObjCIdType()), 2454 Context.getPointerType(Context.UnsignedLongTy), 2455 Context.getConstantArrayType(Context.UnsignedLongTy, 2456 llvm::APInt(32, 5), ArrayType::Normal, 0) 2457 }; 2458 2459 for (size_t i = 0; i < 4; ++i) { 2460 FieldDecl *Field = FieldDecl::Create(Context, 2461 D, 2462 SourceLocation(), 2463 SourceLocation(), 0, 2464 FieldTypes[i], /*TInfo=*/0, 2465 /*BitWidth=*/0, 2466 /*Mutable=*/false, 2467 ICIS_NoInit); 2468 Field->setAccess(AS_public); 2469 D->addDecl(Field); 2470 } 2471 2472 D->completeDefinition(); 2473 ObjCFastEnumerationStateType = Context.getTagDeclType(D); 2474 } 2475 2476 return ObjCFastEnumerationStateType; 2477} 2478 2479llvm::Constant * 2480CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { 2481 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 2482 2483 // Don't emit it as the address of the string, emit the string data itself 2484 // as an inline array. 2485 if (E->getCharByteWidth() == 1) { 2486 SmallString<64> Str(E->getString()); 2487 2488 // Resize the string to the right size, which is indicated by its type. 2489 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType()); 2490 Str.resize(CAT->getSize().getZExtValue()); 2491 return llvm::ConstantDataArray::getString(VMContext, Str, false); 2492 } 2493 2494 llvm::ArrayType *AType = 2495 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); 2496 llvm::Type *ElemTy = AType->getElementType(); 2497 unsigned NumElements = AType->getNumElements(); 2498 2499 // Wide strings have either 2-byte or 4-byte elements. 2500 if (ElemTy->getPrimitiveSizeInBits() == 16) { 2501 SmallVector<uint16_t, 32> Elements; 2502 Elements.reserve(NumElements); 2503 2504 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2505 Elements.push_back(E->getCodeUnit(i)); 2506 Elements.resize(NumElements); 2507 return llvm::ConstantDataArray::get(VMContext, Elements); 2508 } 2509 2510 assert(ElemTy->getPrimitiveSizeInBits() == 32); 2511 SmallVector<uint32_t, 32> Elements; 2512 Elements.reserve(NumElements); 2513 2514 for(unsigned i = 0, e = E->getLength(); i != e; ++i) 2515 Elements.push_back(E->getCodeUnit(i)); 2516 Elements.resize(NumElements); 2517 return llvm::ConstantDataArray::get(VMContext, Elements); 2518} 2519 2520/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 2521/// constant array for the given string literal. 2522llvm::Constant * 2523CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 2524 CharUnits Align = getContext().getTypeAlignInChars(S->getType()); 2525 if (S->isAscii() || S->isUTF8()) { 2526 SmallString<64> Str(S->getString()); 2527 2528 // Resize the string to the right size, which is indicated by its type. 2529 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType()); 2530 Str.resize(CAT->getSize().getZExtValue()); 2531 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity()); 2532 } 2533 2534 // FIXME: the following does not memoize wide strings. 2535 llvm::Constant *C = GetConstantArrayFromStringLiteral(S); 2536 llvm::GlobalVariable *GV = 2537 new llvm::GlobalVariable(getModule(),C->getType(), 2538 !LangOpts.WritableStrings, 2539 llvm::GlobalValue::PrivateLinkage, 2540 C,".str"); 2541 2542 GV->setAlignment(Align.getQuantity()); 2543 GV->setUnnamedAddr(true); 2544 return GV; 2545} 2546 2547/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 2548/// array for the given ObjCEncodeExpr node. 2549llvm::Constant * 2550CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 2551 std::string Str; 2552 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 2553 2554 return GetAddrOfConstantCString(Str); 2555} 2556 2557 2558/// GenerateWritableString -- Creates storage for a string literal. 2559static llvm::GlobalVariable *GenerateStringLiteral(StringRef str, 2560 bool constant, 2561 CodeGenModule &CGM, 2562 const char *GlobalName, 2563 unsigned Alignment) { 2564 // Create Constant for this string literal. Don't add a '\0'. 2565 llvm::Constant *C = 2566 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false); 2567 2568 // Create a global variable for this string 2569 llvm::GlobalVariable *GV = 2570 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 2571 llvm::GlobalValue::PrivateLinkage, 2572 C, GlobalName); 2573 GV->setAlignment(Alignment); 2574 GV->setUnnamedAddr(true); 2575 return GV; 2576} 2577 2578/// GetAddrOfConstantString - Returns a pointer to a character array 2579/// containing the literal. This contents are exactly that of the 2580/// given string, i.e. it will not be null terminated automatically; 2581/// see GetAddrOfConstantCString. Note that whether the result is 2582/// actually a pointer to an LLVM constant depends on 2583/// Feature.WriteableStrings. 2584/// 2585/// The result has pointer to array type. 2586llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str, 2587 const char *GlobalName, 2588 unsigned Alignment) { 2589 // Get the default prefix if a name wasn't specified. 2590 if (!GlobalName) 2591 GlobalName = ".str"; 2592 2593 // Don't share any string literals if strings aren't constant. 2594 if (LangOpts.WritableStrings) 2595 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment); 2596 2597 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = 2598 ConstantStringMap.GetOrCreateValue(Str); 2599 2600 if (llvm::GlobalVariable *GV = Entry.getValue()) { 2601 if (Alignment > GV->getAlignment()) { 2602 GV->setAlignment(Alignment); 2603 } 2604 return GV; 2605 } 2606 2607 // Create a global variable for this. 2608 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, 2609 Alignment); 2610 Entry.setValue(GV); 2611 return GV; 2612} 2613 2614/// GetAddrOfConstantCString - Returns a pointer to a character 2615/// array containing the literal and a terminating '\0' 2616/// character. The result has pointer to array type. 2617llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, 2618 const char *GlobalName, 2619 unsigned Alignment) { 2620 StringRef StrWithNull(Str.c_str(), Str.size() + 1); 2621 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment); 2622} 2623 2624/// EmitObjCPropertyImplementations - Emit information for synthesized 2625/// properties for an implementation. 2626void CodeGenModule::EmitObjCPropertyImplementations(const 2627 ObjCImplementationDecl *D) { 2628 for (ObjCImplementationDecl::propimpl_iterator 2629 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 2630 ObjCPropertyImplDecl *PID = *i; 2631 2632 // Dynamic is just for type-checking. 2633 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 2634 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 2635 2636 // Determine which methods need to be implemented, some may have 2637 // been overridden. Note that ::isPropertyAccessor is not the method 2638 // we want, that just indicates if the decl came from a 2639 // property. What we want to know is if the method is defined in 2640 // this implementation. 2641 if (!D->getInstanceMethod(PD->getGetterName())) 2642 CodeGenFunction(*this).GenerateObjCGetter( 2643 const_cast<ObjCImplementationDecl *>(D), PID); 2644 if (!PD->isReadOnly() && 2645 !D->getInstanceMethod(PD->getSetterName())) 2646 CodeGenFunction(*this).GenerateObjCSetter( 2647 const_cast<ObjCImplementationDecl *>(D), PID); 2648 } 2649 } 2650} 2651 2652static bool needsDestructMethod(ObjCImplementationDecl *impl) { 2653 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 2654 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 2655 ivar; ivar = ivar->getNextIvar()) 2656 if (ivar->getType().isDestructedType()) 2657 return true; 2658 2659 return false; 2660} 2661 2662/// EmitObjCIvarInitializations - Emit information for ivar initialization 2663/// for an implementation. 2664void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { 2665 // We might need a .cxx_destruct even if we don't have any ivar initializers. 2666 if (needsDestructMethod(D)) { 2667 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct"); 2668 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2669 ObjCMethodDecl *DTORMethod = 2670 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), 2671 cxxSelector, getContext().VoidTy, 0, D, 2672 /*isInstance=*/true, /*isVariadic=*/false, 2673 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, 2674 /*isDefined=*/false, ObjCMethodDecl::Required); 2675 D->addInstanceMethod(DTORMethod); 2676 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false); 2677 D->setHasDestructors(true); 2678 } 2679 2680 // If the implementation doesn't have any ivar initializers, we don't need 2681 // a .cxx_construct. 2682 if (D->getNumIvarInitializers() == 0) 2683 return; 2684 2685 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct"); 2686 Selector cxxSelector = getContext().Selectors.getSelector(0, &II); 2687 // The constructor returns 'self'. 2688 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(), 2689 D->getLocation(), 2690 D->getLocation(), 2691 cxxSelector, 2692 getContext().getObjCIdType(), 0, 2693 D, /*isInstance=*/true, 2694 /*isVariadic=*/false, 2695 /*isPropertyAccessor=*/true, 2696 /*isImplicitlyDeclared=*/true, 2697 /*isDefined=*/false, 2698 ObjCMethodDecl::Required); 2699 D->addInstanceMethod(CTORMethod); 2700 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true); 2701 D->setHasNonZeroConstructors(true); 2702} 2703 2704/// EmitNamespace - Emit all declarations in a namespace. 2705void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 2706 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 2707 I != E; ++I) 2708 EmitTopLevelDecl(*I); 2709} 2710 2711// EmitLinkageSpec - Emit all declarations in a linkage spec. 2712void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 2713 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 2714 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 2715 ErrorUnsupported(LSD, "linkage spec"); 2716 return; 2717 } 2718 2719 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 2720 I != E; ++I) { 2721 // Meta-data for ObjC class includes references to implemented methods. 2722 // Generate class's method definitions first. 2723 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) { 2724 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(), 2725 MEnd = OID->meth_end(); 2726 M != MEnd; ++M) 2727 EmitTopLevelDecl(*M); 2728 } 2729 EmitTopLevelDecl(*I); 2730 } 2731} 2732 2733/// EmitTopLevelDecl - Emit code for a single top level declaration. 2734void CodeGenModule::EmitTopLevelDecl(Decl *D) { 2735 // If an error has occurred, stop code generation, but continue 2736 // parsing and semantic analysis (to ensure all warnings and errors 2737 // are emitted). 2738 if (Diags.hasErrorOccurred()) 2739 return; 2740 2741 // Ignore dependent declarations. 2742 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 2743 return; 2744 2745 switch (D->getKind()) { 2746 case Decl::CXXConversion: 2747 case Decl::CXXMethod: 2748 case Decl::Function: 2749 // Skip function templates 2750 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2751 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2752 return; 2753 2754 EmitGlobal(cast<FunctionDecl>(D)); 2755 break; 2756 2757 case Decl::Var: 2758 EmitGlobal(cast<VarDecl>(D)); 2759 break; 2760 2761 // Indirect fields from global anonymous structs and unions can be 2762 // ignored; only the actual variable requires IR gen support. 2763 case Decl::IndirectField: 2764 break; 2765 2766 // C++ Decls 2767 case Decl::Namespace: 2768 EmitNamespace(cast<NamespaceDecl>(D)); 2769 break; 2770 // No code generation needed. 2771 case Decl::UsingShadow: 2772 case Decl::Using: 2773 case Decl::UsingDirective: 2774 case Decl::ClassTemplate: 2775 case Decl::FunctionTemplate: 2776 case Decl::TypeAliasTemplate: 2777 case Decl::NamespaceAlias: 2778 case Decl::Block: 2779 case Decl::Empty: 2780 break; 2781 case Decl::CXXConstructor: 2782 // Skip function templates 2783 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() || 2784 cast<FunctionDecl>(D)->isLateTemplateParsed()) 2785 return; 2786 2787 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 2788 break; 2789 case Decl::CXXDestructor: 2790 if (cast<FunctionDecl>(D)->isLateTemplateParsed()) 2791 return; 2792 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 2793 break; 2794 2795 case Decl::StaticAssert: 2796 // Nothing to do. 2797 break; 2798 2799 // Objective-C Decls 2800 2801 // Forward declarations, no (immediate) code generation. 2802 case Decl::ObjCInterface: 2803 case Decl::ObjCCategory: 2804 break; 2805 2806 case Decl::ObjCProtocol: { 2807 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D); 2808 if (Proto->isThisDeclarationADefinition()) 2809 ObjCRuntime->GenerateProtocol(Proto); 2810 break; 2811 } 2812 2813 case Decl::ObjCCategoryImpl: 2814 // Categories have properties but don't support synthesize so we 2815 // can ignore them here. 2816 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 2817 break; 2818 2819 case Decl::ObjCImplementation: { 2820 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 2821 EmitObjCPropertyImplementations(OMD); 2822 EmitObjCIvarInitializations(OMD); 2823 ObjCRuntime->GenerateClass(OMD); 2824 // Emit global variable debug information. 2825 if (CGDebugInfo *DI = getModuleDebugInfo()) 2826 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 2827 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType( 2828 OMD->getClassInterface()), OMD->getLocation()); 2829 break; 2830 } 2831 case Decl::ObjCMethod: { 2832 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 2833 // If this is not a prototype, emit the body. 2834 if (OMD->getBody()) 2835 CodeGenFunction(*this).GenerateObjCMethod(OMD); 2836 break; 2837 } 2838 case Decl::ObjCCompatibleAlias: 2839 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D)); 2840 break; 2841 2842 case Decl::LinkageSpec: 2843 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 2844 break; 2845 2846 case Decl::FileScopeAsm: { 2847 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 2848 StringRef AsmString = AD->getAsmString()->getString(); 2849 2850 const std::string &S = getModule().getModuleInlineAsm(); 2851 if (S.empty()) 2852 getModule().setModuleInlineAsm(AsmString); 2853 else if (S.end()[-1] == '\n') 2854 getModule().setModuleInlineAsm(S + AsmString.str()); 2855 else 2856 getModule().setModuleInlineAsm(S + '\n' + AsmString.str()); 2857 break; 2858 } 2859 2860 case Decl::Import: { 2861 ImportDecl *Import = cast<ImportDecl>(D); 2862 2863 // Ignore import declarations that come from imported modules. 2864 if (clang::Module *Owner = Import->getOwningModule()) { 2865 if (getLangOpts().CurrentModule.empty() || 2866 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule) 2867 break; 2868 } 2869 2870 ImportedModules.insert(Import->getImportedModule()); 2871 break; 2872 } 2873 2874 default: 2875 // Make sure we handled everything we should, every other kind is a 2876 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 2877 // function. Need to recode Decl::Kind to do that easily. 2878 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 2879 } 2880} 2881 2882/// Turns the given pointer into a constant. 2883static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context, 2884 const void *Ptr) { 2885 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr); 2886 llvm::Type *i64 = llvm::Type::getInt64Ty(Context); 2887 return llvm::ConstantInt::get(i64, PtrInt); 2888} 2889 2890static void EmitGlobalDeclMetadata(CodeGenModule &CGM, 2891 llvm::NamedMDNode *&GlobalMetadata, 2892 GlobalDecl D, 2893 llvm::GlobalValue *Addr) { 2894 if (!GlobalMetadata) 2895 GlobalMetadata = 2896 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs"); 2897 2898 // TODO: should we report variant information for ctors/dtors? 2899 llvm::Value *Ops[] = { 2900 Addr, 2901 GetPointerConstant(CGM.getLLVMContext(), D.getDecl()) 2902 }; 2903 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 2904} 2905 2906/// Emits metadata nodes associating all the global values in the 2907/// current module with the Decls they came from. This is useful for 2908/// projects using IR gen as a subroutine. 2909/// 2910/// Since there's currently no way to associate an MDNode directly 2911/// with an llvm::GlobalValue, we create a global named metadata 2912/// with the name 'clang.global.decl.ptrs'. 2913void CodeGenModule::EmitDeclMetadata() { 2914 llvm::NamedMDNode *GlobalMetadata = 0; 2915 2916 // StaticLocalDeclMap 2917 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator 2918 I = MangledDeclNames.begin(), E = MangledDeclNames.end(); 2919 I != E; ++I) { 2920 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); 2921 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); 2922 } 2923} 2924 2925/// Emits metadata nodes for all the local variables in the current 2926/// function. 2927void CodeGenFunction::EmitDeclMetadata() { 2928 if (LocalDeclMap.empty()) return; 2929 2930 llvm::LLVMContext &Context = getLLVMContext(); 2931 2932 // Find the unique metadata ID for this name. 2933 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); 2934 2935 llvm::NamedMDNode *GlobalMetadata = 0; 2936 2937 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator 2938 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { 2939 const Decl *D = I->first; 2940 llvm::Value *Addr = I->second; 2941 2942 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { 2943 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); 2944 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); 2945 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { 2946 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); 2947 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); 2948 } 2949 } 2950} 2951 2952void CodeGenModule::EmitCoverageFile() { 2953 if (!getCodeGenOpts().CoverageFile.empty()) { 2954 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { 2955 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov"); 2956 llvm::LLVMContext &Ctx = TheModule.getContext(); 2957 llvm::MDString *CoverageFile = 2958 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile); 2959 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) { 2960 llvm::MDNode *CU = CUNode->getOperand(i); 2961 llvm::Value *node[] = { CoverageFile, CU }; 2962 llvm::MDNode *N = llvm::MDNode::get(Ctx, node); 2963 GCov->addOperand(N); 2964 } 2965 } 2966 } 2967} 2968 2969llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid, 2970 QualType GuidType) { 2971 // Sema has checked that all uuid strings are of the form 2972 // "12345678-1234-1234-1234-1234567890ab". 2973 assert(Uuid.size() == 36); 2974 const char *Uuidstr = Uuid.data(); 2975 for (int i = 0; i < 36; ++i) { 2976 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-'); 2977 else assert(isHexDigit(Uuidstr[i])); 2978 } 2979 2980 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16); 2981 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16); 2982 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16); 2983 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 }; 2984 2985 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4); 2986 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0)); 2987 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1)); 2988 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2)); 2989 APValue& Arr = InitStruct.getStructField(3); 2990 Arr = APValue(APValue::UninitArray(), 8, 8); 2991 for (int t = 0; t < 8; ++t) 2992 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt( 2993 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16))); 2994 2995 return EmitConstantValue(InitStruct, GuidType); 2996} 2997