1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This coordinates the per-module state used while generating code.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenModule.h"
15 #include "CGCUDARuntime.h"
18 #include "CGDebugInfo.h"
19 #include "CGObjCRuntime.h"
20 #include "CGOpenCLRuntime.h"
21 #include "CodeGenFunction.h"
22 #include "CodeGenTBAA.h"
23 #include "TargetInfo.h"
24 #include "clang/AST/ASTContext.h"
25 #include "clang/AST/CharUnits.h"
26 #include "clang/AST/DeclCXX.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/Mangle.h"
30 #include "clang/AST/RecordLayout.h"
31 #include "clang/AST/RecursiveASTVisitor.h"
32 #include "clang/Basic/Builtins.h"
33 #include "clang/Basic/CharInfo.h"
34 #include "clang/Basic/Diagnostic.h"
35 #include "clang/Basic/Module.h"
36 #include "clang/Basic/SourceManager.h"
37 #include "clang/Basic/TargetInfo.h"
38 #include "clang/Basic/TargetOptions.h"
39 #include "clang/Frontend/CodeGenOptions.h"
40 #include "llvm/ADT/APSInt.h"
41 #include "llvm/ADT/Triple.h"
42 #include "llvm/IR/CallingConv.h"
43 #include "llvm/IR/DataLayout.h"
44 #include "llvm/IR/Intrinsics.h"
45 #include "llvm/IR/LLVMContext.h"
46 #include "llvm/IR/Module.h"
47 #include "llvm/Support/CallSite.h"
48 #include "llvm/Support/ConvertUTF.h"
49 #include "llvm/Support/ErrorHandling.h"
50 #include "llvm/Target/Mangler.h"
52 using namespace clang;
53 using namespace CodeGen;
55 static const char AnnotationSection[] = "llvm.metadata";
57 static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
58 switch (CGM.getContext().getTargetInfo().getCXXABI().getKind()) {
59 case TargetCXXABI::GenericAArch64:
60 case TargetCXXABI::GenericARM:
61 case TargetCXXABI::iOS:
62 case TargetCXXABI::GenericItanium:
63 return *CreateItaniumCXXABI(CGM);
64 case TargetCXXABI::Microsoft:
65 return *CreateMicrosoftCXXABI(CGM);
68 llvm_unreachable("invalid C++ ABI kind");
72 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
73 const TargetOptions &TO, llvm::Module &M,
74 const llvm::DataLayout &TD,
75 DiagnosticsEngine &diags)
76 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TargetOpts(TO),
77 TheModule(M), TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
78 ABI(createCXXABI(*this)),
81 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
82 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
83 RRData(0), CFConstantStringClassRef(0),
84 ConstantStringClassRef(0), NSConstantStringType(0),
85 VMContext(M.getContext()),
86 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
87 BlockObjectAssign(0), BlockObjectDispose(0),
88 BlockDescriptorType(0), GenericBlockLiteralType(0),
89 LifetimeStartFn(0), LifetimeEndFn(0),
90 SanitizerBlacklist(CGO.SanitizerBlacklistFile),
91 SanOpts(SanitizerBlacklist.isIn(M) ?
92 SanitizerOptions::Disabled : LangOpts.Sanitize) {
94 // Initialize the type cache.
95 llvm::LLVMContext &LLVMContext = M.getContext();
96 VoidTy = llvm::Type::getVoidTy(LLVMContext);
97 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
98 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
99 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
100 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
101 FloatTy = llvm::Type::getFloatTy(LLVMContext);
102 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
103 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
104 PointerAlignInBytes =
105 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
106 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
107 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
108 Int8PtrTy = Int8Ty->getPointerTo(0);
109 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
111 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
116 createOpenCLRuntime();
120 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
121 if (SanOpts.Thread ||
122 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
123 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
124 ABI.getMangleContext());
126 // If debug info or coverage generation is enabled, create the CGDebugInfo
128 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
129 CodeGenOpts.EmitGcovArcs ||
130 CodeGenOpts.EmitGcovNotes)
131 DebugInfo = new CGDebugInfo(*this);
133 Block.GlobalUniqueCount = 0;
135 if (C.getLangOpts().ObjCAutoRefCount)
136 ARCData = new ARCEntrypoints();
137 RRData = new RREntrypoints();
140 CodeGenModule::~CodeGenModule() {
142 delete OpenCLRuntime;
144 delete TheTargetCodeGenInfo;
152 void CodeGenModule::createObjCRuntime() {
153 // This is just isGNUFamily(), but we want to force implementors of
154 // new ABIs to decide how best to do this.
155 switch (LangOpts.ObjCRuntime.getKind()) {
156 case ObjCRuntime::GNUstep:
157 case ObjCRuntime::GCC:
158 case ObjCRuntime::ObjFW:
159 ObjCRuntime = CreateGNUObjCRuntime(*this);
162 case ObjCRuntime::FragileMacOSX:
163 case ObjCRuntime::MacOSX:
164 case ObjCRuntime::iOS:
165 ObjCRuntime = CreateMacObjCRuntime(*this);
168 llvm_unreachable("bad runtime kind");
171 void CodeGenModule::createOpenCLRuntime() {
172 OpenCLRuntime = new CGOpenCLRuntime(*this);
175 void CodeGenModule::createCUDARuntime() {
176 CUDARuntime = CreateNVCUDARuntime(*this);
179 void CodeGenModule::Release() {
181 EmitCXXGlobalInitFunc();
182 EmitCXXGlobalDtorFunc();
184 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
185 AddGlobalCtor(ObjCInitFunction);
186 EmitCtorList(GlobalCtors, "llvm.global_ctors");
187 EmitCtorList(GlobalDtors, "llvm.global_dtors");
188 EmitGlobalAnnotations();
191 if (CodeGenOpts.ModulesAutolink) {
192 EmitModuleLinkOptions();
195 SimplifyPersonality();
197 if (getCodeGenOpts().EmitDeclMetadata)
200 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
204 DebugInfo->finalize();
207 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
208 // Make sure that this type is translated.
209 Types.UpdateCompletedType(TD);
212 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
215 return TBAA->getTBAAInfo(QTy);
218 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
221 return TBAA->getTBAAInfoForVTablePtr();
224 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
227 return TBAA->getTBAAStructInfo(QTy);
230 llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) {
233 return TBAA->getTBAAStructTypeInfo(QTy);
236 llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy,
237 llvm::MDNode *AccessN,
241 return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O);
244 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
245 llvm::MDNode *TBAAInfo) {
246 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
249 bool CodeGenModule::isTargetDarwin() const {
250 return getContext().getTargetInfo().getTriple().isOSDarwin();
253 void CodeGenModule::Error(SourceLocation loc, StringRef error) {
254 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
255 getDiags().Report(Context.getFullLoc(loc), diagID);
258 /// ErrorUnsupported - Print out an error that codegen doesn't support the
259 /// specified stmt yet.
260 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
262 if (OmitOnError && getDiags().hasErrorOccurred())
264 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
265 "cannot compile this %0 yet");
266 std::string Msg = Type;
267 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
268 << Msg << S->getSourceRange();
271 /// ErrorUnsupported - Print out an error that codegen doesn't support the
272 /// specified decl yet.
273 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
275 if (OmitOnError && getDiags().hasErrorOccurred())
277 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
278 "cannot compile this %0 yet");
279 std::string Msg = Type;
280 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
283 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
284 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
287 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
288 const NamedDecl *D) const {
289 // Internal definitions always have default visibility.
290 if (GV->hasLocalLinkage()) {
291 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
295 // Set visibility for definitions.
296 LinkageInfo LV = D->getLinkageAndVisibility();
297 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
298 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
301 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
302 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
303 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
304 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
305 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
306 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
309 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
310 CodeGenOptions::TLSModel M) {
312 case CodeGenOptions::GeneralDynamicTLSModel:
313 return llvm::GlobalVariable::GeneralDynamicTLSModel;
314 case CodeGenOptions::LocalDynamicTLSModel:
315 return llvm::GlobalVariable::LocalDynamicTLSModel;
316 case CodeGenOptions::InitialExecTLSModel:
317 return llvm::GlobalVariable::InitialExecTLSModel;
318 case CodeGenOptions::LocalExecTLSModel:
319 return llvm::GlobalVariable::LocalExecTLSModel;
321 llvm_unreachable("Invalid TLS model!");
324 void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
325 const VarDecl &D) const {
326 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
328 llvm::GlobalVariable::ThreadLocalMode TLM;
329 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
331 // Override the TLS model if it is explicitly specified.
332 if (D.hasAttr<TLSModelAttr>()) {
333 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
334 TLM = GetLLVMTLSModel(Attr->getModel());
337 GV->setThreadLocalMode(TLM);
340 /// Set the symbol visibility of type information (vtable and RTTI)
341 /// associated with the given type.
342 void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
343 const CXXRecordDecl *RD,
344 TypeVisibilityKind TVK) const {
345 setGlobalVisibility(GV, RD);
347 if (!CodeGenOpts.HiddenWeakVTables)
350 // We never want to drop the visibility for RTTI names.
351 if (TVK == TVK_ForRTTIName)
354 // We want to drop the visibility to hidden for weak type symbols.
355 // This isn't possible if there might be unresolved references
356 // elsewhere that rely on this symbol being visible.
358 // This should be kept roughly in sync with setThunkVisibility
362 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
363 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
366 // Don't override an explicit visibility attribute.
367 if (RD->getExplicitVisibility(NamedDecl::VisibilityForType))
370 switch (RD->getTemplateSpecializationKind()) {
371 // We have to disable the optimization if this is an EI definition
372 // because there might be EI declarations in other shared objects.
373 case TSK_ExplicitInstantiationDefinition:
374 case TSK_ExplicitInstantiationDeclaration:
377 // Every use of a non-template class's type information has to emit it.
381 // In theory, implicit instantiations can ignore the possibility of
382 // an explicit instantiation declaration because there necessarily
383 // must be an EI definition somewhere with default visibility. In
384 // practice, it's possible to have an explicit instantiation for
385 // an arbitrary template class, and linkers aren't necessarily able
386 // to deal with mixed-visibility symbols.
387 case TSK_ExplicitSpecialization:
388 case TSK_ImplicitInstantiation:
392 // If there's a key function, there may be translation units
393 // that don't have the key function's definition. But ignore
394 // this if we're emitting RTTI under -fno-rtti.
395 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
396 // FIXME: what should we do if we "lose" the key function during
397 // the emission of the file?
398 if (Context.getCurrentKeyFunction(RD))
402 // Otherwise, drop the visibility to hidden.
403 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
404 GV->setUnnamedAddr(true);
407 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
408 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
410 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
414 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
415 IdentifierInfo *II = ND->getIdentifier();
416 assert(II && "Attempt to mangle unnamed decl.");
422 SmallString<256> Buffer;
423 llvm::raw_svector_ostream Out(Buffer);
424 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
425 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
426 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
427 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
428 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
429 getCXXABI().getMangleContext().mangleBlock(BD, Out,
430 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
432 getCXXABI().getMangleContext().mangleName(ND, Out);
434 // Allocate space for the mangled name.
436 size_t Length = Buffer.size();
437 char *Name = MangledNamesAllocator.Allocate<char>(Length);
438 std::copy(Buffer.begin(), Buffer.end(), Name);
440 Str = StringRef(Name, Length);
445 void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
446 const BlockDecl *BD) {
447 MangleContext &MangleCtx = getCXXABI().getMangleContext();
448 const Decl *D = GD.getDecl();
449 llvm::raw_svector_ostream Out(Buffer.getBuffer());
451 MangleCtx.mangleGlobalBlock(BD,
452 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
453 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
454 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
455 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
456 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
458 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
461 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
462 return getModule().getNamedValue(Name);
465 /// AddGlobalCtor - Add a function to the list that will be called before
467 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
468 // FIXME: Type coercion of void()* types.
469 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
472 /// AddGlobalDtor - Add a function to the list that will be called
473 /// when the module is unloaded.
474 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
475 // FIXME: Type coercion of void()* types.
476 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
479 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
480 // Ctor function type is void()*.
481 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
482 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
484 // Get the type of a ctor entry, { i32, void ()* }.
485 llvm::StructType *CtorStructTy =
486 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
488 // Construct the constructor and destructor arrays.
489 SmallVector<llvm::Constant*, 8> Ctors;
490 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
491 llvm::Constant *S[] = {
492 llvm::ConstantInt::get(Int32Ty, I->second, false),
493 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
495 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
498 if (!Ctors.empty()) {
499 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
500 new llvm::GlobalVariable(TheModule, AT, false,
501 llvm::GlobalValue::AppendingLinkage,
502 llvm::ConstantArray::get(AT, Ctors),
507 llvm::GlobalValue::LinkageTypes
508 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
509 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
511 if (Linkage == GVA_Internal)
512 return llvm::Function::InternalLinkage;
514 if (D->hasAttr<DLLExportAttr>())
515 return llvm::Function::DLLExportLinkage;
517 if (D->hasAttr<WeakAttr>())
518 return llvm::Function::WeakAnyLinkage;
520 // In C99 mode, 'inline' functions are guaranteed to have a strong
521 // definition somewhere else, so we can use available_externally linkage.
522 if (Linkage == GVA_C99Inline)
523 return llvm::Function::AvailableExternallyLinkage;
525 // Note that Apple's kernel linker doesn't support symbol
526 // coalescing, so we need to avoid linkonce and weak linkages there.
527 // Normally, this means we just map to internal, but for explicit
528 // instantiations we'll map to external.
530 // In C++, the compiler has to emit a definition in every translation unit
531 // that references the function. We should use linkonce_odr because
532 // a) if all references in this translation unit are optimized away, we
533 // don't need to codegen it. b) if the function persists, it needs to be
534 // merged with other definitions. c) C++ has the ODR, so we know the
535 // definition is dependable.
536 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
537 return !Context.getLangOpts().AppleKext
538 ? llvm::Function::LinkOnceODRLinkage
539 : llvm::Function::InternalLinkage;
541 // An explicit instantiation of a template has weak linkage, since
542 // explicit instantiations can occur in multiple translation units
543 // and must all be equivalent. However, we are not allowed to
544 // throw away these explicit instantiations.
545 if (Linkage == GVA_ExplicitTemplateInstantiation)
546 return !Context.getLangOpts().AppleKext
547 ? llvm::Function::WeakODRLinkage
548 : llvm::Function::ExternalLinkage;
550 // Otherwise, we have strong external linkage.
551 assert(Linkage == GVA_StrongExternal);
552 return llvm::Function::ExternalLinkage;
556 /// SetFunctionDefinitionAttributes - Set attributes for a global.
558 /// FIXME: This is currently only done for aliases and functions, but not for
559 /// variables (these details are set in EmitGlobalVarDefinition for variables).
560 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
561 llvm::GlobalValue *GV) {
562 SetCommonAttributes(D, GV);
565 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
566 const CGFunctionInfo &Info,
568 unsigned CallingConv;
569 AttributeListType AttributeList;
570 ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
571 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
572 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
575 /// Determines whether the language options require us to model
576 /// unwind exceptions. We treat -fexceptions as mandating this
577 /// except under the fragile ObjC ABI with only ObjC exceptions
578 /// enabled. This means, for example, that C with -fexceptions
580 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
581 // If exceptions are completely disabled, obviously this is false.
582 if (!LangOpts.Exceptions) return false;
584 // If C++ exceptions are enabled, this is true.
585 if (LangOpts.CXXExceptions) return true;
587 // If ObjC exceptions are enabled, this depends on the ABI.
588 if (LangOpts.ObjCExceptions) {
589 return LangOpts.ObjCRuntime.hasUnwindExceptions();
595 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
597 if (CodeGenOpts.UnwindTables)
600 if (!hasUnwindExceptions(LangOpts))
601 F->addFnAttr(llvm::Attribute::NoUnwind);
603 if (D->hasAttr<NakedAttr>()) {
604 // Naked implies noinline: we should not be inlining such functions.
605 F->addFnAttr(llvm::Attribute::Naked);
606 F->addFnAttr(llvm::Attribute::NoInline);
609 if (D->hasAttr<NoInlineAttr>())
610 F->addFnAttr(llvm::Attribute::NoInline);
612 // (noinline wins over always_inline, and we can't specify both in IR)
613 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
614 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
615 llvm::Attribute::NoInline))
616 F->addFnAttr(llvm::Attribute::AlwaysInline);
618 // FIXME: Communicate hot and cold attributes to LLVM more directly.
619 if (D->hasAttr<ColdAttr>())
620 F->addFnAttr(llvm::Attribute::OptimizeForSize);
622 if (D->hasAttr<MinSizeAttr>())
623 F->addFnAttr(llvm::Attribute::MinSize);
625 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
626 F->setUnnamedAddr(true);
628 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
630 F->setUnnamedAddr(true);
632 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
633 F->addFnAttr(llvm::Attribute::StackProtect);
634 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
635 F->addFnAttr(llvm::Attribute::StackProtectReq);
637 // Add sanitizer attributes if function is not blacklisted.
638 if (!SanitizerBlacklist.isIn(*F)) {
639 // When AddressSanitizer is enabled, set SanitizeAddress attribute
640 // unless __attribute__((no_sanitize_address)) is used.
641 if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>())
642 F->addFnAttr(llvm::Attribute::SanitizeAddress);
643 // Same for ThreadSanitizer and __attribute__((no_sanitize_thread))
644 if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) {
645 F->addFnAttr(llvm::Attribute::SanitizeThread);
647 // Same for MemorySanitizer and __attribute__((no_sanitize_memory))
648 if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>())
649 F->addFnAttr(llvm::Attribute::SanitizeMemory);
652 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
654 F->setAlignment(alignment);
656 // C++ ABI requires 2-byte alignment for member functions.
657 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
661 void CodeGenModule::SetCommonAttributes(const Decl *D,
662 llvm::GlobalValue *GV) {
663 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
664 setGlobalVisibility(GV, ND);
666 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
668 if (D->hasAttr<UsedAttr>())
671 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
672 GV->setSection(SA->getName());
674 // Alias cannot have attributes. Filter them here.
675 if (!isa<llvm::GlobalAlias>(GV))
676 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
679 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
681 const CGFunctionInfo &FI) {
682 SetLLVMFunctionAttributes(D, FI, F);
683 SetLLVMFunctionAttributesForDefinition(D, F);
685 F->setLinkage(llvm::Function::InternalLinkage);
687 SetCommonAttributes(D, F);
690 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
692 bool IsIncompleteFunction) {
693 if (unsigned IID = F->getIntrinsicID()) {
694 // If this is an intrinsic function, set the function's attributes
695 // to the intrinsic's attributes.
696 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
697 (llvm::Intrinsic::ID)IID));
701 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
703 if (!IsIncompleteFunction)
704 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
706 // Only a few attributes are set on declarations; these may later be
707 // overridden by a definition.
709 if (FD->hasAttr<DLLImportAttr>()) {
710 F->setLinkage(llvm::Function::DLLImportLinkage);
711 } else if (FD->hasAttr<WeakAttr>() ||
712 FD->isWeakImported()) {
713 // "extern_weak" is overloaded in LLVM; we probably should have
714 // separate linkage types for this.
715 F->setLinkage(llvm::Function::ExternalWeakLinkage);
717 F->setLinkage(llvm::Function::ExternalLinkage);
719 LinkageInfo LV = FD->getLinkageAndVisibility();
720 if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) {
721 F->setVisibility(GetLLVMVisibility(LV.getVisibility()));
725 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
726 F->setSection(SA->getName());
729 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
730 assert(!GV->isDeclaration() &&
731 "Only globals with definition can force usage.");
732 LLVMUsed.push_back(GV);
735 void CodeGenModule::EmitLLVMUsed() {
736 // Don't create llvm.used if there is no need.
737 if (LLVMUsed.empty())
740 // Convert LLVMUsed to what ConstantArray needs.
741 SmallVector<llvm::Constant*, 8> UsedArray;
742 UsedArray.resize(LLVMUsed.size());
743 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
745 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
749 if (UsedArray.empty())
751 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
753 llvm::GlobalVariable *GV =
754 new llvm::GlobalVariable(getModule(), ATy, false,
755 llvm::GlobalValue::AppendingLinkage,
756 llvm::ConstantArray::get(ATy, UsedArray),
759 GV->setSection("llvm.metadata");
762 /// \brief Add link options implied by the given module, including modules
763 /// it depends on, using a postorder walk.
764 static void addLinkOptionsPostorder(llvm::LLVMContext &Context,
766 SmallVectorImpl<llvm::Value *> &Metadata,
767 llvm::SmallPtrSet<Module *, 16> &Visited) {
768 // Import this module's parent.
769 if (Mod->Parent && Visited.insert(Mod->Parent)) {
770 addLinkOptionsPostorder(Context, Mod->Parent, Metadata, Visited);
773 // Import this module's dependencies.
774 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
775 if (Visited.insert(Mod->Imports[I-1]))
776 addLinkOptionsPostorder(Context, Mod->Imports[I-1], Metadata, Visited);
779 // Add linker options to link against the libraries/frameworks
780 // described by this module.
781 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
782 // FIXME: -lfoo is Unix-centric and -framework Foo is Darwin-centric.
783 // We need to know more about the linker to know how to encode these
784 // options propertly.
786 // Link against a framework.
787 if (Mod->LinkLibraries[I-1].IsFramework) {
788 llvm::Value *Args[2] = {
789 llvm::MDString::get(Context, "-framework"),
790 llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library)
793 Metadata.push_back(llvm::MDNode::get(Context, Args));
797 // Link against a library.
798 llvm::Value *OptString
799 = llvm::MDString::get(Context,
800 "-l" + Mod->LinkLibraries[I-1].Library);
801 Metadata.push_back(llvm::MDNode::get(Context, OptString));
805 void CodeGenModule::EmitModuleLinkOptions() {
806 // Collect the set of all of the modules we want to visit to emit link
807 // options, which is essentially the imported modules and all of their
808 // non-explicit child modules.
809 llvm::SetVector<clang::Module *> LinkModules;
810 llvm::SmallPtrSet<clang::Module *, 16> Visited;
811 SmallVector<clang::Module *, 16> Stack;
813 // Seed the stack with imported modules.
814 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
815 MEnd = ImportedModules.end();
817 if (Visited.insert(*M))
821 // Find all of the modules to import, making a little effort to prune
823 while (!Stack.empty()) {
824 clang::Module *Mod = Stack.back();
827 bool AnyChildren = false;
829 // Visit the submodules of this module.
830 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
831 SubEnd = Mod->submodule_end();
832 Sub != SubEnd; ++Sub) {
833 // Skip explicit children; they need to be explicitly imported to be
835 if ((*Sub)->IsExplicit)
838 if (Visited.insert(*Sub)) {
839 Stack.push_back(*Sub);
844 // We didn't find any children, so add this module to the list of
845 // modules to link against.
847 LinkModules.insert(Mod);
851 // Add link options for all of the imported modules in reverse topological
853 SmallVector<llvm::Value *, 16> MetadataArgs;
855 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
856 MEnd = LinkModules.end();
858 if (Visited.insert(*M))
859 addLinkOptionsPostorder(getLLVMContext(), *M, MetadataArgs, Visited);
861 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
863 // Add the linker options metadata flag.
864 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
865 llvm::MDNode::get(getLLVMContext(), MetadataArgs));
868 void CodeGenModule::EmitDeferred() {
869 // Emit code for any potentially referenced deferred decls. Since a
870 // previously unused static decl may become used during the generation of code
871 // for a static function, iterate until no changes are made.
874 if (!DeferredVTables.empty()) {
875 EmitDeferredVTables();
877 // Emitting a v-table doesn't directly cause more v-tables to
878 // become deferred, although it can cause functions to be
879 // emitted that then need those v-tables.
880 assert(DeferredVTables.empty());
883 // Stop if we're out of both deferred v-tables and deferred declarations.
884 if (DeferredDeclsToEmit.empty()) break;
886 GlobalDecl D = DeferredDeclsToEmit.back();
887 DeferredDeclsToEmit.pop_back();
889 // Check to see if we've already emitted this. This is necessary
890 // for a couple of reasons: first, decls can end up in the
891 // deferred-decls queue multiple times, and second, decls can end
892 // up with definitions in unusual ways (e.g. by an extern inline
893 // function acquiring a strong function redefinition). Just
894 // ignore these cases.
896 // TODO: That said, looking this up multiple times is very wasteful.
897 StringRef Name = getMangledName(D);
898 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
899 assert(CGRef && "Deferred decl wasn't referenced?");
901 if (!CGRef->isDeclaration())
904 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
905 // purposes an alias counts as a definition.
906 if (isa<llvm::GlobalAlias>(CGRef))
909 // Otherwise, emit the definition and move on to the next one.
910 EmitGlobalDefinition(D);
914 void CodeGenModule::EmitGlobalAnnotations() {
915 if (Annotations.empty())
918 // Create a new global variable for the ConstantStruct in the Module.
919 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
920 Annotations[0]->getType(), Annotations.size()), Annotations);
921 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
922 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
923 "llvm.global.annotations");
924 gv->setSection(AnnotationSection);
927 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
928 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
929 if (i != AnnotationStrings.end())
932 // Not found yet, create a new global.
933 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
934 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
935 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
936 gv->setSection(AnnotationSection);
937 gv->setUnnamedAddr(true);
938 AnnotationStrings[Str] = gv;
942 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
943 SourceManager &SM = getContext().getSourceManager();
944 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
946 return EmitAnnotationString(PLoc.getFilename());
947 return EmitAnnotationString(SM.getBufferName(Loc));
950 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
951 SourceManager &SM = getContext().getSourceManager();
952 PresumedLoc PLoc = SM.getPresumedLoc(L);
953 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
954 SM.getExpansionLineNumber(L);
955 return llvm::ConstantInt::get(Int32Ty, LineNo);
958 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
959 const AnnotateAttr *AA,
961 // Get the globals for file name, annotation, and the line number.
962 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
963 *UnitGV = EmitAnnotationUnit(L),
964 *LineNoCst = EmitAnnotationLineNo(L);
966 // Create the ConstantStruct for the global annotation.
967 llvm::Constant *Fields[4] = {
968 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
969 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
970 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
973 return llvm::ConstantStruct::getAnon(Fields);
976 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
977 llvm::GlobalValue *GV) {
978 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
979 // Get the struct elements for these annotations.
980 for (specific_attr_iterator<AnnotateAttr>
981 ai = D->specific_attr_begin<AnnotateAttr>(),
982 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
983 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
986 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
987 // Never defer when EmitAllDecls is specified.
988 if (LangOpts.EmitAllDecls)
991 return !getContext().DeclMustBeEmitted(Global);
994 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
995 const CXXUuidofExpr* E) {
996 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
999 if (E->isTypeOperand())
1000 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
1002 // Special case: __uuidof(0) means an all-zero GUID.
1003 Expr *Op = E->getExprOperand();
1004 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
1005 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
1007 Uuid = "00000000-0000-0000-0000-000000000000";
1009 std::string Name = "__uuid_" + Uuid.str();
1011 // Look for an existing global.
1012 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1015 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
1016 assert(Init && "failed to initialize as constant");
1018 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
1019 // first field is declared as "long", which for many targets is 8 bytes.
1020 // Those architectures are not supported. (With the MS abi, long is always 4
1022 llvm::Type *GuidType = getTypes().ConvertType(E->getType());
1023 if (Init->getType() != GuidType) {
1024 DiagnosticsEngine &Diags = getDiags();
1025 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1026 "__uuidof codegen is not supported on this architecture");
1027 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
1028 Init = llvm::UndefValue::get(GuidType);
1031 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
1032 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
1033 GV->setUnnamedAddr(true);
1037 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1038 const AliasAttr *AA = VD->getAttr<AliasAttr>();
1039 assert(AA && "No alias?");
1041 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
1043 // See if there is already something with the target's name in the module.
1044 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
1046 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1047 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1050 llvm::Constant *Aliasee;
1051 if (isa<llvm::FunctionType>(DeclTy))
1052 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1053 GlobalDecl(cast<FunctionDecl>(VD)),
1054 /*ForVTable=*/false);
1056 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1057 llvm::PointerType::getUnqual(DeclTy), 0);
1059 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
1060 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1061 WeakRefReferences.insert(F);
1066 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
1067 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
1069 // Weak references don't produce any output by themselves.
1070 if (Global->hasAttr<WeakRefAttr>())
1073 // If this is an alias definition (which otherwise looks like a declaration)
1075 if (Global->hasAttr<AliasAttr>())
1076 return EmitAliasDefinition(GD);
1078 // If this is CUDA, be selective about which declarations we emit.
1079 if (LangOpts.CUDA) {
1080 if (CodeGenOpts.CUDAIsDevice) {
1081 if (!Global->hasAttr<CUDADeviceAttr>() &&
1082 !Global->hasAttr<CUDAGlobalAttr>() &&
1083 !Global->hasAttr<CUDAConstantAttr>() &&
1084 !Global->hasAttr<CUDASharedAttr>())
1087 if (!Global->hasAttr<CUDAHostAttr>() && (
1088 Global->hasAttr<CUDADeviceAttr>() ||
1089 Global->hasAttr<CUDAConstantAttr>() ||
1090 Global->hasAttr<CUDASharedAttr>()))
1095 // Ignore declarations, they will be emitted on their first use.
1096 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
1097 // Forward declarations are emitted lazily on first use.
1098 if (!FD->doesThisDeclarationHaveABody()) {
1099 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1102 const FunctionDecl *InlineDefinition = 0;
1103 FD->getBody(InlineDefinition);
1105 StringRef MangledName = getMangledName(GD);
1106 DeferredDecls.erase(MangledName);
1107 EmitGlobalDefinition(InlineDefinition);
1111 const VarDecl *VD = cast<VarDecl>(Global);
1112 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1114 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
1118 // Defer code generation when possible if this is a static definition, inline
1119 // function etc. These we only want to emit if they are used.
1120 if (!MayDeferGeneration(Global)) {
1121 // Emit the definition if it can't be deferred.
1122 EmitGlobalDefinition(GD);
1126 // If we're deferring emission of a C++ variable with an
1127 // initializer, remember the order in which it appeared in the file.
1128 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
1129 cast<VarDecl>(Global)->hasInit()) {
1130 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1131 CXXGlobalInits.push_back(0);
1134 // If the value has already been used, add it directly to the
1135 // DeferredDeclsToEmit list.
1136 StringRef MangledName = getMangledName(GD);
1137 if (GetGlobalValue(MangledName))
1138 DeferredDeclsToEmit.push_back(GD);
1140 // Otherwise, remember that we saw a deferred decl with this name. The
1141 // first use of the mangled name will cause it to move into
1142 // DeferredDeclsToEmit.
1143 DeferredDecls[MangledName] = GD;
1148 struct FunctionIsDirectlyRecursive :
1149 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1150 const StringRef Name;
1151 const Builtin::Context &BI;
1153 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1154 Name(N), BI(C), Result(false) {
1156 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1158 bool TraverseCallExpr(CallExpr *E) {
1159 const FunctionDecl *FD = E->getDirectCallee();
1162 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1163 if (Attr && Name == Attr->getLabel()) {
1167 unsigned BuiltinID = FD->getBuiltinID();
1170 StringRef BuiltinName = BI.GetName(BuiltinID);
1171 if (BuiltinName.startswith("__builtin_") &&
1172 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1181 // isTriviallyRecursive - Check if this function calls another
1182 // decl that, because of the asm attribute or the other decl being a builtin,
1183 // ends up pointing to itself.
1185 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1187 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1188 // asm labels are a special kind of mangling we have to support.
1189 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1192 Name = Attr->getLabel();
1194 Name = FD->getName();
1197 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1198 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1199 return Walker.Result;
1203 CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1204 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1206 if (CodeGenOpts.OptimizationLevel == 0 &&
1207 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
1209 // PR9614. Avoid cases where the source code is lying to us. An available
1210 // externally function should have an equivalent function somewhere else,
1211 // but a function that calls itself is clearly not equivalent to the real
1213 // This happens in glibc's btowc and in some configure checks.
1214 return !isTriviallyRecursive(F);
1217 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
1218 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
1220 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
1221 Context.getSourceManager(),
1222 "Generating code for declaration");
1224 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1225 // At -O0, don't generate IR for functions with available_externally
1227 if (!shouldEmitFunction(Function))
1230 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1231 // Make sure to emit the definition(s) before we emit the thunks.
1232 // This is necessary for the generation of certain thunks.
1233 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1234 EmitCXXConstructor(CD, GD.getCtorType());
1235 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1236 EmitCXXDestructor(DD, GD.getDtorType());
1238 EmitGlobalFunctionDefinition(GD);
1240 if (Method->isVirtual())
1241 getVTables().EmitThunks(GD);
1246 return EmitGlobalFunctionDefinition(GD);
1249 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1250 return EmitGlobalVarDefinition(VD);
1252 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
1255 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1256 /// module, create and return an llvm Function with the specified type. If there
1257 /// is something in the module with the specified name, return it potentially
1258 /// bitcasted to the right type.
1260 /// If D is non-null, it specifies a decl that correspond to this. This is used
1261 /// to set the attributes on the function when it is first created.
1263 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
1265 GlobalDecl D, bool ForVTable,
1266 llvm::AttributeSet ExtraAttrs) {
1267 // Lookup the entry, lazily creating it if necessary.
1268 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1270 if (WeakRefReferences.erase(Entry)) {
1271 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1272 if (FD && !FD->hasAttr<WeakAttr>())
1273 Entry->setLinkage(llvm::Function::ExternalLinkage);
1276 if (Entry->getType()->getElementType() == Ty)
1279 // Make sure the result is of the correct type.
1280 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
1283 // This function doesn't have a complete type (for example, the return
1284 // type is an incomplete struct). Use a fake type instead, and make
1285 // sure not to try to set attributes.
1286 bool IsIncompleteFunction = false;
1288 llvm::FunctionType *FTy;
1289 if (isa<llvm::FunctionType>(Ty)) {
1290 FTy = cast<llvm::FunctionType>(Ty);
1292 FTy = llvm::FunctionType::get(VoidTy, false);
1293 IsIncompleteFunction = true;
1296 llvm::Function *F = llvm::Function::Create(FTy,
1297 llvm::Function::ExternalLinkage,
1298 MangledName, &getModule());
1299 assert(F->getName() == MangledName && "name was uniqued!");
1301 SetFunctionAttributes(D, F, IsIncompleteFunction);
1302 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1303 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
1304 F->addAttributes(llvm::AttributeSet::FunctionIndex,
1305 llvm::AttributeSet::get(VMContext,
1306 llvm::AttributeSet::FunctionIndex,
1310 // This is the first use or definition of a mangled name. If there is a
1311 // deferred decl with this name, remember that we need to emit it at the end
1313 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1314 if (DDI != DeferredDecls.end()) {
1315 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1316 // list, and remove it from DeferredDecls (since we don't need it anymore).
1317 DeferredDeclsToEmit.push_back(DDI->second);
1318 DeferredDecls.erase(DDI);
1320 // Otherwise, there are cases we have to worry about where we're
1321 // using a declaration for which we must emit a definition but where
1322 // we might not find a top-level definition:
1323 // - member functions defined inline in their classes
1324 // - friend functions defined inline in some class
1325 // - special member functions with implicit definitions
1326 // If we ever change our AST traversal to walk into class methods,
1327 // this will be unnecessary.
1329 // We also don't emit a definition for a function if it's going to be an entry
1330 // in a vtable, unless it's already marked as used.
1331 } else if (getLangOpts().CPlusPlus && D.getDecl()) {
1332 // Look for a declaration that's lexically in a record.
1333 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
1334 FD = FD->getMostRecentDecl();
1336 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
1337 if (FD->isImplicit() && !ForVTable) {
1338 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
1339 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1341 } else if (FD->doesThisDeclarationHaveABody()) {
1342 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1346 FD = FD->getPreviousDecl();
1350 // Make sure the result is of the requested type.
1351 if (!IsIncompleteFunction) {
1352 assert(F->getType()->getElementType() == Ty);
1356 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
1357 return llvm::ConstantExpr::getBitCast(F, PTy);
1360 /// GetAddrOfFunction - Return the address of the given function. If Ty is
1361 /// non-null, then this function will use the specified type if it has to
1362 /// create it (this occurs when we see a definition of the function).
1363 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
1366 // If there was no specific requested type, just convert it now.
1368 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
1370 StringRef MangledName = getMangledName(GD);
1371 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
1374 /// CreateRuntimeFunction - Create a new runtime function with the specified
1377 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
1379 llvm::AttributeSet ExtraAttrs) {
1381 = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1383 if (llvm::Function *F = dyn_cast<llvm::Function>(C))
1385 F->setCallingConv(getRuntimeCC());
1389 /// isTypeConstant - Determine whether an object of this type can be emitted
1392 /// If ExcludeCtor is true, the duration when the object's constructor runs
1393 /// will not be considered. The caller will need to verify that the object is
1394 /// not written to during its construction.
1395 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1396 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
1399 if (Context.getLangOpts().CPlusPlus) {
1400 if (const CXXRecordDecl *Record
1401 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1402 return ExcludeCtor && !Record->hasMutableFields() &&
1403 Record->hasTrivialDestructor();
1409 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1410 /// create and return an llvm GlobalVariable with the specified type. If there
1411 /// is something in the module with the specified name, return it potentially
1412 /// bitcasted to the right type.
1414 /// If D is non-null, it specifies a decl that correspond to this. This is used
1415 /// to set the attributes on the global when it is first created.
1417 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
1418 llvm::PointerType *Ty,
1421 // Lookup the entry, lazily creating it if necessary.
1422 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1424 if (WeakRefReferences.erase(Entry)) {
1425 if (D && !D->hasAttr<WeakAttr>())
1426 Entry->setLinkage(llvm::Function::ExternalLinkage);
1430 Entry->setUnnamedAddr(true);
1432 if (Entry->getType() == Ty)
1435 // Make sure the result is of the correct type.
1436 return llvm::ConstantExpr::getBitCast(Entry, Ty);
1439 // This is the first use or definition of a mangled name. If there is a
1440 // deferred decl with this name, remember that we need to emit it at the end
1442 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1443 if (DDI != DeferredDecls.end()) {
1444 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1445 // list, and remove it from DeferredDecls (since we don't need it anymore).
1446 DeferredDeclsToEmit.push_back(DDI->second);
1447 DeferredDecls.erase(DDI);
1450 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
1451 llvm::GlobalVariable *GV =
1452 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
1453 llvm::GlobalValue::ExternalLinkage,
1455 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
1457 // Handle things which are present even on external declarations.
1459 // FIXME: This code is overly simple and should be merged with other global
1461 GV->setConstant(isTypeConstant(D->getType(), false));
1463 // Set linkage and visibility in case we never see a definition.
1464 LinkageInfo LV = D->getLinkageAndVisibility();
1465 if (LV.getLinkage() != ExternalLinkage) {
1466 // Don't set internal linkage on declarations.
1468 if (D->hasAttr<DLLImportAttr>())
1469 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
1470 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
1471 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1473 // Set visibility on a declaration only if it's explicit.
1474 if (LV.isVisibilityExplicit())
1475 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
1478 if (D->isThreadSpecified())
1482 if (AddrSpace != Ty->getAddressSpace())
1483 return llvm::ConstantExpr::getBitCast(GV, Ty);
1489 llvm::GlobalVariable *
1490 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
1492 llvm::GlobalValue::LinkageTypes Linkage) {
1493 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1494 llvm::GlobalVariable *OldGV = 0;
1498 // Check if the variable has the right type.
1499 if (GV->getType()->getElementType() == Ty)
1502 // Because C++ name mangling, the only way we can end up with an already
1503 // existing global with the same name is if it has been declared extern "C".
1504 assert(GV->isDeclaration() && "Declaration has wrong type!");
1508 // Create a new variable.
1509 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1513 // Replace occurrences of the old variable if needed.
1514 GV->takeName(OldGV);
1516 if (!OldGV->use_empty()) {
1517 llvm::Constant *NewPtrForOldDecl =
1518 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1519 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1522 OldGV->eraseFromParent();
1528 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1529 /// given global variable. If Ty is non-null and if the global doesn't exist,
1530 /// then it will be created with the specified type instead of whatever the
1531 /// normal requested type would be.
1532 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1534 assert(D->hasGlobalStorage() && "Not a global variable");
1535 QualType ASTTy = D->getType();
1537 Ty = getTypes().ConvertTypeForMem(ASTTy);
1539 llvm::PointerType *PTy =
1540 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
1542 StringRef MangledName = getMangledName(D);
1543 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
1546 /// CreateRuntimeVariable - Create a new runtime global variable with the
1547 /// specified type and name.
1549 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
1551 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
1555 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1556 assert(!D->getInit() && "Cannot emit definite definitions here!");
1558 if (MayDeferGeneration(D)) {
1559 // If we have not seen a reference to this variable yet, place it
1560 // into the deferred declarations table to be emitted if needed
1562 StringRef MangledName = getMangledName(D);
1563 if (!GetGlobalValue(MangledName)) {
1564 DeferredDecls[MangledName] = D;
1569 // The tentative definition is the only definition.
1570 EmitGlobalVarDefinition(D);
1573 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
1574 return Context.toCharUnitsFromBits(
1575 TheDataLayout.getTypeStoreSizeInBits(Ty));
1579 CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1580 const Expr *rawInit) {
1581 ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1582 if (const ExprWithCleanups *withCleanups =
1583 dyn_cast<ExprWithCleanups>(rawInit)) {
1584 cleanups = withCleanups->getObjects();
1585 rawInit = withCleanups->getSubExpr();
1588 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1589 if (!init || !init->initializesStdInitializerList() ||
1590 init->getNumInits() == 0)
1593 ASTContext &ctx = getContext();
1594 unsigned numInits = init->getNumInits();
1595 // FIXME: This check is here because we would otherwise silently miscompile
1596 // nested global std::initializer_lists. Better would be to have a real
1598 for (unsigned i = 0; i < numInits; ++i) {
1599 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1600 if (inner && inner->initializesStdInitializerList()) {
1601 ErrorUnsupported(inner, "nested global std::initializer_list");
1606 // Synthesize a fake VarDecl for the array and initialize that.
1607 QualType elementType = init->getInit(0)->getType();
1608 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1609 QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1610 ArrayType::Normal, 0);
1612 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1613 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1614 arrayType, D->getLocation());
1615 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1616 D->getDeclContext()),
1617 D->getLocStart(), D->getLocation(),
1618 name, arrayType, sourceInfo,
1621 // Now clone the InitListExpr to initialize the array instead.
1622 // Incredible hack: we want to use the existing InitListExpr here, so we need
1623 // to tell it that it no longer initializes a std::initializer_list.
1624 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1625 init->getNumInits());
1626 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1627 init->getRBraceLoc());
1628 arrayInit->setType(arrayType);
1630 if (!cleanups.empty())
1631 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1633 backingArray->setInit(arrayInit);
1635 // Emit the definition of the array.
1636 EmitGlobalVarDefinition(backingArray);
1638 // Inspect the initializer list to validate it and determine its type.
1639 // FIXME: doing this every time is probably inefficient; caching would be nice
1640 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1641 RecordDecl::field_iterator field = record->field_begin();
1642 if (field == record->field_end()) {
1643 ErrorUnsupported(D, "weird std::initializer_list");
1646 QualType elementPtr = ctx.getPointerType(elementType.withConst());
1648 if (!ctx.hasSameType(field->getType(), elementPtr)) {
1649 ErrorUnsupported(D, "weird std::initializer_list");
1653 if (field == record->field_end()) {
1654 ErrorUnsupported(D, "weird std::initializer_list");
1657 bool isStartEnd = false;
1658 if (ctx.hasSameType(field->getType(), elementPtr)) {
1661 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1662 ErrorUnsupported(D, "weird std::initializer_list");
1666 // Now build an APValue representing the std::initializer_list.
1667 APValue initListValue(APValue::UninitStruct(), 0, 2);
1668 APValue &startField = initListValue.getStructField(0);
1669 APValue::LValuePathEntry startOffsetPathEntry;
1670 startOffsetPathEntry.ArrayIndex = 0;
1671 startField = APValue(APValue::LValueBase(backingArray),
1672 CharUnits::fromQuantity(0),
1673 llvm::makeArrayRef(startOffsetPathEntry),
1674 /*IsOnePastTheEnd=*/false, 0);
1677 APValue &endField = initListValue.getStructField(1);
1678 APValue::LValuePathEntry endOffsetPathEntry;
1679 endOffsetPathEntry.ArrayIndex = numInits;
1680 endField = APValue(APValue::LValueBase(backingArray),
1681 ctx.getTypeSizeInChars(elementType) * numInits,
1682 llvm::makeArrayRef(endOffsetPathEntry),
1683 /*IsOnePastTheEnd=*/true, 0);
1685 APValue &sizeField = initListValue.getStructField(1);
1686 sizeField = APValue(llvm::APSInt(numElements));
1689 // Emit the constant for the initializer_list.
1690 llvm::Constant *llvmInit =
1691 EmitConstantValueForMemory(initListValue, D->getType());
1692 assert(llvmInit && "failed to initialize as constant");
1696 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1697 unsigned AddrSpace) {
1698 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1699 if (D->hasAttr<CUDAConstantAttr>())
1700 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1701 else if (D->hasAttr<CUDASharedAttr>())
1702 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1704 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1710 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1711 llvm::Constant *Init = 0;
1712 QualType ASTTy = D->getType();
1713 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1714 bool NeedsGlobalCtor = false;
1715 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
1717 const VarDecl *InitDecl;
1718 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
1721 // This is a tentative definition; tentative definitions are
1722 // implicitly initialized with { 0 }.
1724 // Note that tentative definitions are only emitted at the end of
1725 // a translation unit, so they should never have incomplete
1726 // type. In addition, EmitTentativeDefinition makes sure that we
1727 // never attempt to emit a tentative definition if a real one
1728 // exists. A use may still exists, however, so we still may need
1730 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
1731 Init = EmitNullConstant(D->getType());
1733 // If this is a std::initializer_list, emit the special initializer.
1734 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1735 // An empty init list will perform zero-initialization, which happens
1736 // to be exactly what we want.
1737 // FIXME: It does so in a global constructor, which is *not* what we
1741 initializedGlobalDecl = GlobalDecl(D);
1742 Init = EmitConstantInit(*InitDecl);
1745 QualType T = InitExpr->getType();
1746 if (D->getType()->isReferenceType())
1749 if (getLangOpts().CPlusPlus) {
1750 Init = EmitNullConstant(T);
1751 NeedsGlobalCtor = true;
1753 ErrorUnsupported(D, "static initializer");
1754 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1757 // We don't need an initializer, so remove the entry for the delayed
1758 // initializer position (just in case this entry was delayed) if we
1759 // also don't need to register a destructor.
1760 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
1761 DelayedCXXInitPosition.erase(D);
1765 llvm::Type* InitType = Init->getType();
1766 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
1768 // Strip off a bitcast if we got one back.
1769 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1770 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1771 // all zero index gep.
1772 CE->getOpcode() == llvm::Instruction::GetElementPtr);
1773 Entry = CE->getOperand(0);
1776 // Entry is now either a Function or GlobalVariable.
1777 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
1779 // We have a definition after a declaration with the wrong type.
1780 // We must make a new GlobalVariable* and update everything that used OldGV
1781 // (a declaration or tentative definition) with the new GlobalVariable*
1782 // (which will be a definition).
1784 // This happens if there is a prototype for a global (e.g.
1785 // "extern int x[];") and then a definition of a different type (e.g.
1786 // "int x[10];"). This also happens when an initializer has a different type
1787 // from the type of the global (this happens with unions).
1789 GV->getType()->getElementType() != InitType ||
1790 GV->getType()->getAddressSpace() !=
1791 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
1793 // Move the old entry aside so that we'll create a new one.
1794 Entry->setName(StringRef());
1796 // Make a new global with the correct type, this is now guaranteed to work.
1797 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
1799 // Replace all uses of the old global with the new global
1800 llvm::Constant *NewPtrForOldDecl =
1801 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
1802 Entry->replaceAllUsesWith(NewPtrForOldDecl);
1804 // Erase the old global, since it is no longer used.
1805 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
1808 if (D->hasAttr<AnnotateAttr>())
1809 AddGlobalAnnotations(D, GV);
1811 GV->setInitializer(Init);
1813 // If it is safe to mark the global 'constant', do so now.
1814 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1815 isTypeConstant(D->getType(), true));
1817 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1819 // Set the llvm linkage type as appropriate.
1820 llvm::GlobalValue::LinkageTypes Linkage =
1821 GetLLVMLinkageVarDefinition(D, GV);
1822 GV->setLinkage(Linkage);
1823 if (Linkage == llvm::GlobalVariable::CommonLinkage)
1824 // common vars aren't constant even if declared const.
1825 GV->setConstant(false);
1827 SetCommonAttributes(D, GV);
1829 // Emit the initializer function if necessary.
1830 if (NeedsGlobalCtor || NeedsGlobalDtor)
1831 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
1833 // If we are compiling with ASan, add metadata indicating dynamically
1834 // initialized globals.
1835 if (SanOpts.Address && NeedsGlobalCtor) {
1836 llvm::Module &M = getModule();
1838 llvm::NamedMDNode *DynamicInitializers =
1839 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1840 llvm::Value *GlobalToAdd[] = { GV };
1841 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1842 DynamicInitializers->addOperand(ThisGlobal);
1845 // Emit global variable debug information.
1846 if (CGDebugInfo *DI = getModuleDebugInfo())
1847 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
1848 DI->EmitGlobalVariable(GV, D);
1851 llvm::GlobalValue::LinkageTypes
1852 CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1853 llvm::GlobalVariable *GV) {
1854 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1855 if (Linkage == GVA_Internal)
1856 return llvm::Function::InternalLinkage;
1857 else if (D->hasAttr<DLLImportAttr>())
1858 return llvm::Function::DLLImportLinkage;
1859 else if (D->hasAttr<DLLExportAttr>())
1860 return llvm::Function::DLLExportLinkage;
1861 else if (D->hasAttr<WeakAttr>()) {
1862 if (GV->isConstant())
1863 return llvm::GlobalVariable::WeakODRLinkage;
1865 return llvm::GlobalVariable::WeakAnyLinkage;
1866 } else if (Linkage == GVA_TemplateInstantiation ||
1867 Linkage == GVA_ExplicitTemplateInstantiation)
1868 return llvm::GlobalVariable::WeakODRLinkage;
1869 else if (!getLangOpts().CPlusPlus &&
1870 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1871 D->getAttr<CommonAttr>()) &&
1872 !D->hasExternalStorage() && !D->getInit() &&
1873 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1874 !D->getAttr<WeakImportAttr>()) {
1875 // Thread local vars aren't considered common linkage.
1876 return llvm::GlobalVariable::CommonLinkage;
1878 return llvm::GlobalVariable::ExternalLinkage;
1881 /// Replace the uses of a function that was declared with a non-proto type.
1882 /// We want to silently drop extra arguments from call sites
1883 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
1884 llvm::Function *newFn) {
1886 if (old->use_empty()) return;
1888 llvm::Type *newRetTy = newFn->getReturnType();
1889 SmallVector<llvm::Value*, 4> newArgs;
1891 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
1893 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
1894 llvm::User *user = *use;
1896 // Recognize and replace uses of bitcasts. Most calls to
1897 // unprototyped functions will use bitcasts.
1898 if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
1899 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
1900 replaceUsesOfNonProtoConstant(bitcast, newFn);
1904 // Recognize calls to the function.
1905 llvm::CallSite callSite(user);
1906 if (!callSite) continue;
1907 if (!callSite.isCallee(use)) continue;
1909 // If the return types don't match exactly, then we can't
1910 // transform this call unless it's dead.
1911 if (callSite->getType() != newRetTy && !callSite->use_empty())
1914 // Get the call site's attribute list.
1915 SmallVector<llvm::AttributeSet, 8> newAttrs;
1916 llvm::AttributeSet oldAttrs = callSite.getAttributes();
1918 // Collect any return attributes from the call.
1919 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
1921 llvm::AttributeSet::get(newFn->getContext(),
1922 oldAttrs.getRetAttributes()));
1924 // If the function was passed too few arguments, don't transform.
1925 unsigned newNumArgs = newFn->arg_size();
1926 if (callSite.arg_size() < newNumArgs) continue;
1928 // If extra arguments were passed, we silently drop them.
1929 // If any of the types mismatch, we don't transform.
1931 bool dontTransform = false;
1932 for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
1933 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
1934 if (callSite.getArgument(argNo)->getType() != ai->getType()) {
1935 dontTransform = true;
1939 // Add any parameter attributes.
1940 if (oldAttrs.hasAttributes(argNo + 1))
1943 AttributeSet::get(newFn->getContext(),
1944 oldAttrs.getParamAttributes(argNo + 1)));
1949 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
1950 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
1951 oldAttrs.getFnAttributes()));
1953 // Okay, we can transform this. Create the new call instruction and copy
1954 // over the required information.
1955 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
1957 llvm::CallSite newCall;
1958 if (callSite.isCall()) {
1959 newCall = llvm::CallInst::Create(newFn, newArgs, "",
1960 callSite.getInstruction());
1962 llvm::InvokeInst *oldInvoke =
1963 cast<llvm::InvokeInst>(callSite.getInstruction());
1964 newCall = llvm::InvokeInst::Create(newFn,
1965 oldInvoke->getNormalDest(),
1966 oldInvoke->getUnwindDest(),
1968 callSite.getInstruction());
1970 newArgs.clear(); // for the next iteration
1972 if (!newCall->getType()->isVoidTy())
1973 newCall->takeName(callSite.getInstruction());
1974 newCall.setAttributes(
1975 llvm::AttributeSet::get(newFn->getContext(), newAttrs));
1976 newCall.setCallingConv(callSite.getCallingConv());
1978 // Finally, remove the old call, replacing any uses with the new one.
1979 if (!callSite->use_empty())
1980 callSite->replaceAllUsesWith(newCall.getInstruction());
1982 // Copy debug location attached to CI.
1983 if (!callSite->getDebugLoc().isUnknown())
1984 newCall->setDebugLoc(callSite->getDebugLoc());
1985 callSite->eraseFromParent();
1989 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1990 /// implement a function with no prototype, e.g. "int foo() {}". If there are
1991 /// existing call uses of the old function in the module, this adjusts them to
1992 /// call the new function directly.
1994 /// This is not just a cleanup: the always_inline pass requires direct calls to
1995 /// functions to be able to inline them. If there is a bitcast in the way, it
1996 /// won't inline them. Instcombine normally deletes these calls, but it isn't
1998 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1999 llvm::Function *NewFn) {
2000 // If we're redefining a global as a function, don't transform it.
2001 if (!isa<llvm::Function>(Old)) return;
2003 replaceUsesOfNonProtoConstant(Old, NewFn);
2006 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2007 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2008 // If we have a definition, this might be a deferred decl. If the
2009 // instantiation is explicit, make sure we emit it at the end.
2010 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2011 GetAddrOfGlobalVar(VD);
2013 EmitTopLevelDecl(VD);
2016 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
2017 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
2019 // Compute the function info and LLVM type.
2020 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2021 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2023 // Get or create the prototype for the function.
2024 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
2026 // Strip off a bitcast if we got one back.
2027 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2028 assert(CE->getOpcode() == llvm::Instruction::BitCast);
2029 Entry = CE->getOperand(0);
2033 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
2034 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
2036 // If the types mismatch then we have to rewrite the definition.
2037 assert(OldFn->isDeclaration() &&
2038 "Shouldn't replace non-declaration");
2040 // F is the Function* for the one with the wrong type, we must make a new
2041 // Function* and update everything that used F (a declaration) with the new
2042 // Function* (which will be a definition).
2044 // This happens if there is a prototype for a function
2045 // (e.g. "int f()") and then a definition of a different type
2046 // (e.g. "int f(int x)"). Move the old function aside so that it
2047 // doesn't interfere with GetAddrOfFunction.
2048 OldFn->setName(StringRef());
2049 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
2051 // This might be an implementation of a function without a
2052 // prototype, in which case, try to do special replacement of
2053 // calls which match the new prototype. The really key thing here
2054 // is that we also potentially drop arguments from the call site
2055 // so as to make a direct call, which makes the inliner happier
2056 // and suppresses a number of optimizer warnings (!) about
2057 // dropping arguments.
2058 if (!OldFn->use_empty()) {
2059 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
2060 OldFn->removeDeadConstantUsers();
2063 // Replace uses of F with the Function we will endow with a body.
2064 if (!Entry->use_empty()) {
2065 llvm::Constant *NewPtrForOldDecl =
2066 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
2067 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2070 // Ok, delete the old function now, which is dead.
2071 OldFn->eraseFromParent();
2076 // We need to set linkage and visibility on the function before
2077 // generating code for it because various parts of IR generation
2078 // want to propagate this information down (e.g. to local static
2080 llvm::Function *Fn = cast<llvm::Function>(Entry);
2081 setFunctionLinkage(D, Fn);
2083 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
2084 setGlobalVisibility(Fn, D);
2086 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
2088 SetFunctionDefinitionAttributes(D, Fn);
2089 SetLLVMFunctionAttributesForDefinition(D, Fn);
2091 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
2092 AddGlobalCtor(Fn, CA->getPriority());
2093 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
2094 AddGlobalDtor(Fn, DA->getPriority());
2095 if (D->hasAttr<AnnotateAttr>())
2096 AddGlobalAnnotations(D, Fn);
2099 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2100 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
2101 const AliasAttr *AA = D->getAttr<AliasAttr>();
2102 assert(AA && "Not an alias?");
2104 StringRef MangledName = getMangledName(GD);
2106 // If there is a definition in the module, then it wins over the alias.
2107 // This is dubious, but allow it to be safe. Just ignore the alias.
2108 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2109 if (Entry && !Entry->isDeclaration())
2112 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
2114 // Create a reference to the named value. This ensures that it is emitted
2115 // if a deferred decl.
2116 llvm::Constant *Aliasee;
2117 if (isa<llvm::FunctionType>(DeclTy))
2118 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
2119 /*ForVTable=*/false);
2121 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2122 llvm::PointerType::getUnqual(DeclTy), 0);
2124 // Create the new alias itself, but don't set a name yet.
2125 llvm::GlobalValue *GA =
2126 new llvm::GlobalAlias(Aliasee->getType(),
2127 llvm::Function::ExternalLinkage,
2128 "", Aliasee, &getModule());
2131 assert(Entry->isDeclaration());
2133 // If there is a declaration in the module, then we had an extern followed
2134 // by the alias, as in:
2135 // extern int test6();
2137 // int test6() __attribute__((alias("test7")));
2139 // Remove it and replace uses of it with the alias.
2140 GA->takeName(Entry);
2142 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
2144 Entry->eraseFromParent();
2146 GA->setName(MangledName);
2149 // Set attributes which are particular to an alias; this is a
2150 // specialization of the attributes which may be set on a global
2151 // variable/function.
2152 if (D->hasAttr<DLLExportAttr>()) {
2153 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2154 // The dllexport attribute is ignored for undefined symbols.
2156 GA->setLinkage(llvm::Function::DLLExportLinkage);
2158 GA->setLinkage(llvm::Function::DLLExportLinkage);
2160 } else if (D->hasAttr<WeakAttr>() ||
2161 D->hasAttr<WeakRefAttr>() ||
2162 D->isWeakImported()) {
2163 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2166 SetCommonAttributes(D, GA);
2169 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
2170 ArrayRef<llvm::Type*> Tys) {
2171 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
2175 static llvm::StringMapEntry<llvm::Constant*> &
2176 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2177 const StringLiteral *Literal,
2180 unsigned &StringLength) {
2181 StringRef String = Literal->getString();
2182 unsigned NumBytes = String.size();
2184 // Check for simple case.
2185 if (!Literal->containsNonAsciiOrNull()) {
2186 StringLength = NumBytes;
2187 return Map.GetOrCreateValue(String);
2190 // Otherwise, convert the UTF8 literals into a string of shorts.
2193 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
2194 const UTF8 *FromPtr = (const UTF8 *)String.data();
2195 UTF16 *ToPtr = &ToBuf[0];
2197 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2198 &ToPtr, ToPtr + NumBytes,
2201 // ConvertUTF8toUTF16 returns the length in ToPtr.
2202 StringLength = ToPtr - &ToBuf[0];
2204 // Add an explicit null.
2207 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2208 (StringLength + 1) * 2));
2211 static llvm::StringMapEntry<llvm::Constant*> &
2212 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2213 const StringLiteral *Literal,
2214 unsigned &StringLength) {
2215 StringRef String = Literal->getString();
2216 StringLength = String.size();
2217 return Map.GetOrCreateValue(String);
2221 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2222 unsigned StringLength = 0;
2223 bool isUTF16 = false;
2224 llvm::StringMapEntry<llvm::Constant*> &Entry =
2225 GetConstantCFStringEntry(CFConstantStringMap, Literal,
2226 getDataLayout().isLittleEndian(),
2227 isUTF16, StringLength);
2229 if (llvm::Constant *C = Entry.getValue())
2232 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2233 llvm::Constant *Zeros[] = { Zero, Zero };
2235 // If we don't already have it, get __CFConstantStringClassReference.
2236 if (!CFConstantStringClassRef) {
2237 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2238 Ty = llvm::ArrayType::get(Ty, 0);
2239 llvm::Constant *GV = CreateRuntimeVariable(Ty,
2240 "__CFConstantStringClassReference");
2241 // Decay array -> ptr
2242 CFConstantStringClassRef =
2243 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2246 QualType CFTy = getContext().getCFConstantStringType();
2248 llvm::StructType *STy =
2249 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2251 llvm::Constant *Fields[4];
2254 Fields[0] = CFConstantStringClassRef;
2257 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2258 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
2259 llvm::ConstantInt::get(Ty, 0x07C8);
2262 llvm::Constant *C = 0;
2264 ArrayRef<uint16_t> Arr =
2265 llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>(
2266 const_cast<char *>(Entry.getKey().data())),
2267 Entry.getKey().size() / 2);
2268 C = llvm::ConstantDataArray::get(VMContext, Arr);
2270 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2273 llvm::GlobalValue::LinkageTypes Linkage;
2275 // FIXME: why do utf strings get "_" labels instead of "L" labels?
2276 Linkage = llvm::GlobalValue::InternalLinkage;
2278 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2279 // when using private linkage. It is not clear if this is a bug in ld
2280 // or a reasonable new restriction.
2281 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
2283 // Note: -fwritable-strings doesn't make the backing store strings of
2284 // CFStrings writable. (See <rdar://problem/10657500>)
2285 llvm::GlobalVariable *GV =
2286 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2287 Linkage, C, ".str");
2288 GV->setUnnamedAddr(true);
2290 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2291 GV->setAlignment(Align.getQuantity());
2293 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2294 GV->setAlignment(Align.getQuantity());
2298 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2301 // Cast the UTF16 string to the correct type.
2302 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2305 Ty = getTypes().ConvertType(getContext().LongTy);
2306 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
2309 C = llvm::ConstantStruct::get(STy, Fields);
2310 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2311 llvm::GlobalVariable::PrivateLinkage, C,
2312 "_unnamed_cfstring_");
2313 if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
2314 GV->setSection(Sect);
2321 CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2322 DeclContext *DC, IdentifierInfo *Id) {
2324 if (Ctx.getLangOpts().CPlusPlus)
2325 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2327 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2331 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
2332 unsigned StringLength = 0;
2333 llvm::StringMapEntry<llvm::Constant*> &Entry =
2334 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
2336 if (llvm::Constant *C = Entry.getValue())
2339 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2340 llvm::Constant *Zeros[] = { Zero, Zero };
2342 // If we don't already have it, get _NSConstantStringClassReference.
2343 if (!ConstantStringClassRef) {
2344 std::string StringClass(getLangOpts().ObjCConstantStringClass);
2345 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2347 if (LangOpts.ObjCRuntime.isNonFragile()) {
2349 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2350 : "OBJC_CLASS_$_" + StringClass;
2351 GV = getObjCRuntime().GetClassGlobal(str);
2352 // Make sure the result is of the correct type.
2353 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2354 ConstantStringClassRef =
2355 llvm::ConstantExpr::getBitCast(GV, PTy);
2358 StringClass.empty() ? "_NSConstantStringClassReference"
2359 : "_" + StringClass + "ClassReference";
2360 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
2361 GV = CreateRuntimeVariable(PTy, str);
2362 // Decay array -> ptr
2363 ConstantStringClassRef =
2364 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2368 if (!NSConstantStringType) {
2369 // Construct the type for a constant NSString.
2370 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2371 Context.getTranslationUnitDecl(),
2372 &Context.Idents.get("__builtin_NSString"));
2373 D->startDefinition();
2375 QualType FieldTypes[3];
2378 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2380 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2381 // unsigned int length;
2382 FieldTypes[2] = Context.UnsignedIntTy;
2385 for (unsigned i = 0; i < 3; ++i) {
2386 FieldDecl *Field = FieldDecl::Create(Context, D,
2388 SourceLocation(), 0,
2389 FieldTypes[i], /*TInfo=*/0,
2393 Field->setAccess(AS_public);
2397 D->completeDefinition();
2398 QualType NSTy = Context.getTagDeclType(D);
2399 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2402 llvm::Constant *Fields[3];
2405 Fields[0] = ConstantStringClassRef;
2409 llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2411 llvm::GlobalValue::LinkageTypes Linkage;
2413 Linkage = llvm::GlobalValue::PrivateLinkage;
2414 isConstant = !LangOpts.WritableStrings;
2416 llvm::GlobalVariable *GV =
2417 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2419 GV->setUnnamedAddr(true);
2420 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2421 GV->setAlignment(Align.getQuantity());
2422 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2425 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2426 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2429 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
2430 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2431 llvm::GlobalVariable::PrivateLinkage, C,
2432 "_unnamed_nsstring_");
2433 // FIXME. Fix section.
2434 if (const char *Sect =
2435 LangOpts.ObjCRuntime.isNonFragile()
2436 ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2437 : getContext().getTargetInfo().getNSStringSection())
2438 GV->setSection(Sect);
2444 QualType CodeGenModule::getObjCFastEnumerationStateType() {
2445 if (ObjCFastEnumerationStateType.isNull()) {
2446 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2447 Context.getTranslationUnitDecl(),
2448 &Context.Idents.get("__objcFastEnumerationState"));
2449 D->startDefinition();
2451 QualType FieldTypes[] = {
2452 Context.UnsignedLongTy,
2453 Context.getPointerType(Context.getObjCIdType()),
2454 Context.getPointerType(Context.UnsignedLongTy),
2455 Context.getConstantArrayType(Context.UnsignedLongTy,
2456 llvm::APInt(32, 5), ArrayType::Normal, 0)
2459 for (size_t i = 0; i < 4; ++i) {
2460 FieldDecl *Field = FieldDecl::Create(Context,
2463 SourceLocation(), 0,
2464 FieldTypes[i], /*TInfo=*/0,
2468 Field->setAccess(AS_public);
2472 D->completeDefinition();
2473 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2476 return ObjCFastEnumerationStateType;
2480 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2481 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2483 // Don't emit it as the address of the string, emit the string data itself
2484 // as an inline array.
2485 if (E->getCharByteWidth() == 1) {
2486 SmallString<64> Str(E->getString());
2488 // Resize the string to the right size, which is indicated by its type.
2489 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2490 Str.resize(CAT->getSize().getZExtValue());
2491 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2494 llvm::ArrayType *AType =
2495 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2496 llvm::Type *ElemTy = AType->getElementType();
2497 unsigned NumElements = AType->getNumElements();
2499 // Wide strings have either 2-byte or 4-byte elements.
2500 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2501 SmallVector<uint16_t, 32> Elements;
2502 Elements.reserve(NumElements);
2504 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2505 Elements.push_back(E->getCodeUnit(i));
2506 Elements.resize(NumElements);
2507 return llvm::ConstantDataArray::get(VMContext, Elements);
2510 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2511 SmallVector<uint32_t, 32> Elements;
2512 Elements.reserve(NumElements);
2514 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2515 Elements.push_back(E->getCodeUnit(i));
2516 Elements.resize(NumElements);
2517 return llvm::ConstantDataArray::get(VMContext, Elements);
2520 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2521 /// constant array for the given string literal.
2523 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
2524 CharUnits Align = getContext().getTypeAlignInChars(S->getType());
2525 if (S->isAscii() || S->isUTF8()) {
2526 SmallString<64> Str(S->getString());
2528 // Resize the string to the right size, which is indicated by its type.
2529 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2530 Str.resize(CAT->getSize().getZExtValue());
2531 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
2534 // FIXME: the following does not memoize wide strings.
2535 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2536 llvm::GlobalVariable *GV =
2537 new llvm::GlobalVariable(getModule(),C->getType(),
2538 !LangOpts.WritableStrings,
2539 llvm::GlobalValue::PrivateLinkage,
2542 GV->setAlignment(Align.getQuantity());
2543 GV->setUnnamedAddr(true);
2547 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2548 /// array for the given ObjCEncodeExpr node.
2550 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2552 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
2554 return GetAddrOfConstantCString(Str);
2558 /// GenerateWritableString -- Creates storage for a string literal.
2559 static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
2562 const char *GlobalName,
2563 unsigned Alignment) {
2564 // Create Constant for this string literal. Don't add a '\0'.
2566 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
2568 // Create a global variable for this string
2569 llvm::GlobalVariable *GV =
2570 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2571 llvm::GlobalValue::PrivateLinkage,
2573 GV->setAlignment(Alignment);
2574 GV->setUnnamedAddr(true);
2578 /// GetAddrOfConstantString - Returns a pointer to a character array
2579 /// containing the literal. This contents are exactly that of the
2580 /// given string, i.e. it will not be null terminated automatically;
2581 /// see GetAddrOfConstantCString. Note that whether the result is
2582 /// actually a pointer to an LLVM constant depends on
2583 /// Feature.WriteableStrings.
2585 /// The result has pointer to array type.
2586 llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
2587 const char *GlobalName,
2588 unsigned Alignment) {
2589 // Get the default prefix if a name wasn't specified.
2591 GlobalName = ".str";
2593 // Don't share any string literals if strings aren't constant.
2594 if (LangOpts.WritableStrings)
2595 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
2597 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2598 ConstantStringMap.GetOrCreateValue(Str);
2600 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2601 if (Alignment > GV->getAlignment()) {
2602 GV->setAlignment(Alignment);
2607 // Create a global variable for this.
2608 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2614 /// GetAddrOfConstantCString - Returns a pointer to a character
2615 /// array containing the literal and a terminating '\0'
2616 /// character. The result has pointer to array type.
2617 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
2618 const char *GlobalName,
2619 unsigned Alignment) {
2620 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
2621 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
2624 /// EmitObjCPropertyImplementations - Emit information for synthesized
2625 /// properties for an implementation.
2626 void CodeGenModule::EmitObjCPropertyImplementations(const
2627 ObjCImplementationDecl *D) {
2628 for (ObjCImplementationDecl::propimpl_iterator
2629 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
2630 ObjCPropertyImplDecl *PID = *i;
2632 // Dynamic is just for type-checking.
2633 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2634 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2636 // Determine which methods need to be implemented, some may have
2637 // been overridden. Note that ::isPropertyAccessor is not the method
2638 // we want, that just indicates if the decl came from a
2639 // property. What we want to know is if the method is defined in
2640 // this implementation.
2641 if (!D->getInstanceMethod(PD->getGetterName()))
2642 CodeGenFunction(*this).GenerateObjCGetter(
2643 const_cast<ObjCImplementationDecl *>(D), PID);
2644 if (!PD->isReadOnly() &&
2645 !D->getInstanceMethod(PD->getSetterName()))
2646 CodeGenFunction(*this).GenerateObjCSetter(
2647 const_cast<ObjCImplementationDecl *>(D), PID);
2652 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
2653 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2654 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
2655 ivar; ivar = ivar->getNextIvar())
2656 if (ivar->getType().isDestructedType())
2662 /// EmitObjCIvarInitializations - Emit information for ivar initialization
2663 /// for an implementation.
2664 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
2665 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2666 if (needsDestructMethod(D)) {
2667 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2668 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2669 ObjCMethodDecl *DTORMethod =
2670 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
2671 cxxSelector, getContext().VoidTy, 0, D,
2672 /*isInstance=*/true, /*isVariadic=*/false,
2673 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
2674 /*isDefined=*/false, ObjCMethodDecl::Required);
2675 D->addInstanceMethod(DTORMethod);
2676 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
2677 D->setHasDestructors(true);
2680 // If the implementation doesn't have any ivar initializers, we don't need
2681 // a .cxx_construct.
2682 if (D->getNumIvarInitializers() == 0)
2685 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2686 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2687 // The constructor returns 'self'.
2688 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2692 getContext().getObjCIdType(), 0,
2693 D, /*isInstance=*/true,
2694 /*isVariadic=*/false,
2695 /*isPropertyAccessor=*/true,
2696 /*isImplicitlyDeclared=*/true,
2697 /*isDefined=*/false,
2698 ObjCMethodDecl::Required);
2699 D->addInstanceMethod(CTORMethod);
2700 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
2701 D->setHasNonZeroConstructors(true);
2704 /// EmitNamespace - Emit all declarations in a namespace.
2705 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
2706 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
2708 EmitTopLevelDecl(*I);
2711 // EmitLinkageSpec - Emit all declarations in a linkage spec.
2712 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
2713 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2714 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
2715 ErrorUnsupported(LSD, "linkage spec");
2719 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
2721 // Meta-data for ObjC class includes references to implemented methods.
2722 // Generate class's method definitions first.
2723 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2724 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2725 MEnd = OID->meth_end();
2727 EmitTopLevelDecl(*M);
2729 EmitTopLevelDecl(*I);
2733 /// EmitTopLevelDecl - Emit code for a single top level declaration.
2734 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2735 // If an error has occurred, stop code generation, but continue
2736 // parsing and semantic analysis (to ensure all warnings and errors
2738 if (Diags.hasErrorOccurred())
2741 // Ignore dependent declarations.
2742 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2745 switch (D->getKind()) {
2746 case Decl::CXXConversion:
2747 case Decl::CXXMethod:
2748 case Decl::Function:
2749 // Skip function templates
2750 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2751 cast<FunctionDecl>(D)->isLateTemplateParsed())
2754 EmitGlobal(cast<FunctionDecl>(D));
2758 EmitGlobal(cast<VarDecl>(D));
2761 // Indirect fields from global anonymous structs and unions can be
2762 // ignored; only the actual variable requires IR gen support.
2763 case Decl::IndirectField:
2767 case Decl::Namespace:
2768 EmitNamespace(cast<NamespaceDecl>(D));
2770 // No code generation needed.
2771 case Decl::UsingShadow:
2773 case Decl::UsingDirective:
2774 case Decl::ClassTemplate:
2775 case Decl::FunctionTemplate:
2776 case Decl::TypeAliasTemplate:
2777 case Decl::NamespaceAlias:
2781 case Decl::CXXConstructor:
2782 // Skip function templates
2783 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2784 cast<FunctionDecl>(D)->isLateTemplateParsed())
2787 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2789 case Decl::CXXDestructor:
2790 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2792 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2795 case Decl::StaticAssert:
2799 // Objective-C Decls
2801 // Forward declarations, no (immediate) code generation.
2802 case Decl::ObjCInterface:
2803 case Decl::ObjCCategory:
2806 case Decl::ObjCProtocol: {
2807 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2808 if (Proto->isThisDeclarationADefinition())
2809 ObjCRuntime->GenerateProtocol(Proto);
2813 case Decl::ObjCCategoryImpl:
2814 // Categories have properties but don't support synthesize so we
2815 // can ignore them here.
2816 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
2819 case Decl::ObjCImplementation: {
2820 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2821 EmitObjCPropertyImplementations(OMD);
2822 EmitObjCIvarInitializations(OMD);
2823 ObjCRuntime->GenerateClass(OMD);
2824 // Emit global variable debug information.
2825 if (CGDebugInfo *DI = getModuleDebugInfo())
2826 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2827 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2828 OMD->getClassInterface()), OMD->getLocation());
2831 case Decl::ObjCMethod: {
2832 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2833 // If this is not a prototype, emit the body.
2835 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2838 case Decl::ObjCCompatibleAlias:
2839 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
2842 case Decl::LinkageSpec:
2843 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
2846 case Decl::FileScopeAsm: {
2847 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
2848 StringRef AsmString = AD->getAsmString()->getString();
2850 const std::string &S = getModule().getModuleInlineAsm();
2852 getModule().setModuleInlineAsm(AsmString);
2853 else if (S.end()[-1] == '\n')
2854 getModule().setModuleInlineAsm(S + AsmString.str());
2856 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
2860 case Decl::Import: {
2861 ImportDecl *Import = cast<ImportDecl>(D);
2863 // Ignore import declarations that come from imported modules.
2864 if (clang::Module *Owner = Import->getOwningModule()) {
2865 if (getLangOpts().CurrentModule.empty() ||
2866 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
2870 ImportedModules.insert(Import->getImportedModule());
2875 // Make sure we handled everything we should, every other kind is a
2876 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2877 // function. Need to recode Decl::Kind to do that easily.
2878 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2882 /// Turns the given pointer into a constant.
2883 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2885 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2886 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2887 return llvm::ConstantInt::get(i64, PtrInt);
2890 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2891 llvm::NamedMDNode *&GlobalMetadata,
2893 llvm::GlobalValue *Addr) {
2894 if (!GlobalMetadata)
2896 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2898 // TODO: should we report variant information for ctors/dtors?
2899 llvm::Value *Ops[] = {
2901 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2903 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
2906 /// Emits metadata nodes associating all the global values in the
2907 /// current module with the Decls they came from. This is useful for
2908 /// projects using IR gen as a subroutine.
2910 /// Since there's currently no way to associate an MDNode directly
2911 /// with an llvm::GlobalValue, we create a global named metadata
2912 /// with the name 'clang.global.decl.ptrs'.
2913 void CodeGenModule::EmitDeclMetadata() {
2914 llvm::NamedMDNode *GlobalMetadata = 0;
2916 // StaticLocalDeclMap
2917 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
2918 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2920 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2921 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2925 /// Emits metadata nodes for all the local variables in the current
2927 void CodeGenFunction::EmitDeclMetadata() {
2928 if (LocalDeclMap.empty()) return;
2930 llvm::LLVMContext &Context = getLLVMContext();
2932 // Find the unique metadata ID for this name.
2933 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2935 llvm::NamedMDNode *GlobalMetadata = 0;
2937 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2938 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2939 const Decl *D = I->first;
2940 llvm::Value *Addr = I->second;
2942 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2943 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2944 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
2945 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2946 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2947 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2952 void CodeGenModule::EmitCoverageFile() {
2953 if (!getCodeGenOpts().CoverageFile.empty()) {
2954 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2955 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2956 llvm::LLVMContext &Ctx = TheModule.getContext();
2957 llvm::MDString *CoverageFile =
2958 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
2959 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2960 llvm::MDNode *CU = CUNode->getOperand(i);
2961 llvm::Value *node[] = { CoverageFile, CU };
2962 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2963 GCov->addOperand(N);
2969 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2970 QualType GuidType) {
2971 // Sema has checked that all uuid strings are of the form
2972 // "12345678-1234-1234-1234-1234567890ab".
2973 assert(Uuid.size() == 36);
2974 const char *Uuidstr = Uuid.data();
2975 for (int i = 0; i < 36; ++i) {
2976 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
2977 else assert(isHexDigit(Uuidstr[i]));
2980 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16);
2981 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16);
2982 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
2983 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
2985 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
2986 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
2987 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
2988 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
2989 APValue& Arr = InitStruct.getStructField(3);
2990 Arr = APValue(APValue::UninitArray(), 8, 8);
2991 for (int t = 0; t < 8; ++t)
2992 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
2993 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
2995 return EmitConstantValue(InitStruct, GuidType);