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