clang  6.0.0svn
CodeGenModule.cpp
Go to the documentation of this file.
1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This coordinates the per-module state used while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenModule.h"
15 #include "CGBlocks.h"
16 #include "CGCUDARuntime.h"
17 #include "CGCXXABI.h"
18 #include "CGCall.h"
19 #include "CGDebugInfo.h"
20 #include "CGObjCRuntime.h"
21 #include "CGOpenCLRuntime.h"
22 #include "CGOpenMPRuntime.h"
23 #include "CGOpenMPRuntimeNVPTX.h"
24 #include "CodeGenFunction.h"
25 #include "CodeGenPGO.h"
26 #include "ConstantEmitter.h"
27 #include "CoverageMappingGen.h"
28 #include "TargetInfo.h"
29 #include "clang/AST/ASTContext.h"
30 #include "clang/AST/CharUnits.h"
31 #include "clang/AST/DeclCXX.h"
32 #include "clang/AST/DeclObjC.h"
33 #include "clang/AST/DeclTemplate.h"
34 #include "clang/AST/Mangle.h"
35 #include "clang/AST/RecordLayout.h"
37 #include "clang/Basic/Builtins.h"
38 #include "clang/Basic/CharInfo.h"
39 #include "clang/Basic/Diagnostic.h"
40 #include "clang/Basic/Module.h"
42 #include "clang/Basic/TargetInfo.h"
43 #include "clang/Basic/Version.h"
47 #include "llvm/ADT/Triple.h"
48 #include "llvm/Analysis/TargetLibraryInfo.h"
49 #include "llvm/IR/CallSite.h"
50 #include "llvm/IR/CallingConv.h"
51 #include "llvm/IR/DataLayout.h"
52 #include "llvm/IR/Intrinsics.h"
53 #include "llvm/IR/LLVMContext.h"
54 #include "llvm/IR/Module.h"
55 #include "llvm/ProfileData/InstrProfReader.h"
56 #include "llvm/Support/ConvertUTF.h"
57 #include "llvm/Support/ErrorHandling.h"
58 #include "llvm/Support/MD5.h"
59 
60 using namespace clang;
61 using namespace CodeGen;
62 
63 static llvm::cl::opt<bool> LimitedCoverage(
64  "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
65  llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
66  llvm::cl::init(false));
67 
68 static const char AnnotationSection[] = "llvm.metadata";
69 
71  switch (CGM.getTarget().getCXXABI().getKind()) {
74  case TargetCXXABI::iOS:
80  return CreateItaniumCXXABI(CGM);
82  return CreateMicrosoftCXXABI(CGM);
83  }
84 
85  llvm_unreachable("invalid C++ ABI kind");
86 }
87 
88 CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
89  const PreprocessorOptions &PPO,
90  const CodeGenOptions &CGO, llvm::Module &M,
91  DiagnosticsEngine &diags,
92  CoverageSourceInfo *CoverageInfo)
93  : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
94  PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
95  Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
96  VMContext(M.getContext()), Types(*this), VTables(*this),
97  SanitizerMD(new SanitizerMetadata(*this)) {
98 
99  // Initialize the type cache.
100  llvm::LLVMContext &LLVMContext = M.getContext();
101  VoidTy = llvm::Type::getVoidTy(LLVMContext);
102  Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
103  Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
104  Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
105  Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
106  FloatTy = llvm::Type::getFloatTy(LLVMContext);
107  DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
110  C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
114  C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
115  IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
116  IntPtrTy = llvm::IntegerType::get(LLVMContext,
118  Int8PtrTy = Int8Ty->getPointerTo(0);
119  Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
120  AllocaInt8PtrTy = Int8Ty->getPointerTo(
121  M.getDataLayout().getAllocaAddrSpace());
123 
126 
127  if (LangOpts.ObjC1)
128  createObjCRuntime();
129  if (LangOpts.OpenCL)
130  createOpenCLRuntime();
131  if (LangOpts.OpenMP)
132  createOpenMPRuntime();
133  if (LangOpts.CUDA)
134  createCUDARuntime();
135 
136  // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
137  if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
138  (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
139  TBAA.reset(new CodeGenTBAA(Context, TheModule, CodeGenOpts, getLangOpts(),
140  getCXXABI().getMangleContext()));
141 
142  // If debug info or coverage generation is enabled, create the CGDebugInfo
143  // object.
144  if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo ||
145  CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
146  DebugInfo.reset(new CGDebugInfo(*this));
147 
148  Block.GlobalUniqueCount = 0;
149 
150  if (C.getLangOpts().ObjC1)
151  ObjCData.reset(new ObjCEntrypoints());
152 
153  if (CodeGenOpts.hasProfileClangUse()) {
154  auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
155  CodeGenOpts.ProfileInstrumentUsePath);
156  if (auto E = ReaderOrErr.takeError()) {
157  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
158  "Could not read profile %0: %1");
159  llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
160  getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath
161  << EI.message();
162  });
163  } else
164  PGOReader = std::move(ReaderOrErr.get());
165  }
166 
167  // If coverage mapping generation is enabled, create the
168  // CoverageMappingModuleGen object.
169  if (CodeGenOpts.CoverageMapping)
170  CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
171 }
172 
174 
175 void CodeGenModule::createObjCRuntime() {
176  // This is just isGNUFamily(), but we want to force implementors of
177  // new ABIs to decide how best to do this.
178  switch (LangOpts.ObjCRuntime.getKind()) {
180  case ObjCRuntime::GCC:
181  case ObjCRuntime::ObjFW:
182  ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
183  return;
184 
186  case ObjCRuntime::MacOSX:
187  case ObjCRuntime::iOS:
189  ObjCRuntime.reset(CreateMacObjCRuntime(*this));
190  return;
191  }
192  llvm_unreachable("bad runtime kind");
193 }
194 
195 void CodeGenModule::createOpenCLRuntime() {
196  OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
197 }
198 
199 void CodeGenModule::createOpenMPRuntime() {
200  // Select a specialized code generation class based on the target, if any.
201  // If it does not exist use the default implementation.
202  switch (getTriple().getArch()) {
203  case llvm::Triple::nvptx:
204  case llvm::Triple::nvptx64:
205  assert(getLangOpts().OpenMPIsDevice &&
206  "OpenMP NVPTX is only prepared to deal with device code.");
207  OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this));
208  break;
209  default:
210  OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
211  break;
212  }
213 }
214 
215 void CodeGenModule::createCUDARuntime() {
216  CUDARuntime.reset(CreateNVCUDARuntime(*this));
217 }
218 
219 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
220  Replacements[Name] = C;
221 }
222 
223 void CodeGenModule::applyReplacements() {
224  for (auto &I : Replacements) {
225  StringRef MangledName = I.first();
226  llvm::Constant *Replacement = I.second;
227  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
228  if (!Entry)
229  continue;
230  auto *OldF = cast<llvm::Function>(Entry);
231  auto *NewF = dyn_cast<llvm::Function>(Replacement);
232  if (!NewF) {
233  if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
234  NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
235  } else {
236  auto *CE = cast<llvm::ConstantExpr>(Replacement);
237  assert(CE->getOpcode() == llvm::Instruction::BitCast ||
238  CE->getOpcode() == llvm::Instruction::GetElementPtr);
239  NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
240  }
241  }
242 
243  // Replace old with new, but keep the old order.
244  OldF->replaceAllUsesWith(Replacement);
245  if (NewF) {
246  NewF->removeFromParent();
247  OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
248  NewF);
249  }
250  OldF->eraseFromParent();
251  }
252 }
253 
254 void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
255  GlobalValReplacements.push_back(std::make_pair(GV, C));
256 }
257 
258 void CodeGenModule::applyGlobalValReplacements() {
259  for (auto &I : GlobalValReplacements) {
260  llvm::GlobalValue *GV = I.first;
261  llvm::Constant *C = I.second;
262 
263  GV->replaceAllUsesWith(C);
264  GV->eraseFromParent();
265  }
266 }
267 
268 // This is only used in aliases that we created and we know they have a
269 // linear structure.
270 static const llvm::GlobalObject *getAliasedGlobal(
271  const llvm::GlobalIndirectSymbol &GIS) {
272  llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
273  const llvm::Constant *C = &GIS;
274  for (;;) {
275  C = C->stripPointerCasts();
276  if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
277  return GO;
278  // stripPointerCasts will not walk over weak aliases.
279  auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C);
280  if (!GIS2)
281  return nullptr;
282  if (!Visited.insert(GIS2).second)
283  return nullptr;
284  C = GIS2->getIndirectSymbol();
285  }
286 }
287 
288 void CodeGenModule::checkAliases() {
289  // Check if the constructed aliases are well formed. It is really unfortunate
290  // that we have to do this in CodeGen, but we only construct mangled names
291  // and aliases during codegen.
292  bool Error = false;
293  DiagnosticsEngine &Diags = getDiags();
294  for (const GlobalDecl &GD : Aliases) {
295  const auto *D = cast<ValueDecl>(GD.getDecl());
296  SourceLocation Location;
297  bool IsIFunc = D->hasAttr<IFuncAttr>();
298  if (const Attr *A = D->getDefiningAttr())
299  Location = A->getLocation();
300  else
301  llvm_unreachable("Not an alias or ifunc?");
302  StringRef MangledName = getMangledName(GD);
303  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
304  auto *Alias = cast<llvm::GlobalIndirectSymbol>(Entry);
305  const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
306  if (!GV) {
307  Error = true;
308  Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
309  } else if (GV->isDeclaration()) {
310  Error = true;
311  Diags.Report(Location, diag::err_alias_to_undefined)
312  << IsIFunc << IsIFunc;
313  } else if (IsIFunc) {
314  // Check resolver function type.
315  llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
316  GV->getType()->getPointerElementType());
317  assert(FTy);
318  if (!FTy->getReturnType()->isPointerTy())
319  Diags.Report(Location, diag::err_ifunc_resolver_return);
320  if (FTy->getNumParams())
321  Diags.Report(Location, diag::err_ifunc_resolver_params);
322  }
323 
324  llvm::Constant *Aliasee = Alias->getIndirectSymbol();
325  llvm::GlobalValue *AliaseeGV;
326  if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
327  AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
328  else
329  AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
330 
331  if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
332  StringRef AliasSection = SA->getName();
333  if (AliasSection != AliaseeGV->getSection())
334  Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
335  << AliasSection << IsIFunc << IsIFunc;
336  }
337 
338  // We have to handle alias to weak aliases in here. LLVM itself disallows
339  // this since the object semantics would not match the IL one. For
340  // compatibility with gcc we implement it by just pointing the alias
341  // to its aliasee's aliasee. We also warn, since the user is probably
342  // expecting the link to be weak.
343  if (auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) {
344  if (GA->isInterposable()) {
345  Diags.Report(Location, diag::warn_alias_to_weak_alias)
346  << GV->getName() << GA->getName() << IsIFunc;
347  Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
348  GA->getIndirectSymbol(), Alias->getType());
349  Alias->setIndirectSymbol(Aliasee);
350  }
351  }
352  }
353  if (!Error)
354  return;
355 
356  for (const GlobalDecl &GD : Aliases) {
357  StringRef MangledName = getMangledName(GD);
358  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
359  auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
360  Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
361  Alias->eraseFromParent();
362  }
363 }
364 
366  DeferredDeclsToEmit.clear();
367  if (OpenMPRuntime)
368  OpenMPRuntime->clear();
369 }
370 
372  StringRef MainFile) {
373  if (!hasDiagnostics())
374  return;
375  if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
376  if (MainFile.empty())
377  MainFile = "<stdin>";
378  Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
379  } else {
380  if (Mismatched > 0)
381  Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
382 
383  if (Missing > 0)
384  Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
385  }
386 }
387 
389  EmitDeferred();
390  EmitVTablesOpportunistically();
391  applyGlobalValReplacements();
392  applyReplacements();
393  checkAliases();
394  EmitCXXGlobalInitFunc();
395  EmitCXXGlobalDtorFunc();
396  EmitCXXThreadLocalInitFunc();
397  if (ObjCRuntime)
398  if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
399  AddGlobalCtor(ObjCInitFunction);
400  if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
401  CUDARuntime) {
402  if (llvm::Function *CudaCtorFunction = CUDARuntime->makeModuleCtorFunction())
403  AddGlobalCtor(CudaCtorFunction);
404  if (llvm::Function *CudaDtorFunction = CUDARuntime->makeModuleDtorFunction())
405  AddGlobalDtor(CudaDtorFunction);
406  }
407  if (OpenMPRuntime)
408  if (llvm::Function *OpenMPRegistrationFunction =
409  OpenMPRuntime->emitRegistrationFunction()) {
410  auto ComdatKey = OpenMPRegistrationFunction->hasComdat() ?
411  OpenMPRegistrationFunction : nullptr;
412  AddGlobalCtor(OpenMPRegistrationFunction, 0, ComdatKey);
413  }
414  if (PGOReader) {
415  getModule().setProfileSummary(PGOReader->getSummary().getMD(VMContext));
416  if (PGOStats.hasDiagnostics())
417  PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
418  }
419  EmitCtorList(GlobalCtors, "llvm.global_ctors");
420  EmitCtorList(GlobalDtors, "llvm.global_dtors");
422  EmitStaticExternCAliases();
424  if (CoverageMapping)
425  CoverageMapping->emit();
426  if (CodeGenOpts.SanitizeCfiCrossDso) {
429  }
430  emitAtAvailableLinkGuard();
431  emitLLVMUsed();
432  if (SanStats)
433  SanStats->finish();
434 
435  if (CodeGenOpts.Autolink &&
436  (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
437  EmitModuleLinkOptions();
438  }
439 
440  // Record mregparm value now so it is visible through rest of codegen.
441  if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
442  getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
443  CodeGenOpts.NumRegisterParameters);
444 
445  if (CodeGenOpts.DwarfVersion) {
446  // We actually want the latest version when there are conflicts.
447  // We can change from Warning to Latest if such mode is supported.
448  getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
449  CodeGenOpts.DwarfVersion);
450  }
451  if (CodeGenOpts.EmitCodeView) {
452  // Indicate that we want CodeView in the metadata.
453  getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
454  }
455  if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
456  // We don't support LTO with 2 with different StrictVTablePointers
457  // FIXME: we could support it by stripping all the information introduced
458  // by StrictVTablePointers.
459 
460  getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
461 
462  llvm::Metadata *Ops[2] = {
463  llvm::MDString::get(VMContext, "StrictVTablePointers"),
464  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
465  llvm::Type::getInt32Ty(VMContext), 1))};
466 
467  getModule().addModuleFlag(llvm::Module::Require,
468  "StrictVTablePointersRequirement",
469  llvm::MDNode::get(VMContext, Ops));
470  }
471  if (DebugInfo)
472  // We support a single version in the linked module. The LLVM
473  // parser will drop debug info with a different version number
474  // (and warn about it, too).
475  getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
476  llvm::DEBUG_METADATA_VERSION);
477 
478  // We need to record the widths of enums and wchar_t, so that we can generate
479  // the correct build attributes in the ARM backend. wchar_size is also used by
480  // TargetLibraryInfo.
481  uint64_t WCharWidth =
482  Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
483  getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
484 
485  llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
486  if ( Arch == llvm::Triple::arm
487  || Arch == llvm::Triple::armeb
488  || Arch == llvm::Triple::thumb
489  || Arch == llvm::Triple::thumbeb) {
490  // The minimum width of an enum in bytes
491  uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
492  getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
493  }
494 
495  if (CodeGenOpts.SanitizeCfiCrossDso) {
496  // Indicate that we want cross-DSO control flow integrity checks.
497  getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
498  }
499 
500  if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
501  // Indicate whether __nvvm_reflect should be configured to flush denormal
502  // floating point values to 0. (This corresponds to its "__CUDA_FTZ"
503  // property.)
504  getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
505  LangOpts.CUDADeviceFlushDenormalsToZero ? 1 : 0);
506  }
507 
508  // Emit OpenCL specific module metadata: OpenCL/SPIR version.
509  if (LangOpts.OpenCL) {
510  EmitOpenCLMetadata();
511  // Emit SPIR version.
512  if (getTriple().getArch() == llvm::Triple::spir ||
513  getTriple().getArch() == llvm::Triple::spir64) {
514  // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
515  // opencl.spir.version named metadata.
516  llvm::Metadata *SPIRVerElts[] = {
517  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
518  Int32Ty, LangOpts.OpenCLVersion / 100)),
519  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
520  Int32Ty, (LangOpts.OpenCLVersion / 100 > 1) ? 0 : 2))};
521  llvm::NamedMDNode *SPIRVerMD =
522  TheModule.getOrInsertNamedMetadata("opencl.spir.version");
523  llvm::LLVMContext &Ctx = TheModule.getContext();
524  SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
525  }
526  }
527 
528  if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
529  assert(PLevel < 3 && "Invalid PIC Level");
530  getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
531  if (Context.getLangOpts().PIE)
532  getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
533  }
534 
535  SimplifyPersonality();
536 
537  if (getCodeGenOpts().EmitDeclMetadata)
538  EmitDeclMetadata();
539 
540  if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
541  EmitCoverageFile();
542 
543  if (DebugInfo)
544  DebugInfo->finalize();
545 
546  EmitVersionIdentMetadata();
547 
548  EmitTargetMetadata();
549 }
550 
551 void CodeGenModule::EmitOpenCLMetadata() {
552  // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
553  // opencl.ocl.version named metadata node.
554  llvm::Metadata *OCLVerElts[] = {
555  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
556  Int32Ty, LangOpts.OpenCLVersion / 100)),
557  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
558  Int32Ty, (LangOpts.OpenCLVersion % 100) / 10))};
559  llvm::NamedMDNode *OCLVerMD =
560  TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
561  llvm::LLVMContext &Ctx = TheModule.getContext();
562  OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
563 }
564 
566  // Make sure that this type is translated.
567  Types.UpdateCompletedType(TD);
568 }
569 
571  // Make sure that this type is translated.
572  Types.RefreshTypeCacheForClass(RD);
573 }
574 
576  if (!TBAA)
577  return nullptr;
578  return TBAA->getTypeInfo(QTy);
579 }
580 
582  // Pointee values may have incomplete types, but they shall never be
583  // dereferenced.
584  if (AccessType->isIncompleteType())
586 
587  uint64_t Size = Context.getTypeSizeInChars(AccessType).getQuantity();
588  return TBAAAccessInfo(getTBAATypeInfo(AccessType), Size);
589 }
590 
593  if (!TBAA)
594  return TBAAAccessInfo();
595  return TBAA->getVTablePtrAccessInfo(VTablePtrType);
596 }
597 
599  if (!TBAA)
600  return nullptr;
601  return TBAA->getTBAAStructInfo(QTy);
602 }
603 
605  if (!TBAA)
606  return nullptr;
607  return TBAA->getBaseTypeInfo(QTy);
608 }
609 
611  if (!TBAA)
612  return nullptr;
613  return TBAA->getAccessTagInfo(Info);
614 }
615 
618  if (!TBAA)
619  return TBAAAccessInfo();
620  return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
621 }
622 
625  TBAAAccessInfo InfoB) {
626  if (!TBAA)
627  return TBAAAccessInfo();
628  return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
629 }
630 
631 void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst,
632  TBAAAccessInfo TBAAInfo) {
633  if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
634  Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
635 }
636 
638  llvm::Instruction *I, const CXXRecordDecl *RD) {
639  I->setMetadata(llvm::LLVMContext::MD_invariant_group,
640  llvm::MDNode::get(getLLVMContext(), {}));
641 }
642 
643 void CodeGenModule::Error(SourceLocation loc, StringRef message) {
644  unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
645  getDiags().Report(Context.getFullLoc(loc), diagID) << message;
646 }
647 
648 /// ErrorUnsupported - Print out an error that codegen doesn't support the
649 /// specified stmt yet.
650 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
652  "cannot compile this %0 yet");
653  std::string Msg = Type;
654  getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
655  << Msg << S->getSourceRange();
656 }
657 
658 /// ErrorUnsupported - Print out an error that codegen doesn't support the
659 /// specified decl yet.
660 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
662  "cannot compile this %0 yet");
663  std::string Msg = Type;
664  getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
665 }
666 
667 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
668  return llvm::ConstantInt::get(SizeTy, size.getQuantity());
669 }
670 
671 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
672  const NamedDecl *D,
673  ForDefinition_t IsForDefinition) const {
674  // Internal definitions always have default visibility.
675  if (GV->hasLocalLinkage()) {
676  GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
677  return;
678  }
679 
680  // Set visibility for definitions.
682  if (LV.isVisibilityExplicit() ||
683  (IsForDefinition && !GV->hasAvailableExternallyLinkage()))
684  GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
685 }
686 
687 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
688  return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
689  .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
690  .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
691  .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
692  .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
693 }
694 
695 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
697  switch (M) {
699  return llvm::GlobalVariable::GeneralDynamicTLSModel;
701  return llvm::GlobalVariable::LocalDynamicTLSModel;
703  return llvm::GlobalVariable::InitialExecTLSModel;
705  return llvm::GlobalVariable::LocalExecTLSModel;
706  }
707  llvm_unreachable("Invalid TLS model!");
708 }
709 
710 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
711  assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
712 
713  llvm::GlobalValue::ThreadLocalMode TLM;
714  TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
715 
716  // Override the TLS model if it is explicitly specified.
717  if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
718  TLM = GetLLVMTLSModel(Attr->getModel());
719  }
720 
721  GV->setThreadLocalMode(TLM);
722 }
723 
725  GlobalDecl CanonicalGD = GD.getCanonicalDecl();
726 
727  // Some ABIs don't have constructor variants. Make sure that base and
728  // complete constructors get mangled the same.
729  if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
731  CXXCtorType OrigCtorType = GD.getCtorType();
732  assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
733  if (OrigCtorType == Ctor_Base)
734  CanonicalGD = GlobalDecl(CD, Ctor_Complete);
735  }
736  }
737 
738  auto FoundName = MangledDeclNames.find(CanonicalGD);
739  if (FoundName != MangledDeclNames.end())
740  return FoundName->second;
741 
742  const auto *ND = cast<NamedDecl>(GD.getDecl());
743  SmallString<256> Buffer;
744  StringRef Str;
746  llvm::raw_svector_ostream Out(Buffer);
747  if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
749  else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
751  else
753  Str = Out.str();
754  } else {
755  IdentifierInfo *II = ND->getIdentifier();
756  assert(II && "Attempt to mangle unnamed decl.");
757  const auto *FD = dyn_cast<FunctionDecl>(ND);
758 
759  if (FD &&
760  FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
761  llvm::raw_svector_ostream Out(Buffer);
762  Out << "__regcall3__" << II->getName();
763  Str = Out.str();
764  } else {
765  Str = II->getName();
766  }
767  }
768 
769  // Keep the first result in the case of a mangling collision.
770  auto Result = Manglings.insert(std::make_pair(Str, GD));
771  return MangledDeclNames[CanonicalGD] = Result.first->first();
772 }
773 
775  const BlockDecl *BD) {
776  MangleContext &MangleCtx = getCXXABI().getMangleContext();
777  const Decl *D = GD.getDecl();
778 
779  SmallString<256> Buffer;
780  llvm::raw_svector_ostream Out(Buffer);
781  if (!D)
782  MangleCtx.mangleGlobalBlock(BD,
783  dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
784  else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
785  MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
786  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
787  MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
788  else
789  MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
790 
791  auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
792  return Result.first->first();
793 }
794 
795 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
796  return getModule().getNamedValue(Name);
797 }
798 
799 /// AddGlobalCtor - Add a function to the list that will be called before
800 /// main() runs.
801 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
802  llvm::Constant *AssociatedData) {
803  // FIXME: Type coercion of void()* types.
804  GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
805 }
806 
807 /// AddGlobalDtor - Add a function to the list that will be called
808 /// when the module is unloaded.
809 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
810  // FIXME: Type coercion of void()* types.
811  GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
812 }
813 
814 void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
815  if (Fns.empty()) return;
816 
817  // Ctor function type is void()*.
818  llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
819  llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
820 
821  // Get the type of a ctor entry, { i32, void ()*, i8* }.
822  llvm::StructType *CtorStructTy = llvm::StructType::get(
823  Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy);
824 
825  // Construct the constructor and destructor arrays.
826  ConstantInitBuilder builder(*this);
827  auto ctors = builder.beginArray(CtorStructTy);
828  for (const auto &I : Fns) {
829  auto ctor = ctors.beginStruct(CtorStructTy);
830  ctor.addInt(Int32Ty, I.Priority);
831  ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
832  if (I.AssociatedData)
833  ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy));
834  else
835  ctor.addNullPointer(VoidPtrTy);
836  ctor.finishAndAddTo(ctors);
837  }
838 
839  auto list =
840  ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
841  /*constant*/ false,
842  llvm::GlobalValue::AppendingLinkage);
843 
844  // The LTO linker doesn't seem to like it when we set an alignment
845  // on appending variables. Take it off as a workaround.
846  list->setAlignment(0);
847 
848  Fns.clear();
849 }
850 
851 llvm::GlobalValue::LinkageTypes
853  const auto *D = cast<FunctionDecl>(GD.getDecl());
854 
856 
857  if (isa<CXXDestructorDecl>(D) &&
858  getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
859  GD.getDtorType())) {
860  // Destructor variants in the Microsoft C++ ABI are always internal or
861  // linkonce_odr thunks emitted on an as-needed basis.
863  : llvm::GlobalValue::LinkOnceODRLinkage;
864  }
865 
866  if (isa<CXXConstructorDecl>(D) &&
867  cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
868  Context.getTargetInfo().getCXXABI().isMicrosoft()) {
869  // Our approach to inheriting constructors is fundamentally different from
870  // that used by the MS ABI, so keep our inheriting constructor thunks
871  // internal rather than trying to pick an unambiguous mangling for them.
873  }
874 
875  return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
876 }
877 
879  const auto *FD = cast<FunctionDecl>(GD.getDecl());
880 
881  if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) {
882  if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
883  // Don't dllexport/import destructor thunks.
884  F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
885  return;
886  }
887  }
888 
889  if (FD->hasAttr<DLLImportAttr>())
890  F->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
891  else if (FD->hasAttr<DLLExportAttr>())
892  F->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
893  else
894  F->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
895 }
896 
897 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
898  llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
899  if (!MDS) return nullptr;
900 
901  return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
902 }
903 
905  llvm::Function *F) {
906  setNonAliasAttributes(D, F);
907 }
908 
910  const CGFunctionInfo &Info,
911  llvm::Function *F) {
912  unsigned CallingConv;
913  llvm::AttributeList PAL;
914  ConstructAttributeList(F->getName(), Info, D, PAL, CallingConv, false);
915  F->setAttributes(PAL);
916  F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
917 }
918 
919 /// Determines whether the language options require us to model
920 /// unwind exceptions. We treat -fexceptions as mandating this
921 /// except under the fragile ObjC ABI with only ObjC exceptions
922 /// enabled. This means, for example, that C with -fexceptions
923 /// enables this.
924 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
925  // If exceptions are completely disabled, obviously this is false.
926  if (!LangOpts.Exceptions) return false;
927 
928  // If C++ exceptions are enabled, this is true.
929  if (LangOpts.CXXExceptions) return true;
930 
931  // If ObjC exceptions are enabled, this depends on the ABI.
932  if (LangOpts.ObjCExceptions) {
933  return LangOpts.ObjCRuntime.hasUnwindExceptions();
934  }
935 
936  return true;
937 }
938 
940  llvm::Function *F) {
941  llvm::AttrBuilder B;
942 
943  if (CodeGenOpts.UnwindTables)
944  B.addAttribute(llvm::Attribute::UWTable);
945 
946  if (!hasUnwindExceptions(LangOpts))
947  B.addAttribute(llvm::Attribute::NoUnwind);
948 
949  if (LangOpts.getStackProtector() == LangOptions::SSPOn)
950  B.addAttribute(llvm::Attribute::StackProtect);
951  else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
952  B.addAttribute(llvm::Attribute::StackProtectStrong);
953  else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
954  B.addAttribute(llvm::Attribute::StackProtectReq);
955 
956  if (!D) {
957  // If we don't have a declaration to control inlining, the function isn't
958  // explicitly marked as alwaysinline for semantic reasons, and inlining is
959  // disabled, mark the function as noinline.
960  if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
961  CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
962  B.addAttribute(llvm::Attribute::NoInline);
963 
964  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
965  return;
966  }
967 
968  // Track whether we need to add the optnone LLVM attribute,
969  // starting with the default for this optimization level.
970  bool ShouldAddOptNone =
971  !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
972  // We can't add optnone in the following cases, it won't pass the verifier.
973  ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
974  ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
975  ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
976 
977  if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) {
978  B.addAttribute(llvm::Attribute::OptimizeNone);
979 
980  // OptimizeNone implies noinline; we should not be inlining such functions.
981  B.addAttribute(llvm::Attribute::NoInline);
982  assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
983  "OptimizeNone and AlwaysInline on same function!");
984 
985  // We still need to handle naked functions even though optnone subsumes
986  // much of their semantics.
987  if (D->hasAttr<NakedAttr>())
988  B.addAttribute(llvm::Attribute::Naked);
989 
990  // OptimizeNone wins over OptimizeForSize and MinSize.
991  F->removeFnAttr(llvm::Attribute::OptimizeForSize);
992  F->removeFnAttr(llvm::Attribute::MinSize);
993  } else if (D->hasAttr<NakedAttr>()) {
994  // Naked implies noinline: we should not be inlining such functions.
995  B.addAttribute(llvm::Attribute::Naked);
996  B.addAttribute(llvm::Attribute::NoInline);
997  } else if (D->hasAttr<NoDuplicateAttr>()) {
998  B.addAttribute(llvm::Attribute::NoDuplicate);
999  } else if (D->hasAttr<NoInlineAttr>()) {
1000  B.addAttribute(llvm::Attribute::NoInline);
1001  } else if (D->hasAttr<AlwaysInlineAttr>() &&
1002  !F->hasFnAttribute(llvm::Attribute::NoInline)) {
1003  // (noinline wins over always_inline, and we can't specify both in IR)
1004  B.addAttribute(llvm::Attribute::AlwaysInline);
1005  } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
1006  // If we're not inlining, then force everything that isn't always_inline to
1007  // carry an explicit noinline attribute.
1008  if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
1009  B.addAttribute(llvm::Attribute::NoInline);
1010  } else {
1011  // Otherwise, propagate the inline hint attribute and potentially use its
1012  // absence to mark things as noinline.
1013  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
1014  if (any_of(FD->redecls(), [&](const FunctionDecl *Redecl) {
1015  return Redecl->isInlineSpecified();
1016  })) {
1017  B.addAttribute(llvm::Attribute::InlineHint);
1018  } else if (CodeGenOpts.getInlining() ==
1020  !FD->isInlined() &&
1021  !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
1022  B.addAttribute(llvm::Attribute::NoInline);
1023  }
1024  }
1025  }
1026 
1027  // Add other optimization related attributes if we are optimizing this
1028  // function.
1029  if (!D->hasAttr<OptimizeNoneAttr>()) {
1030  if (D->hasAttr<ColdAttr>()) {
1031  if (!ShouldAddOptNone)
1032  B.addAttribute(llvm::Attribute::OptimizeForSize);
1033  B.addAttribute(llvm::Attribute::Cold);
1034  }
1035 
1036  if (D->hasAttr<MinSizeAttr>())
1037  B.addAttribute(llvm::Attribute::MinSize);
1038  }
1039 
1040  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1041 
1042  unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
1043  if (alignment)
1044  F->setAlignment(alignment);
1045 
1046  // Some C++ ABIs require 2-byte alignment for member functions, in order to
1047  // reserve a bit for differentiating between virtual and non-virtual member
1048  // functions. If the current target's C++ ABI requires this and this is a
1049  // member function, set its alignment accordingly.
1050  if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
1051  if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
1052  F->setAlignment(2);
1053  }
1054 
1055  // In the cross-dso CFI mode, we want !type attributes on definitions only.
1056  if (CodeGenOpts.SanitizeCfiCrossDso)
1057  if (auto *FD = dyn_cast<FunctionDecl>(D))
1059 }
1060 
1062  llvm::GlobalValue *GV) {
1063  if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
1065  else
1066  GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1067 
1068  if (D && D->hasAttr<UsedAttr>())
1069  addUsedGlobal(GV);
1070 }
1071 
1073  llvm::GlobalValue *GV) {
1074  SetCommonAttributes(D, GV);
1075 
1076  // Process the dllexport attribute based on whether the original definition
1077  // (not necessarily the aliasee) was exported.
1078  if (D->hasAttr<DLLExportAttr>())
1079  GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1080 }
1081 
1082 void CodeGenModule::setNonAliasAttributes(const Decl *D,
1083  llvm::GlobalObject *GO) {
1084  SetCommonAttributes(D, GO);
1085 
1086  if (D) {
1087  if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
1088  if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
1089  GV->addAttribute("bss-section", SA->getName());
1090  if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
1091  GV->addAttribute("data-section", SA->getName());
1092  if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
1093  GV->addAttribute("rodata-section", SA->getName());
1094  }
1095 
1096  if (auto *F = dyn_cast<llvm::Function>(GO)) {
1097  if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
1098  if (!D->getAttr<SectionAttr>())
1099  F->addFnAttr("implicit-section-name", SA->getName());
1100  }
1101 
1102  if (const SectionAttr *SA = D->getAttr<SectionAttr>())
1103  GO->setSection(SA->getName());
1104  }
1105 
1107 }
1108 
1110  llvm::Function *F,
1111  const CGFunctionInfo &FI) {
1112  SetLLVMFunctionAttributes(D, FI, F);
1114 
1115  F->setLinkage(llvm::Function::InternalLinkage);
1116 
1117  setNonAliasAttributes(D, F);
1118 }
1119 
1120 static void setLinkageForGV(llvm::GlobalValue *GV,
1121  const NamedDecl *ND) {
1122  // Set linkage and visibility in case we never see a definition.
1124  if (!isExternallyVisible(LV.getLinkage())) {
1125  // Don't set internal linkage on declarations.
1126  } else {
1127  if (ND->hasAttr<DLLImportAttr>()) {
1129  GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1130  } else if (ND->hasAttr<DLLExportAttr>()) {
1131  GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
1132  } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) {
1133  // "extern_weak" is overloaded in LLVM; we probably should have
1134  // separate linkage types for this.
1135  GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1136  }
1137  }
1138 }
1139 
1141  llvm::Function *F) {
1142  // Only if we are checking indirect calls.
1143  if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
1144  return;
1145 
1146  // Non-static class methods are handled via vtable pointer checks elsewhere.
1147  if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
1148  return;
1149 
1150  // Additionally, if building with cross-DSO support...
1151  if (CodeGenOpts.SanitizeCfiCrossDso) {
1152  // Skip available_externally functions. They won't be codegen'ed in the
1153  // current module anyway.
1155  return;
1156  }
1157 
1158  llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType());
1159  F->addTypeMetadata(0, MD);
1160  F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
1161 
1162  // Emit a hash-based bit set entry for cross-DSO calls.
1163  if (CodeGenOpts.SanitizeCfiCrossDso)
1164  if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
1165  F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
1166 }
1167 
1168 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1169  bool IsIncompleteFunction,
1170  bool IsThunk,
1171  ForDefinition_t IsForDefinition) {
1172 
1173  if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
1174  // If this is an intrinsic function, set the function's attributes
1175  // to the intrinsic's attributes.
1176  F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
1177  return;
1178  }
1179 
1180  const auto *FD = cast<FunctionDecl>(GD.getDecl());
1181 
1182  if (!IsIncompleteFunction) {
1183  SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
1184  // Setup target-specific attributes.
1185  if (!IsForDefinition)
1188  }
1189 
1190  // Add the Returned attribute for "this", except for iOS 5 and earlier
1191  // where substantial code, including the libstdc++ dylib, was compiled with
1192  // GCC and does not actually return "this".
1193  if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
1194  !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
1195  assert(!F->arg_empty() &&
1196  F->arg_begin()->getType()
1197  ->canLosslesslyBitCastTo(F->getReturnType()) &&
1198  "unexpected this return");
1199  F->addAttribute(1, llvm::Attribute::Returned);
1200  }
1201 
1202  // Only a few attributes are set on declarations; these may later be
1203  // overridden by a definition.
1204 
1205  setLinkageForGV(F, FD);
1207 
1208  if (FD->getAttr<PragmaClangTextSectionAttr>()) {
1209  F->addFnAttr("implicit-section-name");
1210  }
1211 
1212  if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
1213  F->setSection(SA->getName());
1214 
1215  if (FD->isReplaceableGlobalAllocationFunction()) {
1216  // A replaceable global allocation function does not act like a builtin by
1217  // default, only if it is invoked by a new-expression or delete-expression.
1218  F->addAttribute(llvm::AttributeList::FunctionIndex,
1219  llvm::Attribute::NoBuiltin);
1220 
1221  // A sane operator new returns a non-aliasing pointer.
1222  // FIXME: Also add NonNull attribute to the return value
1223  // for the non-nothrow forms?
1224  auto Kind = FD->getDeclName().getCXXOverloadedOperator();
1225  if (getCodeGenOpts().AssumeSaneOperatorNew &&
1226  (Kind == OO_New || Kind == OO_Array_New))
1227  F->addAttribute(llvm::AttributeList::ReturnIndex,
1228  llvm::Attribute::NoAlias);
1229  }
1230 
1231  if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
1232  F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1233  else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1234  if (MD->isVirtual())
1235  F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1236 
1237  // Don't emit entries for function declarations in the cross-DSO mode. This
1238  // is handled with better precision by the receiving DSO.
1239  if (!CodeGenOpts.SanitizeCfiCrossDso)
1241 }
1242 
1243 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
1244  assert(!GV->isDeclaration() &&
1245  "Only globals with definition can force usage.");
1246  LLVMUsed.emplace_back(GV);
1247 }
1248 
1249 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
1250  assert(!GV->isDeclaration() &&
1251  "Only globals with definition can force usage.");
1252  LLVMCompilerUsed.emplace_back(GV);
1253 }
1254 
1255 static void emitUsed(CodeGenModule &CGM, StringRef Name,
1256  std::vector<llvm::WeakTrackingVH> &List) {
1257  // Don't create llvm.used if there is no need.
1258  if (List.empty())
1259  return;
1260 
1261  // Convert List to what ConstantArray needs.
1263  UsedArray.resize(List.size());
1264  for (unsigned i = 0, e = List.size(); i != e; ++i) {
1265  UsedArray[i] =
1266  llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1267  cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
1268  }
1269 
1270  if (UsedArray.empty())
1271  return;
1272  llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
1273 
1274  auto *GV = new llvm::GlobalVariable(
1275  CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
1276  llvm::ConstantArray::get(ATy, UsedArray), Name);
1277 
1278  GV->setSection("llvm.metadata");
1279 }
1280 
1281 void CodeGenModule::emitLLVMUsed() {
1282  emitUsed(*this, "llvm.used", LLVMUsed);
1283  emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
1284 }
1285 
1287  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
1288  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1289 }
1290 
1291 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
1293  getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
1294  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1295  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1296 }
1297 
1298 void CodeGenModule::AddDependentLib(StringRef Lib) {
1301  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1302  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1303 }
1304 
1305 /// \brief Add link options implied by the given module, including modules
1306 /// it depends on, using a postorder walk.
1309  llvm::SmallPtrSet<Module *, 16> &Visited) {
1310  // Import this module's parent.
1311  if (Mod->Parent && Visited.insert(Mod->Parent).second) {
1312  addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
1313  }
1314 
1315  // Import this module's dependencies.
1316  for (unsigned I = Mod->Imports.size(); I > 0; --I) {
1317  if (Visited.insert(Mod->Imports[I - 1]).second)
1318  addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
1319  }
1320 
1321  // Add linker options to link against the libraries/frameworks
1322  // described by this module.
1323  llvm::LLVMContext &Context = CGM.getLLVMContext();
1324  for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
1325  // Link against a framework. Frameworks are currently Darwin only, so we
1326  // don't to ask TargetCodeGenInfo for the spelling of the linker option.
1327  if (Mod->LinkLibraries[I-1].IsFramework) {
1328  llvm::Metadata *Args[2] = {
1329  llvm::MDString::get(Context, "-framework"),
1330  llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
1331 
1332  Metadata.push_back(llvm::MDNode::get(Context, Args));
1333  continue;
1334  }
1335 
1336  // Link against a library.
1339  Mod->LinkLibraries[I-1].Library, Opt);
1340  auto *OptString = llvm::MDString::get(Context, Opt);
1341  Metadata.push_back(llvm::MDNode::get(Context, OptString));
1342  }
1343 }
1344 
1345 void CodeGenModule::EmitModuleLinkOptions() {
1346  // Collect the set of all of the modules we want to visit to emit link
1347  // options, which is essentially the imported modules and all of their
1348  // non-explicit child modules.
1349  llvm::SetVector<clang::Module *> LinkModules;
1350  llvm::SmallPtrSet<clang::Module *, 16> Visited;
1352 
1353  // Seed the stack with imported modules.
1354  for (Module *M : ImportedModules) {
1355  // Do not add any link flags when an implementation TU of a module imports
1356  // a header of that same module.
1357  if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
1359  continue;
1360  if (Visited.insert(M).second)
1361  Stack.push_back(M);
1362  }
1363 
1364  // Find all of the modules to import, making a little effort to prune
1365  // non-leaf modules.
1366  while (!Stack.empty()) {
1367  clang::Module *Mod = Stack.pop_back_val();
1368 
1369  bool AnyChildren = false;
1370 
1371  // Visit the submodules of this module.
1373  SubEnd = Mod->submodule_end();
1374  Sub != SubEnd; ++Sub) {
1375  // Skip explicit children; they need to be explicitly imported to be
1376  // linked against.
1377  if ((*Sub)->IsExplicit)
1378  continue;
1379 
1380  if (Visited.insert(*Sub).second) {
1381  Stack.push_back(*Sub);
1382  AnyChildren = true;
1383  }
1384  }
1385 
1386  // We didn't find any children, so add this module to the list of
1387  // modules to link against.
1388  if (!AnyChildren) {
1389  LinkModules.insert(Mod);
1390  }
1391  }
1392 
1393  // Add link options for all of the imported modules in reverse topological
1394  // order. We don't do anything to try to order import link flags with respect
1395  // to linker options inserted by things like #pragma comment().
1396  SmallVector<llvm::MDNode *, 16> MetadataArgs;
1397  Visited.clear();
1398  for (Module *M : LinkModules)
1399  if (Visited.insert(M).second)
1400  addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
1401  std::reverse(MetadataArgs.begin(), MetadataArgs.end());
1402  LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
1403 
1404  // Add the linker options metadata flag.
1405  auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
1406  for (auto *MD : LinkerOptionsMetadata)
1407  NMD->addOperand(MD);
1408 }
1409 
1410 void CodeGenModule::EmitDeferred() {
1411  // Emit code for any potentially referenced deferred decls. Since a
1412  // previously unused static decl may become used during the generation of code
1413  // for a static function, iterate until no changes are made.
1414 
1415  if (!DeferredVTables.empty()) {
1416  EmitDeferredVTables();
1417 
1418  // Emitting a vtable doesn't directly cause more vtables to
1419  // become deferred, although it can cause functions to be
1420  // emitted that then need those vtables.
1421  assert(DeferredVTables.empty());
1422  }
1423 
1424  // Stop if we're out of both deferred vtables and deferred declarations.
1425  if (DeferredDeclsToEmit.empty())
1426  return;
1427 
1428  // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1429  // work, it will not interfere with this.
1430  std::vector<GlobalDecl> CurDeclsToEmit;
1431  CurDeclsToEmit.swap(DeferredDeclsToEmit);
1432 
1433  for (GlobalDecl &D : CurDeclsToEmit) {
1434  // We should call GetAddrOfGlobal with IsForDefinition set to true in order
1435  // to get GlobalValue with exactly the type we need, not something that
1436  // might had been created for another decl with the same mangled name but
1437  // different type.
1438  llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
1440 
1441  // In case of different address spaces, we may still get a cast, even with
1442  // IsForDefinition equal to true. Query mangled names table to get
1443  // GlobalValue.
1444  if (!GV)
1445  GV = GetGlobalValue(getMangledName(D));
1446 
1447  // Make sure GetGlobalValue returned non-null.
1448  assert(GV);
1449 
1450  // Check to see if we've already emitted this. This is necessary
1451  // for a couple of reasons: first, decls can end up in the
1452  // deferred-decls queue multiple times, and second, decls can end
1453  // up with definitions in unusual ways (e.g. by an extern inline
1454  // function acquiring a strong function redefinition). Just
1455  // ignore these cases.
1456  if (!GV->isDeclaration())
1457  continue;
1458 
1459  // Otherwise, emit the definition and move on to the next one.
1460  EmitGlobalDefinition(D, GV);
1461 
1462  // If we found out that we need to emit more decls, do that recursively.
1463  // This has the advantage that the decls are emitted in a DFS and related
1464  // ones are close together, which is convenient for testing.
1465  if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1466  EmitDeferred();
1467  assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1468  }
1469  }
1470 }
1471 
1472 void CodeGenModule::EmitVTablesOpportunistically() {
1473  // Try to emit external vtables as available_externally if they have emitted
1474  // all inlined virtual functions. It runs after EmitDeferred() and therefore
1475  // is not allowed to create new references to things that need to be emitted
1476  // lazily. Note that it also uses fact that we eagerly emitting RTTI.
1477 
1478  assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
1479  && "Only emit opportunistic vtables with optimizations");
1480 
1481  for (const CXXRecordDecl *RD : OpportunisticVTables) {
1482  assert(getVTables().isVTableExternal(RD) &&
1483  "This queue should only contain external vtables");
1484  if (getCXXABI().canSpeculativelyEmitVTable(RD))
1485  VTables.GenerateClassData(RD);
1486  }
1487  OpportunisticVTables.clear();
1488 }
1489 
1491  if (Annotations.empty())
1492  return;
1493 
1494  // Create a new global variable for the ConstantStruct in the Module.
1495  llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1496  Annotations[0]->getType(), Annotations.size()), Annotations);
1497  auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1498  llvm::GlobalValue::AppendingLinkage,
1499  Array, "llvm.global.annotations");
1500  gv->setSection(AnnotationSection);
1501 }
1502 
1503 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
1504  llvm::Constant *&AStr = AnnotationStrings[Str];
1505  if (AStr)
1506  return AStr;
1507 
1508  // Not found yet, create a new global.
1509  llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
1510  auto *gv =
1511  new llvm::GlobalVariable(getModule(), s->getType(), true,
1512  llvm::GlobalValue::PrivateLinkage, s, ".str");
1513  gv->setSection(AnnotationSection);
1514  gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1515  AStr = gv;
1516  return gv;
1517 }
1518 
1521  PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1522  if (PLoc.isValid())
1523  return EmitAnnotationString(PLoc.getFilename());
1524  return EmitAnnotationString(SM.getBufferName(Loc));
1525 }
1526 
1529  PresumedLoc PLoc = SM.getPresumedLoc(L);
1530  unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1531  SM.getExpansionLineNumber(L);
1532  return llvm::ConstantInt::get(Int32Ty, LineNo);
1533 }
1534 
1535 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
1536  const AnnotateAttr *AA,
1537  SourceLocation L) {
1538  // Get the globals for file name, annotation, and the line number.
1539  llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1540  *UnitGV = EmitAnnotationUnit(L),
1541  *LineNoCst = EmitAnnotationLineNo(L);
1542 
1543  // Create the ConstantStruct for the global annotation.
1544  llvm::Constant *Fields[4] = {
1545  llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1546  llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1547  llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1548  LineNoCst
1549  };
1550  return llvm::ConstantStruct::getAnon(Fields);
1551 }
1552 
1554  llvm::GlobalValue *GV) {
1555  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1556  // Get the struct elements for these annotations.
1557  for (const auto *I : D->specific_attrs<AnnotateAttr>())
1558  Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
1559 }
1560 
1562  llvm::Function *Fn,
1563  SourceLocation Loc) const {
1564  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1565  // Blacklist by function name.
1566  if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
1567  return true;
1568  // Blacklist by location.
1569  if (Loc.isValid())
1570  return SanitizerBL.isBlacklistedLocation(Kind, Loc);
1571  // If location is unknown, this may be a compiler-generated function. Assume
1572  // it's located in the main file.
1573  auto &SM = Context.getSourceManager();
1574  if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1575  return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
1576  }
1577  return false;
1578 }
1579 
1580 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
1581  SourceLocation Loc, QualType Ty,
1582  StringRef Category) const {
1583  // For now globals can be blacklisted only in ASan and KASan.
1584  const SanitizerMask EnabledAsanMask = LangOpts.Sanitize.Mask &
1585  (SanitizerKind::Address | SanitizerKind::KernelAddress | SanitizerKind::HWAddress);
1586  if (!EnabledAsanMask)
1587  return false;
1588  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1589  if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category))
1590  return true;
1591  if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
1592  return true;
1593  // Check global type.
1594  if (!Ty.isNull()) {
1595  // Drill down the array types: if global variable of a fixed type is
1596  // blacklisted, we also don't instrument arrays of them.
1597  while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
1598  Ty = AT->getElementType();
1600  // We allow to blacklist only record types (classes, structs etc.)
1601  if (Ty->isRecordType()) {
1602  std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
1603  if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
1604  return true;
1605  }
1606  }
1607  return false;
1608 }
1609 
1610 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
1611  StringRef Category) const {
1612  if (!LangOpts.XRayInstrument)
1613  return false;
1614  const auto &XRayFilter = getContext().getXRayFilter();
1615  using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
1617  if (Loc.isValid())
1618  Attr = XRayFilter.shouldImbueLocation(Loc, Category);
1619  if (Attr == ImbueAttr::NONE)
1620  Attr = XRayFilter.shouldImbueFunction(Fn->getName());
1621  switch (Attr) {
1622  case ImbueAttr::NONE:
1623  return false;
1624  case ImbueAttr::ALWAYS:
1625  Fn->addFnAttr("function-instrument", "xray-always");
1626  break;
1627  case ImbueAttr::ALWAYS_ARG1:
1628  Fn->addFnAttr("function-instrument", "xray-always");
1629  Fn->addFnAttr("xray-log-args", "1");
1630  break;
1631  case ImbueAttr::NEVER:
1632  Fn->addFnAttr("function-instrument", "xray-never");
1633  break;
1634  }
1635  return true;
1636 }
1637 
1638 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
1639  // Never defer when EmitAllDecls is specified.
1640  if (LangOpts.EmitAllDecls)
1641  return true;
1642 
1643  return getContext().DeclMustBeEmitted(Global);
1644 }
1645 
1646 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
1647  if (const auto *FD = dyn_cast<FunctionDecl>(Global))
1648  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1649  // Implicit template instantiations may change linkage if they are later
1650  // explicitly instantiated, so they should not be emitted eagerly.
1651  return false;
1652  if (const auto *VD = dyn_cast<VarDecl>(Global))
1653  if (Context.getInlineVariableDefinitionKind(VD) ==
1655  // A definition of an inline constexpr static data member may change
1656  // linkage later if it's redeclared outside the class.
1657  return false;
1658  // If OpenMP is enabled and threadprivates must be generated like TLS, delay
1659  // codegen for global variables, because they may be marked as threadprivate.
1660  if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
1661  getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global))
1662  return false;
1663 
1664  return true;
1665 }
1666 
1668  const CXXUuidofExpr* E) {
1669  // Sema has verified that IIDSource has a __declspec(uuid()), and that its
1670  // well-formed.
1671  StringRef Uuid = E->getUuidStr();
1672  std::string Name = "_GUID_" + Uuid.lower();
1673  std::replace(Name.begin(), Name.end(), '-', '_');
1674 
1675  // The UUID descriptor should be pointer aligned.
1677 
1678  // Look for an existing global.
1679  if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1680  return ConstantAddress(GV, Alignment);
1681 
1682  llvm::Constant *Init = EmitUuidofInitializer(Uuid);
1683  assert(Init && "failed to initialize as constant");
1684 
1685  auto *GV = new llvm::GlobalVariable(
1686  getModule(), Init->getType(),
1687  /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
1688  if (supportsCOMDAT())
1689  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
1690  return ConstantAddress(GV, Alignment);
1691 }
1692 
1694  const AliasAttr *AA = VD->getAttr<AliasAttr>();
1695  assert(AA && "No alias?");
1696 
1697  CharUnits Alignment = getContext().getDeclAlign(VD);
1698  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
1699 
1700  // See if there is already something with the target's name in the module.
1701  llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
1702  if (Entry) {
1703  unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1704  auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1705  return ConstantAddress(Ptr, Alignment);
1706  }
1707 
1708  llvm::Constant *Aliasee;
1709  if (isa<llvm::FunctionType>(DeclTy))
1710  Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1711  GlobalDecl(cast<FunctionDecl>(VD)),
1712  /*ForVTable=*/false);
1713  else
1714  Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1715  llvm::PointerType::getUnqual(DeclTy),
1716  nullptr);
1717 
1718  auto *F = cast<llvm::GlobalValue>(Aliasee);
1719  F->setLinkage(llvm::Function::ExternalWeakLinkage);
1720  WeakRefReferences.insert(F);
1721 
1722  return ConstantAddress(Aliasee, Alignment);
1723 }
1724 
1726  const auto *Global = cast<ValueDecl>(GD.getDecl());
1727 
1728  // Weak references don't produce any output by themselves.
1729  if (Global->hasAttr<WeakRefAttr>())
1730  return;
1731 
1732  // If this is an alias definition (which otherwise looks like a declaration)
1733  // emit it now.
1734  if (Global->hasAttr<AliasAttr>())
1735  return EmitAliasDefinition(GD);
1736 
1737  // IFunc like an alias whose value is resolved at runtime by calling resolver.
1738  if (Global->hasAttr<IFuncAttr>())
1739  return emitIFuncDefinition(GD);
1740 
1741  // If this is CUDA, be selective about which declarations we emit.
1742  if (LangOpts.CUDA) {
1743  if (LangOpts.CUDAIsDevice) {
1744  if (!Global->hasAttr<CUDADeviceAttr>() &&
1745  !Global->hasAttr<CUDAGlobalAttr>() &&
1746  !Global->hasAttr<CUDAConstantAttr>() &&
1747  !Global->hasAttr<CUDASharedAttr>())
1748  return;
1749  } else {
1750  // We need to emit host-side 'shadows' for all global
1751  // device-side variables because the CUDA runtime needs their
1752  // size and host-side address in order to provide access to
1753  // their device-side incarnations.
1754 
1755  // So device-only functions are the only things we skip.
1756  if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() &&
1757  Global->hasAttr<CUDADeviceAttr>())
1758  return;
1759 
1760  assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
1761  "Expected Variable or Function");
1762  }
1763  }
1764 
1765  if (LangOpts.OpenMP) {
1766  // If this is OpenMP device, check if it is legal to emit this global
1767  // normally.
1768  if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
1769  return;
1770  if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
1771  if (MustBeEmitted(Global))
1773  return;
1774  }
1775  }
1776 
1777  // Ignore declarations, they will be emitted on their first use.
1778  if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
1779  // Forward declarations are emitted lazily on first use.
1780  if (!FD->doesThisDeclarationHaveABody()) {
1781  if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1782  return;
1783 
1784  StringRef MangledName = getMangledName(GD);
1785 
1786  // Compute the function info and LLVM type.
1788  llvm::Type *Ty = getTypes().GetFunctionType(FI);
1789 
1790  GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
1791  /*DontDefer=*/false);
1792  return;
1793  }
1794  } else {
1795  const auto *VD = cast<VarDecl>(Global);
1796  assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1797  // We need to emit device-side global CUDA variables even if a
1798  // variable does not have a definition -- we still need to define
1799  // host-side shadow for it.
1800  bool MustEmitForCuda = LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
1801  !VD->hasDefinition() &&
1802  (VD->hasAttr<CUDAConstantAttr>() ||
1803  VD->hasAttr<CUDADeviceAttr>());
1804  if (!MustEmitForCuda &&
1805  VD->isThisDeclarationADefinition() != VarDecl::Definition &&
1806  !Context.isMSStaticDataMemberInlineDefinition(VD)) {
1807  // If this declaration may have caused an inline variable definition to
1808  // change linkage, make sure that it's emitted.
1809  if (Context.getInlineVariableDefinitionKind(VD) ==
1811  GetAddrOfGlobalVar(VD);
1812  return;
1813  }
1814  }
1815 
1816  // Defer code generation to first use when possible, e.g. if this is an inline
1817  // function. If the global must always be emitted, do it eagerly if possible
1818  // to benefit from cache locality.
1819  if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
1820  // Emit the definition if it can't be deferred.
1821  EmitGlobalDefinition(GD);
1822  return;
1823  }
1824 
1825  // If we're deferring emission of a C++ variable with an
1826  // initializer, remember the order in which it appeared in the file.
1827  if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
1828  cast<VarDecl>(Global)->hasInit()) {
1829  DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1830  CXXGlobalInits.push_back(nullptr);
1831  }
1832 
1833  StringRef MangledName = getMangledName(GD);
1834  if (GetGlobalValue(MangledName) != nullptr) {
1835  // The value has already been used and should therefore be emitted.
1836  addDeferredDeclToEmit(GD);
1837  } else if (MustBeEmitted(Global)) {
1838  // The value must be emitted, but cannot be emitted eagerly.
1839  assert(!MayBeEmittedEagerly(Global));
1840  addDeferredDeclToEmit(GD);
1841  } else {
1842  // Otherwise, remember that we saw a deferred decl with this name. The
1843  // first use of the mangled name will cause it to move into
1844  // DeferredDeclsToEmit.
1845  DeferredDecls[MangledName] = GD;
1846  }
1847 }
1848 
1849 // Check if T is a class type with a destructor that's not dllimport.
1851  if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>())
1852  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
1853  if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
1854  return true;
1855 
1856  return false;
1857 }
1858 
1859 namespace {
1860  struct FunctionIsDirectlyRecursive :
1861  public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1862  const StringRef Name;
1863  const Builtin::Context &BI;
1864  bool Result;
1865  FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1866  Name(N), BI(C), Result(false) {
1867  }
1869 
1870  bool TraverseCallExpr(CallExpr *E) {
1871  const FunctionDecl *FD = E->getDirectCallee();
1872  if (!FD)
1873  return true;
1874  AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1875  if (Attr && Name == Attr->getLabel()) {
1876  Result = true;
1877  return false;
1878  }
1879  unsigned BuiltinID = FD->getBuiltinID();
1880  if (!BuiltinID || !BI.isLibFunction(BuiltinID))
1881  return true;
1882  StringRef BuiltinName = BI.getName(BuiltinID);
1883  if (BuiltinName.startswith("__builtin_") &&
1884  Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1885  Result = true;
1886  return false;
1887  }
1888  return true;
1889  }
1890  };
1891 
1892  // Make sure we're not referencing non-imported vars or functions.
1893  struct DLLImportFunctionVisitor
1894  : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
1895  bool SafeToInline = true;
1896 
1897  bool shouldVisitImplicitCode() const { return true; }
1898 
1899  bool VisitVarDecl(VarDecl *VD) {
1900  if (VD->getTLSKind()) {
1901  // A thread-local variable cannot be imported.
1902  SafeToInline = false;
1903  return SafeToInline;
1904  }
1905 
1906  // A variable definition might imply a destructor call.
1907  if (VD->isThisDeclarationADefinition())
1908  SafeToInline = !HasNonDllImportDtor(VD->getType());
1909 
1910  return SafeToInline;
1911  }
1912 
1913  bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1914  if (const auto *D = E->getTemporary()->getDestructor())
1915  SafeToInline = D->hasAttr<DLLImportAttr>();
1916  return SafeToInline;
1917  }
1918 
1919  bool VisitDeclRefExpr(DeclRefExpr *E) {
1920  ValueDecl *VD = E->getDecl();
1921  if (isa<FunctionDecl>(VD))
1922  SafeToInline = VD->hasAttr<DLLImportAttr>();
1923  else if (VarDecl *V = dyn_cast<VarDecl>(VD))
1924  SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
1925  return SafeToInline;
1926  }
1927 
1928  bool VisitCXXConstructExpr(CXXConstructExpr *E) {
1929  SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
1930  return SafeToInline;
1931  }
1932 
1933  bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1934  CXXMethodDecl *M = E->getMethodDecl();
1935  if (!M) {
1936  // Call through a pointer to member function. This is safe to inline.
1937  SafeToInline = true;
1938  } else {
1939  SafeToInline = M->hasAttr<DLLImportAttr>();
1940  }
1941  return SafeToInline;
1942  }
1943 
1944  bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1945  SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
1946  return SafeToInline;
1947  }
1948 
1949  bool VisitCXXNewExpr(CXXNewExpr *E) {
1950  SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
1951  return SafeToInline;
1952  }
1953  };
1954 }
1955 
1956 // isTriviallyRecursive - Check if this function calls another
1957 // decl that, because of the asm attribute or the other decl being a builtin,
1958 // ends up pointing to itself.
1959 bool
1960 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1961  StringRef Name;
1962  if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1963  // asm labels are a special kind of mangling we have to support.
1964  AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1965  if (!Attr)
1966  return false;
1967  Name = Attr->getLabel();
1968  } else {
1969  Name = FD->getName();
1970  }
1971 
1972  FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1973  Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1974  return Walker.Result;
1975 }
1976 
1977 bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
1978  if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
1979  return true;
1980  const auto *F = cast<FunctionDecl>(GD.getDecl());
1981  if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
1982  return false;
1983 
1984  if (F->hasAttr<DLLImportAttr>()) {
1985  // Check whether it would be safe to inline this dllimport function.
1986  DLLImportFunctionVisitor Visitor;
1987  Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
1988  if (!Visitor.SafeToInline)
1989  return false;
1990 
1991  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
1992  // Implicit destructor invocations aren't captured in the AST, so the
1993  // check above can't see them. Check for them manually here.
1994  for (const Decl *Member : Dtor->getParent()->decls())
1995  if (isa<FieldDecl>(Member))
1996  if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType()))
1997  return false;
1998  for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
1999  if (HasNonDllImportDtor(B.getType()))
2000  return false;
2001  }
2002  }
2003 
2004  // PR9614. Avoid cases where the source code is lying to us. An available
2005  // externally function should have an equivalent function somewhere else,
2006  // but a function that calls itself is clearly not equivalent to the real
2007  // implementation.
2008  // This happens in glibc's btowc and in some configure checks.
2009  return !isTriviallyRecursive(F);
2010 }
2011 
2012 bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
2013  return CodeGenOpts.OptimizationLevel > 0;
2014 }
2015 
2016 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
2017  const auto *D = cast<ValueDecl>(GD.getDecl());
2018 
2019  PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
2020  Context.getSourceManager(),
2021  "Generating code for declaration");
2022 
2023  if (isa<FunctionDecl>(D)) {
2024  // At -O0, don't generate IR for functions with available_externally
2025  // linkage.
2026  if (!shouldEmitFunction(GD))
2027  return;
2028 
2029  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2030  // Make sure to emit the definition(s) before we emit the thunks.
2031  // This is necessary for the generation of certain thunks.
2032  if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
2033  ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
2034  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
2035  ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
2036  else
2037  EmitGlobalFunctionDefinition(GD, GV);
2038 
2039  if (Method->isVirtual())
2040  getVTables().EmitThunks(GD);
2041 
2042  return;
2043  }
2044 
2045  return EmitGlobalFunctionDefinition(GD, GV);
2046  }
2047 
2048  if (const auto *VD = dyn_cast<VarDecl>(D))
2049  return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
2050 
2051  llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
2052 }
2053 
2054 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2055  llvm::Function *NewFn);
2056 
2057 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
2058 /// module, create and return an llvm Function with the specified type. If there
2059 /// is something in the module with the specified name, return it potentially
2060 /// bitcasted to the right type.
2061 ///
2062 /// If D is non-null, it specifies a decl that correspond to this. This is used
2063 /// to set the attributes on the function when it is first created.
2064 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
2065  StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
2066  bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
2067  ForDefinition_t IsForDefinition) {
2068  const Decl *D = GD.getDecl();
2069 
2070  // Lookup the entry, lazily creating it if necessary.
2071  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2072  if (Entry) {
2073  if (WeakRefReferences.erase(Entry)) {
2074  const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
2075  if (FD && !FD->hasAttr<WeakAttr>())
2076  Entry->setLinkage(llvm::Function::ExternalLinkage);
2077  }
2078 
2079  // Handle dropped DLL attributes.
2080  if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
2081  Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2082 
2083  // If there are two attempts to define the same mangled name, issue an
2084  // error.
2085  if (IsForDefinition && !Entry->isDeclaration()) {
2086  GlobalDecl OtherGD;
2087  // Check that GD is not yet in DiagnosedConflictingDefinitions is required
2088  // to make sure that we issue an error only once.
2089  if (lookupRepresentativeDecl(MangledName, OtherGD) &&
2090  (GD.getCanonicalDecl().getDecl() !=
2091  OtherGD.getCanonicalDecl().getDecl()) &&
2092  DiagnosedConflictingDefinitions.insert(GD).second) {
2093  getDiags().Report(D->getLocation(),
2094  diag::err_duplicate_mangled_name);
2095  getDiags().Report(OtherGD.getDecl()->getLocation(),
2096  diag::note_previous_definition);
2097  }
2098  }
2099 
2100  if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
2101  (Entry->getType()->getElementType() == Ty)) {
2102  return Entry;
2103  }
2104 
2105  // Make sure the result is of the correct type.
2106  // (If function is requested for a definition, we always need to create a new
2107  // function, not just return a bitcast.)
2108  if (!IsForDefinition)
2109  return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
2110  }
2111 
2112  // This function doesn't have a complete type (for example, the return
2113  // type is an incomplete struct). Use a fake type instead, and make
2114  // sure not to try to set attributes.
2115  bool IsIncompleteFunction = false;
2116 
2117  llvm::FunctionType *FTy;
2118  if (isa<llvm::FunctionType>(Ty)) {
2119  FTy = cast<llvm::FunctionType>(Ty);
2120  } else {
2121  FTy = llvm::FunctionType::get(VoidTy, false);
2122  IsIncompleteFunction = true;
2123  }
2124 
2125  llvm::Function *F =
2127  Entry ? StringRef() : MangledName, &getModule());
2128 
2129  // If we already created a function with the same mangled name (but different
2130  // type) before, take its name and add it to the list of functions to be
2131  // replaced with F at the end of CodeGen.
2132  //
2133  // This happens if there is a prototype for a function (e.g. "int f()") and
2134  // then a definition of a different type (e.g. "int f(int x)").
2135  if (Entry) {
2136  F->takeName(Entry);
2137 
2138  // This might be an implementation of a function without a prototype, in
2139  // which case, try to do special replacement of calls which match the new
2140  // prototype. The really key thing here is that we also potentially drop
2141  // arguments from the call site so as to make a direct call, which makes the
2142  // inliner happier and suppresses a number of optimizer warnings (!) about
2143  // dropping arguments.
2144  if (!Entry->use_empty()) {
2146  Entry->removeDeadConstantUsers();
2147  }
2148 
2149  llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
2150  F, Entry->getType()->getElementType()->getPointerTo());
2151  addGlobalValReplacement(Entry, BC);
2152  }
2153 
2154  assert(F->getName() == MangledName && "name was uniqued!");
2155  if (D)
2156  SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk,
2157  IsForDefinition);
2158  if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
2159  llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
2160  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
2161  }
2162 
2163  if (!DontDefer) {
2164  // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
2165  // each other bottoming out with the base dtor. Therefore we emit non-base
2166  // dtors on usage, even if there is no dtor definition in the TU.
2167  if (D && isa<CXXDestructorDecl>(D) &&
2168  getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
2169  GD.getDtorType()))
2170  addDeferredDeclToEmit(GD);
2171 
2172  // This is the first use or definition of a mangled name. If there is a
2173  // deferred decl with this name, remember that we need to emit it at the end
2174  // of the file.
2175  auto DDI = DeferredDecls.find(MangledName);
2176  if (DDI != DeferredDecls.end()) {
2177  // Move the potentially referenced deferred decl to the
2178  // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
2179  // don't need it anymore).
2180  addDeferredDeclToEmit(DDI->second);
2181  DeferredDecls.erase(DDI);
2182 
2183  // Otherwise, there are cases we have to worry about where we're
2184  // using a declaration for which we must emit a definition but where
2185  // we might not find a top-level definition:
2186  // - member functions defined inline in their classes
2187  // - friend functions defined inline in some class
2188  // - special member functions with implicit definitions
2189  // If we ever change our AST traversal to walk into class methods,
2190  // this will be unnecessary.
2191  //
2192  // We also don't emit a definition for a function if it's going to be an
2193  // entry in a vtable, unless it's already marked as used.
2194  } else if (getLangOpts().CPlusPlus && D) {
2195  // Look for a declaration that's lexically in a record.
2196  for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
2197  FD = FD->getPreviousDecl()) {
2198  if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
2199  if (FD->doesThisDeclarationHaveABody()) {
2200  addDeferredDeclToEmit(GD.getWithDecl(FD));
2201  break;
2202  }
2203  }
2204  }
2205  }
2206  }
2207 
2208  // Make sure the result is of the requested type.
2209  if (!IsIncompleteFunction) {
2210  assert(F->getType()->getElementType() == Ty);
2211  return F;
2212  }
2213 
2214  llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2215  return llvm::ConstantExpr::getBitCast(F, PTy);
2216 }
2217 
2218 /// GetAddrOfFunction - Return the address of the given function. If Ty is
2219 /// non-null, then this function will use the specified type if it has to
2220 /// create it (this occurs when we see a definition of the function).
2222  llvm::Type *Ty,
2223  bool ForVTable,
2224  bool DontDefer,
2225  ForDefinition_t IsForDefinition) {
2226  // If there was no specific requested type, just convert it now.
2227  if (!Ty) {
2228  const auto *FD = cast<FunctionDecl>(GD.getDecl());
2229  auto CanonTy = Context.getCanonicalType(FD->getType());
2230  Ty = getTypes().ConvertFunctionType(CanonTy, FD);
2231  }
2232 
2233  StringRef MangledName = getMangledName(GD);
2234  return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
2235  /*IsThunk=*/false, llvm::AttributeList(),
2236  IsForDefinition);
2237 }
2238 
2239 static const FunctionDecl *
2240 GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) {
2243 
2244  IdentifierInfo &CII = C.Idents.get(Name);
2245  for (const auto &Result : DC->lookup(&CII))
2246  if (const auto FD = dyn_cast<FunctionDecl>(Result))
2247  return FD;
2248 
2249  if (!C.getLangOpts().CPlusPlus)
2250  return nullptr;
2251 
2252  // Demangle the premangled name from getTerminateFn()
2253  IdentifierInfo &CXXII =
2254  (Name == "_ZSt9terminatev" || Name == "\01?terminate@@YAXXZ")
2255  ? C.Idents.get("terminate")
2256  : C.Idents.get(Name);
2257 
2258  for (const auto &N : {"__cxxabiv1", "std"}) {
2259  IdentifierInfo &NS = C.Idents.get(N);
2260  for (const auto &Result : DC->lookup(&NS)) {
2261  NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
2262  if (auto LSD = dyn_cast<LinkageSpecDecl>(Result))
2263  for (const auto &Result : LSD->lookup(&NS))
2264  if ((ND = dyn_cast<NamespaceDecl>(Result)))
2265  break;
2266 
2267  if (ND)
2268  for (const auto &Result : ND->lookup(&CXXII))
2269  if (const auto *FD = dyn_cast<FunctionDecl>(Result))
2270  return FD;
2271  }
2272  }
2273 
2274  return nullptr;
2275 }
2276 
2277 /// CreateRuntimeFunction - Create a new runtime function with the specified
2278 /// type and name.
2279 llvm::Constant *
2280 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
2281  llvm::AttributeList ExtraAttrs,
2282  bool Local) {
2283  llvm::Constant *C =
2284  GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
2285  /*DontDefer=*/false, /*IsThunk=*/false,
2286  ExtraAttrs);
2287 
2288  if (auto *F = dyn_cast<llvm::Function>(C)) {
2289  if (F->empty()) {
2290  F->setCallingConv(getRuntimeCC());
2291 
2292  if (!Local && getTriple().isOSBinFormatCOFF() &&
2293  !getCodeGenOpts().LTOVisibilityPublicStd &&
2294  !getTriple().isWindowsGNUEnvironment()) {
2295  const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
2296  if (!FD || FD->hasAttr<DLLImportAttr>()) {
2297  F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2298  F->setLinkage(llvm::GlobalValue::ExternalLinkage);
2299  }
2300  }
2301  }
2302  }
2303 
2304  return C;
2305 }
2306 
2307 /// CreateBuiltinFunction - Create a new builtin function with the specified
2308 /// type and name.
2309 llvm::Constant *
2310 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy, StringRef Name,
2311  llvm::AttributeList ExtraAttrs) {
2312  llvm::Constant *C =
2313  GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
2314  /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
2315  if (auto *F = dyn_cast<llvm::Function>(C))
2316  if (F->empty())
2317  F->setCallingConv(getBuiltinCC());
2318  return C;
2319 }
2320 
2321 /// isTypeConstant - Determine whether an object of this type can be emitted
2322 /// as a constant.
2323 ///
2324 /// If ExcludeCtor is true, the duration when the object's constructor runs
2325 /// will not be considered. The caller will need to verify that the object is
2326 /// not written to during its construction.
2327 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
2328  if (!Ty.isConstant(Context) && !Ty->isReferenceType())
2329  return false;
2330 
2331  if (Context.getLangOpts().CPlusPlus) {
2332  if (const CXXRecordDecl *Record
2333  = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
2334  return ExcludeCtor && !Record->hasMutableFields() &&
2335  Record->hasTrivialDestructor();
2336  }
2337 
2338  return true;
2339 }
2340 
2341 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
2342 /// create and return an llvm GlobalVariable with the specified type. If there
2343 /// is something in the module with the specified name, return it potentially
2344 /// bitcasted to the right type.
2345 ///
2346 /// If D is non-null, it specifies a decl that correspond to this. This is used
2347 /// to set the attributes on the global when it is first created.
2348 ///
2349 /// If IsForDefinition is true, it is guranteed that an actual global with
2350 /// type Ty will be returned, not conversion of a variable with the same
2351 /// mangled name but some other type.
2352 llvm::Constant *
2353 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
2354  llvm::PointerType *Ty,
2355  const VarDecl *D,
2356  ForDefinition_t IsForDefinition) {
2357  // Lookup the entry, lazily creating it if necessary.
2358  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2359  if (Entry) {
2360  if (WeakRefReferences.erase(Entry)) {
2361  if (D && !D->hasAttr<WeakAttr>())
2362  Entry->setLinkage(llvm::Function::ExternalLinkage);
2363  }
2364 
2365  // Handle dropped DLL attributes.
2366  if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
2367  Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2368 
2369  if (Entry->getType() == Ty)
2370  return Entry;
2371 
2372  // If there are two attempts to define the same mangled name, issue an
2373  // error.
2374  if (IsForDefinition && !Entry->isDeclaration()) {
2375  GlobalDecl OtherGD;
2376  const VarDecl *OtherD;
2377 
2378  // Check that D is not yet in DiagnosedConflictingDefinitions is required
2379  // to make sure that we issue an error only once.
2380  if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
2381  (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
2382  (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
2383  OtherD->hasInit() &&
2384  DiagnosedConflictingDefinitions.insert(D).second) {
2385  getDiags().Report(D->getLocation(),
2386  diag::err_duplicate_mangled_name);
2387  getDiags().Report(OtherGD.getDecl()->getLocation(),
2388  diag::note_previous_definition);
2389  }
2390  }
2391 
2392  // Make sure the result is of the correct type.
2393  if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
2394  return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
2395 
2396  // (If global is requested for a definition, we always need to create a new
2397  // global, not just return a bitcast.)
2398  if (!IsForDefinition)
2399  return llvm::ConstantExpr::getBitCast(Entry, Ty);
2400  }
2401 
2402  auto AddrSpace = GetGlobalVarAddressSpace(D);
2403  auto TargetAddrSpace = getContext().getTargetAddressSpace(AddrSpace);
2404 
2405  auto *GV = new llvm::GlobalVariable(
2406  getModule(), Ty->getElementType(), false,
2407  llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
2408  llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace);
2409 
2410  // If we already created a global with the same mangled name (but different
2411  // type) before, take its name and remove it from its parent.
2412  if (Entry) {
2413  GV->takeName(Entry);
2414 
2415  if (!Entry->use_empty()) {
2416  llvm::Constant *NewPtrForOldDecl =
2417  llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2418  Entry->replaceAllUsesWith(NewPtrForOldDecl);
2419  }
2420 
2421  Entry->eraseFromParent();
2422  }
2423 
2424  // This is the first use or definition of a mangled name. If there is a
2425  // deferred decl with this name, remember that we need to emit it at the end
2426  // of the file.
2427  auto DDI = DeferredDecls.find(MangledName);
2428  if (DDI != DeferredDecls.end()) {
2429  // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
2430  // list, and remove it from DeferredDecls (since we don't need it anymore).
2431  addDeferredDeclToEmit(DDI->second);
2432  DeferredDecls.erase(DDI);
2433  }
2434 
2435  // Handle things which are present even on external declarations.
2436  if (D) {
2437  // FIXME: This code is overly simple and should be merged with other global
2438  // handling.
2439  GV->setConstant(isTypeConstant(D->getType(), false));
2440 
2441  GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
2442 
2443  setLinkageForGV(GV, D);
2445 
2446  if (D->getTLSKind()) {
2447  if (D->getTLSKind() == VarDecl::TLS_Dynamic)
2448  CXXThreadLocals.push_back(D);
2449  setTLSMode(GV, *D);
2450  }
2451 
2452  // If required by the ABI, treat declarations of static data members with
2453  // inline initializers as definitions.
2454  if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
2455  EmitGlobalVarDefinition(D);
2456  }
2457 
2458  // Emit section information for extern variables.
2459  if (D->hasExternalStorage()) {
2460  if (const SectionAttr *SA = D->getAttr<SectionAttr>())
2461  GV->setSection(SA->getName());
2462  }
2463 
2464  // Handle XCore specific ABI requirements.
2465  if (getTriple().getArch() == llvm::Triple::xcore &&
2467  D->getType().isConstant(Context) &&
2469  GV->setSection(".cp.rodata");
2470 
2471  // Check if we a have a const declaration with an initializer, we may be
2472  // able to emit it as available_externally to expose it's value to the
2473  // optimizer.
2474  if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
2475  D->getType().isConstQualified() && !GV->hasInitializer() &&
2476  !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
2477  const auto *Record =
2478  Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
2479  bool HasMutableFields = Record && Record->hasMutableFields();
2480  if (!HasMutableFields) {
2481  const VarDecl *InitDecl;
2482  const Expr *InitExpr = D->getAnyInitializer(InitDecl);
2483  if (InitExpr) {
2484  ConstantEmitter emitter(*this);
2485  llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
2486  if (Init) {
2487  auto *InitType = Init->getType();
2488  if (GV->getType()->getElementType() != InitType) {
2489  // The type of the initializer does not match the definition.
2490  // This happens when an initializer has a different type from
2491  // the type of the global (because of padding at the end of a
2492  // structure for instance).
2493  GV->setName(StringRef());
2494  // Make a new global with the correct type, this is now guaranteed
2495  // to work.
2496  auto *NewGV = cast<llvm::GlobalVariable>(
2497  GetAddrOfGlobalVar(D, InitType, IsForDefinition));
2498 
2499  // Erase the old global, since it is no longer used.
2500  cast<llvm::GlobalValue>(GV)->eraseFromParent();
2501  GV = NewGV;
2502  } else {
2503  GV->setInitializer(Init);
2504  GV->setConstant(true);
2505  GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
2506  }
2507  emitter.finalize(GV);
2508  }
2509  }
2510  }
2511  }
2512  }
2513 
2514  LangAS ExpectedAS =
2515  D ? D->getType().getAddressSpace()
2516  : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
2517  assert(getContext().getTargetAddressSpace(ExpectedAS) ==
2518  Ty->getPointerAddressSpace());
2519  if (AddrSpace != ExpectedAS)
2520  return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace,
2521  ExpectedAS, Ty);
2522 
2523  return GV;
2524 }
2525 
2526 llvm::Constant *
2528  ForDefinition_t IsForDefinition) {
2529  const Decl *D = GD.getDecl();
2530  if (isa<CXXConstructorDecl>(D))
2531  return getAddrOfCXXStructor(cast<CXXConstructorDecl>(D),
2533  /*FnInfo=*/nullptr, /*FnType=*/nullptr,
2534  /*DontDefer=*/false, IsForDefinition);
2535  else if (isa<CXXDestructorDecl>(D))
2536  return getAddrOfCXXStructor(cast<CXXDestructorDecl>(D),
2538  /*FnInfo=*/nullptr, /*FnType=*/nullptr,
2539  /*DontDefer=*/false, IsForDefinition);
2540  else if (isa<CXXMethodDecl>(D)) {
2541  auto FInfo = &getTypes().arrangeCXXMethodDeclaration(
2542  cast<CXXMethodDecl>(D));
2543  auto Ty = getTypes().GetFunctionType(*FInfo);
2544  return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
2545  IsForDefinition);
2546  } else if (isa<FunctionDecl>(D)) {
2548  llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2549  return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
2550  IsForDefinition);
2551  } else
2552  return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr,
2553  IsForDefinition);
2554 }
2555 
2556 llvm::GlobalVariable *
2558  llvm::Type *Ty,
2559  llvm::GlobalValue::LinkageTypes Linkage) {
2560  llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
2561  llvm::GlobalVariable *OldGV = nullptr;
2562 
2563  if (GV) {
2564  // Check if the variable has the right type.
2565  if (GV->getType()->getElementType() == Ty)
2566  return GV;
2567 
2568  // Because C++ name mangling, the only way we can end up with an already
2569  // existing global with the same name is if it has been declared extern "C".
2570  assert(GV->isDeclaration() && "Declaration has wrong type!");
2571  OldGV = GV;
2572  }
2573 
2574  // Create a new variable.
2575  GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
2576  Linkage, nullptr, Name);
2577 
2578  if (OldGV) {
2579  // Replace occurrences of the old variable if needed.
2580  GV->takeName(OldGV);
2581 
2582  if (!OldGV->use_empty()) {
2583  llvm::Constant *NewPtrForOldDecl =
2584  llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
2585  OldGV->replaceAllUsesWith(NewPtrForOldDecl);
2586  }
2587 
2588  OldGV->eraseFromParent();
2589  }
2590 
2591  if (supportsCOMDAT() && GV->isWeakForLinker() &&
2592  !GV->hasAvailableExternallyLinkage())
2593  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
2594 
2595  return GV;
2596 }
2597 
2598 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
2599 /// given global variable. If Ty is non-null and if the global doesn't exist,
2600 /// then it will be created with the specified type instead of whatever the
2601 /// normal requested type would be. If IsForDefinition is true, it is guranteed
2602 /// that an actual global with type Ty will be returned, not conversion of a
2603 /// variable with the same mangled name but some other type.
2605  llvm::Type *Ty,
2606  ForDefinition_t IsForDefinition) {
2607  assert(D->hasGlobalStorage() && "Not a global variable");
2608  QualType ASTTy = D->getType();
2609  if (!Ty)
2610  Ty = getTypes().ConvertTypeForMem(ASTTy);
2611 
2612  llvm::PointerType *PTy =
2613  llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
2614 
2615  StringRef MangledName = getMangledName(D);
2616  return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition);
2617 }
2618 
2619 /// CreateRuntimeVariable - Create a new runtime global variable with the
2620 /// specified type and name.
2621 llvm::Constant *
2623  StringRef Name) {
2624  return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
2625 }
2626 
2628  assert(!D->getInit() && "Cannot emit definite definitions here!");
2629 
2630  StringRef MangledName = getMangledName(D);
2631  llvm::GlobalValue *GV = GetGlobalValue(MangledName);
2632 
2633  // We already have a definition, not declaration, with the same mangled name.
2634  // Emitting of declaration is not required (and actually overwrites emitted
2635  // definition).
2636  if (GV && !GV->isDeclaration())
2637  return;
2638 
2639  // If we have not seen a reference to this variable yet, place it into the
2640  // deferred declarations table to be emitted if needed later.
2641  if (!MustBeEmitted(D) && !GV) {
2642  DeferredDecls[MangledName] = D;
2643  return;
2644  }
2645 
2646  // The tentative definition is the only definition.
2647  EmitGlobalVarDefinition(D);
2648 }
2649 
2651  return Context.toCharUnitsFromBits(
2652  getDataLayout().getTypeStoreSizeInBits(Ty));
2653 }
2654 
2656  LangAS AddrSpace = LangAS::Default;
2657  if (LangOpts.OpenCL) {
2658  AddrSpace = D ? D->getType().getAddressSpace() : LangAS::opencl_global;
2659  assert(AddrSpace == LangAS::opencl_global ||
2660  AddrSpace == LangAS::opencl_constant ||
2661  AddrSpace == LangAS::opencl_local ||
2662  AddrSpace >= LangAS::FirstTargetAddressSpace);
2663  return AddrSpace;
2664  }
2665 
2666  if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
2667  if (D && D->hasAttr<CUDAConstantAttr>())
2668  return LangAS::cuda_constant;
2669  else if (D && D->hasAttr<CUDASharedAttr>())
2670  return LangAS::cuda_shared;
2671  else
2672  return LangAS::cuda_device;
2673  }
2674 
2676 }
2677 
2678 template<typename SomeDecl>
2680  llvm::GlobalValue *GV) {
2681  if (!getLangOpts().CPlusPlus)
2682  return;
2683 
2684  // Must have 'used' attribute, or else inline assembly can't rely on
2685  // the name existing.
2686  if (!D->template hasAttr<UsedAttr>())
2687  return;
2688 
2689  // Must have internal linkage and an ordinary name.
2690  if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
2691  return;
2692 
2693  // Must be in an extern "C" context. Entities declared directly within
2694  // a record are not extern "C" even if the record is in such a context.
2695  const SomeDecl *First = D->getFirstDecl();
2696  if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
2697  return;
2698 
2699  // OK, this is an internal linkage entity inside an extern "C" linkage
2700  // specification. Make a note of that so we can give it the "expected"
2701  // mangled name if nothing else is using that name.
2702  std::pair<StaticExternCMap::iterator, bool> R =
2703  StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
2704 
2705  // If we have multiple internal linkage entities with the same name
2706  // in extern "C" regions, none of them gets that name.
2707  if (!R.second)
2708  R.first->second = nullptr;
2709 }
2710 
2711 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
2712  if (!CGM.supportsCOMDAT())
2713  return false;
2714 
2715  if (D.hasAttr<SelectAnyAttr>())
2716  return true;
2717 
2719  if (auto *VD = dyn_cast<VarDecl>(&D))
2720  Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
2721  else
2722  Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
2723 
2724  switch (Linkage) {
2725  case GVA_Internal:
2727  case GVA_StrongExternal:
2728  return false;
2729  case GVA_DiscardableODR:
2730  case GVA_StrongODR:
2731  return true;
2732  }
2733  llvm_unreachable("No such linkage");
2734 }
2735 
2737  llvm::GlobalObject &GO) {
2738  if (!shouldBeInCOMDAT(*this, D))
2739  return;
2740  GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
2741 }
2742 
2743 /// Pass IsTentative as true if you want to create a tentative definition.
2744 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
2745  bool IsTentative) {
2746  // OpenCL global variables of sampler type are translated to function calls,
2747  // therefore no need to be translated.
2748  QualType ASTTy = D->getType();
2749  if (getLangOpts().OpenCL && ASTTy->isSamplerT())
2750  return;
2751 
2752  llvm::Constant *Init = nullptr;
2754  bool NeedsGlobalCtor = false;
2755  bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
2756 
2757  const VarDecl *InitDecl;
2758  const Expr *InitExpr = D->getAnyInitializer(InitDecl);
2759 
2760  Optional<ConstantEmitter> emitter;
2761 
2762  // CUDA E.2.4.1 "__shared__ variables cannot have an initialization
2763  // as part of their declaration." Sema has already checked for
2764  // error cases, so we just need to set Init to UndefValue.
2765  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
2766  D->hasAttr<CUDASharedAttr>())
2767  Init = llvm::UndefValue::get(getTypes().ConvertType(ASTTy));
2768  else if (!InitExpr) {
2769  // This is a tentative definition; tentative definitions are
2770  // implicitly initialized with { 0 }.
2771  //
2772  // Note that tentative definitions are only emitted at the end of
2773  // a translation unit, so they should never have incomplete
2774  // type. In addition, EmitTentativeDefinition makes sure that we
2775  // never attempt to emit a tentative definition if a real one
2776  // exists. A use may still exists, however, so we still may need
2777  // to do a RAUW.
2778  assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
2779  Init = EmitNullConstant(D->getType());
2780  } else {
2781  initializedGlobalDecl = GlobalDecl(D);
2782  emitter.emplace(*this);
2783  Init = emitter->tryEmitForInitializer(*InitDecl);
2784 
2785  if (!Init) {
2786  QualType T = InitExpr->getType();
2787  if (D->getType()->isReferenceType())
2788  T = D->getType();
2789 
2790  if (getLangOpts().CPlusPlus) {
2791  Init = EmitNullConstant(T);
2792  NeedsGlobalCtor = true;
2793  } else {
2794  ErrorUnsupported(D, "static initializer");
2795  Init = llvm::UndefValue::get(getTypes().ConvertType(T));
2796  }
2797  } else {
2798  // We don't need an initializer, so remove the entry for the delayed
2799  // initializer position (just in case this entry was delayed) if we
2800  // also don't need to register a destructor.
2801  if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
2802  DelayedCXXInitPosition.erase(D);
2803  }
2804  }
2805 
2806  llvm::Type* InitType = Init->getType();
2807  llvm::Constant *Entry =
2808  GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative));
2809 
2810  // Strip off a bitcast if we got one back.
2811  if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2812  assert(CE->getOpcode() == llvm::Instruction::BitCast ||
2813  CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
2814  // All zero index gep.
2815  CE->getOpcode() == llvm::Instruction::GetElementPtr);
2816  Entry = CE->getOperand(0);
2817  }
2818 
2819  // Entry is now either a Function or GlobalVariable.
2820  auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
2821 
2822  // We have a definition after a declaration with the wrong type.
2823  // We must make a new GlobalVariable* and update everything that used OldGV
2824  // (a declaration or tentative definition) with the new GlobalVariable*
2825  // (which will be a definition).
2826  //
2827  // This happens if there is a prototype for a global (e.g.
2828  // "extern int x[];") and then a definition of a different type (e.g.
2829  // "int x[10];"). This also happens when an initializer has a different type
2830  // from the type of the global (this happens with unions).
2831  if (!GV || GV->getType()->getElementType() != InitType ||
2832  GV->getType()->getAddressSpace() !=
2834 
2835  // Move the old entry aside so that we'll create a new one.
2836  Entry->setName(StringRef());
2837 
2838  // Make a new global with the correct type, this is now guaranteed to work.
2839  GV = cast<llvm::GlobalVariable>(
2840  GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative)));
2841 
2842  // Replace all uses of the old global with the new global
2843  llvm::Constant *NewPtrForOldDecl =
2844  llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2845  Entry->replaceAllUsesWith(NewPtrForOldDecl);
2846 
2847  // Erase the old global, since it is no longer used.
2848  cast<llvm::GlobalValue>(Entry)->eraseFromParent();
2849  }
2850 
2852 
2853  if (D->hasAttr<AnnotateAttr>())
2854  AddGlobalAnnotations(D, GV);
2855 
2856  // Set the llvm linkage type as appropriate.
2857  llvm::GlobalValue::LinkageTypes Linkage =
2858  getLLVMLinkageVarDefinition(D, GV->isConstant());
2859 
2860  // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
2861  // the device. [...]"
2862  // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
2863  // __device__, declares a variable that: [...]
2864  // Is accessible from all the threads within the grid and from the host
2865  // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize()
2866  // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())."
2867  if (GV && LangOpts.CUDA) {
2868  if (LangOpts.CUDAIsDevice) {
2869  if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>())
2870  GV->setExternallyInitialized(true);
2871  } else {
2872  // Host-side shadows of external declarations of device-side
2873  // global variables become internal definitions. These have to
2874  // be internal in order to prevent name conflicts with global
2875  // host variables with the same name in a different TUs.
2876  if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) {
2878 
2879  // Shadow variables and their properties must be registered
2880  // with CUDA runtime.
2881  unsigned Flags = 0;
2882  if (!D->hasDefinition())
2884  if (D->hasAttr<CUDAConstantAttr>())
2886  getCUDARuntime().registerDeviceVar(*GV, Flags);
2887  } else if (D->hasAttr<CUDASharedAttr>())
2888  // __shared__ variables are odd. Shadows do get created, but
2889  // they are not registered with the CUDA runtime, so they
2890  // can't really be used to access their device-side
2891  // counterparts. It's not clear yet whether it's nvcc's bug or
2892  // a feature, but we've got to do the same for compatibility.
2894  }
2895  }
2896 
2897  GV->setInitializer(Init);
2898  if (emitter) emitter->finalize(GV);
2899 
2900  // If it is safe to mark the global 'constant', do so now.
2901  GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
2902  isTypeConstant(D->getType(), true));
2903 
2904  // If it is in a read-only section, mark it 'constant'.
2905  if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
2906  const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
2907  if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
2908  GV->setConstant(true);
2909  }
2910 
2911  GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
2912 
2913 
2914  // On Darwin, if the normal linkage of a C++ thread_local variable is
2915  // LinkOnce or Weak, we keep the normal linkage to prevent multiple
2916  // copies within a linkage unit; otherwise, the backing variable has
2917  // internal linkage and all accesses should just be calls to the
2918  // Itanium-specified entry point, which has the normal linkage of the
2919  // variable. This is to preserve the ability to change the implementation
2920  // behind the scenes.
2921  if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
2922  Context.getTargetInfo().getTriple().isOSDarwin() &&
2923  !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
2924  !llvm::GlobalVariable::isWeakLinkage(Linkage))
2926 
2927  GV->setLinkage(Linkage);
2928  if (D->hasAttr<DLLImportAttr>())
2929  GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2930  else if (D->hasAttr<DLLExportAttr>())
2931  GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
2932  else
2933  GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
2934 
2935  if (Linkage == llvm::GlobalVariable::CommonLinkage) {
2936  // common vars aren't constant even if declared const.
2937  GV->setConstant(false);
2938  // Tentative definition of global variables may be initialized with
2939  // non-zero null pointers. In this case they should have weak linkage
2940  // since common linkage must have zero initializer and must not have
2941  // explicit section therefore cannot have non-zero initial value.
2942  if (!GV->getInitializer()->isNullValue())
2943  GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
2944  }
2945 
2946  setNonAliasAttributes(D, GV);
2947 
2948  if (D->getTLSKind() && !GV->isThreadLocal()) {
2949  if (D->getTLSKind() == VarDecl::TLS_Dynamic)
2950  CXXThreadLocals.push_back(D);
2951  setTLSMode(GV, *D);
2952  }
2953 
2954  maybeSetTrivialComdat(*D, *GV);
2955 
2956  // Emit the initializer function if necessary.
2957  if (NeedsGlobalCtor || NeedsGlobalDtor)
2958  EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
2959 
2960  SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
2961 
2962  // Emit global variable debug information.
2963  if (CGDebugInfo *DI = getModuleDebugInfo())
2964  if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
2965  DI->EmitGlobalVariable(GV, D);
2966 }
2967 
2968 static bool isVarDeclStrongDefinition(const ASTContext &Context,
2969  CodeGenModule &CGM, const VarDecl *D,
2970  bool NoCommon) {
2971  // Don't give variables common linkage if -fno-common was specified unless it
2972  // was overridden by a NoCommon attribute.
2973  if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
2974  return true;
2975 
2976  // C11 6.9.2/2:
2977  // A declaration of an identifier for an object that has file scope without
2978  // an initializer, and without a storage-class specifier or with the
2979  // storage-class specifier static, constitutes a tentative definition.
2980  if (D->getInit() || D->hasExternalStorage())
2981  return true;
2982 
2983  // A variable cannot be both common and exist in a section.
2984  if (D->hasAttr<SectionAttr>())
2985  return true;
2986 
2987  // A variable cannot be both common and exist in a section.
2988  // We dont try to determine which is the right section in the front-end.
2989  // If no specialized section name is applicable, it will resort to default.
2990  if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
2991  D->hasAttr<PragmaClangDataSectionAttr>() ||
2992  D->hasAttr<PragmaClangRodataSectionAttr>())
2993  return true;
2994 
2995  // Thread local vars aren't considered common linkage.
2996  if (D->getTLSKind())
2997  return true;
2998 
2999  // Tentative definitions marked with WeakImportAttr are true definitions.
3000  if (D->hasAttr<WeakImportAttr>())
3001  return true;
3002 
3003  // A variable cannot be both common and exist in a comdat.
3004  if (shouldBeInCOMDAT(CGM, *D))
3005  return true;
3006 
3007  // Declarations with a required alignment do not have common linkage in MSVC
3008  // mode.
3009  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
3010  if (D->hasAttr<AlignedAttr>())
3011  return true;
3012  QualType VarType = D->getType();
3013  if (Context.isAlignmentRequired(VarType))
3014  return true;
3015 
3016  if (const auto *RT = VarType->getAs<RecordType>()) {
3017  const RecordDecl *RD = RT->getDecl();
3018  for (const FieldDecl *FD : RD->fields()) {
3019  if (FD->isBitField())
3020  continue;
3021  if (FD->hasAttr<AlignedAttr>())
3022  return true;
3023  if (Context.isAlignmentRequired(FD->getType()))
3024  return true;
3025  }
3026  }
3027  }
3028 
3029  return false;
3030 }
3031 
3032 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
3033  const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
3034  if (Linkage == GVA_Internal)
3036 
3037  if (D->hasAttr<WeakAttr>()) {
3038  if (IsConstantVariable)
3039  return llvm::GlobalVariable::WeakODRLinkage;
3040  else
3041  return llvm::GlobalVariable::WeakAnyLinkage;
3042  }
3043 
3044  // We are guaranteed to have a strong definition somewhere else,
3045  // so we can use available_externally linkage.
3046  if (Linkage == GVA_AvailableExternally)
3047  return llvm::GlobalValue::AvailableExternallyLinkage;
3048 
3049  // Note that Apple's kernel linker doesn't support symbol
3050  // coalescing, so we need to avoid linkonce and weak linkages there.
3051  // Normally, this means we just map to internal, but for explicit
3052  // instantiations we'll map to external.
3053 
3054  // In C++, the compiler has to emit a definition in every translation unit
3055  // that references the function. We should use linkonce_odr because
3056  // a) if all references in this translation unit are optimized away, we
3057  // don't need to codegen it. b) if the function persists, it needs to be
3058  // merged with other definitions. c) C++ has the ODR, so we know the
3059  // definition is dependable.
3060  if (Linkage == GVA_DiscardableODR)
3061  return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
3063 
3064  // An explicit instantiation of a template has weak linkage, since
3065  // explicit instantiations can occur in multiple translation units
3066  // and must all be equivalent. However, we are not allowed to
3067  // throw away these explicit instantiations.
3068  //
3069  // We don't currently support CUDA device code spread out across multiple TUs,
3070  // so say that CUDA templates are either external (for kernels) or internal.
3071  // This lets llvm perform aggressive inter-procedural optimizations.
3072  if (Linkage == GVA_StrongODR) {
3073  if (Context.getLangOpts().AppleKext)
3075  if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice)
3076  return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
3078  return llvm::Function::WeakODRLinkage;
3079  }
3080 
3081  // C++ doesn't have tentative definitions and thus cannot have common
3082  // linkage.
3083  if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
3084  !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
3085  CodeGenOpts.NoCommon))
3086  return llvm::GlobalVariable::CommonLinkage;
3087 
3088  // selectany symbols are externally visible, so use weak instead of
3089  // linkonce. MSVC optimizes away references to const selectany globals, so
3090  // all definitions should be the same and ODR linkage should be used.
3091  // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
3092  if (D->hasAttr<SelectAnyAttr>())
3093  return llvm::GlobalVariable::WeakODRLinkage;
3094 
3095  // Otherwise, we have strong external linkage.
3096  assert(Linkage == GVA_StrongExternal);
3098 }
3099 
3100 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
3101  const VarDecl *VD, bool IsConstant) {
3103  return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
3104 }
3105 
3106 /// Replace the uses of a function that was declared with a non-proto type.
3107 /// We want to silently drop extra arguments from call sites
3108 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
3109  llvm::Function *newFn) {
3110  // Fast path.
3111  if (old->use_empty()) return;
3112 
3113  llvm::Type *newRetTy = newFn->getReturnType();
3116 
3117  for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
3118  ui != ue; ) {
3119  llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
3120  llvm::User *user = use->getUser();
3121 
3122  // Recognize and replace uses of bitcasts. Most calls to
3123  // unprototyped functions will use bitcasts.
3124  if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
3125  if (bitcast->getOpcode() == llvm::Instruction::BitCast)
3126  replaceUsesOfNonProtoConstant(bitcast, newFn);
3127  continue;
3128  }
3129 
3130  // Recognize calls to the function.
3131  llvm::CallSite callSite(user);
3132  if (!callSite) continue;
3133  if (!callSite.isCallee(&*use)) continue;
3134 
3135  // If the return types don't match exactly, then we can't
3136  // transform this call unless it's dead.
3137  if (callSite->getType() != newRetTy && !callSite->use_empty())
3138  continue;
3139 
3140  // Get the call site's attribute list.
3142  llvm::AttributeList oldAttrs = callSite.getAttributes();
3143 
3144  // If the function was passed too few arguments, don't transform.
3145  unsigned newNumArgs = newFn->arg_size();
3146  if (callSite.arg_size() < newNumArgs) continue;
3147 
3148  // If extra arguments were passed, we silently drop them.
3149  // If any of the types mismatch, we don't transform.
3150  unsigned argNo = 0;
3151  bool dontTransform = false;
3152  for (llvm::Argument &A : newFn->args()) {
3153  if (callSite.getArgument(argNo)->getType() != A.getType()) {
3154  dontTransform = true;
3155  break;
3156  }
3157 
3158  // Add any parameter attributes.
3159  newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo));
3160  argNo++;
3161  }
3162  if (dontTransform)
3163  continue;
3164 
3165  // Okay, we can transform this. Create the new call instruction and copy
3166  // over the required information.
3167  newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
3168 
3169  // Copy over any operand bundles.
3170  callSite.getOperandBundlesAsDefs(newBundles);
3171 
3172  llvm::CallSite newCall;
3173  if (callSite.isCall()) {
3174  newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "",
3175  callSite.getInstruction());
3176  } else {
3177  auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction());
3178  newCall = llvm::InvokeInst::Create(newFn,
3179  oldInvoke->getNormalDest(),
3180  oldInvoke->getUnwindDest(),
3181  newArgs, newBundles, "",
3182  callSite.getInstruction());
3183  }
3184  newArgs.clear(); // for the next iteration
3185 
3186  if (!newCall->getType()->isVoidTy())
3187  newCall->takeName(callSite.getInstruction());
3188  newCall.setAttributes(llvm::AttributeList::get(
3189  newFn->getContext(), oldAttrs.getFnAttributes(),
3190  oldAttrs.getRetAttributes(), newArgAttrs));
3191  newCall.setCallingConv(callSite.getCallingConv());
3192 
3193  // Finally, remove the old call, replacing any uses with the new one.
3194  if (!callSite->use_empty())
3195  callSite->replaceAllUsesWith(newCall.getInstruction());
3196 
3197  // Copy debug location attached to CI.
3198  if (callSite->getDebugLoc())
3199  newCall->setDebugLoc(callSite->getDebugLoc());
3200 
3201  callSite->eraseFromParent();
3202  }
3203 }
3204 
3205 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
3206 /// implement a function with no prototype, e.g. "int foo() {}". If there are
3207 /// existing call uses of the old function in the module, this adjusts them to
3208 /// call the new function directly.
3209 ///
3210 /// This is not just a cleanup: the always_inline pass requires direct calls to
3211 /// functions to be able to inline them. If there is a bitcast in the way, it
3212 /// won't inline them. Instcombine normally deletes these calls, but it isn't
3213 /// run at -O0.
3214 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
3215  llvm::Function *NewFn) {
3216  // If we're redefining a global as a function, don't transform it.
3217  if (!isa<llvm::Function>(Old)) return;
3218 
3219  replaceUsesOfNonProtoConstant(Old, NewFn);
3220 }
3221 
3223  auto DK = VD->isThisDeclarationADefinition();
3224  if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>())
3225  return;
3226 
3228  // If we have a definition, this might be a deferred decl. If the
3229  // instantiation is explicit, make sure we emit it at the end.
3231  GetAddrOfGlobalVar(VD);
3232 
3233  EmitTopLevelDecl(VD);
3234 }
3235 
3236 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
3237  llvm::GlobalValue *GV) {
3238  const auto *D = cast<FunctionDecl>(GD.getDecl());
3239 
3240  // Compute the function info and LLVM type.
3242  llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
3243 
3244  // Get or create the prototype for the function.
3245  if (!GV || (GV->getType()->getElementType() != Ty))
3246  GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
3247  /*DontDefer=*/true,
3248  ForDefinition));
3249 
3250  // Already emitted.
3251  if (!GV->isDeclaration())
3252  return;
3253 
3254  // We need to set linkage and visibility on the function before
3255  // generating code for it because various parts of IR generation
3256  // want to propagate this information down (e.g. to local static
3257  // declarations).
3258  auto *Fn = cast<llvm::Function>(GV);
3259  setFunctionLinkage(GD, Fn);
3261 
3262  // FIXME: this is redundant with part of setFunctionDefinitionAttributes
3264 
3266 
3267  maybeSetTrivialComdat(*D, *Fn);
3268 
3269  CodeGenFunction(*this).GenerateCode(D, Fn, FI);
3270 
3273 
3274  if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
3275  AddGlobalCtor(Fn, CA->getPriority());
3276  if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
3277  AddGlobalDtor(Fn, DA->getPriority());
3278  if (D->hasAttr<AnnotateAttr>())
3279  AddGlobalAnnotations(D, Fn);
3280 }
3281 
3282 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
3283  const auto *D = cast<ValueDecl>(GD.getDecl());
3284  const AliasAttr *AA = D->getAttr<AliasAttr>();
3285  assert(AA && "Not an alias?");
3286 
3287  StringRef MangledName = getMangledName(GD);
3288 
3289  if (AA->getAliasee() == MangledName) {
3290  Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
3291  return;
3292  }
3293 
3294  // If there is a definition in the module, then it wins over the alias.
3295  // This is dubious, but allow it to be safe. Just ignore the alias.
3296  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3297  if (Entry && !Entry->isDeclaration())
3298  return;
3299 
3300  Aliases.push_back(GD);
3301 
3302  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
3303 
3304  // Create a reference to the named value. This ensures that it is emitted
3305  // if a deferred decl.
3306  llvm::Constant *Aliasee;
3307  if (isa<llvm::FunctionType>(DeclTy))
3308  Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
3309  /*ForVTable=*/false);
3310  else
3311  Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
3312  llvm::PointerType::getUnqual(DeclTy),
3313  /*D=*/nullptr);
3314 
3315  // Create the new alias itself, but don't set a name yet.
3316  auto *GA = llvm::GlobalAlias::create(
3317  DeclTy, 0, llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
3318 
3319  if (Entry) {
3320  if (GA->getAliasee() == Entry) {
3321  Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
3322  return;
3323  }
3324 
3325  assert(Entry->isDeclaration());
3326 
3327  // If there is a declaration in the module, then we had an extern followed
3328  // by the alias, as in:
3329  // extern int test6();
3330  // ...
3331  // int test6() __attribute__((alias("test7")));
3332  //
3333  // Remove it and replace uses of it with the alias.
3334  GA->takeName(Entry);
3335 
3336  Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
3337  Entry->getType()));
3338  Entry->eraseFromParent();
3339  } else {
3340  GA->setName(MangledName);
3341  }
3342 
3343  // Set attributes which are particular to an alias; this is a
3344  // specialization of the attributes which may be set on a global
3345  // variable/function.
3346  if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
3347  D->isWeakImported()) {
3348  GA->setLinkage(llvm::Function::WeakAnyLinkage);
3349  }
3350 
3351  if (const auto *VD = dyn_cast<VarDecl>(D))
3352  if (VD->getTLSKind())
3353  setTLSMode(GA, *VD);
3354 
3355  setAliasAttributes(D, GA);
3356 }
3357 
3358 void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
3359  const auto *D = cast<ValueDecl>(GD.getDecl());
3360  const IFuncAttr *IFA = D->getAttr<IFuncAttr>();
3361  assert(IFA && "Not an ifunc?");
3362 
3363  StringRef MangledName = getMangledName(GD);
3364 
3365  if (IFA->getResolver() == MangledName) {
3366  Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
3367  return;
3368  }
3369 
3370  // Report an error if some definition overrides ifunc.
3371  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3372  if (Entry && !Entry->isDeclaration()) {
3373  GlobalDecl OtherGD;
3374  if (lookupRepresentativeDecl(MangledName, OtherGD) &&
3375  DiagnosedConflictingDefinitions.insert(GD).second) {
3376  Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name);
3377  Diags.Report(OtherGD.getDecl()->getLocation(),
3378  diag::note_previous_definition);
3379  }
3380  return;
3381  }
3382 
3383  Aliases.push_back(GD);
3384 
3385  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
3386  llvm::Constant *Resolver =
3387  GetOrCreateLLVMFunction(IFA->getResolver(), DeclTy, GD,
3388  /*ForVTable=*/false);
3389  llvm::GlobalIFunc *GIF =
3391  "", Resolver, &getModule());
3392  if (Entry) {
3393  if (GIF->getResolver() == Entry) {
3394  Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
3395  return;
3396  }
3397  assert(Entry->isDeclaration());
3398 
3399  // If there is a declaration in the module, then we had an extern followed
3400  // by the ifunc, as in:
3401  // extern int test();
3402  // ...
3403  // int test() __attribute__((ifunc("resolver")));
3404  //
3405  // Remove it and replace uses of it with the ifunc.
3406  GIF->takeName(Entry);
3407 
3408  Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF,
3409  Entry->getType()));
3410  Entry->eraseFromParent();
3411  } else
3412  GIF->setName(MangledName);
3413 
3414  SetCommonAttributes(D, GIF);
3415 }
3416 
3417 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
3418  ArrayRef<llvm::Type*> Tys) {
3419  return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
3420  Tys);
3421 }
3422 
3423 static llvm::StringMapEntry<llvm::GlobalVariable *> &
3424 GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
3425  const StringLiteral *Literal, bool TargetIsLSB,
3426  bool &IsUTF16, unsigned &StringLength) {
3427  StringRef String = Literal->getString();
3428  unsigned NumBytes = String.size();
3429 
3430  // Check for simple case.
3431  if (!Literal->containsNonAsciiOrNull()) {
3432  StringLength = NumBytes;
3433  return *Map.insert(std::make_pair(String, nullptr)).first;
3434  }
3435 
3436  // Otherwise, convert the UTF8 literals into a string of shorts.
3437  IsUTF16 = true;
3438 
3439  SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
3440  const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
3441  llvm::UTF16 *ToPtr = &ToBuf[0];
3442 
3443  (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
3444  ToPtr + NumBytes, llvm::strictConversion);
3445 
3446  // ConvertUTF8toUTF16 returns the length in ToPtr.
3447  StringLength = ToPtr - &ToBuf[0];
3448 
3449  // Add an explicit null.
3450  *ToPtr = 0;
3451  return *Map.insert(std::make_pair(
3452  StringRef(reinterpret_cast<const char *>(ToBuf.data()),
3453  (StringLength + 1) * 2),
3454  nullptr)).first;
3455 }
3456 
3459  unsigned StringLength = 0;
3460  bool isUTF16 = false;
3461  llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
3462  GetConstantCFStringEntry(CFConstantStringMap, Literal,
3463  getDataLayout().isLittleEndian(), isUTF16,
3464  StringLength);
3465 
3466  if (auto *C = Entry.second)
3467  return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
3468 
3469  llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
3470  llvm::Constant *Zeros[] = { Zero, Zero };
3471 
3472  // If we don't already have it, get __CFConstantStringClassReference.
3473  if (!CFConstantStringClassRef) {
3475  Ty = llvm::ArrayType::get(Ty, 0);
3476  llvm::Constant *GV =
3477  CreateRuntimeVariable(Ty, "__CFConstantStringClassReference");
3478 
3479  if (getTriple().isOSBinFormatCOFF()) {
3480  IdentifierInfo &II = getContext().Idents.get(GV->getName());
3483  llvm::GlobalValue *CGV = cast<llvm::GlobalValue>(GV);
3484 
3485  const VarDecl *VD = nullptr;
3486  for (const auto &Result : DC->lookup(&II))
3487  if ((VD = dyn_cast<VarDecl>(Result)))
3488  break;
3489 
3490  if (!VD || !VD->hasAttr<DLLExportAttr>()) {
3491  CGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
3492  CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
3493  } else {
3494  CGV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
3495  CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
3496  }
3497  }
3498 
3499  // Decay array -> ptr
3500  CFConstantStringClassRef =
3501  llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros);
3502  }
3503 
3505 
3506  auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
3507 
3508  ConstantInitBuilder Builder(*this);
3509  auto Fields = Builder.beginStruct(STy);
3510 
3511  // Class pointer.
3512  Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef));
3513 
3514  // Flags.
3515  Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8);
3516 
3517  // String pointer.
3518  llvm::Constant *C = nullptr;
3519  if (isUTF16) {
3520  auto Arr = llvm::makeArrayRef(
3521  reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
3522  Entry.first().size() / 2);
3523  C = llvm::ConstantDataArray::get(VMContext, Arr);
3524  } else {
3525  C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
3526  }
3527 
3528  // Note: -fwritable-strings doesn't make the backing store strings of
3529  // CFStrings writable. (See <rdar://problem/10657500>)
3530  auto *GV =
3531  new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
3532  llvm::GlobalValue::PrivateLinkage, C, ".str");
3533  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3534  // Don't enforce the target's minimum global alignment, since the only use
3535  // of the string is via this class initializer.
3536  CharUnits Align = isUTF16
3539  GV->setAlignment(Align.getQuantity());
3540 
3541  // FIXME: We set the section explicitly to avoid a bug in ld64 224.1.
3542  // Without it LLVM can merge the string with a non unnamed_addr one during
3543  // LTO. Doing that changes the section it ends in, which surprises ld64.
3544  if (getTriple().isOSBinFormatMachO())
3545  GV->setSection(isUTF16 ? "__TEXT,__ustring"
3546  : "__TEXT,__cstring,cstring_literals");
3547 
3548  // String.
3549  llvm::Constant *Str =
3550  llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
3551 
3552  if (isUTF16)
3553  // Cast the UTF16 string to the correct type.
3554  Str = llvm::ConstantExpr::getBitCast(Str, Int8PtrTy);
3555  Fields.add(Str);
3556 
3557  // String length.
3558  auto Ty = getTypes().ConvertType(getContext().LongTy);
3559  Fields.addInt(cast<llvm::IntegerType>(Ty), StringLength);
3560 
3561  CharUnits Alignment = getPointerAlign();
3562 
3563  // The struct.
3564  GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
3565  /*isConstant=*/false,
3566  llvm::GlobalVariable::PrivateLinkage);
3567  switch (getTriple().getObjectFormat()) {
3568  case llvm::Triple::UnknownObjectFormat:
3569  llvm_unreachable("unknown file format");
3570  case llvm::Triple::COFF:
3571  case llvm::Triple::ELF:
3572  case llvm::Triple::Wasm:
3573  GV->setSection("cfstring");
3574  break;
3575  case llvm::Triple::MachO:
3576  GV->setSection("__DATA,__cfstring");
3577  break;
3578  }
3579  Entry.second = GV;
3580 
3581  return ConstantAddress(GV, Alignment);
3582 }
3583 
3585  return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
3586 }
3587 
3589  if (ObjCFastEnumerationStateType.isNull()) {
3590  RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
3591  D->startDefinition();
3592 
3593  QualType FieldTypes[] = {
3594  Context.UnsignedLongTy,
3595  Context.getPointerType(Context.getObjCIdType()),
3596  Context.getPointerType(Context.UnsignedLongTy),
3597  Context.getConstantArrayType(Context.UnsignedLongTy,
3598  llvm::APInt(32, 5), ArrayType::Normal, 0)
3599  };
3600 
3601  for (size_t i = 0; i < 4; ++i) {
3602  FieldDecl *Field = FieldDecl::Create(Context,
3603  D,
3604  SourceLocation(),
3605  SourceLocation(), nullptr,
3606  FieldTypes[i], /*TInfo=*/nullptr,
3607  /*BitWidth=*/nullptr,
3608  /*Mutable=*/false,
3609  ICIS_NoInit);
3610  Field->setAccess(AS_public);
3611  D->addDecl(Field);
3612  }
3613 
3614  D->completeDefinition();
3615  ObjCFastEnumerationStateType = Context.getTagDeclType(D);
3616  }
3617 
3618  return ObjCFastEnumerationStateType;
3619 }
3620 
3621 llvm::Constant *
3623  assert(!E->getType()->isPointerType() && "Strings are always arrays");
3624 
3625  // Don't emit it as the address of the string, emit the string data itself
3626  // as an inline array.
3627  if (E->getCharByteWidth() == 1) {
3628  SmallString<64> Str(E->getString());
3629 
3630  // Resize the string to the right size, which is indicated by its type.
3631  const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
3632  Str.resize(CAT->getSize().getZExtValue());
3633  return llvm::ConstantDataArray::getString(VMContext, Str, false);
3634  }
3635 
3636  auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
3637  llvm::Type *ElemTy = AType->getElementType();
3638  unsigned NumElements = AType->getNumElements();
3639 
3640  // Wide strings have either 2-byte or 4-byte elements.
3641  if (ElemTy->getPrimitiveSizeInBits() == 16) {
3642  SmallVector<uint16_t, 32> Elements;
3643  Elements.reserve(NumElements);
3644 
3645  for(unsigned i = 0, e = E->getLength(); i != e; ++i)
3646  Elements.push_back(E->getCodeUnit(i));
3647  Elements.resize(NumElements);
3648  return llvm::ConstantDataArray::get(VMContext, Elements);
3649  }
3650 
3651  assert(ElemTy->getPrimitiveSizeInBits() == 32);
3652  SmallVector<uint32_t, 32> Elements;
3653  Elements.reserve(NumElements);
3654 
3655  for(unsigned i = 0, e = E->getLength(); i != e; ++i)
3656  Elements.push_back(E->getCodeUnit(i));
3657  Elements.resize(NumElements);
3658  return llvm::ConstantDataArray::get(VMContext, Elements);
3659 }
3660 
3661 static llvm::GlobalVariable *
3662 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
3663  CodeGenModule &CGM, StringRef GlobalName,
3664  CharUnits Alignment) {
3665  // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
3666  unsigned AddrSpace = 0;
3667  if (CGM.getLangOpts().OpenCL)
3669 
3670  llvm::Module &M = CGM.getModule();
3671  // Create a global variable for this string
3672  auto *GV = new llvm::GlobalVariable(
3673  M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
3674  nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
3675  GV->setAlignment(Alignment.getQuantity());
3676  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3677  if (GV->isWeakForLinker()) {
3678  assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
3679  GV->setComdat(M.getOrInsertComdat(GV->getName()));
3680  }
3681 
3682  return GV;
3683 }
3684 
3685 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
3686 /// constant array for the given string literal.
3689  StringRef Name) {
3691 
3692  llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
3693  llvm::GlobalVariable **Entry = nullptr;
3694  if (!LangOpts.WritableStrings) {
3695  Entry = &ConstantStringMap[C];
3696  if (auto GV = *Entry) {
3697  if (Alignment.getQuantity() > GV->getAlignment())
3698  GV->setAlignment(Alignment.getQuantity());
3699  return ConstantAddress(GV, Alignment);
3700  }
3701  }
3702 
3703  SmallString<256> MangledNameBuffer;
3704  StringRef GlobalVariableName;
3705  llvm::GlobalValue::LinkageTypes LT;
3706 
3707  // Mangle the string literal if the ABI allows for it. However, we cannot
3708  // do this if we are compiling with ASan or -fwritable-strings because they
3709  // rely on strings having normal linkage.
3710  if (!LangOpts.WritableStrings &&
3711  !LangOpts.Sanitize.has(SanitizerKind::Address) &&
3713  llvm::raw_svector_ostream Out(MangledNameBuffer);
3715 
3716  LT = llvm::GlobalValue::LinkOnceODRLinkage;
3717  GlobalVariableName = MangledNameBuffer;
3718  } else {
3719  LT = llvm::GlobalValue::PrivateLinkage;
3720  GlobalVariableName = Name;
3721  }
3722 
3723  auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
3724  if (Entry)
3725  *Entry = GV;
3726 
3727  SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
3728  QualType());
3729  return ConstantAddress(GV, Alignment);
3730 }
3731 
3732 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
3733 /// array for the given ObjCEncodeExpr node.
3736  std::string Str;
3738 
3739  return GetAddrOfConstantCString(Str);
3740 }
3741 
3742 /// GetAddrOfConstantCString - Returns a pointer to a character array containing
3743 /// the literal and a terminating '\0' character.
3744 /// The result has pointer to array type.
3746  const std::string &Str, const char *GlobalName) {
3747  StringRef StrWithNull(Str.c_str(), Str.size() + 1);
3748  CharUnits Alignment =
3750 
3751  llvm::Constant *C =
3752  llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
3753 
3754  // Don't share any string literals if strings aren't constant.
3755  llvm::GlobalVariable **Entry = nullptr;
3756  if (!LangOpts.WritableStrings) {
3757  Entry = &ConstantStringMap[C];
3758  if (auto GV = *Entry) {
3759  if (Alignment.getQuantity() > GV->getAlignment())
3760  GV->setAlignment(Alignment.getQuantity());
3761  return ConstantAddress(GV, Alignment);
3762  }
3763  }
3764 
3765  // Get the default prefix if a name wasn't specified.
3766  if (!GlobalName)
3767  GlobalName = ".str";
3768  // Create a global variable for this.
3769  auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
3770  GlobalName, Alignment);
3771  if (Entry)
3772  *Entry = GV;
3773  return ConstantAddress(GV, Alignment);
3774 }
3775 
3777  const MaterializeTemporaryExpr *E, const Expr *Init) {
3778  assert((E->getStorageDuration() == SD_Static ||
3779  E->getStorageDuration() == SD_Thread) && "not a global temporary");
3780  const auto *VD = cast<VarDecl>(E->getExtendingDecl());
3781 
3782  // If we're not materializing a subobject of the temporary, keep the
3783  // cv-qualifiers from the type of the MaterializeTemporaryExpr.
3784  QualType MaterializedType = Init->getType();
3785  if (Init == E->GetTemporaryExpr())
3786  MaterializedType = E->getType();
3787 
3788  CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
3789 
3790  if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
3791  return ConstantAddress(Slot, Align);
3792 
3793  // FIXME: If an externally-visible declaration extends multiple temporaries,
3794  // we need to give each temporary the same name in every translation unit (and
3795  // we also need to make the temporaries externally-visible).
3796  SmallString<256> Name;
3797  llvm::raw_svector_ostream Out(Name);
3799  VD, E->getManglingNumber(), Out);
3800 
3801  APValue *Value = nullptr;
3802  if (E->getStorageDuration() == SD_Static) {
3803  // We might have a cached constant initializer for this temporary. Note
3804  // that this might have a different value from the value computed by
3805  // evaluating the initializer if the surrounding constant expression
3806  // modifies the temporary.
3807  Value = getContext().getMaterializedTemporaryValue(E, false);
3808  if (Value && Value->isUninit())
3809  Value = nullptr;
3810  }
3811 
3812  // Try evaluating it now, it might have a constant initializer.
3813  Expr::EvalResult EvalResult;
3814  if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
3815  !EvalResult.hasSideEffects())
3816  Value = &EvalResult.Val;
3817 
3818  LangAS AddrSpace =
3819  VD ? GetGlobalVarAddressSpace(VD) : MaterializedType.getAddressSpace();
3820 
3821  Optional<ConstantEmitter> emitter;
3822  llvm::Constant *InitialValue = nullptr;
3823  bool Constant = false;
3824  llvm::Type *Type;
3825  if (Value) {
3826  // The temporary has a constant initializer, use it.
3827  emitter.emplace(*this);
3828  InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
3829  MaterializedType);
3830  Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
3831  Type = InitialValue->getType();
3832  } else {
3833  // No initializer, the initialization will be provided when we
3834  // initialize the declaration which performed lifetime extension.
3835  Type = getTypes().ConvertTypeForMem(MaterializedType);
3836  }
3837 
3838  // Create a global variable for this lifetime-extended temporary.
3839  llvm::GlobalValue::LinkageTypes Linkage =
3840  getLLVMLinkageVarDefinition(VD, Constant);
3841  if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
3842  const VarDecl *InitVD;
3843  if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
3844  isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
3845  // Temporaries defined inside a class get linkonce_odr linkage because the
3846  // class can be defined in multipe translation units.
3847  Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
3848  } else {
3849  // There is no need for this temporary to have external linkage if the
3850  // VarDecl has external linkage.
3852  }
3853  }
3854  auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
3855  auto *GV = new llvm::GlobalVariable(
3856  getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
3857  /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
3858  if (emitter) emitter->finalize(GV);
3860  GV->setAlignment(Align.getQuantity());
3861  if (supportsCOMDAT() && GV->isWeakForLinker())
3862  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3863  if (VD->getTLSKind())
3864  setTLSMode(GV, *VD);
3865  llvm::Constant *CV = GV;
3866  if (AddrSpace != LangAS::Default)
3868  *this, GV, AddrSpace, LangAS::Default,
3869  Type->getPointerTo(
3870  getContext().getTargetAddressSpace(LangAS::Default)));
3871  MaterializedGlobalTemporaryMap[E] = CV;
3872  return ConstantAddress(CV, Align);
3873 }
3874 
3875 /// EmitObjCPropertyImplementations - Emit information for synthesized
3876 /// properties for an implementation.
3877 void CodeGenModule::EmitObjCPropertyImplementations(const
3879  for (const auto *PID : D->property_impls()) {
3880  // Dynamic is just for type-checking.
3881  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3882  ObjCPropertyDecl *PD = PID->getPropertyDecl();
3883 
3884  // Determine which methods need to be implemented, some may have
3885  // been overridden. Note that ::isPropertyAccessor is not the method
3886  // we want, that just indicates if the decl came from a
3887  // property. What we want to know is if the method is defined in
3888  // this implementation.
3889  if (!D->getInstanceMethod(PD->getGetterName()))
3891  const_cast<ObjCImplementationDecl *>(D), PID);
3892  if (!PD->isReadOnly() &&
3893  !D->getInstanceMethod(PD->getSetterName()))
3895  const_cast<ObjCImplementationDecl *>(D), PID);
3896  }
3897  }
3898 }
3899 
3901  const ObjCInterfaceDecl *iface = impl->getClassInterface();
3902  for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
3903  ivar; ivar = ivar->getNextIvar())
3904  if (ivar->getType().isDestructedType())
3905  return true;
3906 
3907  return false;
3908 }
3909 
3912  CodeGenFunction CGF(CGM);
3914  E = D->init_end(); B != E; ++B) {
3915  CXXCtorInitializer *CtorInitExp = *B;
3916  Expr *Init = CtorInitExp->getInit();
3917  if (!CGF.isTrivialInitializer(Init))
3918  return false;
3919  }
3920  return true;
3921 }
3922 
3923 /// EmitObjCIvarInitializations - Emit information for ivar initialization
3924 /// for an implementation.
3925 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
3926  // We might need a .cxx_destruct even if we don't have any ivar initializers.
3927  if (needsDestructMethod(D)) {
3928  IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
3929  Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3930  ObjCMethodDecl *DTORMethod =
3932  cxxSelector, getContext().VoidTy, nullptr, D,
3933  /*isInstance=*/true, /*isVariadic=*/false,
3934  /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
3935  /*isDefined=*/false, ObjCMethodDecl::Required);
3936  D->addInstanceMethod(DTORMethod);
3937  CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
3938  D->setHasDestructors(true);
3939  }
3940 
3941  // If the implementation doesn't have any ivar initializers, we don't need
3942  // a .cxx_construct.
3943  if (D->getNumIvarInitializers() == 0 ||
3944  AllTrivialInitializers(*this, D))
3945  return;
3946 
3947  IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
3948  Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3949  // The constructor returns 'self'.
3951  D->getLocation(),
3952  D->getLocation(),
3953  cxxSelector,
3955  nullptr, D, /*isInstance=*/true,
3956  /*isVariadic=*/false,
3957  /*isPropertyAccessor=*/true,
3958  /*isImplicitlyDeclared=*/true,
3959  /*isDefined=*/false,
3961  D->addInstanceMethod(CTORMethod);
3962  CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
3963  D->setHasNonZeroConstructors(true);
3964 }
3965 
3966 // EmitLinkageSpec - Emit all declarations in a linkage spec.
3967 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
3968  if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
3970  ErrorUnsupported(LSD, "linkage spec");
3971  return;
3972  }
3973 
3974  EmitDeclContext(LSD);
3975 }
3976 
3977 void CodeGenModule::EmitDeclContext(const DeclContext *DC) {
3978  for (auto *I : DC->decls()) {
3979  // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
3980  // are themselves considered "top-level", so EmitTopLevelDecl on an
3981  // ObjCImplDecl does not recursively visit them. We need to do that in
3982  // case they're nested inside another construct (LinkageSpecDecl /
3983  // ExportDecl) that does stop them from being considered "top-level".
3984  if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
3985  for (auto *M : OID->methods())
3986  EmitTopLevelDecl(M);
3987  }
3988 
3989  EmitTopLevelDecl(I);
3990  }
3991 }
3992 
3993 /// EmitTopLevelDecl - Emit code for a single top level declaration.
3995  // Ignore dependent declarations.
3996  if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
3997  return;
3998 
3999  switch (D->getKind()) {
4000  case Decl::CXXConversion:
4001  case Decl::CXXMethod:
4002  case Decl::Function:
4003  // Skip function templates
4004  if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
4005  cast<FunctionDecl>(D)->isLateTemplateParsed())
4006  return;
4007 
4008  EmitGlobal(cast<FunctionDecl>(D));
4009  // Always provide some coverage mapping
4010  // even for the functions that aren't emitted.
4012  break;
4013 
4014  case Decl::CXXDeductionGuide:
4015  // Function-like, but does not result in code emission.
4016  break;
4017 
4018  case Decl::Var:
4019  case Decl::Decomposition:
4020  // Skip variable templates
4021  if (cast<VarDecl>(D)->getDescribedVarTemplate())
4022  return;
4023  LLVM_FALLTHROUGH;
4024  case Decl::VarTemplateSpecialization:
4025  EmitGlobal(cast<VarDecl>(D));
4026  if (auto *DD = dyn_cast<DecompositionDecl>(D))
4027  for (auto *B : DD->bindings())
4028  if (auto *HD = B->getHoldingVar())
4029  EmitGlobal(HD);
4030  break;
4031 
4032  // Indirect fields from global anonymous structs and unions can be
4033  // ignored; only the actual variable requires IR gen support.
4034  case Decl::IndirectField:
4035  break;
4036 
4037  // C++ Decls
4038  case Decl::Namespace:
4039  EmitDeclContext(cast<NamespaceDecl>(D));
4040  break;
4041  case Decl::ClassTemplateSpecialization: {
4042  const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
4043  if (DebugInfo &&
4044  Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
4045  Spec->hasDefinition())
4046  DebugInfo->completeTemplateDefinition(*Spec);
4047  } LLVM_FALLTHROUGH;
4048  case Decl::CXXRecord:
4049  if (DebugInfo) {
4050  if (auto *ES = D->getASTContext().getExternalSource())
4051  if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
4052  DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
4053  }
4054  // Emit any static data members, they may be definitions.
4055  for (auto *I : cast<CXXRecordDecl>(D)->decls())
4056  if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
4057  EmitTopLevelDecl(I);
4058  break;
4059  // No code generation needed.
4060  case Decl::UsingShadow:
4061  case Decl::ClassTemplate:
4062  case Decl::VarTemplate:
4063  case Decl::VarTemplatePartialSpecialization:
4064  case Decl::FunctionTemplate:
4065  case Decl::TypeAliasTemplate:
4066  case Decl::Block:
4067  case Decl::Empty:
4068  break;
4069  case Decl::Using: // using X; [C++]
4070  if (CGDebugInfo *DI = getModuleDebugInfo())
4071  DI->EmitUsingDecl(cast<UsingDecl>(*D));
4072  return;
4073  case Decl::NamespaceAlias:
4074  if (CGDebugInfo *DI = getModuleDebugInfo())
4075  DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
4076  return;
4077  case Decl::UsingDirective: // using namespace X; [C++]
4078  if (CGDebugInfo *DI = getModuleDebugInfo())
4079  DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
4080  return;
4081  case Decl::CXXConstructor:
4082  // Skip function templates
4083  if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
4084  cast<FunctionDecl>(D)->isLateTemplateParsed())
4085  return;
4086 
4087  getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
4088  break;
4089  case Decl::CXXDestructor:
4090  if (cast<FunctionDecl>(D)->isLateTemplateParsed())
4091  return;
4092  getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
4093  break;
4094 
4095  case Decl::StaticAssert:
4096  // Nothing to do.
4097  break;
4098 
4099  // Objective-C Decls
4100 
4101  // Forward declarations, no (immediate) code generation.
4102  case Decl::ObjCInterface:
4103  case Decl::ObjCCategory:
4104  break;
4105 
4106  case Decl::ObjCProtocol: {
4107  auto *Proto = cast<ObjCProtocolDecl>(D);
4108  if (Proto->isThisDeclarationADefinition())
4109  ObjCRuntime->GenerateProtocol(Proto);
4110  break;
4111  }
4112 
4113  case Decl::ObjCCategoryImpl:
4114  // Categories have properties but don't support synthesize so we
4115  // can ignore them here.
4116  ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
4117  break;
4118 
4119  case Decl::ObjCImplementation: {
4120  auto *OMD = cast<ObjCImplementationDecl>(D);
4121  EmitObjCPropertyImplementations(OMD);
4122  EmitObjCIvarInitializations(OMD);
4123  ObjCRuntime->GenerateClass(OMD);
4124  // Emit global variable debug information.
4125  if (CGDebugInfo *DI = getModuleDebugInfo())
4126  if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
4127  DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
4128  OMD->getClassInterface()), OMD->getLocation());
4129  break;
4130  }
4131  case Decl::ObjCMethod: {
4132  auto *OMD = cast<ObjCMethodDecl>(D);
4133  // If this is not a prototype, emit the body.
4134  if (OMD->getBody())
4135  CodeGenFunction(*this).GenerateObjCMethod(OMD);
4136  break;
4137  }
4138  case Decl::ObjCCompatibleAlias:
4139  ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
4140  break;
4141 
4142  case Decl::PragmaComment: {
4143  const auto *PCD = cast<PragmaCommentDecl>(D);
4144  switch (PCD->getCommentKind()) {
4145  case PCK_Unknown:
4146  llvm_unreachable("unexpected pragma comment kind");
4147  case PCK_Linker:
4148  AppendLinkerOptions(PCD->getArg());
4149  break;
4150  case PCK_Lib:
4151  AddDependentLib(PCD->getArg());
4152  break;
4153  case PCK_Compiler:
4154  case PCK_ExeStr:
4155  case PCK_User:
4156  break; // We ignore all of these.
4157  }
4158  break;
4159  }
4160 
4161  case Decl::PragmaDetectMismatch: {
4162  const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
4163  AddDetectMismatch(PDMD->getName(), PDMD->getValue());
4164  break;
4165  }
4166 
4167  case Decl::LinkageSpec:
4168  EmitLinkageSpec(cast<LinkageSpecDecl>(D));
4169  break;
4170 
4171  case Decl::FileScopeAsm: {
4172  // File-scope asm is ignored during device-side CUDA compilation.
4173  if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
4174  break;
4175  // File-scope asm is ignored during device-side OpenMP compilation.
4176  if (LangOpts.OpenMPIsDevice)
4177  break;
4178  auto *AD = cast<FileScopeAsmDecl>(D);
4179  getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
4180  break;
4181  }
4182 
4183  case Decl::Import: {
4184  auto *Import = cast<ImportDecl>(D);
4185 
4186  // If we've already imported this module, we're done.
4187  if (!ImportedModules.insert(Import->getImportedModule()))
4188  break;
4189 
4190  // Emit debug information for direct imports.
4191  if (!Import->getImportedOwningModule()) {
4192  if (CGDebugInfo *DI = getModuleDebugInfo())
4193  DI->EmitImportDecl(*Import);
4194  }
4195 
4196  // Find all of the submodules and emit the module initializers.
4197  llvm::SmallPtrSet<clang::Module *, 16> Visited;
4199  Visited.insert(Import->getImportedModule());
4200  Stack.push_back(Import->getImportedModule());
4201 
4202  while (!Stack.empty()) {
4203  clang::Module *Mod = Stack.pop_back_val();
4204  if (!EmittedModuleInitializers.insert(Mod).second)
4205  continue;
4206 
4207  for (auto *D : Context.getModuleInitializers(Mod))
4208  EmitTopLevelDecl(D);
4209 
4210  // Visit the submodules of this module.
4212  SubEnd = Mod->submodule_end();
4213  Sub != SubEnd; ++Sub) {
4214  // Skip explicit children; they need to be explicitly imported to emit
4215  // the initializers.
4216  if ((*Sub)->IsExplicit)
4217  continue;
4218 
4219  if (Visited.insert(*Sub).second)
4220  Stack.push_back(*Sub);
4221  }
4222  }
4223  break;
4224  }
4225 
4226  case Decl::Export:
4227  EmitDeclContext(cast<ExportDecl>(D));
4228  break;
4229 
4230  case Decl::OMPThreadPrivate:
4231  EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
4232  break;
4233 
4234  case Decl::OMPDeclareReduction:
4235  EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(D));
4236  break;
4237 
4238  default:
4239  // Make sure we handled everything we should, every other kind is a
4240  // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
4241  // function. Need to recode Decl::Kind to do that easily.
4242  assert(isa<TypeDecl>(D) && "Unsupported decl kind");
4243  break;
4244  }
4245 }
4246 
4248  // Do we need to generate coverage mapping?
4249  if (!CodeGenOpts.CoverageMapping)
4250  return;
4251  switch (D->getKind()) {
4252  case Decl::CXXConversion:
4253  case Decl::CXXMethod:
4254  case Decl::Function:
4255  case Decl::ObjCMethod:
4256  case Decl::CXXConstructor:
4257  case Decl::CXXDestructor: {
4258  if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
4259  return;
4261  if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getLocStart()))
4262  return;
4263  auto I = DeferredEmptyCoverageMappingDecls.find(D);
4264  if (I == DeferredEmptyCoverageMappingDecls.end())
4265  DeferredEmptyCoverageMappingDecls[D] = true;
4266  break;
4267  }
4268  default:
4269  break;
4270  };
4271 }
4272 
4274  // Do we need to generate coverage mapping?
4275  if (!CodeGenOpts.CoverageMapping)
4276  return;
4277  if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
4278  if (Fn->isTemplateInstantiation())
4279  ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
4280  }
4281  auto I = DeferredEmptyCoverageMappingDecls.find(D);
4282  if (I == DeferredEmptyCoverageMappingDecls.end())
4283  DeferredEmptyCoverageMappingDecls[D] = false;
4284  else
4285  I->second = false;
4286 }
4287 
4289  for (const auto &Entry : DeferredEmptyCoverageMappingDecls) {
4290  if (!Entry.second)
4291  continue;
4292  const Decl *D = Entry.first;
4293  switch (D->getKind()) {
4294  case Decl::CXXConversion:
4295  case Decl::CXXMethod:
4296  case Decl::Function:
4297  case Decl::ObjCMethod: {
4298  CodeGenPGO PGO(*this);
4299  GlobalDecl GD(cast<FunctionDecl>(D));
4301  getFunctionLinkage(GD));
4302  break;
4303  }
4304  case Decl::CXXConstructor: {
4305  CodeGenPGO PGO(*this);
4306  GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
4308  getFunctionLinkage(GD));
4309  break;
4310  }
4311  case Decl::CXXDestructor: {
4312  CodeGenPGO PGO(*this);
4313  GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
4315  getFunctionLinkage(GD));
4316  break;
4317  }
4318  default:
4319  break;
4320  };
4321  }
4322 }
4323 
4324 /// Turns the given pointer into a constant.
4325 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
4326  const void *Ptr) {
4327  uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
4328  llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
4329  return llvm::ConstantInt::get(i64, PtrInt);
4330 }
4331 
4333  llvm::NamedMDNode *&GlobalMetadata,
4334  GlobalDecl D,
4335  llvm::GlobalValue *Addr) {
4336  if (!GlobalMetadata)
4337  GlobalMetadata =
4338  CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
4339 
4340  // TODO: should we report variant information for ctors/dtors?
4341  llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
4342  llvm::ConstantAsMetadata::get(GetPointerConstant(
4343  CGM.getLLVMContext(), D.getDecl()))};
4344  GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
4345 }
4346 
4347 /// For each function which is declared within an extern "C" region and marked
4348 /// as 'used', but has internal linkage, create an alias from the unmangled
4349 /// name to the mangled name if possible. People expect to be able to refer
4350 /// to such functions with an unmangled name from inline assembly within the
4351 /// same translation unit.
4352 void CodeGenModule::EmitStaticExternCAliases() {
4353  // Don't do anything if we're generating CUDA device code -- the NVPTX
4354  // assembly target doesn't support aliases.
4355  if (Context.getTargetInfo().getTriple().isNVPTX())
4356  return;
4357  for (auto &I : StaticExternCValues) {
4358  IdentifierInfo *Name = I.first;
4359  llvm::GlobalValue *Val = I.second;
4360  if (Val && !getModule().getNamedValue(Name->getName()))
4362  }
4363 }
4364 
4365 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
4366  GlobalDecl &Result) const {
4367  auto Res = Manglings.find(MangledName);
4368  if (Res == Manglings.end())
4369  return false;
4370  Result = Res->getValue();
4371  return true;
4372 }
4373 
4374 /// Emits metadata nodes associating all the global values in the
4375 /// current module with the Decls they came from. This is useful for
4376 /// projects using IR gen as a subroutine.
4377 ///
4378 /// Since there's currently no way to associate an MDNode directly
4379 /// with an llvm::GlobalValue, we create a global named metadata
4380 /// with the name 'clang.global.decl.ptrs'.
4381 void CodeGenModule::EmitDeclMetadata() {
4382  llvm::NamedMDNode *GlobalMetadata = nullptr;
4383 
4384  for (auto &I : MangledDeclNames) {
4385  llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
4386  // Some mangled names don't necessarily have an associated GlobalValue
4387  // in this module, e.g. if we mangled it for DebugInfo.
4388  if (Addr)
4389  EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
4390  }
4391 }
4392 
4393 /// Emits metadata nodes for all the local variables in the current
4394 /// function.
4395 void CodeGenFunction::EmitDeclMetadata() {
4396  if (LocalDeclMap.empty()) return;
4397 
4398  llvm::LLVMContext &Context = getLLVMContext();
4399 
4400  // Find the unique metadata ID for this name.
4401  unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
4402 
4403  llvm::NamedMDNode *GlobalMetadata = nullptr;
4404 
4405  for (auto &I : LocalDeclMap) {
4406  const Decl *D = I.first;
4407  llvm::Value *Addr = I.second.getPointer();
4408  if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
4410  Alloca->setMetadata(
4411  DeclPtrKind, llvm::MDNode::get(
4412  Context, llvm::ValueAsMetadata::getConstant(DAddr)));
4413  } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
4414  GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
4415  EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
4416  }
4417  }
4418 }
4419 
4420 void CodeGenModule::EmitVersionIdentMetadata() {
4421  llvm::NamedMDNode *IdentMetadata =
4422  TheModule.getOrInsertNamedMetadata("llvm.ident");
4423  std::string Version = getClangFullVersion();
4424  llvm::LLVMContext &Ctx = TheModule.getContext();
4425 
4426  llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
4427  IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
4428 }
4429 
4430 void CodeGenModule::EmitTargetMetadata() {
4431  // Warning, new MangledDeclNames may be appended within this loop.
4432  // We rely on MapVector insertions adding new elements to the end
4433  // of the container.
4434  // FIXME: Move this loop into the one target that needs it, and only
4435  // loop over those declarations for which we couldn't emit the target
4436  // metadata when we emitted the declaration.
4437  for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
4438  auto Val = *(MangledDeclNames.begin() + I);
4439  const Decl *D = Val.first.getDecl()->getMostRecentDecl();
4440  llvm::GlobalValue *GV = GetGlobalValue(Val.second);
4441  getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
4442  }
4443 }
4444 
4445 void CodeGenModule::EmitCoverageFile() {
4446  if (getCodeGenOpts().CoverageDataFile.empty() &&
4448  return;
4449 
4450  llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu");
4451  if (!CUNode)
4452  return;
4453 
4454  llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
4455  llvm::LLVMContext &Ctx = TheModule.getContext();
4456  auto *CoverageDataFile =
4457  llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile);
4458  auto *CoverageNotesFile =
4459  llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile);
4460  for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
4461  llvm::MDNode *CU = CUNode->getOperand(i);
4462  llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
4463  GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
4464  }
4465 }
4466 
4467 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
4468  // Sema has checked that all uuid strings are of the form
4469  // "12345678-1234-1234-1234-1234567890ab".
4470  assert(Uuid.size() == 36);
4471  for (unsigned i = 0; i < 36; ++i) {
4472  if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
4473  else assert(isHexDigit(Uuid[i]));
4474  }
4475 
4476  // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
4477  const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
4478 
4479  llvm::Constant *Field3[8];
4480  for (unsigned Idx = 0; Idx < 8; ++Idx)
4481  Field3[Idx] = llvm::ConstantInt::get(
4482  Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
4483 
4484  llvm::Constant *Fields[4] = {
4485  llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16),
4486  llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16),
4487  llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
4488  llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
4489  };
4490 
4491  return llvm::ConstantStruct::getAnon(Fields);
4492 }
4493 
4495  bool ForEH) {
4496  // Return a bogus pointer if RTTI is disabled, unless it's for EH.
4497  // FIXME: should we even be calling this method if RTTI is disabled
4498  // and it's not for EH?
4499  if (!ForEH && !getLangOpts().RTTI)
4500  return llvm::Constant::getNullValue(Int8PtrTy);
4501 
4502  if (ForEH && Ty->isObjCObjectPointerType() &&
4503  LangOpts.ObjCRuntime.isGNUFamily())
4504  return ObjCRuntime->GetEHType(Ty);
4505 
4506  return getCXXABI().getAddrOfRTTIDescriptor(Ty);
4507 }
4508 
4510  for (auto RefExpr : D->varlists()) {
4511  auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
4512  bool PerformInit =
4513  VD->getAnyInitializer() &&
4514  !VD->getAnyInitializer()->isConstantInitializer(getContext(),
4515  /*ForRef=*/false);
4516 
4518  if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
4519  VD, Addr, RefExpr->getLocStart(), PerformInit))
4520  CXXGlobalInits.push_back(InitFunction);
4521  }
4522 }
4523 
4525  llvm::Metadata *&InternalId = MetadataIdMap[T.getCanonicalType()];
4526  if (InternalId)
4527  return InternalId;
4528 
4529  if (isExternallyVisible(T->getLinkage())) {
4530  std::string OutName;
4531  llvm::raw_string_ostream Out(OutName);
4533 
4534  InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
4535  } else {
4536  InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
4538  }
4539 
4540  return InternalId;
4541 }
4542 
4543 // Generalize pointer types to a void pointer with the qualifiers of the
4544 // originally pointed-to type, e.g. 'const char *' and 'char * const *'
4545 // generalize to 'const void *' while 'char *' and 'const char **' generalize to
4546 // 'void *'.
4548  if (!Ty->isPointerType())
4549  return Ty;
4550 
4551  return Ctx.getPointerType(
4553  Ty->getPointeeType().getCVRQualifiers()));
4554 }
4555 
4556 // Apply type generalization to a FunctionType's return and argument types
4558  if (auto *FnType = Ty->getAs<FunctionProtoType>()) {
4559  SmallVector<QualType, 8> GeneralizedParams;
4560  for (auto &Param : FnType->param_types())
4561  GeneralizedParams.push_back(GeneralizeType(Ctx, Param));
4562 
4563  return Ctx.getFunctionType(
4564  GeneralizeType(Ctx, FnType->getReturnType()),
4565  GeneralizedParams, FnType->getExtProtoInfo());
4566  }
4567 
4568  if (auto *FnType = Ty->getAs<FunctionNoProtoType>())
4569  return Ctx.getFunctionNoProtoType(
4570  GeneralizeType(Ctx, FnType->getReturnType()));
4571 
4572  llvm_unreachable("Encountered unknown FunctionType");
4573 }
4574 
4577 
4578  llvm::Metadata *&InternalId = GeneralizedMetadataIdMap[T.getCanonicalType()];
4579  if (InternalId)
4580  return InternalId;
4581 
4582  if (isExternallyVisible(T->getLinkage())) {
4583  std::string OutName;
4584  llvm::raw_string_ostream Out(OutName);
4586  Out << ".generalized";
4587 
4588  InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
4589  } else {
4590  InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
4592  }
4593 
4594  return InternalId;
4595 }
4596 
4597 /// Returns whether this module needs the "all-vtables" type identifier.
4599  // Returns true if at least one of vtable-based CFI checkers is enabled and
4600  // is not in the trapping mode.
4601  return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
4602  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
4603  (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
4604  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
4605  (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
4606  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
4607  (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
4608  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
4609 }
4610 
4611 void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable,
4612  CharUnits Offset,
4613  const CXXRecordDecl *RD) {
4614  llvm::Metadata *MD =
4616  VTable->addTypeMetadata(Offset.getQuantity(), MD);
4617 
4618  if (CodeGenOpts.SanitizeCfiCrossDso)
4619  if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
4620  VTable->addTypeMetadata(Offset.getQuantity(),
4621  llvm::ConstantAsMetadata::get(CrossDsoTypeId));
4622 
4623  if (NeedAllVtablesTypeId()) {
4624  llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables");
4625  VTable->addTypeMetadata(Offset.getQuantity(), MD);
4626  }
4627 }
4628 
4629 // Fills in the supplied string map with the set of target features for the
4630 // passed in function.
4631 void CodeGenModule::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
4632  const FunctionDecl *FD) {
4633  StringRef TargetCPU = Target.getTargetOpts().CPU;
4634  if (const auto *TD = FD->getAttr<TargetAttr>()) {
4635  // If we have a TargetAttr build up the feature map based on that.
4636  TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
4637 
4638  ParsedAttr.Features.erase(
4639  llvm::remove_if(ParsedAttr.Features,
4640  [&](const std::string &Feat) {
4641  return !Target.isValidFeatureName(
4642  StringRef{Feat}.substr(1));
4643  }),
4644  ParsedAttr.Features.end());
4645 
4646  // Make a copy of the features as passed on the command line into the
4647  // beginning of the additional features from the function to override.
4648  ParsedAttr.Features.insert(ParsedAttr.Features.begin(),
4649  Target.getTargetOpts().FeaturesAsWritten.begin(),
4650  Target.getTargetOpts().FeaturesAsWritten.end());
4651 
4652  if (ParsedAttr.Architecture != "" &&
4653  Target.isValidCPUName(ParsedAttr.Architecture))
4654  TargetCPU = ParsedAttr.Architecture;
4655 
4656  // Now populate the feature map, first with the TargetCPU which is either
4657  // the default or a new one from the target attribute string. Then we'll use
4658  // the passed in features (FeaturesAsWritten) along with the new ones from
4659  // the attribute.
4660  Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
4661  ParsedAttr.Features);
4662  } else {
4663  Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
4664  Target.getTargetOpts().Features);
4665  }
4666 }
4667 
4668 llvm::SanitizerStatReport &CodeGenModule::getSanStats() {
4669  if (!SanStats)
4670  SanStats = llvm::make_unique<llvm::SanitizerStatReport>(&getModule());
4671 
4672  return *SanStats;
4673 }
4674 llvm::Value *
4676  CodeGenFunction &CGF) {
4677  llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType());
4678  auto SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr());
4679  auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
4680  return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,
4681  "__translate_sampler_initializer"),
4682  {C});
4683 }
void setLinkage(Linkage L)
Definition: Visibility.h:86
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=TTK_Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
const llvm::DataLayout & getDataLayout() const
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
Defines the clang::ASTContext interface.
The generic AArch64 ABI is also a modified version of the Itanium ABI, but it has fewer divergences t...
Definition: TargetCXXABI.h:84
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1175
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1698
llvm::IntegerType * IntTy
int
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2367
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:61
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:1957
void EmitDeferredUnusedCoverageMappings()
Emit all the deferred coverage mappings for the uninstrumented functions.
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1800
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
void DecorateInstructionWithInvariantGroup(llvm::Instruction *I, const CXXRecordDecl *RD)
Adds !invariant.barrier !tag to instruction.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
Definition: Builtins.h:68
Complete object ctor.
Definition: ABI.h:26
A (possibly-)qualified type.
Definition: Type.h:653
The iOS 64-bit ABI is follows ARM&#39;s published 64-bit ABI more closely, but we don&#39;t guarantee to foll...
Definition: TargetCXXABI.h:71
Static storage duration.
Definition: Specifiers.h:277
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty)
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:535
const CodeGenOptions & getCodeGenOpts() const
GlobalDecl getWithDecl(const Decl *D)
Definition: GlobalDecl.h:88
static llvm::cl::opt< bool > LimitedCoverage("limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)"), llvm::cl::init(false))
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the &#39;opaque&#39; type we pr...
llvm::LLVMContext & getLLVMContext()
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
Definition: Version.cpp:118
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:71
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
submodule_iterator submodule_begin()
Definition: Module.h:538
bool containsNonAsciiOrNull() const
Definition: Expr.h:1607
The standard implementation of ConstantInitBuilder used in Clang.
llvm::CallingConv::ID getBuiltinCC() const
Stmt - This represents one statement.
Definition: Stmt.h:66
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3058
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:101
virtual void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type, raw_ostream &)=0
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const
Return the filename or buffer identifier of the buffer the location is in.
Defines the SourceManager interface.
CharUnits getAlignOfGlobalVarInChars(QualType T) const
Return the alignment in characters that should be given to a global variable with type T...
bool isRecordType() const
Definition: Type.h:6017
virtual void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type, raw_ostream &)=0
Defines the clang::Module class, which describes a module in the source code.
const Type * getTypeForDecl() const
Definition: Decl.h:2778
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
llvm::MDNode * getTBAAStructInfo(QualType QTy)
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:1942
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2079
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
void setAliasAttributes(const Decl *D, llvm::GlobalValue *GV)
Set attributes which must be preserved by an alias.
Defines the C++ template declaration subclasses.
Kind getKind() const
Definition: TargetCXXABI.h:132
GlobalDecl getCanonicalDecl() const
Definition: GlobalDecl.h:56
llvm::Type * FloatTy
float, double
bool isUninit() const
Definition: APValue.h:182
The base class of the type hierarchy.
Definition: Type.h:1353
void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)
Stores additional source code information like skipped ranges which is required by the coverage mappi...
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property...
Definition: CGObjC.cpp:1341
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1207
const ABIInfo & getABIInfo() const
getABIInfo() - Returns ABI info helper for the target.
Definition: TargetInfo.h:55
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
bool isCompilingModule() const
Are we compiling a module interface (.cppm or module map)?
Definition: LangOptions.h:167
bool isBlacklistedLocation(SanitizerMask Mask, SourceLocation Loc, StringRef Category=StringRef()) const
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:506
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
virtual void completeDefinition()
completeDefinition - Notes that the definition of this type is now complete.
Definition: Decl.cpp:3946
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
Definition: CGExpr.cpp:3000
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process...
static const llvm::GlobalObject * getAliasedGlobal(const llvm::GlobalIndirectSymbol &GIS)
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3491
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
const Expr * getAnyInitializer() const
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
Definition: Decl.h:1203
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4035
static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)
&#39;gcc&#39; is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
Definition: ObjCRuntime.h:50
void HandleCXXStaticMemberVarInstantiation(VarDecl *VD)
Tell the consumer that this variable has been instantiated.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:807
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
void setFunctionDefinitionAttributes(const FunctionDecl *D, llvm::Function *F)
Set attributes for a global definition.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
Visibility getVisibility() const
Definition: Visibility.h:83
CGDebugInfo * getModuleDebugInfo()
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1576
void setFunctionDLLStorageClass(GlobalDecl GD, llvm::Function *F)
Set the DLL storage class on F.
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:53
static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment)
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
DiagnosticsEngine & getDiags() const
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
Definition: TargetInfo.h:220
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3482
LanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Definition: DeclCXX.h:2789
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:311
static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name)
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:37
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4076
unsigned getIntAlign() const
Definition: TargetInfo.h:347
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
field_range fields() const
Definition: Decl.h:3613
llvm::Constant * getAddrOfCXXStructor(const CXXMethodDecl *MD, StructorType Type, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
Definition: CGCXX.cpp:238
The generic Mips ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:90
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2461
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
StructorType getFromDtorType(CXXDtorType T)
Definition: CodeGenTypes.h:104
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3702
bool isReferenceType() const
Definition: Type.h:5956
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:71
int Category
Definition: Format.cpp:1348
This declaration is definitely a definition.
Definition: Decl.h:1145
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
Definition: CGObjC.cpp:1422
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
unsigned getCharByteWidth() const
Definition: Expr.h:1591
Describes a module or submodule.
Definition: Module.h:65
IdentifierTable & Idents
Definition: ASTContext.h:537
bool shouldMangleDeclName(const NamedDecl *D)
Definition: Mangle.cpp:99
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:44
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr)
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
unsigned getLength() const
Definition: Expr.h:1590
bool isLibFunction(unsigned ID) const
Return true if this is a builtin for a libc/libm function, with a "__builtin_" prefix (e...
Definition: Builtins.h:134
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2123
Base object ctor.
Definition: ABI.h:27
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:573
uint32_t Offset
Definition: CacheTokens.cpp:43
The Microsoft ABI is the ABI used by Microsoft Visual Studio (and compatible compilers).
Definition: TargetCXXABI.h:113
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:222
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
Definition: CGDecl.cpp:1925
virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type...
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2373
CGObjCRuntime * CreateMacObjCRuntime(CodeGenModule &CGM)
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:66
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite)
Get the LLVM attributes and calling convention to use for a particular function type.
Definition: CGCall.cpp:1785
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
std::string getAsString() const
Definition: Type.h:979
Module * Parent
The parent of this module.
Definition: Module.h:91
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
Definition: DeclObjC.h:880
Defines the Diagnostic-related interfaces.
void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D, ForDefinition_t IsForDefinition) const
Set the visibility for the given LLVM GlobalValue.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5720
submodule_iterator submodule_end()
Definition: Module.h:540
static TBAAAccessInfo getIncompleteInfo()
Definition: CodeGenTBAA.h:72
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1196
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:820
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1215
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition: CGCall.cpp:263
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1404
void EmitTentativeDefinition(const VarDecl *D)
void addInstanceMethod(ObjCMethodDecl *method)
Definition: DeclObjC.h:2463
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
llvm::SanitizerStatReport & getSanStats()
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
Represents a linkage specification.
Definition: DeclCXX.h:2743
The iOS ABI is a partial implementation of the ARM ABI.
Definition: TargetCXXABI.h:63
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
Definition: CGCall.cpp:497
void mangleName(const NamedDecl *D, raw_ostream &)
Definition: Mangle.cpp:123
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
Definition: TargetInfo.cpp:434
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create a new runtime function with the specified type and name.
bool lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const
bool hasProfileClangUse() const
Check if Clang profile use is on.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1521
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
llvm::PointerType * getSamplerType(const Type *T)
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3235
llvm::MDNode * getTBAAAccessTagInfo(TBAAAccessInfo Info)
getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
const XRayFunctionFilter & getXRayFilter() const
Definition: ASTContext.h:694
&#39;watchos&#39; is a variant of iOS for Apple&#39;s watchOS.
Definition: ObjCRuntime.h:46
bool hasAttr() const
Definition: DeclBase.h:535
llvm::StringMap< SectionInfo > SectionInfos
Definition: ASTContext.h:2841
const ValueDecl * getExtendingDecl() const
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Definition: ExprCXX.h:4098
StringRef getString() const
Definition: Expr.h:1557
static bool hasUnwindExceptions(const LangOptions &LangOpts)
Determines whether the language options require us to model unwind exceptions.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3270
static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D)
The generic ARM ABI is a modified version of the Itanium ABI proposed by ARM for use on ARM-based pla...
Definition: TargetCXXABI.h:52
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:131
void setHasDestructors(bool val)
Definition: DeclObjC.h:2679
const TargetCodeGenInfo & getTargetCodeGenInfo()
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1302
void AddDetectMismatch(StringRef Name, StringRef Value)
Appends a detect mismatch command to the linker options.
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:681
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:275
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Definition: TargetInfo.cpp:398
static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND)
bool isInSanitizerBlacklist(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition: Builtins.h:86
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M, ForDefinition_t IsForDefinition) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
Definition: TargetInfo.h:59
llvm::CallingConv::ID getRuntimeCC() const
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *FD)
Exposes information about the current target.
Definition: TargetInfo.h:54
void SetLLVMFunctionAttributes(const Decl *D, const CGFunctionInfo &Info, llvm::Function *F)
Set the LLVM function attributes (sext, zext, etc).
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation&#39;s translation unit.
bool isValid() const
static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl< llvm::MDNode *> &Metadata, llvm::SmallPtrSet< Module *, 16 > &Visited)
Add link options implied by the given module, including modules it depends on, using a postorder walk...
virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0
Emit constructor variants required by this ABI.
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3689
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:628
Expr - This represents one expression.
Definition: Expr.h:106
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isImplicitlyDeclared=false, bool isDefined=false, ImplementationControl impControl=None, bool HasRelatedResultType=false)
Definition: DeclObjC.cpp:772
Emit only debug info necessary for generating line number tables (-gline-tables-only).
Selector getSetterName() const
Definition: DeclObjC.h:931
&#39;macosx&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:32
virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0
Emit destructor variants required by this ABI.
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
const FunctionProtoType * T
unsigned getIntWidth() const
getIntWidth/Align - Return the size of &#39;signed int&#39; and &#39;unsigned int&#39; for this target, in bits.
Definition: TargetInfo.h:346
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
Definition: CGObjC.cpp:572
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::CallingConv::ID getBuiltinCC() const
Return the calling convention to use for compiler builtins.
Definition: ABIInfo.h:81
void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
unsigned getLine() const
Return the presumed line number of this location.
Organizes the cross-function state that is used while generating code coverage mapping data...
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile)
Report potential problems we&#39;ve found to Diags.
Defines version macros and version-related utility functions for Clang.
static QualType GeneralizeType(ASTContext &Ctx, QualType Ty)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Linkage getLinkage() const
Definition: Visibility.h:82
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclContext * getDeclContext()
Definition: DeclBase.h:425
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1579
TLSKind getTLSKind() const
Definition: Decl.cpp:1883
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used...
Definition: Module.h:329
Base object dtor.
Definition: ABI.h:37
QualType getType() const
Definition: Expr.h:128
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
Definition: Decl.cpp:2088
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
propimpl_range property_impls() const
Definition: DeclObjC.h:2486
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
Definition: DeclBase.cpp:373
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4079
QualType getEncodedType() const
Definition: ExprObjC.h:407
llvm::PointerType * AllocaInt8PtrTy
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:87
ConstantAddress GetAddrOfUuidDescriptor(const CXXUuidofExpr *E)
Get the address of a uuid descriptor .
llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)
Represents an unpacked "presumed" location which can be presented to the user.
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:517
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1333
static bool isVarDeclStrongDefinition(const ASTContext &Context, CodeGenModule &CGM, const VarDecl *D, bool NoCommon)
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1026
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6265
const TargetInfo & getTarget() const
ValueDecl * getDecl()
Definition: Expr.h:1041
CGOpenMPRuntime(CodeGenModule &CGM)
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
&#39;gnustep&#39; is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:53
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
const LangOptions & getLangOpts() const
ASTContext & getContext() const
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
const SourceManager & SM
Definition: Format.cpp:1337
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:82
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:1973
const SanitizerBlacklist & getSanitizerBlacklist() const
Definition: ASTContext.h:690
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:35
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...
llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage)
Will return a global variable of the given type.
llvm::Constant * EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L)
Generate the llvm::ConstantStruct which contains the annotation information for a given GlobalValue...
init_iterator init_begin()
init_begin() - Retrieve an iterator to the first initializer.
Definition: DeclObjC.h:2640
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5753
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
WatchOS is a modernisation of the iOS ABI, which roughly means it&#39;s the iOS64 ABI ported to 32-bits...
Definition: TargetCXXABI.h:76
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5779
The l-value was considered opaque, so the alignment was determined from a type.
const char * getFilename() const
Return the presumed filename of this location.
Thread storage duration.
Definition: Specifiers.h:276
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:408
QualType getWideCharType() const
Return the type of wide characters.
Definition: ASTContext.h:1516
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
SelectorTable & Selectors
Definition: ASTContext.h:538
Kind
void RefreshTypeCacheForClass(const CXXRecordDecl *Class)
QualType getCanonicalType() const
Definition: Type.h:5759
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:208
void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV)
If the declaration has internal linkage but is inside an extern "C" linkage specification, prepare to emit an alias for it to the expected name.
Encodes a location in the source.
virtual bool shouldMangleStringLiteral(const StringLiteral *SL)=0
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
Definition: Decl.h:129
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5836
void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const
Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D...
&#39;objfw&#39; is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:56
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType)
getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an access to a virtual table poi...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1842
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2938
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:365
llvm::Metadata * CreateMetadataIdentifierForType(QualType T)
Create a metadata identifier for the given type.
Kind getKind() const
Definition: ObjCRuntime.h:75
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
Definition: ObjCRuntime.h:285
const Decl * getDecl() const
Definition: GlobalDecl.h:64
void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, const BlockDecl *BD, raw_ostream &Out)
Definition: Mangle.cpp:220
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Per-function PGO state.
Definition: CodeGenPGO.h:29
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:42
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
SourceLocation getStrTokenLoc(unsigned TokNum) const
Definition: Expr.h:1619
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
Weak for now, might become strong later in this TU.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1068
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
llvm::Constant * CreateBuiltinFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList())
Create a new compiler builtin function with the specified type and name.
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
Definition: CGDecl.cpp:1197
CanQualType VoidTy
Definition: ASTContext.h:996
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded...
void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C)
bool isObjCObjectPointerType() const
Definition: Type.h:6041
llvm::MDNode * getTBAATypeInfo(QualType QTy)
getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
An aligned address.
Definition: Address.h:25
init_iterator init_end()
init_end() - Retrieve an iterator past the last initializer.
Definition: DeclObjC.h:2649
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:746
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
The generic Itanium ABI is the standard ABI of most open-source and Unix-like platforms.
Definition: TargetCXXABI.h:34
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:691
void EmitTopLevelDecl(Decl *D)
Emit code for a single top level declaration.
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:97
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:161
CGCXXABI * CreateMicrosoftCXXABI(CodeGenModule &CGM)
Creates a Microsoft-family ABI.
void CreateFunctionTypeMetadata(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can&#39;t be done.
llvm::CallingConv::ID getRuntimeCC() const
Return the calling convention to use for system runtime functions.
Definition: ABIInfo.h:76