clang  9.0.0svn
CodeGenModule.cpp
Go to the documentation of this file.
1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This coordinates the per-module state used while generating code.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CodeGenModule.h"
14 #include "CGBlocks.h"
15 #include "CGCUDARuntime.h"
16 #include "CGCXXABI.h"
17 #include "CGCall.h"
18 #include "CGDebugInfo.h"
19 #include "CGObjCRuntime.h"
20 #include "CGOpenCLRuntime.h"
21 #include "CGOpenMPRuntime.h"
22 #include "CGOpenMPRuntimeNVPTX.h"
23 #include "CodeGenFunction.h"
24 #include "CodeGenPGO.h"
25 #include "ConstantEmitter.h"
26 #include "CoverageMappingGen.h"
27 #include "TargetInfo.h"
28 #include "clang/AST/ASTContext.h"
29 #include "clang/AST/CharUnits.h"
30 #include "clang/AST/DeclCXX.h"
31 #include "clang/AST/DeclObjC.h"
32 #include "clang/AST/DeclTemplate.h"
33 #include "clang/AST/Mangle.h"
34 #include "clang/AST/RecordLayout.h"
36 #include "clang/AST/StmtVisitor.h"
37 #include "clang/Basic/Builtins.h"
38 #include "clang/Basic/CharInfo.h"
40 #include "clang/Basic/Diagnostic.h"
41 #include "clang/Basic/Module.h"
43 #include "clang/Basic/TargetInfo.h"
44 #include "clang/Basic/Version.h"
47 #include "llvm/ADT/StringSwitch.h"
48 #include "llvm/ADT/Triple.h"
49 #include "llvm/Analysis/TargetLibraryInfo.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/IR/ProfileSummary.h"
56 #include "llvm/ProfileData/InstrProfReader.h"
57 #include "llvm/Support/CodeGen.h"
58 #include "llvm/Support/ConvertUTF.h"
59 #include "llvm/Support/ErrorHandling.h"
60 #include "llvm/Support/MD5.h"
61 #include "llvm/Support/TimeProfiler.h"
62 
63 using namespace clang;
64 using namespace CodeGen;
65 
66 static llvm::cl::opt<bool> LimitedCoverage(
67  "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
68  llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
69  llvm::cl::init(false));
70 
71 static const char AnnotationSection[] = "llvm.metadata";
72 
74  switch (CGM.getTarget().getCXXABI().getKind()) {
77  case TargetCXXABI::iOS:
83  return CreateItaniumCXXABI(CGM);
85  return CreateMicrosoftCXXABI(CGM);
86  }
87 
88  llvm_unreachable("invalid C++ ABI kind");
89 }
90 
91 CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
92  const PreprocessorOptions &PPO,
93  const CodeGenOptions &CGO, llvm::Module &M,
94  DiagnosticsEngine &diags,
95  CoverageSourceInfo *CoverageInfo)
96  : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
97  PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
98  Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
99  VMContext(M.getContext()), Types(*this), VTables(*this),
100  SanitizerMD(new SanitizerMetadata(*this)) {
101 
102  // Initialize the type cache.
103  llvm::LLVMContext &LLVMContext = M.getContext();
104  VoidTy = llvm::Type::getVoidTy(LLVMContext);
105  Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
106  Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
107  Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
108  Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
109  HalfTy = llvm::Type::getHalfTy(LLVMContext);
110  FloatTy = llvm::Type::getFloatTy(LLVMContext);
111  DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
114  C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
118  C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
119  IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
120  IntPtrTy = llvm::IntegerType::get(LLVMContext,
122  Int8PtrTy = Int8Ty->getPointerTo(0);
123  Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
124  AllocaInt8PtrTy = Int8Ty->getPointerTo(
125  M.getDataLayout().getAllocaAddrSpace());
127 
129 
130  if (LangOpts.ObjC)
131  createObjCRuntime();
132  if (LangOpts.OpenCL)
133  createOpenCLRuntime();
134  if (LangOpts.OpenMP)
135  createOpenMPRuntime();
136  if (LangOpts.CUDA)
137  createCUDARuntime();
138 
139  // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
140  if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
141  (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
142  TBAA.reset(new CodeGenTBAA(Context, TheModule, CodeGenOpts, getLangOpts(),
143  getCXXABI().getMangleContext()));
144 
145  // If debug info or coverage generation is enabled, create the CGDebugInfo
146  // object.
147  if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo ||
148  CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
149  DebugInfo.reset(new CGDebugInfo(*this));
150 
151  Block.GlobalUniqueCount = 0;
152 
153  if (C.getLangOpts().ObjC)
154  ObjCData.reset(new ObjCEntrypoints());
155 
156  if (CodeGenOpts.hasProfileClangUse()) {
157  auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
158  CodeGenOpts.ProfileInstrumentUsePath, CodeGenOpts.ProfileRemappingFile);
159  if (auto E = ReaderOrErr.takeError()) {
160  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
161  "Could not read profile %0: %1");
162  llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
163  getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath
164  << EI.message();
165  });
166  } else
167  PGOReader = std::move(ReaderOrErr.get());
168  }
169 
170  // If coverage mapping generation is enabled, create the
171  // CoverageMappingModuleGen object.
172  if (CodeGenOpts.CoverageMapping)
173  CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
174 }
175 
177 
178 void CodeGenModule::createObjCRuntime() {
179  // This is just isGNUFamily(), but we want to force implementors of
180  // new ABIs to decide how best to do this.
181  switch (LangOpts.ObjCRuntime.getKind()) {
183  case ObjCRuntime::GCC:
184  case ObjCRuntime::ObjFW:
185  ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
186  return;
187 
189  case ObjCRuntime::MacOSX:
190  case ObjCRuntime::iOS:
192  ObjCRuntime.reset(CreateMacObjCRuntime(*this));
193  return;
194  }
195  llvm_unreachable("bad runtime kind");
196 }
197 
198 void CodeGenModule::createOpenCLRuntime() {
199  OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
200 }
201 
202 void CodeGenModule::createOpenMPRuntime() {
203  // Select a specialized code generation class based on the target, if any.
204  // If it does not exist use the default implementation.
205  switch (getTriple().getArch()) {
206  case llvm::Triple::nvptx:
207  case llvm::Triple::nvptx64:
208  assert(getLangOpts().OpenMPIsDevice &&
209  "OpenMP NVPTX is only prepared to deal with device code.");
210  OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this));
211  break;
212  default:
213  if (LangOpts.OpenMPSimd)
214  OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
215  else
216  OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
217  break;
218  }
219 }
220 
221 void CodeGenModule::createCUDARuntime() {
222  CUDARuntime.reset(CreateNVCUDARuntime(*this));
223 }
224 
225 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
226  Replacements[Name] = C;
227 }
228 
229 void CodeGenModule::applyReplacements() {
230  for (auto &I : Replacements) {
231  StringRef MangledName = I.first();
232  llvm::Constant *Replacement = I.second;
233  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
234  if (!Entry)
235  continue;
236  auto *OldF = cast<llvm::Function>(Entry);
237  auto *NewF = dyn_cast<llvm::Function>(Replacement);
238  if (!NewF) {
239  if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
240  NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
241  } else {
242  auto *CE = cast<llvm::ConstantExpr>(Replacement);
243  assert(CE->getOpcode() == llvm::Instruction::BitCast ||
244  CE->getOpcode() == llvm::Instruction::GetElementPtr);
245  NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
246  }
247  }
248 
249  // Replace old with new, but keep the old order.
250  OldF->replaceAllUsesWith(Replacement);
251  if (NewF) {
252  NewF->removeFromParent();
253  OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
254  NewF);
255  }
256  OldF->eraseFromParent();
257  }
258 }
259 
260 void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
261  GlobalValReplacements.push_back(std::make_pair(GV, C));
262 }
263 
264 void CodeGenModule::applyGlobalValReplacements() {
265  for (auto &I : GlobalValReplacements) {
266  llvm::GlobalValue *GV = I.first;
267  llvm::Constant *C = I.second;
268 
269  GV->replaceAllUsesWith(C);
270  GV->eraseFromParent();
271  }
272 }
273 
274 // This is only used in aliases that we created and we know they have a
275 // linear structure.
276 static const llvm::GlobalObject *getAliasedGlobal(
277  const llvm::GlobalIndirectSymbol &GIS) {
278  llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
279  const llvm::Constant *C = &GIS;
280  for (;;) {
281  C = C->stripPointerCasts();
282  if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
283  return GO;
284  // stripPointerCasts will not walk over weak aliases.
285  auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C);
286  if (!GIS2)
287  return nullptr;
288  if (!Visited.insert(GIS2).second)
289  return nullptr;
290  C = GIS2->getIndirectSymbol();
291  }
292 }
293 
294 void CodeGenModule::checkAliases() {
295  // Check if the constructed aliases are well formed. It is really unfortunate
296  // that we have to do this in CodeGen, but we only construct mangled names
297  // and aliases during codegen.
298  bool Error = false;
299  DiagnosticsEngine &Diags = getDiags();
300  for (const GlobalDecl &GD : Aliases) {
301  const auto *D = cast<ValueDecl>(GD.getDecl());
302  SourceLocation Location;
303  bool IsIFunc = D->hasAttr<IFuncAttr>();
304  if (const Attr *A = D->getDefiningAttr())
305  Location = A->getLocation();
306  else
307  llvm_unreachable("Not an alias or ifunc?");
308  StringRef MangledName = getMangledName(GD);
309  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
310  auto *Alias = cast<llvm::GlobalIndirectSymbol>(Entry);
311  const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
312  if (!GV) {
313  Error = true;
314  Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
315  } else if (GV->isDeclaration()) {
316  Error = true;
317  Diags.Report(Location, diag::err_alias_to_undefined)
318  << IsIFunc << IsIFunc;
319  } else if (IsIFunc) {
320  // Check resolver function type.
321  llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
322  GV->getType()->getPointerElementType());
323  assert(FTy);
324  if (!FTy->getReturnType()->isPointerTy())
325  Diags.Report(Location, diag::err_ifunc_resolver_return);
326  }
327 
328  llvm::Constant *Aliasee = Alias->getIndirectSymbol();
329  llvm::GlobalValue *AliaseeGV;
330  if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
331  AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
332  else
333  AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
334 
335  if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
336  StringRef AliasSection = SA->getName();
337  if (AliasSection != AliaseeGV->getSection())
338  Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
339  << AliasSection << IsIFunc << IsIFunc;
340  }
341 
342  // We have to handle alias to weak aliases in here. LLVM itself disallows
343  // this since the object semantics would not match the IL one. For
344  // compatibility with gcc we implement it by just pointing the alias
345  // to its aliasee's aliasee. We also warn, since the user is probably
346  // expecting the link to be weak.
347  if (auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) {
348  if (GA->isInterposable()) {
349  Diags.Report(Location, diag::warn_alias_to_weak_alias)
350  << GV->getName() << GA->getName() << IsIFunc;
351  Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
352  GA->getIndirectSymbol(), Alias->getType());
353  Alias->setIndirectSymbol(Aliasee);
354  }
355  }
356  }
357  if (!Error)
358  return;
359 
360  for (const GlobalDecl &GD : Aliases) {
361  StringRef MangledName = getMangledName(GD);
362  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
363  auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
364  Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
365  Alias->eraseFromParent();
366  }
367 }
368 
370  DeferredDeclsToEmit.clear();
371  if (OpenMPRuntime)
372  OpenMPRuntime->clear();
373 }
374 
376  StringRef MainFile) {
377  if (!hasDiagnostics())
378  return;
379  if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
380  if (MainFile.empty())
381  MainFile = "<stdin>";
382  Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
383  } else {
384  if (Mismatched > 0)
385  Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
386 
387  if (Missing > 0)
388  Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
389  }
390 }
391 
393  EmitDeferred();
394  EmitVTablesOpportunistically();
395  applyGlobalValReplacements();
396  applyReplacements();
397  checkAliases();
398  emitMultiVersionFunctions();
399  EmitCXXGlobalInitFunc();
400  EmitCXXGlobalDtorFunc();
401  registerGlobalDtorsWithAtExit();
402  EmitCXXThreadLocalInitFunc();
403  if (ObjCRuntime)
404  if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
405  AddGlobalCtor(ObjCInitFunction);
406  if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
407  CUDARuntime) {
408  if (llvm::Function *CudaCtorFunction =
409  CUDARuntime->makeModuleCtorFunction())
410  AddGlobalCtor(CudaCtorFunction);
411  }
412  if (OpenMPRuntime) {
413  if (llvm::Function *OpenMPRegistrationFunction =
414  OpenMPRuntime->emitRegistrationFunction()) {
415  auto ComdatKey = OpenMPRegistrationFunction->hasComdat() ?
416  OpenMPRegistrationFunction : nullptr;
417  AddGlobalCtor(OpenMPRegistrationFunction, 0, ComdatKey);
418  }
419  OpenMPRuntime->clear();
420  }
421  if (PGOReader) {
422  getModule().setProfileSummary(
423  PGOReader->getSummary(/* UseCS */ false).getMD(VMContext),
424  llvm::ProfileSummary::PSK_Instr);
425  if (PGOStats.hasDiagnostics())
426  PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
427  }
428  EmitCtorList(GlobalCtors, "llvm.global_ctors");
429  EmitCtorList(GlobalDtors, "llvm.global_dtors");
431  EmitStaticExternCAliases();
433  if (CoverageMapping)
434  CoverageMapping->emit();
435  if (CodeGenOpts.SanitizeCfiCrossDso) {
438  }
439  emitAtAvailableLinkGuard();
440  emitLLVMUsed();
441  if (SanStats)
442  SanStats->finish();
443 
444  if (CodeGenOpts.Autolink &&
445  (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
446  EmitModuleLinkOptions();
447  }
448 
449  // Record mregparm value now so it is visible through rest of codegen.
450  if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
451  getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
452  CodeGenOpts.NumRegisterParameters);
453 
454  if (CodeGenOpts.DwarfVersion) {
455  // We actually want the latest version when there are conflicts.
456  // We can change from Warning to Latest if such mode is supported.
457  getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
458  CodeGenOpts.DwarfVersion);
459  }
460  if (CodeGenOpts.EmitCodeView) {
461  // Indicate that we want CodeView in the metadata.
462  getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
463  }
464  if (CodeGenOpts.CodeViewGHash) {
465  getModule().addModuleFlag(llvm::Module::Warning, "CodeViewGHash", 1);
466  }
467  if (CodeGenOpts.ControlFlowGuard) {
468  // We want function ID tables for Control Flow Guard.
469  getModule().addModuleFlag(llvm::Module::Warning, "cfguardtable", 1);
470  }
471  if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
472  // We don't support LTO with 2 with different StrictVTablePointers
473  // FIXME: we could support it by stripping all the information introduced
474  // by StrictVTablePointers.
475 
476  getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
477 
478  llvm::Metadata *Ops[2] = {
479  llvm::MDString::get(VMContext, "StrictVTablePointers"),
480  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
481  llvm::Type::getInt32Ty(VMContext), 1))};
482 
483  getModule().addModuleFlag(llvm::Module::Require,
484  "StrictVTablePointersRequirement",
485  llvm::MDNode::get(VMContext, Ops));
486  }
487  if (DebugInfo)
488  // We support a single version in the linked module. The LLVM
489  // parser will drop debug info with a different version number
490  // (and warn about it, too).
491  getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
492  llvm::DEBUG_METADATA_VERSION);
493 
494  // We need to record the widths of enums and wchar_t, so that we can generate
495  // the correct build attributes in the ARM backend. wchar_size is also used by
496  // TargetLibraryInfo.
497  uint64_t WCharWidth =
498  Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
499  getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
500 
501  llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
502  if ( Arch == llvm::Triple::arm
503  || Arch == llvm::Triple::armeb
504  || Arch == llvm::Triple::thumb
505  || Arch == llvm::Triple::thumbeb) {
506  // The minimum width of an enum in bytes
507  uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
508  getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
509  }
510 
511  if (CodeGenOpts.SanitizeCfiCrossDso) {
512  // Indicate that we want cross-DSO control flow integrity checks.
513  getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
514  }
515 
516  if (CodeGenOpts.CFProtectionReturn &&
518  // Indicate that we want to instrument return control flow protection.
519  getModule().addModuleFlag(llvm::Module::Override, "cf-protection-return",
520  1);
521  }
522 
523  if (CodeGenOpts.CFProtectionBranch &&
525  // Indicate that we want to instrument branch control flow protection.
526  getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch",
527  1);
528  }
529 
530  if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
531  // Indicate whether __nvvm_reflect should be configured to flush denormal
532  // floating point values to 0. (This corresponds to its "__CUDA_FTZ"
533  // property.)
534  getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
535  CodeGenOpts.FlushDenorm ? 1 : 0);
536  }
537 
538  // Emit OpenCL specific module metadata: OpenCL/SPIR version.
539  if (LangOpts.OpenCL) {
540  EmitOpenCLMetadata();
541  // Emit SPIR version.
542  if (getTriple().getArch() == llvm::Triple::spir ||
543  getTriple().getArch() == llvm::Triple::spir64) {
544  // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
545  // opencl.spir.version named metadata.
546  llvm::Metadata *SPIRVerElts[] = {
547  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
548  Int32Ty, LangOpts.OpenCLVersion / 100)),
549  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
550  Int32Ty, (LangOpts.OpenCLVersion / 100 > 1) ? 0 : 2))};
551  llvm::NamedMDNode *SPIRVerMD =
552  TheModule.getOrInsertNamedMetadata("opencl.spir.version");
553  llvm::LLVMContext &Ctx = TheModule.getContext();
554  SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
555  }
556  }
557 
558  if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
559  assert(PLevel < 3 && "Invalid PIC Level");
560  getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
561  if (Context.getLangOpts().PIE)
562  getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
563  }
564 
565  if (getCodeGenOpts().CodeModel.size() > 0) {
566  unsigned CM = llvm::StringSwitch<unsigned>(getCodeGenOpts().CodeModel)
567  .Case("tiny", llvm::CodeModel::Tiny)
568  .Case("small", llvm::CodeModel::Small)
569  .Case("kernel", llvm::CodeModel::Kernel)
570  .Case("medium", llvm::CodeModel::Medium)
571  .Case("large", llvm::CodeModel::Large)
572  .Default(~0u);
573  if (CM != ~0u) {
574  llvm::CodeModel::Model codeModel = static_cast<llvm::CodeModel::Model>(CM);
575  getModule().setCodeModel(codeModel);
576  }
577  }
578 
579  if (CodeGenOpts.NoPLT)
580  getModule().setRtLibUseGOT();
581 
582  SimplifyPersonality();
583 
584  if (getCodeGenOpts().EmitDeclMetadata)
585  EmitDeclMetadata();
586 
587  if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
588  EmitCoverageFile();
589 
590  if (DebugInfo)
591  DebugInfo->finalize();
592 
593  if (getCodeGenOpts().EmitVersionIdentMetadata)
594  EmitVersionIdentMetadata();
595 
596  if (!getCodeGenOpts().RecordCommandLine.empty())
597  EmitCommandLineMetadata();
598 
599  EmitTargetMetadata();
600 }
601 
602 void CodeGenModule::EmitOpenCLMetadata() {
603  // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
604  // opencl.ocl.version named metadata node.
605  llvm::Metadata *OCLVerElts[] = {
606  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
607  Int32Ty, LangOpts.OpenCLVersion / 100)),
608  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
609  Int32Ty, (LangOpts.OpenCLVersion % 100) / 10))};
610  llvm::NamedMDNode *OCLVerMD =
611  TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
612  llvm::LLVMContext &Ctx = TheModule.getContext();
613  OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
614 }
615 
617  // Make sure that this type is translated.
618  Types.UpdateCompletedType(TD);
619 }
620 
622  // Make sure that this type is translated.
623  Types.RefreshTypeCacheForClass(RD);
624 }
625 
627  if (!TBAA)
628  return nullptr;
629  return TBAA->getTypeInfo(QTy);
630 }
631 
633  if (!TBAA)
634  return TBAAAccessInfo();
635  return TBAA->getAccessInfo(AccessType);
636 }
637 
640  if (!TBAA)
641  return TBAAAccessInfo();
642  return TBAA->getVTablePtrAccessInfo(VTablePtrType);
643 }
644 
646  if (!TBAA)
647  return nullptr;
648  return TBAA->getTBAAStructInfo(QTy);
649 }
650 
652  if (!TBAA)
653  return nullptr;
654  return TBAA->getBaseTypeInfo(QTy);
655 }
656 
658  if (!TBAA)
659  return nullptr;
660  return TBAA->getAccessTagInfo(Info);
661 }
662 
665  if (!TBAA)
666  return TBAAAccessInfo();
667  return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
668 }
669 
672  TBAAAccessInfo InfoB) {
673  if (!TBAA)
674  return TBAAAccessInfo();
675  return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
676 }
677 
680  TBAAAccessInfo SrcInfo) {
681  if (!TBAA)
682  return TBAAAccessInfo();
683  return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
684 }
685 
686 void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst,
687  TBAAAccessInfo TBAAInfo) {
688  if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
689  Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
690 }
691 
693  llvm::Instruction *I, const CXXRecordDecl *RD) {
694  I->setMetadata(llvm::LLVMContext::MD_invariant_group,
695  llvm::MDNode::get(getLLVMContext(), {}));
696 }
697 
698 void CodeGenModule::Error(SourceLocation loc, StringRef message) {
699  unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
700  getDiags().Report(Context.getFullLoc(loc), diagID) << message;
701 }
702 
703 /// ErrorUnsupported - Print out an error that codegen doesn't support the
704 /// specified stmt yet.
705 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
707  "cannot compile this %0 yet");
708  std::string Msg = Type;
709  getDiags().Report(Context.getFullLoc(S->getBeginLoc()), DiagID)
710  << Msg << S->getSourceRange();
711 }
712 
713 /// ErrorUnsupported - Print out an error that codegen doesn't support the
714 /// specified decl yet.
715 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
717  "cannot compile this %0 yet");
718  std::string Msg = Type;
719  getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
720 }
721 
722 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
723  return llvm::ConstantInt::get(SizeTy, size.getQuantity());
724 }
725 
726 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
727  const NamedDecl *D) const {
728  if (GV->hasDLLImportStorageClass())
729  return;
730  // Internal definitions always have default visibility.
731  if (GV->hasLocalLinkage()) {
732  GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
733  return;
734  }
735  if (!D)
736  return;
737  // Set visibility for definitions, and for declarations if requested globally
738  // or set explicitly.
740  if (LV.isVisibilityExplicit() || getLangOpts().SetVisibilityForExternDecls ||
741  !GV->isDeclarationForLinker())
742  GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
743 }
744 
745 static bool shouldAssumeDSOLocal(const CodeGenModule &CGM,
746  llvm::GlobalValue *GV) {
747  if (GV->hasLocalLinkage())
748  return true;
749 
750  if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
751  return true;
752 
753  // DLLImport explicitly marks the GV as external.
754  if (GV->hasDLLImportStorageClass())
755  return false;
756 
757  const llvm::Triple &TT = CGM.getTriple();
758  if (TT.isWindowsGNUEnvironment()) {
759  // In MinGW, variables without DLLImport can still be automatically
760  // imported from a DLL by the linker; don't mark variables that
761  // potentially could come from another DLL as DSO local.
762  if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
763  !GV->isThreadLocal())
764  return false;
765  }
766  // Every other GV is local on COFF.
767  // Make an exception for windows OS in the triple: Some firmware builds use
768  // *-win32-macho triples. This (accidentally?) produced windows relocations
769  // without GOT tables in older clang versions; Keep this behaviour.
770  // FIXME: even thread local variables?
771  if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
772  return true;
773 
774  // Only handle COFF and ELF for now.
775  if (!TT.isOSBinFormatELF())
776  return false;
777 
778  // If this is not an executable, don't assume anything is local.
779  const auto &CGOpts = CGM.getCodeGenOpts();
780  llvm::Reloc::Model RM = CGOpts.RelocationModel;
781  const auto &LOpts = CGM.getLangOpts();
782  if (RM != llvm::Reloc::Static && !LOpts.PIE)
783  return false;
784 
785  // A definition cannot be preempted from an executable.
786  if (!GV->isDeclarationForLinker())
787  return true;
788 
789  // Most PIC code sequences that assume that a symbol is local cannot produce a
790  // 0 if it turns out the symbol is undefined. While this is ABI and relocation
791  // depended, it seems worth it to handle it here.
792  if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
793  return false;
794 
795  // PPC has no copy relocations and cannot use a plt entry as a symbol address.
796  llvm::Triple::ArchType Arch = TT.getArch();
797  if (Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
798  Arch == llvm::Triple::ppc64le)
799  return false;
800 
801  // If we can use copy relocations we can assume it is local.
802  if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
803  if (!Var->isThreadLocal() &&
804  (RM == llvm::Reloc::Static || CGOpts.PIECopyRelocations))
805  return true;
806 
807  // If we can use a plt entry as the symbol address we can assume it
808  // is local.
809  // FIXME: This should work for PIE, but the gold linker doesn't support it.
810  if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
811  return true;
812 
813  // Otherwise don't assue it is local.
814  return false;
815 }
816 
817 void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
818  GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV));
819 }
820 
821 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
822  GlobalDecl GD) const {
823  const auto *D = dyn_cast<NamedDecl>(GD.getDecl());
824  // C++ destructors have a few C++ ABI specific special cases.
825  if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
827  return;
828  }
829  setDLLImportDLLExport(GV, D);
830 }
831 
832 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
833  const NamedDecl *D) const {
834  if (D && D->isExternallyVisible()) {
835  if (D->hasAttr<DLLImportAttr>())
836  GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
837  else if (D->hasAttr<DLLExportAttr>() && !GV->isDeclarationForLinker())
838  GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
839  }
840 }
841 
842 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
843  GlobalDecl GD) const {
844  setDLLImportDLLExport(GV, GD);
845  setGlobalVisibilityAndLocal(GV, dyn_cast<NamedDecl>(GD.getDecl()));
846 }
847 
848 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
849  const NamedDecl *D) const {
850  setDLLImportDLLExport(GV, D);
852 }
853 
855  const NamedDecl *D) const {
856  setGlobalVisibility(GV, D);
857  setDSOLocal(GV);
858 }
859 
860 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
861  return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
862  .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
863  .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
864  .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
865  .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
866 }
867 
868 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
870  switch (M) {
872  return llvm::GlobalVariable::GeneralDynamicTLSModel;
874  return llvm::GlobalVariable::LocalDynamicTLSModel;
876  return llvm::GlobalVariable::InitialExecTLSModel;
878  return llvm::GlobalVariable::LocalExecTLSModel;
879  }
880  llvm_unreachable("Invalid TLS model!");
881 }
882 
883 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
884  assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
885 
886  llvm::GlobalValue::ThreadLocalMode TLM;
887  TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
888 
889  // Override the TLS model if it is explicitly specified.
890  if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
891  TLM = GetLLVMTLSModel(Attr->getModel());
892  }
893 
894  GV->setThreadLocalMode(TLM);
895 }
896 
897 static std::string getCPUSpecificMangling(const CodeGenModule &CGM,
898  StringRef Name) {
899  const TargetInfo &Target = CGM.getTarget();
900  return (Twine('.') + Twine(Target.CPUSpecificManglingCharacter(Name))).str();
901 }
902 
904  const CPUSpecificAttr *Attr,
905  unsigned CPUIndex,
906  raw_ostream &Out) {
907  // cpu_specific gets the current name, dispatch gets the resolver if IFunc is
908  // supported.
909  if (Attr)
910  Out << getCPUSpecificMangling(CGM, Attr->getCPUName(CPUIndex)->getName());
911  else if (CGM.getTarget().supportsIFunc())
912  Out << ".resolver";
913 }
914 
915 static void AppendTargetMangling(const CodeGenModule &CGM,
916  const TargetAttr *Attr, raw_ostream &Out) {
917  if (Attr->isDefaultVersion())
918  return;
919 
920  Out << '.';
921  const TargetInfo &Target = CGM.getTarget();
922  TargetAttr::ParsedTargetAttr Info =
923  Attr->parse([&Target](StringRef LHS, StringRef RHS) {
924  // Multiversioning doesn't allow "no-${feature}", so we can
925  // only have "+" prefixes here.
926  assert(LHS.startswith("+") && RHS.startswith("+") &&
927  "Features should always have a prefix.");
928  return Target.multiVersionSortPriority(LHS.substr(1)) >
929  Target.multiVersionSortPriority(RHS.substr(1));
930  });
931 
932  bool IsFirst = true;
933 
934  if (!Info.Architecture.empty()) {
935  IsFirst = false;
936  Out << "arch_" << Info.Architecture;
937  }
938 
939  for (StringRef Feat : Info.Features) {
940  if (!IsFirst)
941  Out << '_';
942  IsFirst = false;
943  Out << Feat.substr(1);
944  }
945 }
946 
947 static std::string getMangledNameImpl(const CodeGenModule &CGM, GlobalDecl GD,
948  const NamedDecl *ND,
949  bool OmitMultiVersionMangling = false) {
950  SmallString<256> Buffer;
951  llvm::raw_svector_ostream Out(Buffer);
953  if (MC.shouldMangleDeclName(ND)) {
954  llvm::raw_svector_ostream Out(Buffer);
955  if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
956  MC.mangleCXXCtor(D, GD.getCtorType(), Out);
957  else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
958  MC.mangleCXXDtor(D, GD.getDtorType(), Out);
959  else
960  MC.mangleName(ND, Out);
961  } else {
962  IdentifierInfo *II = ND->getIdentifier();
963  assert(II && "Attempt to mangle unnamed decl.");
964  const auto *FD = dyn_cast<FunctionDecl>(ND);
965 
966  if (FD &&
967  FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
968  llvm::raw_svector_ostream Out(Buffer);
969  Out << "__regcall3__" << II->getName();
970  } else {
971  Out << II->getName();
972  }
973  }
974 
975  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
976  if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
977  switch (FD->getMultiVersionKind()) {
981  FD->getAttr<CPUSpecificAttr>(),
982  GD.getMultiVersionIndex(), Out);
983  break;
985  AppendTargetMangling(CGM, FD->getAttr<TargetAttr>(), Out);
986  break;
988  llvm_unreachable("None multiversion type isn't valid here");
989  }
990  }
991 
992  return Out.str();
993 }
994 
995 void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
996  const FunctionDecl *FD) {
997  if (!FD->isMultiVersion())
998  return;
999 
1000  // Get the name of what this would be without the 'target' attribute. This
1001  // allows us to lookup the version that was emitted when this wasn't a
1002  // multiversion function.
1003  std::string NonTargetName =
1004  getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
1005  GlobalDecl OtherGD;
1006  if (lookupRepresentativeDecl(NonTargetName, OtherGD)) {
1007  assert(OtherGD.getCanonicalDecl()
1008  .getDecl()
1009  ->getAsFunction()
1010  ->isMultiVersion() &&
1011  "Other GD should now be a multiversioned function");
1012  // OtherFD is the version of this function that was mangled BEFORE
1013  // becoming a MultiVersion function. It potentially needs to be updated.
1014  const FunctionDecl *OtherFD = OtherGD.getCanonicalDecl()
1015  .getDecl()
1016  ->getAsFunction()
1017  ->getMostRecentDecl();
1018  std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD);
1019  // This is so that if the initial version was already the 'default'
1020  // version, we don't try to update it.
1021  if (OtherName != NonTargetName) {
1022  // Remove instead of erase, since others may have stored the StringRef
1023  // to this.
1024  const auto ExistingRecord = Manglings.find(NonTargetName);
1025  if (ExistingRecord != std::end(Manglings))
1026  Manglings.remove(&(*ExistingRecord));
1027  auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1028  MangledDeclNames[OtherGD.getCanonicalDecl()] = Result.first->first();
1029  if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName))
1030  Entry->setName(OtherName);
1031  }
1032  }
1033 }
1034 
1036  GlobalDecl CanonicalGD = GD.getCanonicalDecl();
1037 
1038  // Some ABIs don't have constructor variants. Make sure that base and
1039  // complete constructors get mangled the same.
1040  if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
1042  CXXCtorType OrigCtorType = GD.getCtorType();
1043  assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
1044  if (OrigCtorType == Ctor_Base)
1045  CanonicalGD = GlobalDecl(CD, Ctor_Complete);
1046  }
1047  }
1048 
1049  auto FoundName = MangledDeclNames.find(CanonicalGD);
1050  if (FoundName != MangledDeclNames.end())
1051  return FoundName->second;
1052 
1053  // Keep the first result in the case of a mangling collision.
1054  const auto *ND = cast<NamedDecl>(GD.getDecl());
1055  std::string MangledName = getMangledNameImpl(*this, GD, ND);
1056 
1057  // Postfix kernel stub names with .stub to differentiate them from kernel
1058  // names in device binaries. This is to facilitate the debugger to find
1059  // the correct symbols for kernels in the device binary.
1060  if (auto *FD = dyn_cast<FunctionDecl>(GD.getDecl()))
1061  if (getLangOpts().HIP && !getLangOpts().CUDAIsDevice &&
1062  FD->hasAttr<CUDAGlobalAttr>())
1063  MangledName = MangledName + ".stub";
1064 
1065  auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1066  return MangledDeclNames[CanonicalGD] = Result.first->first();
1067 }
1068 
1070  const BlockDecl *BD) {
1071  MangleContext &MangleCtx = getCXXABI().getMangleContext();
1072  const Decl *D = GD.getDecl();
1073 
1074  SmallString<256> Buffer;
1075  llvm::raw_svector_ostream Out(Buffer);
1076  if (!D)
1077  MangleCtx.mangleGlobalBlock(BD,
1078  dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
1079  else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1080  MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
1081  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1082  MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
1083  else
1084  MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
1085 
1086  auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1087  return Result.first->first();
1088 }
1089 
1090 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
1091  return getModule().getNamedValue(Name);
1092 }
1093 
1094 /// AddGlobalCtor - Add a function to the list that will be called before
1095 /// main() runs.
1096 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
1097  llvm::Constant *AssociatedData) {
1098  // FIXME: Type coercion of void()* types.
1099  GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
1100 }
1101 
1102 /// AddGlobalDtor - Add a function to the list that will be called
1103 /// when the module is unloaded.
1104 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
1105  if (CodeGenOpts.RegisterGlobalDtorsWithAtExit) {
1106  DtorsUsingAtExit[Priority].push_back(Dtor);
1107  return;
1108  }
1109 
1110  // FIXME: Type coercion of void()* types.
1111  GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
1112 }
1113 
1114 void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
1115  if (Fns.empty()) return;
1116 
1117  // Ctor function type is void()*.
1118  llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
1119  llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
1120  TheModule.getDataLayout().getProgramAddressSpace());
1121 
1122  // Get the type of a ctor entry, { i32, void ()*, i8* }.
1123  llvm::StructType *CtorStructTy = llvm::StructType::get(
1124  Int32Ty, CtorPFTy, VoidPtrTy);
1125 
1126  // Construct the constructor and destructor arrays.
1127  ConstantInitBuilder builder(*this);
1128  auto ctors = builder.beginArray(CtorStructTy);
1129  for (const auto &I : Fns) {
1130  auto ctor = ctors.beginStruct(CtorStructTy);
1131  ctor.addInt(Int32Ty, I.Priority);
1132  ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
1133  if (I.AssociatedData)
1134  ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy));
1135  else
1136  ctor.addNullPointer(VoidPtrTy);
1137  ctor.finishAndAddTo(ctors);
1138  }
1139 
1140  auto list =
1141  ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
1142  /*constant*/ false,
1143  llvm::GlobalValue::AppendingLinkage);
1144 
1145  // The LTO linker doesn't seem to like it when we set an alignment
1146  // on appending variables. Take it off as a workaround.
1147  list->setAlignment(0);
1148 
1149  Fns.clear();
1150 }
1151 
1152 llvm::GlobalValue::LinkageTypes
1154  const auto *D = cast<FunctionDecl>(GD.getDecl());
1155 
1157 
1158  if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
1159  return getCXXABI().getCXXDestructorLinkage(Linkage, Dtor, GD.getDtorType());
1160 
1161  if (isa<CXXConstructorDecl>(D) &&
1162  cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
1163  Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1164  // Our approach to inheriting constructors is fundamentally different from
1165  // that used by the MS ABI, so keep our inheriting constructor thunks
1166  // internal rather than trying to pick an unambiguous mangling for them.
1168  }
1169 
1170  return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
1171 }
1172 
1173 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
1174  llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
1175  if (!MDS) return nullptr;
1176 
1177  return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
1178 }
1179 
1181  const CGFunctionInfo &Info,
1182  llvm::Function *F) {
1183  unsigned CallingConv;
1184  llvm::AttributeList PAL;
1185  ConstructAttributeList(F->getName(), Info, GD, PAL, CallingConv, false);
1186  F->setAttributes(PAL);
1187  F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
1188 }
1189 
1190 /// Determines whether the language options require us to model
1191 /// unwind exceptions. We treat -fexceptions as mandating this
1192 /// except under the fragile ObjC ABI with only ObjC exceptions
1193 /// enabled. This means, for example, that C with -fexceptions
1194 /// enables this.
1195 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
1196  // If exceptions are completely disabled, obviously this is false.
1197  if (!LangOpts.Exceptions) return false;
1198 
1199  // If C++ exceptions are enabled, this is true.
1200  if (LangOpts.CXXExceptions) return true;
1201 
1202  // If ObjC exceptions are enabled, this depends on the ABI.
1203  if (LangOpts.ObjCExceptions) {
1204  return LangOpts.ObjCRuntime.hasUnwindExceptions();
1205  }
1206 
1207  return true;
1208 }
1209 
1211  const CXXMethodDecl *MD) {
1212  // Check that the type metadata can ever actually be used by a call.
1213  if (!CGM.getCodeGenOpts().LTOUnit ||
1214  !CGM.HasHiddenLTOVisibility(MD->getParent()))
1215  return false;
1216 
1217  // Only functions whose address can be taken with a member function pointer
1218  // need this sort of type metadata.
1219  return !MD->isStatic() && !MD->isVirtual() && !isa<CXXConstructorDecl>(MD) &&
1220  !isa<CXXDestructorDecl>(MD);
1221 }
1222 
1223 std::vector<const CXXRecordDecl *>
1225  llvm::SetVector<const CXXRecordDecl *> MostBases;
1226 
1227  std::function<void (const CXXRecordDecl *)> CollectMostBases;
1228  CollectMostBases = [&](const CXXRecordDecl *RD) {
1229  if (RD->getNumBases() == 0)
1230  MostBases.insert(RD);
1231  for (const CXXBaseSpecifier &B : RD->bases())
1232  CollectMostBases(B.getType()->getAsCXXRecordDecl());
1233  };
1234  CollectMostBases(RD);
1235  return MostBases.takeVector();
1236 }
1237 
1239  llvm::Function *F) {
1240  llvm::AttrBuilder B;
1241 
1242  if (CodeGenOpts.UnwindTables)
1243  B.addAttribute(llvm::Attribute::UWTable);
1244 
1245  if (!hasUnwindExceptions(LangOpts))
1246  B.addAttribute(llvm::Attribute::NoUnwind);
1247 
1248  if (!D || !D->hasAttr<NoStackProtectorAttr>()) {
1249  if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1250  B.addAttribute(llvm::Attribute::StackProtect);
1251  else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1252  B.addAttribute(llvm::Attribute::StackProtectStrong);
1253  else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1254  B.addAttribute(llvm::Attribute::StackProtectReq);
1255  }
1256 
1257  if (!D) {
1258  // If we don't have a declaration to control inlining, the function isn't
1259  // explicitly marked as alwaysinline for semantic reasons, and inlining is
1260  // disabled, mark the function as noinline.
1261  if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1262  CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
1263  B.addAttribute(llvm::Attribute::NoInline);
1264 
1265  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1266  return;
1267  }
1268 
1269  // Track whether we need to add the optnone LLVM attribute,
1270  // starting with the default for this optimization level.
1271  bool ShouldAddOptNone =
1272  !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
1273  // We can't add optnone in the following cases, it won't pass the verifier.
1274  ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
1275  ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
1276  ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
1277 
1278  if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) {
1279  B.addAttribute(llvm::Attribute::OptimizeNone);
1280 
1281  // OptimizeNone implies noinline; we should not be inlining such functions.
1282  B.addAttribute(llvm::Attribute::NoInline);
1283  assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1284  "OptimizeNone and AlwaysInline on same function!");
1285 
1286  // We still need to handle naked functions even though optnone subsumes
1287  // much of their semantics.
1288  if (D->hasAttr<NakedAttr>())
1289  B.addAttribute(llvm::Attribute::Naked);
1290 
1291  // OptimizeNone wins over OptimizeForSize and MinSize.
1292  F->removeFnAttr(llvm::Attribute::OptimizeForSize);
1293  F->removeFnAttr(llvm::Attribute::MinSize);
1294  } else if (D->hasAttr<NakedAttr>()) {
1295  // Naked implies noinline: we should not be inlining such functions.
1296  B.addAttribute(llvm::Attribute::Naked);
1297  B.addAttribute(llvm::Attribute::NoInline);
1298  } else if (D->hasAttr<NoDuplicateAttr>()) {
1299  B.addAttribute(llvm::Attribute::NoDuplicate);
1300  } else if (D->hasAttr<NoInlineAttr>()) {
1301  B.addAttribute(llvm::Attribute::NoInline);
1302  } else if (D->hasAttr<AlwaysInlineAttr>() &&
1303  !F->hasFnAttribute(llvm::Attribute::NoInline)) {
1304  // (noinline wins over always_inline, and we can't specify both in IR)
1305  B.addAttribute(llvm::Attribute::AlwaysInline);
1306  } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
1307  // If we're not inlining, then force everything that isn't always_inline to
1308  // carry an explicit noinline attribute.
1309  if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
1310  B.addAttribute(llvm::Attribute::NoInline);
1311  } else {
1312  // Otherwise, propagate the inline hint attribute and potentially use its
1313  // absence to mark things as noinline.
1314  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
1315  // Search function and template pattern redeclarations for inline.
1316  auto CheckForInline = [](const FunctionDecl *FD) {
1317  auto CheckRedeclForInline = [](const FunctionDecl *Redecl) {
1318  return Redecl->isInlineSpecified();
1319  };
1320  if (any_of(FD->redecls(), CheckRedeclForInline))
1321  return true;
1322  const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern();
1323  if (!Pattern)
1324  return false;
1325  return any_of(Pattern->redecls(), CheckRedeclForInline);
1326  };
1327  if (CheckForInline(FD)) {
1328  B.addAttribute(llvm::Attribute::InlineHint);
1329  } else if (CodeGenOpts.getInlining() ==
1331  !FD->isInlined() &&
1332  !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
1333  B.addAttribute(llvm::Attribute::NoInline);
1334  }
1335  }
1336  }
1337 
1338  // Add other optimization related attributes if we are optimizing this
1339  // function.
1340  if (!D->hasAttr<OptimizeNoneAttr>()) {
1341  if (D->hasAttr<ColdAttr>()) {
1342  if (!ShouldAddOptNone)
1343  B.addAttribute(llvm::Attribute::OptimizeForSize);
1344  B.addAttribute(llvm::Attribute::Cold);
1345  }
1346 
1347  if (D->hasAttr<MinSizeAttr>())
1348  B.addAttribute(llvm::Attribute::MinSize);
1349  }
1350 
1351  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1352 
1353  unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
1354  if (alignment)
1355  F->setAlignment(alignment);
1356 
1357  if (!D->hasAttr<AlignedAttr>())
1358  if (LangOpts.FunctionAlignment)
1359  F->setAlignment(1 << LangOpts.FunctionAlignment);
1360 
1361  // Some C++ ABIs require 2-byte alignment for member functions, in order to
1362  // reserve a bit for differentiating between virtual and non-virtual member
1363  // functions. If the current target's C++ ABI requires this and this is a
1364  // member function, set its alignment accordingly.
1365  if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
1366  if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
1367  F->setAlignment(2);
1368  }
1369 
1370  // In the cross-dso CFI mode, we want !type attributes on definitions only.
1371  if (CodeGenOpts.SanitizeCfiCrossDso)
1372  if (auto *FD = dyn_cast<FunctionDecl>(D))
1374 
1375  // Emit type metadata on member functions for member function pointer checks.
1376  // These are only ever necessary on definitions; we're guaranteed that the
1377  // definition will be present in the LTO unit as a result of LTO visibility.
1378  auto *MD = dyn_cast<CXXMethodDecl>(D);
1379  if (MD && requiresMemberFunctionPointerTypeMetadata(*this, MD)) {
1380  for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
1381  llvm::Metadata *Id =
1383  MD->getType(), Context.getRecordType(Base).getTypePtr()));
1384  F->addTypeMetadata(0, Id);
1385  }
1386  }
1387 }
1388 
1389 void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
1390  const Decl *D = GD.getDecl();
1391  if (dyn_cast_or_null<NamedDecl>(D))
1392  setGVProperties(GV, GD);
1393  else
1394  GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1395 
1396  if (D && D->hasAttr<UsedAttr>())
1397  addUsedGlobal(GV);
1398 
1399  if (CodeGenOpts.KeepStaticConsts && D && isa<VarDecl>(D)) {
1400  const auto *VD = cast<VarDecl>(D);
1401  if (VD->getType().isConstQualified() &&
1402  VD->getStorageDuration() == SD_Static)
1403  addUsedGlobal(GV);
1404  }
1405 }
1406 
1407 bool CodeGenModule::GetCPUAndFeaturesAttributes(GlobalDecl GD,
1408  llvm::AttrBuilder &Attrs) {
1409  // Add target-cpu and target-features attributes to functions. If
1410  // we have a decl for the function and it has a target attribute then
1411  // parse that and add it to the feature set.
1412  StringRef TargetCPU = getTarget().getTargetOpts().CPU;
1413  std::vector<std::string> Features;
1414  const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.getDecl());
1415  FD = FD ? FD->getMostRecentDecl() : FD;
1416  const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
1417  const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr;
1418  bool AddedAttr = false;
1419  if (TD || SD) {
1420  llvm::StringMap<bool> FeatureMap;
1421  getFunctionFeatureMap(FeatureMap, GD);
1422 
1423  // Produce the canonical string for this set of features.
1424  for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
1425  Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
1426 
1427  // Now add the target-cpu and target-features to the function.
1428  // While we populated the feature map above, we still need to
1429  // get and parse the target attribute so we can get the cpu for
1430  // the function.
1431  if (TD) {
1432  TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
1433  if (ParsedAttr.Architecture != "" &&
1434  getTarget().isValidCPUName(ParsedAttr.Architecture))
1435  TargetCPU = ParsedAttr.Architecture;
1436  }
1437  } else {
1438  // Otherwise just add the existing target cpu and target features to the
1439  // function.
1440  Features = getTarget().getTargetOpts().Features;
1441  }
1442 
1443  if (TargetCPU != "") {
1444  Attrs.addAttribute("target-cpu", TargetCPU);
1445  AddedAttr = true;
1446  }
1447  if (!Features.empty()) {
1448  llvm::sort(Features);
1449  Attrs.addAttribute("target-features", llvm::join(Features, ","));
1450  AddedAttr = true;
1451  }
1452 
1453  return AddedAttr;
1454 }
1455 
1456 void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
1457  llvm::GlobalObject *GO) {
1458  const Decl *D = GD.getDecl();
1459  SetCommonAttributes(GD, GO);
1460 
1461  if (D) {
1462  if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
1463  if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
1464  GV->addAttribute("bss-section", SA->getName());
1465  if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
1466  GV->addAttribute("data-section", SA->getName());
1467  if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
1468  GV->addAttribute("rodata-section", SA->getName());
1469  }
1470 
1471  if (auto *F = dyn_cast<llvm::Function>(GO)) {
1472  if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
1473  if (!D->getAttr<SectionAttr>())
1474  F->addFnAttr("implicit-section-name", SA->getName());
1475 
1476  llvm::AttrBuilder Attrs;
1477  if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
1478  // We know that GetCPUAndFeaturesAttributes will always have the
1479  // newest set, since it has the newest possible FunctionDecl, so the
1480  // new ones should replace the old.
1481  F->removeFnAttr("target-cpu");
1482  F->removeFnAttr("target-features");
1483  F->addAttributes(llvm::AttributeList::FunctionIndex, Attrs);
1484  }
1485  }
1486 
1487  if (const auto *CSA = D->getAttr<CodeSegAttr>())
1488  GO->setSection(CSA->getName());
1489  else if (const auto *SA = D->getAttr<SectionAttr>())
1490  GO->setSection(SA->getName());
1491  }
1492 
1493  getTargetCodeGenInfo().setTargetAttributes(D, GO, *this);
1494 }
1495 
1497  llvm::Function *F,
1498  const CGFunctionInfo &FI) {
1499  const Decl *D = GD.getDecl();
1500  SetLLVMFunctionAttributes(GD, FI, F);
1502 
1503  F->setLinkage(llvm::Function::InternalLinkage);
1504 
1505  setNonAliasAttributes(GD, F);
1506 }
1507 
1508 static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) {
1509  // Set linkage and visibility in case we never see a definition.
1511  // Don't set internal linkage on declarations.
1512  // "extern_weak" is overloaded in LLVM; we probably should have
1513  // separate linkage types for this.
1514  if (isExternallyVisible(LV.getLinkage()) &&
1515  (ND->hasAttr<WeakAttr>() || ND->isWeakImported()))
1516  GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1517 }
1518 
1520  llvm::Function *F) {
1521  // Only if we are checking indirect calls.
1522  if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
1523  return;
1524 
1525  // Non-static class methods are handled via vtable or member function pointer
1526  // checks elsewhere.
1527  if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
1528  return;
1529 
1530  // Additionally, if building with cross-DSO support...
1531  if (CodeGenOpts.SanitizeCfiCrossDso) {
1532  // Skip available_externally functions. They won't be codegen'ed in the
1533  // current module anyway.
1535  return;
1536  }
1537 
1538  llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType());
1539  F->addTypeMetadata(0, MD);
1540  F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
1541 
1542  // Emit a hash-based bit set entry for cross-DSO calls.
1543  if (CodeGenOpts.SanitizeCfiCrossDso)
1544  if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
1545  F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
1546 }
1547 
1548 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1549  bool IsIncompleteFunction,
1550  bool IsThunk) {
1551 
1552  if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
1553  // If this is an intrinsic function, set the function's attributes
1554  // to the intrinsic's attributes.
1555  F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
1556  return;
1557  }
1558 
1559  const auto *FD = cast<FunctionDecl>(GD.getDecl());
1560 
1561  if (!IsIncompleteFunction) {
1562  SetLLVMFunctionAttributes(GD, getTypes().arrangeGlobalDeclaration(GD), F);
1563  // Setup target-specific attributes.
1564  if (F->isDeclaration())
1565  getTargetCodeGenInfo().setTargetAttributes(FD, F, *this);
1566  }
1567 
1568  // Add the Returned attribute for "this", except for iOS 5 and earlier
1569  // where substantial code, including the libstdc++ dylib, was compiled with
1570  // GCC and does not actually return "this".
1571  if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
1572  !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
1573  assert(!F->arg_empty() &&
1574  F->arg_begin()->getType()
1575  ->canLosslesslyBitCastTo(F->getReturnType()) &&
1576  "unexpected this return");
1577  F->addAttribute(1, llvm::Attribute::Returned);
1578  }
1579 
1580  // Only a few attributes are set on declarations; these may later be
1581  // overridden by a definition.
1582 
1583  setLinkageForGV(F, FD);
1584  setGVProperties(F, FD);
1585 
1586  if (const auto *CSA = FD->getAttr<CodeSegAttr>())
1587  F->setSection(CSA->getName());
1588  else if (const auto *SA = FD->getAttr<SectionAttr>())
1589  F->setSection(SA->getName());
1590 
1592  // A replaceable global allocation function does not act like a builtin by
1593  // default, only if it is invoked by a new-expression or delete-expression.
1594  F->addAttribute(llvm::AttributeList::FunctionIndex,
1595  llvm::Attribute::NoBuiltin);
1596 
1597  // A sane operator new returns a non-aliasing pointer.
1598  // FIXME: Also add NonNull attribute to the return value
1599  // for the non-nothrow forms?
1600  auto Kind = FD->getDeclName().getCXXOverloadedOperator();
1601  if (getCodeGenOpts().AssumeSaneOperatorNew &&
1602  (Kind == OO_New || Kind == OO_Array_New))
1603  F->addAttribute(llvm::AttributeList::ReturnIndex,
1604  llvm::Attribute::NoAlias);
1605  }
1606 
1607  if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
1608  F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1609  else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1610  if (MD->isVirtual())
1611  F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1612 
1613  // Don't emit entries for function declarations in the cross-DSO mode. This
1614  // is handled with better precision by the receiving DSO.
1615  if (!CodeGenOpts.SanitizeCfiCrossDso)
1617 
1618  if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
1619  getOpenMPRuntime().emitDeclareSimdFunction(FD, F);
1620 
1621  if (const auto *CB = FD->getAttr<CallbackAttr>()) {
1622  // Annotate the callback behavior as metadata:
1623  // - The callback callee (as argument number).
1624  // - The callback payloads (as argument numbers).
1625  llvm::LLVMContext &Ctx = F->getContext();
1626  llvm::MDBuilder MDB(Ctx);
1627 
1628  // The payload indices are all but the first one in the encoding. The first
1629  // identifies the callback callee.
1630  int CalleeIdx = *CB->encoding_begin();
1631  ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
1632  F->addMetadata(llvm::LLVMContext::MD_callback,
1633  *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
1634  CalleeIdx, PayloadIndices,
1635  /* VarArgsArePassed */ false)}));
1636  }
1637 }
1638 
1639 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
1640  assert(!GV->isDeclaration() &&
1641  "Only globals with definition can force usage.");
1642  LLVMUsed.emplace_back(GV);
1643 }
1644 
1645 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
1646  assert(!GV->isDeclaration() &&
1647  "Only globals with definition can force usage.");
1648  LLVMCompilerUsed.emplace_back(GV);
1649 }
1650 
1651 static void emitUsed(CodeGenModule &CGM, StringRef Name,
1652  std::vector<llvm::WeakTrackingVH> &List) {
1653  // Don't create llvm.used if there is no need.
1654  if (List.empty())
1655  return;
1656 
1657  // Convert List to what ConstantArray needs.
1659  UsedArray.resize(List.size());
1660  for (unsigned i = 0, e = List.size(); i != e; ++i) {
1661  UsedArray[i] =
1662  llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1663  cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
1664  }
1665 
1666  if (UsedArray.empty())
1667  return;
1668  llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
1669 
1670  auto *GV = new llvm::GlobalVariable(
1671  CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
1672  llvm::ConstantArray::get(ATy, UsedArray), Name);
1673 
1674  GV->setSection("llvm.metadata");
1675 }
1676 
1677 void CodeGenModule::emitLLVMUsed() {
1678  emitUsed(*this, "llvm.used", LLVMUsed);
1679  emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
1680 }
1681 
1683  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
1684  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1685 }
1686 
1687 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
1689  getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
1690  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1691  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1692 }
1693 
1695  auto &C = getLLVMContext();
1696  LinkerOptionsMetadata.push_back(llvm::MDNode::get(
1697  C, {llvm::MDString::get(C, "lib"), llvm::MDString::get(C, Lib)}));
1698 }
1699 
1700 void CodeGenModule::AddDependentLib(StringRef Lib) {
1703  auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1704  LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1705 }
1706 
1707 /// Add link options implied by the given module, including modules
1708 /// it depends on, using a postorder walk.
1711  llvm::SmallPtrSet<Module *, 16> &Visited) {
1712  // Import this module's parent.
1713  if (Mod->Parent && Visited.insert(Mod->Parent).second) {
1714  addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
1715  }
1716 
1717  // Import this module's dependencies.
1718  for (unsigned I = Mod->Imports.size(); I > 0; --I) {
1719  if (Visited.insert(Mod->Imports[I - 1]).second)
1720  addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
1721  }
1722 
1723  // Add linker options to link against the libraries/frameworks
1724  // described by this module.
1725  llvm::LLVMContext &Context = CGM.getLLVMContext();
1726  bool IsELF = CGM.getTarget().getTriple().isOSBinFormatELF();
1727  bool IsPS4 = CGM.getTarget().getTriple().isPS4();
1728 
1729  // For modules that use export_as for linking, use that module
1730  // name instead.
1731  if (Mod->UseExportAsModuleLinkName)
1732  return;
1733 
1734  for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
1735  // Link against a framework. Frameworks are currently Darwin only, so we
1736  // don't to ask TargetCodeGenInfo for the spelling of the linker option.
1737  if (Mod->LinkLibraries[I-1].IsFramework) {
1738  llvm::Metadata *Args[2] = {
1739  llvm::MDString::get(Context, "-framework"),
1740  llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
1741 
1742  Metadata.push_back(llvm::MDNode::get(Context, Args));
1743  continue;
1744  }
1745 
1746  // Link against a library.
1747  if (IsELF && !IsPS4) {
1748  llvm::Metadata *Args[2] = {
1749  llvm::MDString::get(Context, "lib"),
1750  llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library),
1751  };
1752  Metadata.push_back(llvm::MDNode::get(Context, Args));
1753  } else {
1756  Mod->LinkLibraries[I - 1].Library, Opt);
1757  auto *OptString = llvm::MDString::get(Context, Opt);
1758  Metadata.push_back(llvm::MDNode::get(Context, OptString));
1759  }
1760  }
1761 }
1762 
1763 void CodeGenModule::EmitModuleLinkOptions() {
1764  // Collect the set of all of the modules we want to visit to emit link
1765  // options, which is essentially the imported modules and all of their
1766  // non-explicit child modules.
1767  llvm::SetVector<clang::Module *> LinkModules;
1768  llvm::SmallPtrSet<clang::Module *, 16> Visited;
1770 
1771  // Seed the stack with imported modules.
1772  for (Module *M : ImportedModules) {
1773  // Do not add any link flags when an implementation TU of a module imports
1774  // a header of that same module.
1775  if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
1777  continue;
1778  if (Visited.insert(M).second)
1779  Stack.push_back(M);
1780  }
1781 
1782  // Find all of the modules to import, making a little effort to prune
1783  // non-leaf modules.
1784  while (!Stack.empty()) {
1785  clang::Module *Mod = Stack.pop_back_val();
1786 
1787  bool AnyChildren = false;
1788 
1789  // Visit the submodules of this module.
1790  for (const auto &SM : Mod->submodules()) {
1791  // Skip explicit children; they need to be explicitly imported to be
1792  // linked against.
1793  if (SM->IsExplicit)
1794  continue;
1795 
1796  if (Visited.insert(SM).second) {
1797  Stack.push_back(SM);
1798  AnyChildren = true;
1799  }
1800  }
1801 
1802  // We didn't find any children, so add this module to the list of
1803  // modules to link against.
1804  if (!AnyChildren) {
1805  LinkModules.insert(Mod);
1806  }
1807  }
1808 
1809  // Add link options for all of the imported modules in reverse topological
1810  // order. We don't do anything to try to order import link flags with respect
1811  // to linker options inserted by things like #pragma comment().
1812  SmallVector<llvm::MDNode *, 16> MetadataArgs;
1813  Visited.clear();
1814  for (Module *M : LinkModules)
1815  if (Visited.insert(M).second)
1816  addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
1817  std::reverse(MetadataArgs.begin(), MetadataArgs.end());
1818  LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
1819 
1820  // Add the linker options metadata flag.
1821  auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
1822  for (auto *MD : LinkerOptionsMetadata)
1823  NMD->addOperand(MD);
1824 }
1825 
1826 void CodeGenModule::EmitDeferred() {
1827  // Emit deferred declare target declarations.
1828  if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
1829  getOpenMPRuntime().emitDeferredTargetDecls();
1830 
1831  // Emit code for any potentially referenced deferred decls. Since a
1832  // previously unused static decl may become used during the generation of code
1833  // for a static function, iterate until no changes are made.
1834 
1835  if (!DeferredVTables.empty()) {
1836  EmitDeferredVTables();
1837 
1838  // Emitting a vtable doesn't directly cause more vtables to
1839  // become deferred, although it can cause functions to be
1840  // emitted that then need those vtables.
1841  assert(DeferredVTables.empty());
1842  }
1843 
1844  // Stop if we're out of both deferred vtables and deferred declarations.
1845  if (DeferredDeclsToEmit.empty())
1846  return;
1847 
1848  // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1849  // work, it will not interfere with this.
1850  std::vector<GlobalDecl> CurDeclsToEmit;
1851  CurDeclsToEmit.swap(DeferredDeclsToEmit);
1852 
1853  for (GlobalDecl &D : CurDeclsToEmit) {
1854  // We should call GetAddrOfGlobal with IsForDefinition set to true in order
1855  // to get GlobalValue with exactly the type we need, not something that
1856  // might had been created for another decl with the same mangled name but
1857  // different type.
1858  llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
1860 
1861  // In case of different address spaces, we may still get a cast, even with
1862  // IsForDefinition equal to true. Query mangled names table to get
1863  // GlobalValue.
1864  if (!GV)
1865  GV = GetGlobalValue(getMangledName(D));
1866 
1867  // Make sure GetGlobalValue returned non-null.
1868  assert(GV);
1869 
1870  // Check to see if we've already emitted this. This is necessary
1871  // for a couple of reasons: first, decls can end up in the
1872  // deferred-decls queue multiple times, and second, decls can end
1873  // up with definitions in unusual ways (e.g. by an extern inline
1874  // function acquiring a strong function redefinition). Just
1875  // ignore these cases.
1876  if (!GV->isDeclaration())
1877  continue;
1878 
1879  // Otherwise, emit the definition and move on to the next one.
1880  EmitGlobalDefinition(D, GV);
1881 
1882  // If we found out that we need to emit more decls, do that recursively.
1883  // This has the advantage that the decls are emitted in a DFS and related
1884  // ones are close together, which is convenient for testing.
1885  if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1886  EmitDeferred();
1887  assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1888  }
1889  }
1890 }
1891 
1892 void CodeGenModule::EmitVTablesOpportunistically() {
1893  // Try to emit external vtables as available_externally if they have emitted
1894  // all inlined virtual functions. It runs after EmitDeferred() and therefore
1895  // is not allowed to create new references to things that need to be emitted
1896  // lazily. Note that it also uses fact that we eagerly emitting RTTI.
1897 
1898  assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
1899  && "Only emit opportunistic vtables with optimizations");
1900 
1901  for (const CXXRecordDecl *RD : OpportunisticVTables) {
1902  assert(getVTables().isVTableExternal(RD) &&
1903  "This queue should only contain external vtables");
1904  if (getCXXABI().canSpeculativelyEmitVTable(RD))
1905  VTables.GenerateClassData(RD);
1906  }
1907  OpportunisticVTables.clear();
1908 }
1909 
1911  if (Annotations.empty())
1912  return;
1913 
1914  // Create a new global variable for the ConstantStruct in the Module.
1915  llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1916  Annotations[0]->getType(), Annotations.size()), Annotations);
1917  auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1918  llvm::GlobalValue::AppendingLinkage,
1919  Array, "llvm.global.annotations");
1920  gv->setSection(AnnotationSection);
1921 }
1922 
1923 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
1924  llvm::Constant *&AStr = AnnotationStrings[Str];
1925  if (AStr)
1926  return AStr;
1927 
1928  // Not found yet, create a new global.
1929  llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
1930  auto *gv =
1931  new llvm::GlobalVariable(getModule(), s->getType(), true,
1932  llvm::GlobalValue::PrivateLinkage, s, ".str");
1933  gv->setSection(AnnotationSection);
1934  gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1935  AStr = gv;
1936  return gv;
1937 }
1938 
1941  PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1942  if (PLoc.isValid())
1943  return EmitAnnotationString(PLoc.getFilename());
1944  return EmitAnnotationString(SM.getBufferName(Loc));
1945 }
1946 
1949  PresumedLoc PLoc = SM.getPresumedLoc(L);
1950  unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1951  SM.getExpansionLineNumber(L);
1952  return llvm::ConstantInt::get(Int32Ty, LineNo);
1953 }
1954 
1955 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
1956  const AnnotateAttr *AA,
1957  SourceLocation L) {
1958  // Get the globals for file name, annotation, and the line number.
1959  llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1960  *UnitGV = EmitAnnotationUnit(L),
1961  *LineNoCst = EmitAnnotationLineNo(L);
1962 
1963  // Create the ConstantStruct for the global annotation.
1964  llvm::Constant *Fields[4] = {
1965  llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1966  llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1967  llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1968  LineNoCst
1969  };
1970  return llvm::ConstantStruct::getAnon(Fields);
1971 }
1972 
1974  llvm::GlobalValue *GV) {
1975  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1976  // Get the struct elements for these annotations.
1977  for (const auto *I : D->specific_attrs<AnnotateAttr>())
1978  Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
1979 }
1980 
1982  llvm::Function *Fn,
1983  SourceLocation Loc) const {
1984  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1985  // Blacklist by function name.
1986  if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
1987  return true;
1988  // Blacklist by location.
1989  if (Loc.isValid())
1990  return SanitizerBL.isBlacklistedLocation(Kind, Loc);
1991  // If location is unknown, this may be a compiler-generated function. Assume
1992  // it's located in the main file.
1993  auto &SM = Context.getSourceManager();
1994  if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1995  return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
1996  }
1997  return false;
1998 }
1999 
2000 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
2001  SourceLocation Loc, QualType Ty,
2002  StringRef Category) const {
2003  // For now globals can be blacklisted only in ASan and KASan.
2004  const SanitizerMask EnabledAsanMask = LangOpts.Sanitize.Mask &
2005  (SanitizerKind::Address | SanitizerKind::KernelAddress |
2006  SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress);
2007  if (!EnabledAsanMask)
2008  return false;
2009  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
2010  if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category))
2011  return true;
2012  if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
2013  return true;
2014  // Check global type.
2015  if (!Ty.isNull()) {
2016  // Drill down the array types: if global variable of a fixed type is
2017  // blacklisted, we also don't instrument arrays of them.
2018  while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
2019  Ty = AT->getElementType();
2021  // We allow to blacklist only record types (classes, structs etc.)
2022  if (Ty->isRecordType()) {
2023  std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
2024  if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
2025  return true;
2026  }
2027  }
2028  return false;
2029 }
2030 
2031 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
2032  StringRef Category) const {
2033  const auto &XRayFilter = getContext().getXRayFilter();
2034  using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
2035  auto Attr = ImbueAttr::NONE;
2036  if (Loc.isValid())
2037  Attr = XRayFilter.shouldImbueLocation(Loc, Category);
2038  if (Attr == ImbueAttr::NONE)
2039  Attr = XRayFilter.shouldImbueFunction(Fn->getName());
2040  switch (Attr) {
2041  case ImbueAttr::NONE:
2042  return false;
2043  case ImbueAttr::ALWAYS:
2044  Fn->addFnAttr("function-instrument", "xray-always");
2045  break;
2046  case ImbueAttr::ALWAYS_ARG1:
2047  Fn->addFnAttr("function-instrument", "xray-always");
2048  Fn->addFnAttr("xray-log-args", "1");
2049  break;
2050  case ImbueAttr::NEVER:
2051  Fn->addFnAttr("function-instrument", "xray-never");
2052  break;
2053  }
2054  return true;
2055 }
2056 
2057 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
2058  // Never defer when EmitAllDecls is specified.
2059  if (LangOpts.EmitAllDecls)
2060  return true;
2061 
2062  if (CodeGenOpts.KeepStaticConsts) {
2063  const auto *VD = dyn_cast<VarDecl>(Global);
2064  if (VD && VD->getType().isConstQualified() &&
2065  VD->getStorageDuration() == SD_Static)
2066  return true;
2067  }
2068 
2069  return getContext().DeclMustBeEmitted(Global);
2070 }
2071 
2072 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
2073  if (const auto *FD = dyn_cast<FunctionDecl>(Global))
2075  // Implicit template instantiations may change linkage if they are later
2076  // explicitly instantiated, so they should not be emitted eagerly.
2077  return false;
2078  if (const auto *VD = dyn_cast<VarDecl>(Global))
2079  if (Context.getInlineVariableDefinitionKind(VD) ==
2081  // A definition of an inline constexpr static data member may change
2082  // linkage later if it's redeclared outside the class.
2083  return false;
2084  // If OpenMP is enabled and threadprivates must be generated like TLS, delay
2085  // codegen for global variables, because they may be marked as threadprivate.
2086  if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
2087  getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
2088  !isTypeConstant(Global->getType(), false) &&
2089  !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
2090  return false;
2091 
2092  return true;
2093 }
2094 
2096  const CXXUuidofExpr* E) {
2097  // Sema has verified that IIDSource has a __declspec(uuid()), and that its
2098  // well-formed.
2099  StringRef Uuid = E->getUuidStr();
2100  std::string Name = "_GUID_" + Uuid.lower();
2101  std::replace(Name.begin(), Name.end(), '-', '_');
2102 
2103  // The UUID descriptor should be pointer aligned.
2105 
2106  // Look for an existing global.
2107  if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
2108  return ConstantAddress(GV, Alignment);
2109 
2110  llvm::Constant *Init = EmitUuidofInitializer(Uuid);
2111  assert(Init && "failed to initialize as constant");
2112 
2113  auto *GV = new llvm::GlobalVariable(
2114  getModule(), Init->getType(),
2115  /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
2116  if (supportsCOMDAT())
2117  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
2118  setDSOLocal(GV);
2119  return ConstantAddress(GV, Alignment);
2120 }
2121 
2123  const AliasAttr *AA = VD->getAttr<AliasAttr>();
2124  assert(AA && "No alias?");
2125 
2126  CharUnits Alignment = getContext().getDeclAlign(VD);
2127  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
2128 
2129  // See if there is already something with the target's name in the module.
2130  llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
2131  if (Entry) {
2132  unsigned AS = getContext().getTargetAddressSpace(VD->getType());
2133  auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
2134  return ConstantAddress(Ptr, Alignment);
2135  }
2136 
2137  llvm::Constant *Aliasee;
2138  if (isa<llvm::FunctionType>(DeclTy))
2139  Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
2140  GlobalDecl(cast<FunctionDecl>(VD)),
2141  /*ForVTable=*/false);
2142  else
2143  Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2144  llvm::PointerType::getUnqual(DeclTy),
2145  nullptr);
2146 
2147  auto *F = cast<llvm::GlobalValue>(Aliasee);
2148  F->setLinkage(llvm::Function::ExternalWeakLinkage);
2149  WeakRefReferences.insert(F);
2150 
2151  return ConstantAddress(Aliasee, Alignment);
2152 }
2153 
2155  const auto *Global = cast<ValueDecl>(GD.getDecl());
2156 
2157  // Weak references don't produce any output by themselves.
2158  if (Global->hasAttr<WeakRefAttr>())
2159  return;
2160 
2161  // If this is an alias definition (which otherwise looks like a declaration)
2162  // emit it now.
2163  if (Global->hasAttr<AliasAttr>())
2164  return EmitAliasDefinition(GD);
2165 
2166  // IFunc like an alias whose value is resolved at runtime by calling resolver.
2167  if (Global->hasAttr<IFuncAttr>())
2168  return emitIFuncDefinition(GD);
2169 
2170  // If this is a cpu_dispatch multiversion function, emit the resolver.
2171  if (Global->hasAttr<CPUDispatchAttr>())
2172  return emitCPUDispatchDefinition(GD);
2173 
2174  // If this is CUDA, be selective about which declarations we emit.
2175  if (LangOpts.CUDA) {
2176  if (LangOpts.CUDAIsDevice) {
2177  if (!Global->hasAttr<CUDADeviceAttr>() &&
2178  !Global->hasAttr<CUDAGlobalAttr>() &&
2179  !Global->hasAttr<CUDAConstantAttr>() &&
2180  !Global->hasAttr<CUDASharedAttr>())
2181  return;
2182  } else {
2183  // We need to emit host-side 'shadows' for all global
2184  // device-side variables because the CUDA runtime needs their
2185  // size and host-side address in order to provide access to
2186  // their device-side incarnations.
2187 
2188  // So device-only functions are the only things we skip.
2189  if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() &&
2190  Global->hasAttr<CUDADeviceAttr>())
2191  return;
2192 
2193  assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
2194  "Expected Variable or Function");
2195  }
2196  }
2197 
2198  if (LangOpts.OpenMP) {
2199  // If this is OpenMP device, check if it is legal to emit this global
2200  // normally.
2201  if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
2202  return;
2203  if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
2204  if (MustBeEmitted(Global))
2206  return;
2207  } else if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
2208  if (MustBeEmitted(Global))
2209  EmitOMPDeclareMapper(DMD);
2210  return;
2211  }
2212  }
2213 
2214  // Ignore declarations, they will be emitted on their first use.
2215  if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
2216  // Forward declarations are emitted lazily on first use.
2217  if (!FD->doesThisDeclarationHaveABody()) {
2219  return;
2220 
2221  StringRef MangledName = getMangledName(GD);
2222 
2223  // Compute the function info and LLVM type.
2225  llvm::Type *Ty = getTypes().GetFunctionType(FI);
2226 
2227  GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
2228  /*DontDefer=*/false);
2229  return;
2230  }
2231  } else {
2232  const auto *VD = cast<VarDecl>(Global);
2233  assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
2234  if (VD->isThisDeclarationADefinition() != VarDecl::Definition &&
2235  !Context.isMSStaticDataMemberInlineDefinition(VD)) {
2236  if (LangOpts.OpenMP) {
2237  // Emit declaration of the must-be-emitted declare target variable.
2239  OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
2240  if (*Res == OMPDeclareTargetDeclAttr::MT_To) {
2241  (void)GetAddrOfGlobalVar(VD);
2242  } else {
2243  assert(*Res == OMPDeclareTargetDeclAttr::MT_Link &&
2244  "link claue expected.");
2245  (void)getOpenMPRuntime().getAddrOfDeclareTargetLink(VD);
2246  }
2247  return;
2248  }
2249  }
2250  // If this declaration may have caused an inline variable definition to
2251  // change linkage, make sure that it's emitted.
2252  if (Context.getInlineVariableDefinitionKind(VD) ==
2254  GetAddrOfGlobalVar(VD);
2255  return;
2256  }
2257  }
2258 
2259  // Defer code generation to first use when possible, e.g. if this is an inline
2260  // function. If the global must always be emitted, do it eagerly if possible
2261  // to benefit from cache locality.
2262  if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
2263  // Emit the definition if it can't be deferred.
2264  EmitGlobalDefinition(GD);
2265  return;
2266  }
2267 
2268  // If we're deferring emission of a C++ variable with an
2269  // initializer, remember the order in which it appeared in the file.
2270  if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
2271  cast<VarDecl>(Global)->hasInit()) {
2272  DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
2273  CXXGlobalInits.push_back(nullptr);
2274  }
2275 
2276  StringRef MangledName = getMangledName(GD);
2277  if (GetGlobalValue(MangledName) != nullptr) {
2278  // The value has already been used and should therefore be emitted.
2279  addDeferredDeclToEmit(GD);
2280  } else if (MustBeEmitted(Global)) {
2281  // The value must be emitted, but cannot be emitted eagerly.
2282  assert(!MayBeEmittedEagerly(Global));
2283  addDeferredDeclToEmit(GD);
2284  } else {
2285  // Otherwise, remember that we saw a deferred decl with this name. The
2286  // first use of the mangled name will cause it to move into
2287  // DeferredDeclsToEmit.
2288  DeferredDecls[MangledName] = GD;
2289  }
2290 }
2291 
2292 // Check if T is a class type with a destructor that's not dllimport.
2294  if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>())
2295  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2296  if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
2297  return true;
2298 
2299  return false;
2300 }
2301 
2302 namespace {
2303  struct FunctionIsDirectlyRecursive
2304  : public ConstStmtVisitor<FunctionIsDirectlyRecursive, bool> {
2305  const StringRef Name;
2306  const Builtin::Context &BI;
2307  FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C)
2308  : Name(N), BI(C) {}
2309 
2310  bool VisitCallExpr(const CallExpr *E) {
2311  const FunctionDecl *FD = E->getDirectCallee();
2312  if (!FD)
2313  return false;
2314  AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2315  if (Attr && Name == Attr->getLabel())
2316  return true;
2317  unsigned BuiltinID = FD->getBuiltinID();
2318  if (!BuiltinID || !BI.isLibFunction(BuiltinID))
2319  return false;
2320  StringRef BuiltinName = BI.getName(BuiltinID);
2321  if (BuiltinName.startswith("__builtin_") &&
2322  Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
2323  return true;
2324  }
2325  return false;
2326  }
2327 
2328  bool VisitStmt(const Stmt *S) {
2329  for (const Stmt *Child : S->children())
2330  if (Child && this->Visit(Child))
2331  return true;
2332  return false;
2333  }
2334  };
2335 
2336  // Make sure we're not referencing non-imported vars or functions.
2337  struct DLLImportFunctionVisitor
2338  : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
2339  bool SafeToInline = true;
2340 
2341  bool shouldVisitImplicitCode() const { return true; }
2342 
2343  bool VisitVarDecl(VarDecl *VD) {
2344  if (VD->getTLSKind()) {
2345  // A thread-local variable cannot be imported.
2346  SafeToInline = false;
2347  return SafeToInline;
2348  }
2349 
2350  // A variable definition might imply a destructor call.
2351  if (VD->isThisDeclarationADefinition())
2352  SafeToInline = !HasNonDllImportDtor(VD->getType());
2353 
2354  return SafeToInline;
2355  }
2356 
2357  bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
2358  if (const auto *D = E->getTemporary()->getDestructor())
2359  SafeToInline = D->hasAttr<DLLImportAttr>();
2360  return SafeToInline;
2361  }
2362 
2363  bool VisitDeclRefExpr(DeclRefExpr *E) {
2364  ValueDecl *VD = E->getDecl();
2365  if (isa<FunctionDecl>(VD))
2366  SafeToInline = VD->hasAttr<DLLImportAttr>();
2367  else if (VarDecl *V = dyn_cast<VarDecl>(VD))
2368  SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
2369  return SafeToInline;
2370  }
2371 
2372  bool VisitCXXConstructExpr(CXXConstructExpr *E) {
2373  SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
2374  return SafeToInline;
2375  }
2376 
2377  bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2378  CXXMethodDecl *M = E->getMethodDecl();
2379  if (!M) {
2380  // Call through a pointer to member function. This is safe to inline.
2381  SafeToInline = true;
2382  } else {
2383  SafeToInline = M->hasAttr<DLLImportAttr>();
2384  }
2385  return SafeToInline;
2386  }
2387 
2388  bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2389  SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
2390  return SafeToInline;
2391  }
2392 
2393  bool VisitCXXNewExpr(CXXNewExpr *E) {
2394  SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
2395  return SafeToInline;
2396  }
2397  };
2398 }
2399 
2400 // isTriviallyRecursive - Check if this function calls another
2401 // decl that, because of the asm attribute or the other decl being a builtin,
2402 // ends up pointing to itself.
2403 bool
2404 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
2405  StringRef Name;
2406  if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
2407  // asm labels are a special kind of mangling we have to support.
2408  AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2409  if (!Attr)
2410  return false;
2411  Name = Attr->getLabel();
2412  } else {
2413  Name = FD->getName();
2414  }
2415 
2416  FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
2417  const Stmt *Body = FD->getBody();
2418  return Body ? Walker.Visit(Body) : false;
2419 }
2420 
2421 bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
2422  if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
2423  return true;
2424  const auto *F = cast<FunctionDecl>(GD.getDecl());
2425  if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
2426  return false;
2427 
2428  if (F->hasAttr<DLLImportAttr>()) {
2429  // Check whether it would be safe to inline this dllimport function.
2430  DLLImportFunctionVisitor Visitor;
2431  Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
2432  if (!Visitor.SafeToInline)
2433  return false;
2434 
2435  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
2436  // Implicit destructor invocations aren't captured in the AST, so the
2437  // check above can't see them. Check for them manually here.
2438  for (const Decl *Member : Dtor->getParent()->decls())
2439  if (isa<FieldDecl>(Member))
2440  if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType()))
2441  return false;
2442  for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
2443  if (HasNonDllImportDtor(B.getType()))
2444  return false;
2445  }
2446  }
2447 
2448  // PR9614. Avoid cases where the source code is lying to us. An available
2449  // externally function should have an equivalent function somewhere else,
2450  // but a function that calls itself is clearly not equivalent to the real
2451  // implementation.
2452  // This happens in glibc's btowc and in some configure checks.
2453  return !isTriviallyRecursive(F);
2454 }
2455 
2456 bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
2457  return CodeGenOpts.OptimizationLevel > 0;
2458 }
2459 
2460 void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD,
2461  llvm::GlobalValue *GV) {
2462  const auto *FD = cast<FunctionDecl>(GD.getDecl());
2463 
2464  if (FD->isCPUSpecificMultiVersion()) {
2465  auto *Spec = FD->getAttr<CPUSpecificAttr>();
2466  for (unsigned I = 0; I < Spec->cpus_size(); ++I)
2467  EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
2468  // Requires multiple emits.
2469  } else
2470  EmitGlobalFunctionDefinition(GD, GV);
2471 }
2472 
2473 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
2474  const auto *D = cast<ValueDecl>(GD.getDecl());
2475 
2476  PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
2477  Context.getSourceManager(),
2478  "Generating code for declaration");
2479 
2480  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2481  // At -O0, don't generate IR for functions with available_externally
2482  // linkage.
2483  if (!shouldEmitFunction(GD))
2484  return;
2485 
2486  llvm::TimeTraceScope TimeScope(
2487  "CodeGen Function", [&]() { return FD->getQualifiedNameAsString(); });
2488 
2489  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2490  // Make sure to emit the definition(s) before we emit the thunks.
2491  // This is necessary for the generation of certain thunks.
2492  if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
2493  ABI->emitCXXStructor(GD);
2494  else if (FD->isMultiVersion())
2495  EmitMultiVersionFunctionDefinition(GD, GV);
2496  else
2497  EmitGlobalFunctionDefinition(GD, GV);
2498 
2499  if (Method->isVirtual())
2500  getVTables().EmitThunks(GD);
2501 
2502  return;
2503  }
2504 
2505  if (FD->isMultiVersion())
2506  return EmitMultiVersionFunctionDefinition(GD, GV);
2507  return EmitGlobalFunctionDefinition(GD, GV);
2508  }
2509 
2510  if (const auto *VD = dyn_cast<VarDecl>(D))
2511  return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
2512 
2513  llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
2514 }
2515 
2516 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2517  llvm::Function *NewFn);
2518 
2519 static unsigned
2522  unsigned Priority = 0;
2523  for (StringRef Feat : RO.Conditions.Features)
2524  Priority = std::max(Priority, TI.multiVersionSortPriority(Feat));
2525 
2526  if (!RO.Conditions.Architecture.empty())
2527  Priority = std::max(
2529  return Priority;
2530 }
2531 
2532 void CodeGenModule::emitMultiVersionFunctions() {
2533  for (GlobalDecl GD : MultiVersionFuncs) {
2535  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
2537  FD, [this, &GD, &Options](const FunctionDecl *CurFD) {
2538  GlobalDecl CurGD{
2539  (CurFD->isDefined() ? CurFD->getDefinition() : CurFD)};
2540  StringRef MangledName = getMangledName(CurGD);
2541  llvm::Constant *Func = GetGlobalValue(MangledName);
2542  if (!Func) {
2543  if (CurFD->isDefined()) {
2544  EmitGlobalFunctionDefinition(CurGD, nullptr);
2545  Func = GetGlobalValue(MangledName);
2546  } else {
2547  const CGFunctionInfo &FI =
2549  llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2550  Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
2551  /*DontDefer=*/false, ForDefinition);
2552  }
2553  assert(Func && "This should have just been created");
2554  }
2555 
2556  const auto *TA = CurFD->getAttr<TargetAttr>();
2558  TA->getAddedFeatures(Feats);
2559 
2560  Options.emplace_back(cast<llvm::Function>(Func),
2561  TA->getArchitecture(), Feats);
2562  });
2563 
2564  llvm::Function *ResolverFunc;
2565  const TargetInfo &TI = getTarget();
2566 
2567  if (TI.supportsIFunc() || FD->isTargetMultiVersion())
2568  ResolverFunc = cast<llvm::Function>(
2569  GetGlobalValue((getMangledName(GD) + ".resolver").str()));
2570  else
2571  ResolverFunc = cast<llvm::Function>(GetGlobalValue(getMangledName(GD)));
2572 
2573  if (supportsCOMDAT())
2574  ResolverFunc->setComdat(
2575  getModule().getOrInsertComdat(ResolverFunc->getName()));
2576 
2577  std::stable_sort(
2578  Options.begin(), Options.end(),
2581  return TargetMVPriority(TI, LHS) > TargetMVPriority(TI, RHS);
2582  });
2583  CodeGenFunction CGF(*this);
2584  CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2585  }
2586 }
2587 
2588 void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) {
2589  const auto *FD = cast<FunctionDecl>(GD.getDecl());
2590  assert(FD && "Not a FunctionDecl?");
2591  const auto *DD = FD->getAttr<CPUDispatchAttr>();
2592  assert(DD && "Not a cpu_dispatch Function?");
2593  llvm::Type *DeclTy = getTypes().ConvertType(FD->getType());
2594 
2595  if (const auto *CXXFD = dyn_cast<CXXMethodDecl>(FD)) {
2596  const CGFunctionInfo &FInfo = getTypes().arrangeCXXMethodDeclaration(CXXFD);
2597  DeclTy = getTypes().GetFunctionType(FInfo);
2598  }
2599 
2600  StringRef ResolverName = getMangledName(GD);
2601 
2602  llvm::Type *ResolverType;
2603  GlobalDecl ResolverGD;
2604  if (getTarget().supportsIFunc())
2605  ResolverType = llvm::FunctionType::get(
2606  llvm::PointerType::get(DeclTy,
2607  Context.getTargetAddressSpace(FD->getType())),
2608  false);
2609  else {
2610  ResolverType = DeclTy;
2611  ResolverGD = GD;
2612  }
2613 
2614  auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
2615  ResolverName, ResolverType, ResolverGD, /*ForVTable=*/false));
2616 
2618  const TargetInfo &Target = getTarget();
2619  unsigned Index = 0;
2620  for (const IdentifierInfo *II : DD->cpus()) {
2621  // Get the name of the target function so we can look it up/create it.
2622  std::string MangledName = getMangledNameImpl(*this, GD, FD, true) +
2623  getCPUSpecificMangling(*this, II->getName());
2624 
2625  llvm::Constant *Func = GetGlobalValue(MangledName);
2626 
2627  if (!Func) {
2628  GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
2629  if (ExistingDecl.getDecl() &&
2630  ExistingDecl.getDecl()->getAsFunction()->isDefined()) {
2631  EmitGlobalFunctionDefinition(ExistingDecl, nullptr);
2632  Func = GetGlobalValue(MangledName);
2633  } else {
2634  if (!ExistingDecl.getDecl())
2635  ExistingDecl = GD.getWithMultiVersionIndex(Index);
2636 
2637  Func = GetOrCreateLLVMFunction(
2638  MangledName, DeclTy, ExistingDecl,
2639  /*ForVTable=*/false, /*DontDefer=*/true,
2640  /*IsThunk=*/false, llvm::AttributeList(), ForDefinition);
2641  }
2642  }
2643 
2645  Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
2646  llvm::transform(Features, Features.begin(),
2647  [](StringRef Str) { return Str.substr(1); });
2648  Features.erase(std::remove_if(
2649  Features.begin(), Features.end(), [&Target](StringRef Feat) {
2650  return !Target.validateCpuSupports(Feat);
2651  }), Features.end());
2652  Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
2653  ++Index;
2654  }
2655 
2656  llvm::sort(
2657  Options, [](const CodeGenFunction::MultiVersionResolverOption &LHS,
2661  });
2662 
2663  // If the list contains multiple 'default' versions, such as when it contains
2664  // 'pentium' and 'generic', don't emit the call to the generic one (since we
2665  // always run on at least a 'pentium'). We do this by deleting the 'least
2666  // advanced' (read, lowest mangling letter).
2667  while (Options.size() > 1 &&
2669  (Options.end() - 2)->Conditions.Features) == 0) {
2670  StringRef LHSName = (Options.end() - 2)->Function->getName();
2671  StringRef RHSName = (Options.end() - 1)->Function->getName();
2672  if (LHSName.compare(RHSName) < 0)
2673  Options.erase(Options.end() - 2);
2674  else
2675  Options.erase(Options.end() - 1);
2676  }
2677 
2678  CodeGenFunction CGF(*this);
2679  CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2680 }
2681 
2682 /// If a dispatcher for the specified mangled name is not in the module, create
2683 /// and return an llvm Function with the specified type.
2684 llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
2685  GlobalDecl GD, llvm::Type *DeclTy, const FunctionDecl *FD) {
2686  std::string MangledName =
2687  getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
2688 
2689  // Holds the name of the resolver, in ifunc mode this is the ifunc (which has
2690  // a separate resolver).
2691  std::string ResolverName = MangledName;
2692  if (getTarget().supportsIFunc())
2693  ResolverName += ".ifunc";
2694  else if (FD->isTargetMultiVersion())
2695  ResolverName += ".resolver";
2696 
2697  // If this already exists, just return that one.
2698  if (llvm::GlobalValue *ResolverGV = GetGlobalValue(ResolverName))
2699  return ResolverGV;
2700 
2701  // Since this is the first time we've created this IFunc, make sure
2702  // that we put this multiversioned function into the list to be
2703  // replaced later if necessary (target multiversioning only).
2705  MultiVersionFuncs.push_back(GD);
2706 
2707  if (getTarget().supportsIFunc()) {
2708  llvm::Type *ResolverType = llvm::FunctionType::get(
2709  llvm::PointerType::get(
2710  DeclTy, getContext().getTargetAddressSpace(FD->getType())),
2711  false);
2712  llvm::Constant *Resolver = GetOrCreateLLVMFunction(
2713  MangledName + ".resolver", ResolverType, GlobalDecl{},
2714  /*ForVTable=*/false);
2715  llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
2716  DeclTy, 0, llvm::Function::ExternalLinkage, "", Resolver, &getModule());
2717  GIF->setName(ResolverName);
2718  SetCommonAttributes(FD, GIF);
2719 
2720  return GIF;
2721  }
2722 
2723  llvm::Constant *Resolver = GetOrCreateLLVMFunction(
2724  ResolverName, DeclTy, GlobalDecl{}, /*ForVTable=*/false);
2725  assert(isa<llvm::GlobalValue>(Resolver) &&
2726  "Resolver should be created for the first time");
2727  SetCommonAttributes(FD, cast<llvm::GlobalValue>(Resolver));
2728  return Resolver;
2729 }
2730 
2731 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
2732 /// module, create and return an llvm Function with the specified type. If there
2733 /// is something in the module with the specified name, return it potentially
2734 /// bitcasted to the right type.
2735 ///
2736 /// If D is non-null, it specifies a decl that correspond to this. This is used
2737 /// to set the attributes on the function when it is first created.
2738 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
2739  StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
2740  bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
2741  ForDefinition_t IsForDefinition) {
2742  const Decl *D = GD.getDecl();
2743 
2744  // Any attempts to use a MultiVersion function should result in retrieving
2745  // the iFunc instead. Name Mangling will handle the rest of the changes.
2746  if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
2747  // For the device mark the function as one that should be emitted.
2748  if (getLangOpts().OpenMPIsDevice && OpenMPRuntime &&
2749  !OpenMPRuntime->markAsGlobalTarget(GD) && FD->isDefined() &&
2750  !DontDefer && !IsForDefinition) {
2751  if (const FunctionDecl *FDDef = FD->getDefinition()) {
2752  GlobalDecl GDDef;
2753  if (const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
2754  GDDef = GlobalDecl(CD, GD.getCtorType());
2755  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
2756  GDDef = GlobalDecl(DD, GD.getDtorType());
2757  else
2758  GDDef = GlobalDecl(FDDef);
2759  EmitGlobal(GDDef);
2760  }
2761  }
2762 
2763  if (FD->isMultiVersion()) {
2764  const auto *TA = FD->getAttr<TargetAttr>();
2765  if (TA && TA->isDefaultVersion())
2766  UpdateMultiVersionNames(GD, FD);
2767  if (!IsForDefinition)
2768  return GetOrCreateMultiVersionResolver(GD, Ty, FD);
2769  }
2770  }
2771 
2772  // Lookup the entry, lazily creating it if necessary.
2773  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2774  if (Entry) {
2775  if (WeakRefReferences.erase(Entry)) {
2776  const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
2777  if (FD && !FD->hasAttr<WeakAttr>())
2778  Entry->setLinkage(llvm::Function::ExternalLinkage);
2779  }
2780 
2781  // Handle dropped DLL attributes.
2782  if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) {
2783  Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2784  setDSOLocal(Entry);
2785  }
2786 
2787  // If there are two attempts to define the same mangled name, issue an
2788  // error.
2789  if (IsForDefinition && !Entry->isDeclaration()) {
2790  GlobalDecl OtherGD;
2791  // Check that GD is not yet in DiagnosedConflictingDefinitions is required
2792  // to make sure that we issue an error only once.
2793  if (lookupRepresentativeDecl(MangledName, OtherGD) &&
2794  (GD.getCanonicalDecl().getDecl() !=
2795  OtherGD.getCanonicalDecl().getDecl()) &&
2796  DiagnosedConflictingDefinitions.insert(GD).second) {
2797  getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
2798  << MangledName;
2799  getDiags().Report(OtherGD.getDecl()->getLocation(),
2800  diag::note_previous_definition);
2801  }
2802  }
2803 
2804  if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
2805  (Entry->getType()->getElementType() == Ty)) {
2806  return Entry;
2807  }
2808 
2809  // Make sure the result is of the correct type.
2810  // (If function is requested for a definition, we always need to create a new
2811  // function, not just return a bitcast.)
2812  if (!IsForDefinition)
2813  return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
2814  }
2815 
2816  // This function doesn't have a complete type (for example, the return
2817  // type is an incomplete struct). Use a fake type instead, and make
2818  // sure not to try to set attributes.
2819  bool IsIncompleteFunction = false;
2820 
2821  llvm::FunctionType *FTy;
2822  if (isa<llvm::FunctionType>(Ty)) {
2823  FTy = cast<llvm::FunctionType>(Ty);
2824  } else {
2825  FTy = llvm::FunctionType::get(VoidTy, false);
2826  IsIncompleteFunction = true;
2827  }
2828 
2829  llvm::Function *F =
2831  Entry ? StringRef() : MangledName, &getModule());
2832 
2833  // If we already created a function with the same mangled name (but different
2834  // type) before, take its name and add it to the list of functions to be
2835  // replaced with F at the end of CodeGen.
2836  //
2837  // This happens if there is a prototype for a function (e.g. "int f()") and
2838  // then a definition of a different type (e.g. "int f(int x)").
2839  if (Entry) {
2840  F->takeName(Entry);
2841 
2842  // This might be an implementation of a function without a prototype, in
2843  // which case, try to do special replacement of calls which match the new
2844  // prototype. The really key thing here is that we also potentially drop
2845  // arguments from the call site so as to make a direct call, which makes the
2846  // inliner happier and suppresses a number of optimizer warnings (!) about
2847  // dropping arguments.
2848  if (!Entry->use_empty()) {
2850  Entry->removeDeadConstantUsers();
2851  }
2852 
2853  llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
2854  F, Entry->getType()->getElementType()->getPointerTo());
2855  addGlobalValReplacement(Entry, BC);
2856  }
2857 
2858  assert(F->getName() == MangledName && "name was uniqued!");
2859  if (D)
2860  SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
2861  if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
2862  llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
2863  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
2864  }
2865 
2866  if (!DontDefer) {
2867  // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
2868  // each other bottoming out with the base dtor. Therefore we emit non-base
2869  // dtors on usage, even if there is no dtor definition in the TU.
2870  if (D && isa<CXXDestructorDecl>(D) &&
2871  getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
2872  GD.getDtorType()))
2873  addDeferredDeclToEmit(GD);
2874 
2875  // This is the first use or definition of a mangled name. If there is a
2876  // deferred decl with this name, remember that we need to emit it at the end
2877  // of the file.
2878  auto DDI = DeferredDecls.find(MangledName);
2879  if (DDI != DeferredDecls.end()) {
2880  // Move the potentially referenced deferred decl to the
2881  // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
2882  // don't need it anymore).
2883  addDeferredDeclToEmit(DDI->second);
2884  DeferredDecls.erase(DDI);
2885 
2886  // Otherwise, there are cases we have to worry about where we're
2887  // using a declaration for which we must emit a definition but where
2888  // we might not find a top-level definition:
2889  // - member functions defined inline in their classes
2890  // - friend functions defined inline in some class
2891  // - special member functions with implicit definitions
2892  // If we ever change our AST traversal to walk into class methods,
2893  // this will be unnecessary.
2894  //
2895  // We also don't emit a definition for a function if it's going to be an
2896  // entry in a vtable, unless it's already marked as used.
2897  } else if (getLangOpts().CPlusPlus && D) {
2898  // Look for a declaration that's lexically in a record.
2899  for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
2900  FD = FD->getPreviousDecl()) {
2901  if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
2902  if (FD->doesThisDeclarationHaveABody()) {
2903  addDeferredDeclToEmit(GD.getWithDecl(FD));
2904  break;
2905  }
2906  }
2907  }
2908  }
2909  }
2910 
2911  // Make sure the result is of the requested type.
2912  if (!IsIncompleteFunction) {
2913  assert(F->getType()->getElementType() == Ty);
2914  return F;
2915  }
2916 
2917  llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2918  return llvm::ConstantExpr::getBitCast(F, PTy);
2919 }
2920 
2921 /// GetAddrOfFunction - Return the address of the given function. If Ty is
2922 /// non-null, then this function will use the specified type if it has to
2923 /// create it (this occurs when we see a definition of the function).
2925  llvm::Type *Ty,
2926  bool ForVTable,
2927  bool DontDefer,
2928  ForDefinition_t IsForDefinition) {
2929  // If there was no specific requested type, just convert it now.
2930  if (!Ty) {
2931  const auto *FD = cast<FunctionDecl>(GD.getDecl());
2932  Ty = getTypes().ConvertType(FD->getType());
2933  }
2934 
2935  // Devirtualized destructor calls may come through here instead of via
2936  // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead
2937  // of the complete destructor when necessary.
2938  if (const auto *DD = dyn_cast<CXXDestructorDecl>(GD.getDecl())) {
2939  if (getTarget().getCXXABI().isMicrosoft() &&
2940  GD.getDtorType() == Dtor_Complete &&
2941  DD->getParent()->getNumVBases() == 0)
2942  GD = GlobalDecl(DD, Dtor_Base);
2943  }
2944 
2945  StringRef MangledName = getMangledName(GD);
2946  return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
2947  /*IsThunk=*/false, llvm::AttributeList(),
2948  IsForDefinition);
2949 }
2950 
2951 static const FunctionDecl *
2952 GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) {
2955 
2956  IdentifierInfo &CII = C.Idents.get(Name);
2957  for (const auto &Result : DC->lookup(&CII))
2958  if (const auto FD = dyn_cast<FunctionDecl>(Result))
2959  return FD;
2960 
2961  if (!C.getLangOpts().CPlusPlus)
2962  return nullptr;
2963 
2964  // Demangle the premangled name from getTerminateFn()
2965  IdentifierInfo &CXXII =
2966  (Name == "_ZSt9terminatev" || Name == "?terminate@@YAXXZ")
2967  ? C.Idents.get("terminate")
2968  : C.Idents.get(Name);
2969 
2970  for (const auto &N : {"__cxxabiv1", "std"}) {
2971  IdentifierInfo &NS = C.Idents.get(N);
2972  for (const auto &Result : DC->lookup(&NS)) {
2973  NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
2974  if (auto LSD = dyn_cast<LinkageSpecDecl>(Result))
2975  for (const auto &Result : LSD->lookup(&NS))
2976  if ((ND = dyn_cast<NamespaceDecl>(Result)))
2977  break;
2978 
2979  if (ND)
2980  for (const auto &Result : ND->lookup(&CXXII))
2981  if (const auto *FD = dyn_cast<FunctionDecl>(Result))
2982  return FD;
2983  }
2984  }
2985 
2986  return nullptr;
2987 }
2988 
2989 /// CreateRuntimeFunction - Create a new runtime function with the specified
2990 /// type and name.
2991 llvm::FunctionCallee
2992 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
2993  llvm::AttributeList ExtraAttrs,
2994  bool Local) {
2995  llvm::Constant *C =
2996  GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
2997  /*DontDefer=*/false, /*IsThunk=*/false,
2998  ExtraAttrs);
2999 
3000  if (auto *F = dyn_cast<llvm::Function>(C)) {
3001  if (F->empty()) {
3002  F->setCallingConv(getRuntimeCC());
3003 
3004  if (!Local && getTriple().isOSBinFormatCOFF() &&
3005  !getCodeGenOpts().LTOVisibilityPublicStd &&
3006  !getTriple().isWindowsGNUEnvironment()) {
3007  const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
3008  if (!FD || FD->hasAttr<DLLImportAttr>()) {
3009  F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
3010  F->setLinkage(llvm::GlobalValue::ExternalLinkage);
3011  }
3012  }
3013  setDSOLocal(F);
3014  }
3015  }
3016 
3017  return {FTy, C};
3018 }
3019 
3020 /// isTypeConstant - Determine whether an object of this type can be emitted
3021 /// as a constant.
3022 ///
3023 /// If ExcludeCtor is true, the duration when the object's constructor runs
3024 /// will not be considered. The caller will need to verify that the object is
3025 /// not written to during its construction.
3026 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
3027  if (!Ty.isConstant(Context) && !Ty->isReferenceType())
3028  return false;
3029 
3030  if (Context.getLangOpts().CPlusPlus) {
3031  if (const CXXRecordDecl *Record
3032  = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
3033  return ExcludeCtor && !Record->hasMutableFields() &&
3034  Record->hasTrivialDestructor();
3035  }
3036 
3037  return true;
3038 }
3039 
3040 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
3041 /// create and return an llvm GlobalVariable with the specified type. If there
3042 /// is something in the module with the specified name, return it potentially
3043 /// bitcasted to the right type.
3044 ///
3045 /// If D is non-null, it specifies a decl that correspond to this. This is used
3046 /// to set the attributes on the global when it is first created.
3047 ///
3048 /// If IsForDefinition is true, it is guaranteed that an actual global with
3049 /// type Ty will be returned, not conversion of a variable with the same
3050 /// mangled name but some other type.
3051 llvm::Constant *
3052 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
3053  llvm::PointerType *Ty,
3054  const VarDecl *D,
3055  ForDefinition_t IsForDefinition) {
3056  // Lookup the entry, lazily creating it if necessary.
3057  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3058  if (Entry) {
3059  if (WeakRefReferences.erase(Entry)) {
3060  if (D && !D->hasAttr<WeakAttr>())
3061  Entry->setLinkage(llvm::Function::ExternalLinkage);
3062  }
3063 
3064  // Handle dropped DLL attributes.
3065  if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
3066  Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
3067 
3068  if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
3069  getOpenMPRuntime().registerTargetGlobalVariable(D, Entry);
3070 
3071  if (Entry->getType() == Ty)
3072  return Entry;
3073 
3074  // If there are two attempts to define the same mangled name, issue an
3075  // error.
3076  if (IsForDefinition && !Entry->isDeclaration()) {
3077  GlobalDecl OtherGD;
3078  const VarDecl *OtherD;
3079 
3080  // Check that D is not yet in DiagnosedConflictingDefinitions is required
3081  // to make sure that we issue an error only once.
3082  if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
3083  (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
3084  (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
3085  OtherD->hasInit() &&
3086  DiagnosedConflictingDefinitions.insert(D).second) {
3087  getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
3088  << MangledName;
3089  getDiags().Report(OtherGD.getDecl()->getLocation(),
3090  diag::note_previous_definition);
3091  }
3092  }
3093 
3094  // Make sure the result is of the correct type.
3095  if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
3096  return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
3097 
3098  // (If global is requested for a definition, we always need to create a new
3099  // global, not just return a bitcast.)
3100  if (!IsForDefinition)
3101  return llvm::ConstantExpr::getBitCast(Entry, Ty);
3102  }
3103 
3104  auto AddrSpace = GetGlobalVarAddressSpace(D);
3105  auto TargetAddrSpace = getContext().getTargetAddressSpace(AddrSpace);
3106 
3107  auto *GV = new llvm::GlobalVariable(
3108  getModule(), Ty->getElementType(), false,
3109  llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
3110  llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace);
3111 
3112  // If we already created a global with the same mangled name (but different
3113  // type) before, take its name and remove it from its parent.
3114  if (Entry) {
3115  GV->takeName(Entry);
3116 
3117  if (!Entry->use_empty()) {
3118  llvm::Constant *NewPtrForOldDecl =
3119  llvm::ConstantExpr::getBitCast(GV, Entry->getType());
3120  Entry->replaceAllUsesWith(NewPtrForOldDecl);
3121  }
3122 
3123  Entry->eraseFromParent();
3124  }
3125 
3126  // This is the first use or definition of a mangled name. If there is a
3127  // deferred decl with this name, remember that we need to emit it at the end
3128  // of the file.
3129  auto DDI = DeferredDecls.find(MangledName);
3130  if (DDI != DeferredDecls.end()) {
3131  // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
3132  // list, and remove it from DeferredDecls (since we don't need it anymore).
3133  addDeferredDeclToEmit(DDI->second);
3134  DeferredDecls.erase(DDI);
3135  }
3136 
3137  // Handle things which are present even on external declarations.
3138  if (D) {
3139  if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
3140  getOpenMPRuntime().registerTargetGlobalVariable(D, GV);
3141 
3142  // FIXME: This code is overly simple and should be merged with other global
3143  // handling.
3144  GV->setConstant(isTypeConstant(D->getType(), false));
3145 
3146  GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
3147 
3148  setLinkageForGV(GV, D);
3149 
3150  if (D->getTLSKind()) {
3151  if (D->getTLSKind() == VarDecl::TLS_Dynamic)
3152  CXXThreadLocals.push_back(D);
3153  setTLSMode(GV, *D);
3154  }
3155 
3156  setGVProperties(GV, D);
3157 
3158  // If required by the ABI, treat declarations of static data members with
3159  // inline initializers as definitions.
3160  if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
3161  EmitGlobalVarDefinition(D);
3162  }
3163 
3164  // Emit section information for extern variables.
3165  if (D->hasExternalStorage()) {
3166  if (const SectionAttr *SA = D->getAttr<SectionAttr>())
3167  GV->setSection(SA->getName());
3168  }
3169 
3170  // Handle XCore specific ABI requirements.
3171  if (getTriple().getArch() == llvm::Triple::xcore &&
3173  D->getType().isConstant(Context) &&
3175  GV->setSection(".cp.rodata");
3176 
3177  // Check if we a have a const declaration with an initializer, we may be
3178  // able to emit it as available_externally to expose it's value to the
3179  // optimizer.
3180  if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
3181  D->getType().isConstQualified() && !GV->hasInitializer() &&
3182  !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
3183  const auto *Record =
3184  Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
3185  bool HasMutableFields = Record && Record->hasMutableFields();
3186  if (!HasMutableFields) {
3187  const VarDecl *InitDecl;
3188  const Expr *InitExpr = D->getAnyInitializer(InitDecl);
3189  if (InitExpr) {
3190  ConstantEmitter emitter(*this);
3191  llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
3192  if (Init) {
3193  auto *InitType = Init->getType();
3194  if (GV->getType()->getElementType() != InitType) {
3195  // The type of the initializer does not match the definition.
3196  // This happens when an initializer has a different type from
3197  // the type of the global (because of padding at the end of a
3198  // structure for instance).
3199  GV->setName(StringRef());
3200  // Make a new global with the correct type, this is now guaranteed
3201  // to work.
3202  auto *NewGV = cast<llvm::GlobalVariable>(
3203  GetAddrOfGlobalVar(D, InitType, IsForDefinition));
3204 
3205  // Erase the old global, since it is no longer used.
3206  GV->eraseFromParent();
3207  GV = NewGV;
3208  } else {
3209  GV->setInitializer(Init);
3210  GV->setConstant(true);
3211  GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
3212  }
3213  emitter.finalize(GV);
3214  }
3215  }
3216  }
3217  }
3218  }
3219 
3220  LangAS ExpectedAS =
3221  D ? D->getType().getAddressSpace()
3222  : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
3223  assert(getContext().getTargetAddressSpace(ExpectedAS) ==
3224  Ty->getPointerAddressSpace());
3225  if (AddrSpace != ExpectedAS)
3226  return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace,
3227  ExpectedAS, Ty);
3228 
3229  if (GV->isDeclaration())
3230  getTargetCodeGenInfo().setTargetAttributes(D, GV, *this);
3231 
3232  return GV;
3233 }
3234 
3235 llvm::Constant *
3237  ForDefinition_t IsForDefinition) {
3238  const Decl *D = GD.getDecl();
3239  if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
3240  return getAddrOfCXXStructor(GD, /*FnInfo=*/nullptr, /*FnType=*/nullptr,
3241  /*DontDefer=*/false, IsForDefinition);
3242  else if (isa<CXXMethodDecl>(D)) {
3243  auto FInfo = &getTypes().arrangeCXXMethodDeclaration(
3244  cast<CXXMethodDecl>(D));
3245  auto Ty = getTypes().GetFunctionType(*FInfo);
3246  return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
3247  IsForDefinition);
3248  } else if (isa<FunctionDecl>(D)) {
3250  llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
3251  return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
3252  IsForDefinition);
3253  } else
3254  return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr,
3255  IsForDefinition);
3256 }
3257 
3259  StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
3260  unsigned Alignment) {
3261  llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
3262  llvm::GlobalVariable *OldGV = nullptr;
3263 
3264  if (GV) {
3265  // Check if the variable has the right type.
3266  if (GV->getType()->getElementType() == Ty)
3267  return GV;
3268 
3269  // Because C++ name mangling, the only way we can end up with an already
3270  // existing global with the same name is if it has been declared extern "C".
3271  assert(GV->isDeclaration() && "Declaration has wrong type!");
3272  OldGV = GV;
3273  }
3274 
3275  // Create a new variable.
3276  GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
3277  Linkage, nullptr, Name);
3278 
3279  if (OldGV) {
3280  // Replace occurrences of the old variable if needed.
3281  GV->takeName(OldGV);
3282 
3283  if (!OldGV->use_empty()) {
3284  llvm::Constant *NewPtrForOldDecl =
3285  llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3286  OldGV->replaceAllUsesWith(NewPtrForOldDecl);
3287  }
3288 
3289  OldGV->eraseFromParent();
3290  }
3291 
3292  if (supportsCOMDAT() && GV->isWeakForLinker() &&
3293  !GV->hasAvailableExternallyLinkage())
3294  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3295 
3296  GV->setAlignment(Alignment);
3297 
3298  return GV;
3299 }
3300 
3301 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
3302 /// given global variable. If Ty is non-null and if the global doesn't exist,
3303 /// then it will be created with the specified type instead of whatever the
3304 /// normal requested type would be. If IsForDefinition is true, it is guaranteed
3305 /// that an actual global with type Ty will be returned, not conversion of a
3306 /// variable with the same mangled name but some other type.
3308  llvm::Type *Ty,
3309  ForDefinition_t IsForDefinition) {
3310  assert(D->hasGlobalStorage() && "Not a global variable");
3311  QualType ASTTy = D->getType();
3312  if (!Ty)
3313  Ty = getTypes().ConvertTypeForMem(ASTTy);
3314 
3315  llvm::PointerType *PTy =
3316  llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
3317 
3318  StringRef MangledName = getMangledName(D);
3319  return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition);
3320 }
3321 
3322 /// CreateRuntimeVariable - Create a new runtime global variable with the
3323 /// specified type and name.
3324 llvm::Constant *
3326  StringRef Name) {
3327  auto *Ret =
3328  GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
3329  setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
3330  return Ret;
3331 }
3332 
3334  assert(!D->getInit() && "Cannot emit definite definitions here!");
3335 
3336  StringRef MangledName = getMangledName(D);
3337  llvm::GlobalValue *GV = GetGlobalValue(MangledName);
3338 
3339  // We already have a definition, not declaration, with the same mangled name.
3340  // Emitting of declaration is not required (and actually overwrites emitted
3341  // definition).
3342  if (GV && !GV->isDeclaration())
3343  return;
3344 
3345  // If we have not seen a reference to this variable yet, place it into the
3346  // deferred declarations table to be emitted if needed later.
3347  if (!MustBeEmitted(D) && !GV) {
3348  DeferredDecls[MangledName] = D;
3349  return;
3350  }
3351 
3352  // The tentative definition is the only definition.
3353  EmitGlobalVarDefinition(D);
3354 }
3355 
3357  return Context.toCharUnitsFromBits(
3358  getDataLayout().getTypeStoreSizeInBits(Ty));
3359 }
3360 
3362  LangAS AddrSpace = LangAS::Default;
3363  if (LangOpts.OpenCL) {
3364  AddrSpace = D ? D->getType().getAddressSpace() : LangAS::opencl_global;
3365  assert(AddrSpace == LangAS::opencl_global ||
3366  AddrSpace == LangAS::opencl_constant ||
3367  AddrSpace == LangAS::opencl_local ||
3368  AddrSpace >= LangAS::FirstTargetAddressSpace);
3369  return AddrSpace;
3370  }
3371 
3372  if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
3373  if (D && D->hasAttr<CUDAConstantAttr>())
3374  return LangAS::cuda_constant;
3375  else if (D && D->hasAttr<CUDASharedAttr>())
3376  return LangAS::cuda_shared;
3377  else if (D && D->hasAttr<CUDADeviceAttr>())
3378  return LangAS::cuda_device;
3379  else if (D && D->getType().isConstQualified())
3380  return LangAS::cuda_constant;
3381  else
3382  return LangAS::cuda_device;
3383  }
3384 
3385  if (LangOpts.OpenMP) {
3386  LangAS AS;
3387  if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
3388  return AS;
3389  }
3391 }
3392 
3394  // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
3395  if (LangOpts.OpenCL)
3396  return LangAS::opencl_constant;
3397  if (auto AS = getTarget().getConstantAddressSpace())
3398  return AS.getValue();
3399  return LangAS::Default;
3400 }
3401 
3402 // In address space agnostic languages, string literals are in default address
3403 // space in AST. However, certain targets (e.g. amdgcn) request them to be
3404 // emitted in constant address space in LLVM IR. To be consistent with other
3405 // parts of AST, string literal global variables in constant address space
3406 // need to be casted to default address space before being put into address
3407 // map and referenced by other part of CodeGen.
3408 // In OpenCL, string literals are in constant address space in AST, therefore
3409 // they should not be casted to default address space.
3410 static llvm::Constant *
3412  llvm::GlobalVariable *GV) {
3413  llvm::Constant *Cast = GV;
3414  if (!CGM.getLangOpts().OpenCL) {
3415  if (auto AS = CGM.getTarget().getConstantAddressSpace()) {
3416  if (AS != LangAS::Default)
3418  CGM, GV, AS.getValue(), LangAS::Default,
3419  GV->getValueType()->getPointerTo(
3421  }
3422  }
3423  return Cast;
3424 }
3425 
3426 template<typename SomeDecl>
3428  llvm::GlobalValue *GV) {
3429  if (!getLangOpts().CPlusPlus)
3430  return;
3431 
3432  // Must have 'used' attribute, or else inline assembly can't rely on
3433  // the name existing.
3434  if (!D->template hasAttr<UsedAttr>())
3435  return;
3436 
3437  // Must have internal linkage and an ordinary name.
3438  if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
3439  return;
3440 
3441  // Must be in an extern "C" context. Entities declared directly within
3442  // a record are not extern "C" even if the record is in such a context.
3443  const SomeDecl *First = D->getFirstDecl();
3444  if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
3445  return;
3446 
3447  // OK, this is an internal linkage entity inside an extern "C" linkage
3448  // specification. Make a note of that so we can give it the "expected"
3449  // mangled name if nothing else is using that name.
3450  std::pair<StaticExternCMap::iterator, bool> R =
3451  StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
3452 
3453  // If we have multiple internal linkage entities with the same name
3454  // in extern "C" regions, none of them gets that name.
3455  if (!R.second)
3456  R.first->second = nullptr;
3457 }
3458 
3459 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
3460  if (!CGM.supportsCOMDAT())
3461  return false;
3462 
3463  if (D.hasAttr<SelectAnyAttr>())
3464  return true;
3465 
3467  if (auto *VD = dyn_cast<VarDecl>(&D))
3468  Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
3469  else
3470  Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
3471 
3472  switch (Linkage) {
3473  case GVA_Internal:
3475  case GVA_StrongExternal:
3476  return false;
3477  case GVA_DiscardableODR:
3478  case GVA_StrongODR:
3479  return true;
3480  }
3481  llvm_unreachable("No such linkage");
3482 }
3483 
3485  llvm::GlobalObject &GO) {
3486  if (!shouldBeInCOMDAT(*this, D))
3487  return;
3488  GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
3489 }
3490 
3491 /// Pass IsTentative as true if you want to create a tentative definition.
3492 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
3493  bool IsTentative) {
3494  // OpenCL global variables of sampler type are translated to function calls,
3495  // therefore no need to be translated.
3496  QualType ASTTy = D->getType();
3497  if (getLangOpts().OpenCL && ASTTy->isSamplerT())
3498  return;
3499 
3500  // If this is OpenMP device, check if it is legal to emit this global
3501  // normally.
3502  if (LangOpts.OpenMPIsDevice && OpenMPRuntime &&
3503  OpenMPRuntime->emitTargetGlobalVariable(D))
3504  return;
3505 
3506  llvm::Constant *Init = nullptr;
3508  bool NeedsGlobalCtor = false;
3509  bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
3510 
3511  const VarDecl *InitDecl;
3512  const Expr *InitExpr = D->getAnyInitializer(InitDecl);
3513 
3514  Optional<ConstantEmitter> emitter;
3515 
3516  // CUDA E.2.4.1 "__shared__ variables cannot have an initialization
3517  // as part of their declaration." Sema has already checked for
3518  // error cases, so we just need to set Init to UndefValue.
3519  bool IsCUDASharedVar =
3520  getLangOpts().CUDAIsDevice && D->hasAttr<CUDASharedAttr>();
3521  // Shadows of initialized device-side global variables are also left
3522  // undefined.
3523  bool IsCUDAShadowVar =
3524  !getLangOpts().CUDAIsDevice &&
3525  (D->hasAttr<CUDAConstantAttr>() || D->hasAttr<CUDADeviceAttr>() ||
3526  D->hasAttr<CUDASharedAttr>());
3527  if (getLangOpts().CUDA && (IsCUDASharedVar || IsCUDAShadowVar))
3528  Init = llvm::UndefValue::get(getTypes().ConvertType(ASTTy));
3529  else if (!InitExpr) {
3530  // This is a tentative definition; tentative definitions are
3531  // implicitly initialized with { 0 }.
3532  //
3533  // Note that tentative definitions are only emitted at the end of
3534  // a translation unit, so they should never have incomplete
3535  // type. In addition, EmitTentativeDefinition makes sure that we
3536  // never attempt to emit a tentative definition if a real one
3537  // exists. A use may still exists, however, so we still may need
3538  // to do a RAUW.
3539  assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
3540  Init = EmitNullConstant(D->getType());
3541  } else {
3542  initializedGlobalDecl = GlobalDecl(D);
3543  emitter.emplace(*this);
3544  Init = emitter->tryEmitForInitializer(*InitDecl);
3545 
3546  if (!Init) {
3547  QualType T = InitExpr->getType();
3548  if (D->getType()->isReferenceType())
3549  T = D->getType();
3550 
3551  if (getLangOpts().CPlusPlus) {
3552  Init = EmitNullConstant(T);
3553  NeedsGlobalCtor = true;
3554  } else {
3555  ErrorUnsupported(D, "static initializer");
3556  Init = llvm::UndefValue::get(getTypes().ConvertType(T));
3557  }
3558  } else {
3559  // We don't need an initializer, so remove the entry for the delayed
3560  // initializer position (just in case this entry was delayed) if we
3561  // also don't need to register a destructor.
3562  if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
3563  DelayedCXXInitPosition.erase(D);
3564  }
3565  }
3566 
3567  llvm::Type* InitType = Init->getType();
3568  llvm::Constant *Entry =
3569  GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative));
3570 
3571  // Strip off a bitcast if we got one back.
3572  if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
3573  assert(CE->getOpcode() == llvm::Instruction::BitCast ||
3574  CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
3575  // All zero index gep.
3576  CE->getOpcode() == llvm::Instruction::GetElementPtr);
3577  Entry = CE->getOperand(0);
3578  }
3579 
3580  // Entry is now either a Function or GlobalVariable.
3581  auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
3582 
3583  // We have a definition after a declaration with the wrong type.
3584  // We must make a new GlobalVariable* and update everything that used OldGV
3585  // (a declaration or tentative definition) with the new GlobalVariable*
3586  // (which will be a definition).
3587  //
3588  // This happens if there is a prototype for a global (e.g.
3589  // "extern int x[];") and then a definition of a different type (e.g.
3590  // "int x[10];"). This also happens when an initializer has a different type
3591  // from the type of the global (this happens with unions).
3592  if (!GV || GV->getType()->getElementType() != InitType ||
3593  GV->getType()->getAddressSpace() !=
3595 
3596  // Move the old entry aside so that we'll create a new one.
3597  Entry->setName(StringRef());
3598 
3599  // Make a new global with the correct type, this is now guaranteed to work.
3600  GV = cast<llvm::GlobalVariable>(
3601  GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative)));
3602 
3603  // Replace all uses of the old global with the new global
3604  llvm::Constant *NewPtrForOldDecl =
3605  llvm::ConstantExpr::getBitCast(GV, Entry->getType());
3606  Entry->replaceAllUsesWith(NewPtrForOldDecl);
3607 
3608  // Erase the old global, since it is no longer used.
3609  cast<llvm::GlobalValue>(Entry)->eraseFromParent();
3610  }
3611 
3613 
3614  if (D->hasAttr<AnnotateAttr>())
3615  AddGlobalAnnotations(D, GV);
3616 
3617  // Set the llvm linkage type as appropriate.
3618  llvm::GlobalValue::LinkageTypes Linkage =
3619  getLLVMLinkageVarDefinition(D, GV->isConstant());
3620 
3621  // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
3622  // the device. [...]"
3623  // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
3624  // __device__, declares a variable that: [...]
3625  // Is accessible from all the threads within the grid and from the host
3626  // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize()
3627  // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())."
3628  if (GV && LangOpts.CUDA) {
3629  if (LangOpts.CUDAIsDevice) {
3630  if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>())
3631  GV->setExternallyInitialized(true);
3632  } else {
3633  // Host-side shadows of external declarations of device-side
3634  // global variables become internal definitions. These have to
3635  // be internal in order to prevent name conflicts with global
3636  // host variables with the same name in a different TUs.
3637  if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) {
3639 
3640  // Shadow variables and their properties must be registered
3641  // with CUDA runtime.
3642  unsigned Flags = 0;
3643  if (!D->hasDefinition())
3645  if (D->hasAttr<CUDAConstantAttr>())
3647  // Extern global variables will be registered in the TU where they are
3648  // defined.
3649  if (!D->hasExternalStorage())
3650  getCUDARuntime().registerDeviceVar(D, *GV, Flags);
3651  } else if (D->hasAttr<CUDASharedAttr>())
3652  // __shared__ variables are odd. Shadows do get created, but
3653  // they are not registered with the CUDA runtime, so they
3654  // can't really be used to access their device-side
3655  // counterparts. It's not clear yet whether it's nvcc's bug or
3656  // a feature, but we've got to do the same for compatibility.
3658  }
3659  }
3660 
3661  GV->setInitializer(Init);
3662  if (emitter) emitter->finalize(GV);
3663 
3664  // If it is safe to mark the global 'constant', do so now.
3665  GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
3666  isTypeConstant(D->getType(), true));
3667 
3668  // If it is in a read-only section, mark it 'constant'.
3669  if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
3670  const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
3671  if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
3672  GV->setConstant(true);
3673  }
3674 
3675  GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
3676 
3677 
3678  // On Darwin, if the normal linkage of a C++ thread_local variable is
3679  // LinkOnce or Weak, we keep the normal linkage to prevent multiple
3680  // copies within a linkage unit; otherwise, the backing variable has
3681  // internal linkage and all accesses should just be calls to the
3682  // Itanium-specified entry point, which has the normal linkage of the
3683  // variable. This is to preserve the ability to change the implementation
3684  // behind the scenes.
3685  if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
3686  Context.getTargetInfo().getTriple().isOSDarwin() &&
3687  !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
3688  !llvm::GlobalVariable::isWeakLinkage(Linkage))
3690 
3691  GV->setLinkage(Linkage);
3692  if (D->hasAttr<DLLImportAttr>())
3693  GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
3694  else if (D->hasAttr<DLLExportAttr>())
3695  GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
3696  else
3697  GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
3698 
3699  if (Linkage == llvm::GlobalVariable::CommonLinkage) {
3700  // common vars aren't constant even if declared const.
3701  GV->setConstant(false);
3702  // Tentative definition of global variables may be initialized with
3703  // non-zero null pointers. In this case they should have weak linkage
3704  // since common linkage must have zero initializer and must not have
3705  // explicit section therefore cannot have non-zero initial value.
3706  if (!GV->getInitializer()->isNullValue())
3707  GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
3708  }
3709 
3710  setNonAliasAttributes(D, GV);
3711 
3712  if (D->getTLSKind() && !GV->isThreadLocal()) {
3713  if (D->getTLSKind() == VarDecl::TLS_Dynamic)
3714  CXXThreadLocals.push_back(D);
3715  setTLSMode(GV, *D);
3716  }
3717 
3718  maybeSetTrivialComdat(*D, *GV);
3719 
3720  // Emit the initializer function if necessary.
3721  if (NeedsGlobalCtor || NeedsGlobalDtor)
3722  EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
3723 
3724  SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
3725 
3726  // Emit global variable debug information.
3727  if (CGDebugInfo *DI = getModuleDebugInfo())
3728  if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
3729  DI->EmitGlobalVariable(GV, D);
3730 }
3731 
3732 static bool isVarDeclStrongDefinition(const ASTContext &Context,
3733  CodeGenModule &CGM, const VarDecl *D,
3734  bool NoCommon) {
3735  // Don't give variables common linkage if -fno-common was specified unless it
3736  // was overridden by a NoCommon attribute.
3737  if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
3738  return true;
3739 
3740  // C11 6.9.2/2:
3741  // A declaration of an identifier for an object that has file scope without
3742  // an initializer, and without a storage-class specifier or with the
3743  // storage-class specifier static, constitutes a tentative definition.
3744  if (D->getInit() || D->hasExternalStorage())
3745  return true;
3746 
3747  // A variable cannot be both common and exist in a section.
3748  if (D->hasAttr<SectionAttr>())
3749  return true;
3750 
3751  // A variable cannot be both common and exist in a section.
3752  // We don't try to determine which is the right section in the front-end.
3753  // If no specialized section name is applicable, it will resort to default.
3754  if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
3755  D->hasAttr<PragmaClangDataSectionAttr>() ||
3756  D->hasAttr<PragmaClangRodataSectionAttr>())
3757  return true;
3758 
3759  // Thread local vars aren't considered common linkage.
3760  if (D->getTLSKind())
3761  return true;
3762 
3763  // Tentative definitions marked with WeakImportAttr are true definitions.
3764  if (D->hasAttr<WeakImportAttr>())
3765  return true;
3766 
3767  // A variable cannot be both common and exist in a comdat.
3768  if (shouldBeInCOMDAT(CGM, *D))
3769  return true;
3770 
3771  // Declarations with a required alignment do not have common linkage in MSVC
3772  // mode.
3773  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
3774  if (D->hasAttr<AlignedAttr>())
3775  return true;
3776  QualType VarType = D->getType();
3777  if (Context.isAlignmentRequired(VarType))
3778  return true;
3779 
3780  if (const auto *RT = VarType->getAs<RecordType>()) {
3781  const RecordDecl *RD = RT->getDecl();
3782  for (const FieldDecl *FD : RD->fields()) {
3783  if (FD->isBitField())
3784  continue;
3785  if (FD->hasAttr<AlignedAttr>())
3786  return true;
3787  if (Context.isAlignmentRequired(FD->getType()))
3788  return true;
3789  }
3790  }
3791  }
3792 
3793  // Microsoft's link.exe doesn't support alignments greater than 32 bytes for
3794  // common symbols, so symbols with greater alignment requirements cannot be
3795  // common.
3796  // Other COFF linkers (ld.bfd and LLD) support arbitrary power-of-two
3797  // alignments for common symbols via the aligncomm directive, so this
3798  // restriction only applies to MSVC environments.
3799  if (Context.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
3800  Context.getTypeAlignIfKnown(D->getType()) >
3801  Context.toBits(CharUnits::fromQuantity(32)))
3802  return true;
3803 
3804  return false;
3805 }
3806 
3807 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
3808  const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
3809  if (Linkage == GVA_Internal)
3811 
3812  if (D->hasAttr<WeakAttr>()) {
3813  if (IsConstantVariable)
3814  return llvm::GlobalVariable::WeakODRLinkage;
3815  else
3816  return llvm::GlobalVariable::WeakAnyLinkage;
3817  }
3818 
3819  if (const auto *FD = D->getAsFunction())
3820  if (FD->isMultiVersion() && Linkage == GVA_AvailableExternally)
3821  return llvm::GlobalVariable::LinkOnceAnyLinkage;
3822 
3823  // We are guaranteed to have a strong definition somewhere else,
3824  // so we can use available_externally linkage.
3825  if (Linkage == GVA_AvailableExternally)
3826  return llvm::GlobalValue::AvailableExternallyLinkage;
3827 
3828  // Note that Apple's kernel linker doesn't support symbol
3829  // coalescing, so we need to avoid linkonce and weak linkages there.
3830  // Normally, this means we just map to internal, but for explicit
3831  // instantiations we'll map to external.
3832 
3833  // In C++, the compiler has to emit a definition in every translation unit
3834  // that references the function. We should use linkonce_odr because
3835  // a) if all references in this translation unit are optimized away, we
3836  // don't need to codegen it. b) if the function persists, it needs to be
3837  // merged with other definitions. c) C++ has the ODR, so we know the
3838  // definition is dependable.
3839  if (Linkage == GVA_DiscardableODR)
3840  return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
3842 
3843  // An explicit instantiation of a template has weak linkage, since
3844  // explicit instantiations can occur in multiple translation units
3845  // and must all be equivalent. However, we are not allowed to
3846  // throw away these explicit instantiations.
3847  //
3848  // We don't currently support CUDA device code spread out across multiple TUs,
3849  // so say that CUDA templates are either external (for kernels) or internal.
3850  // This lets llvm perform aggressive inter-procedural optimizations.
3851  if (Linkage == GVA_StrongODR) {
3852  if (Context.getLangOpts().AppleKext)
3854  if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice)
3855  return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
3857  return llvm::Function::WeakODRLinkage;
3858  }
3859 
3860  // C++ doesn't have tentative definitions and thus cannot have common
3861  // linkage.
3862  if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
3863  !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
3864  CodeGenOpts.NoCommon))
3865  return llvm::GlobalVariable::CommonLinkage;
3866 
3867  // selectany symbols are externally visible, so use weak instead of
3868  // linkonce. MSVC optimizes away references to const selectany globals, so
3869  // all definitions should be the same and ODR linkage should be used.
3870  // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
3871  if (D->hasAttr<SelectAnyAttr>())
3872  return llvm::GlobalVariable::WeakODRLinkage;
3873 
3874  // Otherwise, we have strong external linkage.
3875  assert(Linkage == GVA_StrongExternal);
3877 }
3878 
3879 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
3880  const VarDecl *VD, bool IsConstant) {
3882  return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
3883 }
3884 
3885 /// Replace the uses of a function that was declared with a non-proto type.
3886 /// We want to silently drop extra arguments from call sites
3887 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
3888  llvm::Function *newFn) {
3889  // Fast path.
3890  if (old->use_empty()) return;
3891 
3892  llvm::Type *newRetTy = newFn->getReturnType();
3895 
3896  for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
3897  ui != ue; ) {
3898  llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
3899  llvm::User *user = use->getUser();
3900 
3901  // Recognize and replace uses of bitcasts. Most calls to
3902  // unprototyped functions will use bitcasts.
3903  if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
3904  if (bitcast->getOpcode() == llvm::Instruction::BitCast)
3905  replaceUsesOfNonProtoConstant(bitcast, newFn);
3906  continue;
3907  }
3908 
3909  // Recognize calls to the function.
3910  llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
3911  if (!callSite) continue;
3912  if (!callSite->isCallee(&*use))
3913  continue;
3914 
3915  // If the return types don't match exactly, then we can't
3916  // transform this call unless it's dead.
3917  if (callSite->getType() != newRetTy && !callSite->use_empty())
3918  continue;
3919 
3920  // Get the call site's attribute list.
3922  llvm::AttributeList oldAttrs = callSite->getAttributes();
3923 
3924  // If the function was passed too few arguments, don't transform.
3925  unsigned newNumArgs = newFn->arg_size();
3926  if (callSite->arg_size() < newNumArgs)
3927  continue;
3928 
3929  // If extra arguments were passed, we silently drop them.
3930  // If any of the types mismatch, we don't transform.
3931  unsigned argNo = 0;
3932  bool dontTransform = false;
3933  for (llvm::Argument &A : newFn->args()) {
3934  if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
3935  dontTransform = true;
3936  break;
3937  }
3938 
3939  // Add any parameter attributes.
3940  newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo));
3941  argNo++;
3942  }
3943  if (dontTransform)
3944  continue;
3945 
3946  // Okay, we can transform this. Create the new call instruction and copy
3947  // over the required information.
3948  newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
3949 
3950  // Copy over any operand bundles.
3951  callSite->getOperandBundlesAsDefs(newBundles);
3952 
3953  llvm::CallBase *newCall;
3954  if (dyn_cast<llvm::CallInst>(callSite)) {
3955  newCall =
3956  llvm::CallInst::Create(newFn, newArgs, newBundles, "", callSite);
3957  } else {
3958  auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
3959  newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(),
3960  oldInvoke->getUnwindDest(), newArgs,
3961  newBundles, "", callSite);
3962  }
3963  newArgs.clear(); // for the next iteration
3964 
3965  if (!newCall->getType()->isVoidTy())
3966  newCall->takeName(callSite);
3967  newCall->setAttributes(llvm::AttributeList::get(
3968  newFn->getContext(), oldAttrs.getFnAttributes(),
3969  oldAttrs.getRetAttributes(), newArgAttrs));
3970  newCall->setCallingConv(callSite->getCallingConv());
3971 
3972  // Finally, remove the old call, replacing any uses with the new one.
3973  if (!callSite->use_empty())
3974  callSite->replaceAllUsesWith(newCall);
3975 
3976  // Copy debug location attached to CI.
3977  if (callSite->getDebugLoc())
3978  newCall->setDebugLoc(callSite->getDebugLoc());
3979 
3980  callSite->eraseFromParent();
3981  }
3982 }
3983 
3984 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
3985 /// implement a function with no prototype, e.g. "int foo() {}". If there are
3986 /// existing call uses of the old function in the module, this adjusts them to
3987 /// call the new function directly.
3988 ///
3989 /// This is not just a cleanup: the always_inline pass requires direct calls to
3990 /// functions to be able to inline them. If there is a bitcast in the way, it
3991 /// won't inline them. Instcombine normally deletes these calls, but it isn't
3992 /// run at -O0.
3993 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
3994  llvm::Function *NewFn) {
3995  // If we're redefining a global as a function, don't transform it.
3996  if (!isa<llvm::Function>(Old)) return;
3997 
3998  replaceUsesOfNonProtoConstant(Old, NewFn);
3999 }
4000 
4002  auto DK = VD->isThisDeclarationADefinition();
4003  if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>())
4004  return;
4005 
4007  // If we have a definition, this might be a deferred decl. If the
4008  // instantiation is explicit, make sure we emit it at the end.
4010  GetAddrOfGlobalVar(VD);
4011 
4012  EmitTopLevelDecl(VD);
4013 }
4014 
4015 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
4016  llvm::GlobalValue *GV) {
4017  const auto *D = cast<FunctionDecl>(GD.getDecl());
4018 
4019  // Compute the function info and LLVM type.
4021  llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
4022 
4023  // Get or create the prototype for the function.
4024  if (!GV || (GV->getType()->getElementType() != Ty))
4025  GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
4026  /*DontDefer=*/true,
4027  ForDefinition));
4028 
4029  // Already emitted.
4030  if (!GV->isDeclaration())
4031  return;
4032 
4033  // We need to set linkage and visibility on the function before
4034  // generating code for it because various parts of IR generation
4035  // want to propagate this information down (e.g. to local static
4036  // declarations).
4037  auto *Fn = cast<llvm::Function>(GV);
4038  setFunctionLinkage(GD, Fn);
4039 
4040  // FIXME: this is redundant with part of setFunctionDefinitionAttributes
4041  setGVProperties(Fn, GD);
4042 
4044 
4045 
4046  maybeSetTrivialComdat(*D, *Fn);
4047 
4048  CodeGenFunction(*this).GenerateCode(D, Fn, FI);
4049 
4050  setNonAliasAttributes(GD, Fn);
4052 
4053  if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
4054  AddGlobalCtor(Fn, CA->getPriority());
4055  if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
4056  AddGlobalDtor(Fn, DA->getPriority());
4057  if (D->hasAttr<AnnotateAttr>())
4058  AddGlobalAnnotations(D, Fn);
4059 }
4060 
4061 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
4062  const auto *D = cast<ValueDecl>(GD.getDecl());
4063  const AliasAttr *AA = D->getAttr<AliasAttr>();
4064  assert(AA && "Not an alias?");
4065 
4066  StringRef MangledName = getMangledName(GD);
4067 
4068  if (AA->getAliasee() == MangledName) {
4069  Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
4070  return;
4071  }
4072 
4073  // If there is a definition in the module, then it wins over the alias.
4074  // This is dubious, but allow it to be safe. Just ignore the alias.
4075  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
4076  if (Entry && !Entry->isDeclaration())
4077  return;
4078 
4079  Aliases.push_back(GD);
4080 
4081  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
4082 
4083  // Create a reference to the named value. This ensures that it is emitted
4084  // if a deferred decl.
4085  llvm::Constant *Aliasee;
4086  if (isa<llvm::FunctionType>(DeclTy))
4087  Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
4088  /*ForVTable=*/false);
4089  else
4090  Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
4091  llvm::PointerType::getUnqual(DeclTy),
4092  /*D=*/nullptr);
4093 
4094  // Create the new alias itself, but don't set a name yet.
4095  auto *GA = llvm::GlobalAlias::create(
4096  DeclTy, 0, llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
4097 
4098  if (Entry) {
4099  if (GA->getAliasee() == Entry) {
4100  Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
4101  return;
4102  }
4103 
4104  assert(Entry->isDeclaration());
4105 
4106  // If there is a declaration in the module, then we had an extern followed
4107  // by the alias, as in:
4108  // extern int test6();
4109  // ...
4110  // int test6() __attribute__((alias("test7")));
4111  //
4112  // Remove it and replace uses of it with the alias.
4113  GA->takeName(Entry);
4114 
4115  Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
4116  Entry->getType()));
4117  Entry->eraseFromParent();
4118  } else {
4119  GA->setName(MangledName);
4120  }
4121 
4122  // Set attributes which are particular to an alias; this is a
4123  // specialization of the attributes which may be set on a global
4124  // variable/function.
4125  if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
4126  D->isWeakImported()) {
4127  GA->setLinkage(llvm::Function::WeakAnyLinkage);
4128  }
4129 
4130  if (const auto *VD = dyn_cast<VarDecl>(D))
4131  if (VD->getTLSKind())
4132  setTLSMode(GA, *VD);
4133 
4134  SetCommonAttributes(GD, GA);
4135 }
4136 
4137 void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
4138  const auto *D = cast<ValueDecl>(GD.getDecl());
4139  const IFuncAttr *IFA = D->getAttr<IFuncAttr>();
4140  assert(IFA && "Not an ifunc?");
4141 
4142  StringRef MangledName = getMangledName(GD);
4143 
4144  if (IFA->getResolver() == MangledName) {
4145  Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
4146  return;
4147  }
4148 
4149  // Report an error if some definition overrides ifunc.
4150  llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
4151  if (Entry && !Entry->isDeclaration()) {
4152  GlobalDecl OtherGD;
4153  if (lookupRepresentativeDecl(MangledName, OtherGD) &&
4154  DiagnosedConflictingDefinitions.insert(GD).second) {
4155  Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name)
4156  << MangledName;
4157  Diags.Report(OtherGD.getDecl()->getLocation(),
4158  diag::note_previous_definition);
4159  }
4160  return;
4161  }
4162 
4163  Aliases.push_back(GD);
4164 
4165  llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
4166  llvm::Constant *Resolver =
4167  GetOrCreateLLVMFunction(IFA->getResolver(), DeclTy, GD,
4168  /*ForVTable=*/false);
4169  llvm::GlobalIFunc *GIF =
4171  "", Resolver, &getModule());
4172  if (Entry) {
4173  if (GIF->getResolver() == Entry) {
4174  Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
4175  return;
4176  }
4177  assert(Entry->isDeclaration());
4178 
4179  // If there is a declaration in the module, then we had an extern followed
4180  // by the ifunc, as in:
4181  // extern int test();
4182  // ...
4183  // int test() __attribute__((ifunc("resolver")));
4184  //
4185  // Remove it and replace uses of it with the ifunc.
4186  GIF->takeName(Entry);
4187 
4188  Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF,
4189  Entry->getType()));
4190  Entry->eraseFromParent();
4191  } else
4192  GIF->setName(MangledName);
4193 
4194  SetCommonAttributes(GD, GIF);
4195 }
4196 
4197 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
4198  ArrayRef<llvm::Type*> Tys) {
4199  return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
4200  Tys);
4201 }
4202 
4203 static llvm::StringMapEntry<llvm::GlobalVariable *> &
4204 GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
4205  const StringLiteral *Literal, bool TargetIsLSB,
4206  bool &IsUTF16, unsigned &StringLength) {
4207  StringRef String = Literal->getString();
4208  unsigned NumBytes = String.size();
4209 
4210  // Check for simple case.
4211  if (!Literal->containsNonAsciiOrNull()) {
4212  StringLength = NumBytes;
4213  return *Map.insert(std::make_pair(String, nullptr)).first;
4214  }
4215 
4216  // Otherwise, convert the UTF8 literals into a string of shorts.
4217  IsUTF16 = true;
4218 
4219  SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
4220  const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
4221  llvm::UTF16 *ToPtr = &ToBuf[0];
4222 
4223  (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
4224  ToPtr + NumBytes, llvm::strictConversion);
4225 
4226  // ConvertUTF8toUTF16 returns the length in ToPtr.
4227  StringLength = ToPtr - &ToBuf[0];
4228 
4229  // Add an explicit null.
4230  *ToPtr = 0;
4231  return *Map.insert(std::make_pair(
4232  StringRef(reinterpret_cast<const char *>(ToBuf.data()),
4233  (StringLength + 1) * 2),
4234  nullptr)).first;
4235 }
4236 
4239  unsigned StringLength = 0;
4240  bool isUTF16 = false;
4241  llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
4242  GetConstantCFStringEntry(CFConstantStringMap, Literal,
4243  getDataLayout().isLittleEndian(), isUTF16,
4244  StringLength);
4245 
4246  if (auto *C = Entry.second)
4247  return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
4248 
4249  llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
4250  llvm::Constant *Zeros[] = { Zero, Zero };
4251 
4252  const ASTContext &Context = getContext();
4253  const llvm::Triple &Triple = getTriple();
4254 
4255  const auto CFRuntime = getLangOpts().CFRuntime;
4256  const bool IsSwiftABI =
4257  static_cast<unsigned>(CFRuntime) >=
4258  static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift);
4259  const bool IsSwift4_1 = CFRuntime == LangOptions::CoreFoundationABI::Swift4_1;
4260 
4261  // If we don't already have it, get __CFConstantStringClassReference.
4262  if (!CFConstantStringClassRef) {
4263  const char *CFConstantStringClassName = "__CFConstantStringClassReference";
4265  Ty = llvm::ArrayType::get(Ty, 0);
4266 
4267  switch (CFRuntime) {
4268  default: break;
4269  case LangOptions::CoreFoundationABI::Swift: LLVM_FALLTHROUGH;
4271  CFConstantStringClassName =
4272  Triple.isOSDarwin() ? "$s15SwiftFoundation19_NSCFConstantStringCN"
4273  : "$s10Foundation19_NSCFConstantStringCN";
4274  Ty = IntPtrTy;
4275  break;
4277  CFConstantStringClassName =
4278  Triple.isOSDarwin() ? "$S15SwiftFoundation19_NSCFConstantStringCN"
4279  : "$S10Foundation19_NSCFConstantStringCN";
4280  Ty = IntPtrTy;
4281  break;
4283  CFConstantStringClassName =
4284  Triple.isOSDarwin() ? "__T015SwiftFoundation19_NSCFConstantStringCN"
4285  : "__T010Foundation19_NSCFConstantStringCN";
4286  Ty = IntPtrTy;
4287  break;
4288  }
4289 
4290  llvm::Constant *C = CreateRuntimeVariable(Ty, CFConstantStringClassName);
4291 
4292  if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
4293  llvm::GlobalValue *GV = nullptr;
4294 
4295  if ((GV = dyn_cast<llvm::GlobalValue>(C))) {
4296  IdentifierInfo &II = Context.Idents.get(GV->getName());
4297  TranslationUnitDecl *TUDecl = Context.getTranslationUnitDecl();
4299 
4300  const VarDecl *VD = nullptr;
4301  for (const auto &Result : DC->lookup(&II))
4302  if ((VD = dyn_cast<VarDecl>(Result)))
4303  break;
4304 
4305  if (Triple.isOSBinFormatELF()) {
4306  if (!VD)
4307  GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4308  } else {
4309  GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4310  if (!VD || !VD->hasAttr<DLLExportAttr>())
4311  GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4312  else
4313  GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
4314  }
4315 
4316  setDSOLocal(GV);
4317  }
4318  }
4319 
4320  // Decay array -> ptr
4321  CFConstantStringClassRef =
4322  IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(C, Ty)
4323  : llvm::ConstantExpr::getGetElementPtr(Ty, C, Zeros);
4324  }
4325 
4326  QualType CFTy = Context.getCFConstantStringType();
4327 
4328  auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
4329 
4330  ConstantInitBuilder Builder(*this);
4331  auto Fields = Builder.beginStruct(STy);
4332 
4333  // Class pointer.
4334  Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef));
4335 
4336  // Flags.
4337  if (IsSwiftABI) {
4338  Fields.addInt(IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
4339  Fields.addInt(Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
4340  } else {
4341  Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8);
4342  }
4343 
4344  // String pointer.
4345  llvm::Constant *C = nullptr;
4346  if (isUTF16) {
4347  auto Arr = llvm::makeArrayRef(
4348  reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
4349  Entry.first().size() / 2);
4350  C = llvm::ConstantDataArray::get(VMContext, Arr);
4351  } else {
4352  C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
4353  }
4354 
4355  // Note: -fwritable-strings doesn't make the backing store strings of
4356  // CFStrings writable. (See <rdar://problem/10657500>)
4357  auto *GV =
4358  new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
4359  llvm::GlobalValue::PrivateLinkage, C, ".str");
4360  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4361  // Don't enforce the target's minimum global alignment, since the only use
4362  // of the string is via this class initializer.
4363  CharUnits Align = isUTF16 ? Context.getTypeAlignInChars(Context.ShortTy)
4364  : Context.getTypeAlignInChars(Context.CharTy);
4365  GV->setAlignment(Align.getQuantity());
4366 
4367  // FIXME: We set the section explicitly to avoid a bug in ld64 224.1.
4368  // Without it LLVM can merge the string with a non unnamed_addr one during
4369  // LTO. Doing that changes the section it ends in, which surprises ld64.
4370  if (Triple.isOSBinFormatMachO())
4371  GV->setSection(isUTF16 ? "__TEXT,__ustring"
4372  : "__TEXT,__cstring,cstring_literals");
4373  // Make sure the literal ends up in .rodata to allow for safe ICF and for
4374  // the static linker to adjust permissions to read-only later on.
4375  else if (Triple.isOSBinFormatELF())
4376  GV->setSection(".rodata");
4377 
4378  // String.
4379  llvm::Constant *Str =
4380  llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
4381 
4382  if (isUTF16)
4383  // Cast the UTF16 string to the correct type.
4384  Str = llvm::ConstantExpr::getBitCast(Str, Int8PtrTy);
4385  Fields.add(Str);
4386 
4387  // String length.
4388  llvm::IntegerType *LengthTy =
4389  llvm::IntegerType::get(getModule().getContext(),
4390  Context.getTargetInfo().getLongWidth());
4391  if (IsSwiftABI) {
4392  if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
4394  LengthTy = Int32Ty;
4395  else
4396  LengthTy = IntPtrTy;
4397  }
4398  Fields.addInt(LengthTy, StringLength);
4399 
4400  CharUnits Alignment = getPointerAlign();
4401 
4402  // The struct.
4403  GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
4404  /*isConstant=*/false,
4405  llvm::GlobalVariable::PrivateLinkage);
4406  switch (Triple.getObjectFormat()) {
4407  case llvm::Triple::UnknownObjectFormat:
4408  llvm_unreachable("unknown file format");
4409  case llvm::Triple::XCOFF:
4410  llvm_unreachable("XCOFF is not yet implemented");
4411  case llvm::Triple::COFF:
4412  case llvm::Triple::ELF:
4413  case llvm::Triple::Wasm:
4414  GV->setSection("cfstring");
4415  break;
4416  case llvm::Triple::MachO:
4417  GV->setSection("__DATA,__cfstring");
4418  break;
4419  }
4420  Entry.second = GV;
4421 
4422  return ConstantAddress(GV, Alignment);
4423 }
4424 
4426  return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
4427 }
4428 
4430  if (ObjCFastEnumerationStateType.isNull()) {
4431  RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
4432  D->startDefinition();
4433 
4434  QualType FieldTypes[] = {
4435  Context.UnsignedLongTy,
4436  Context.getPointerType(Context.getObjCIdType()),
4437  Context.getPointerType(Context.UnsignedLongTy),
4438  Context.getConstantArrayType(Context.UnsignedLongTy,
4439  llvm::APInt(32, 5), ArrayType::Normal, 0)
4440  };
4441 
4442  for (size_t i = 0; i < 4; ++i) {
4443  FieldDecl *Field = FieldDecl::Create(Context,
4444  D,
4445  SourceLocation(),
4446  SourceLocation(), nullptr,
4447  FieldTypes[i], /*TInfo=*/nullptr,
4448  /*BitWidth=*/nullptr,
4449  /*Mutable=*/false,
4450  ICIS_NoInit);
4451  Field->setAccess(AS_public);
4452  D->addDecl(Field);
4453  }
4454 
4455  D->completeDefinition();
4456  ObjCFastEnumerationStateType = Context.getTagDeclType(D);
4457  }
4458 
4459  return ObjCFastEnumerationStateType;
4460 }
4461 
4462 llvm::Constant *
4464  assert(!E->getType()->isPointerType() && "Strings are always arrays");
4465 
4466  // Don't emit it as the address of the string, emit the string data itself
4467  // as an inline array.
4468  if (E->getCharByteWidth() == 1) {
4469  SmallString<64> Str(E->getString());
4470 
4471  // Resize the string to the right size, which is indicated by its type.
4472  const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
4473  Str.resize(CAT->getSize().getZExtValue());
4474  return llvm::ConstantDataArray::getString(VMContext, Str, false);
4475  }
4476 
4477  auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
4478  llvm::Type *ElemTy = AType->getElementType();
4479  unsigned NumElements = AType->getNumElements();
4480 
4481  // Wide strings have either 2-byte or 4-byte elements.
4482  if (ElemTy->getPrimitiveSizeInBits() == 16) {
4483  SmallVector<uint16_t, 32> Elements;
4484  Elements.reserve(NumElements);
4485 
4486  for(unsigned i = 0, e = E->getLength(); i != e; ++i)
4487  Elements.push_back(E->getCodeUnit(i));
4488  Elements.resize(NumElements);
4489  return llvm::ConstantDataArray::get(VMContext, Elements);
4490  }
4491 
4492  assert(ElemTy->getPrimitiveSizeInBits() == 32);
4493  SmallVector<uint32_t, 32> Elements;
4494  Elements.reserve(NumElements);
4495 
4496  for(unsigned i = 0, e = E->getLength(); i != e; ++i)
4497  Elements.push_back(E->getCodeUnit(i));
4498  Elements.resize(NumElements);
4499  return llvm::ConstantDataArray::get(VMContext, Elements);
4500 }
4501 
4502 static llvm::GlobalVariable *
4503 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
4504  CodeGenModule &CGM, StringRef GlobalName,
4505  CharUnits Alignment) {
4506  unsigned AddrSpace = CGM.getContext().getTargetAddressSpace(
4508 
4509  llvm::Module &M = CGM.getModule();
4510  // Create a global variable for this string
4511  auto *GV = new llvm::GlobalVariable(
4512  M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
4513  nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
4514  GV->setAlignment(Alignment.getQuantity());
4515  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4516  if (GV->isWeakForLinker()) {
4517  assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
4518  GV->setComdat(M.getOrInsertComdat(GV->getName()));
4519  }
4520  CGM.setDSOLocal(GV);
4521 
4522  return GV;
4523 }
4524 
4525 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
4526 /// constant array for the given string literal.
4529  StringRef Name) {
4531 
4532  llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
4533  llvm::GlobalVariable **Entry = nullptr;
4534  if (!LangOpts.WritableStrings) {
4535  Entry = &ConstantStringMap[C];
4536  if (auto GV = *Entry) {
4537  if (Alignment.getQuantity() > GV->getAlignment())
4538  GV->setAlignment(Alignment.getQuantity());
4540  Alignment);
4541  }
4542  }
4543 
4544  SmallString<256> MangledNameBuffer;
4545  StringRef GlobalVariableName;
4546  llvm::GlobalValue::LinkageTypes LT;
4547 
4548  // Mangle the string literal if that's how the ABI merges duplicate strings.
4549  // Don't do it if they are writable, since we don't want writes in one TU to
4550  // affect strings in another.
4551  if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
4552  !LangOpts.WritableStrings) {
4553  llvm::raw_svector_ostream Out(MangledNameBuffer);
4555  LT = llvm::GlobalValue::LinkOnceODRLinkage;
4556  GlobalVariableName = MangledNameBuffer;
4557  } else {
4558  LT = llvm::GlobalValue::PrivateLinkage;
4559  GlobalVariableName = Name;
4560  }
4561 
4562  auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
4563  if (Entry)
4564  *Entry = GV;
4565 
4566  SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
4567  QualType());
4568 
4570  Alignment);
4571 }
4572 
4573 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
4574 /// array for the given ObjCEncodeExpr node.
4577  std::string Str;
4579 
4580  return GetAddrOfConstantCString(Str);
4581 }
4582 
4583 /// GetAddrOfConstantCString - Returns a pointer to a character array containing
4584 /// the literal and a terminating '\0' character.
4585 /// The result has pointer to array type.
4587  const std::string &Str, const char *GlobalName) {
4588  StringRef StrWithNull(Str.c_str(), Str.size() + 1);
4589  CharUnits Alignment =
4591 
4592  llvm::Constant *C =
4593  llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
4594 
4595  // Don't share any string literals if strings aren't constant.
4596  llvm::GlobalVariable **Entry = nullptr;
4597  if (!LangOpts.WritableStrings) {
4598  Entry = &ConstantStringMap[C];
4599  if (auto GV = *Entry) {
4600  if (Alignment.getQuantity() > GV->getAlignment())
4601  GV->setAlignment(Alignment.getQuantity());
4603  Alignment);
4604  }
4605  }
4606 
4607  // Get the default prefix if a name wasn't specified.
4608  if (!GlobalName)
4609  GlobalName = ".str";
4610  // Create a global variable for this.
4611  auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
4612  GlobalName, Alignment);
4613  if (Entry)
4614  *Entry = GV;
4615 
4617  Alignment);
4618 }
4619 
4621  const MaterializeTemporaryExpr *E, const Expr *Init) {
4622  assert((E->getStorageDuration() == SD_Static ||
4623  E->getStorageDuration() == SD_Thread) && "not a global temporary");
4624  const auto *VD = cast<VarDecl>(E->getExtendingDecl());
4625 
4626  // If we're not materializing a subobject of the temporary, keep the
4627  // cv-qualifiers from the type of the MaterializeTemporaryExpr.
4628  QualType MaterializedType = Init->getType();
4629  if (Init == E->GetTemporaryExpr())
4630  MaterializedType = E->getType();
4631 
4632  CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
4633 
4634  if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
4635  return ConstantAddress(Slot, Align);
4636 
4637  // FIXME: If an externally-visible declaration extends multiple temporaries,
4638  // we need to give each temporary the same name in every translation unit (and
4639  // we also need to make the temporaries externally-visible).
4640  SmallString<256> Name;
4641  llvm::raw_svector_ostream Out(Name);
4643  VD, E->getManglingNumber(), Out);
4644 
4645  APValue *Value = nullptr;
4646  if (E->getStorageDuration() == SD_Static) {
4647  // We might have a cached constant initializer for this temporary. Note
4648  // that this might have a different value from the value computed by
4649  // evaluating the initializer if the surrounding constant expression
4650  // modifies the temporary.
4651  Value = getContext().getMaterializedTemporaryValue(E, false);
4652  if (Value && Value->isUninit())
4653  Value = nullptr;
4654  }
4655 
4656  // Try evaluating it now, it might have a constant initializer.
4657  Expr::EvalResult EvalResult;
4658  if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
4659  !EvalResult.hasSideEffects())
4660  Value = &EvalResult.Val;
4661 
4662  LangAS AddrSpace =
4663  VD ? GetGlobalVarAddressSpace(VD) : MaterializedType.getAddressSpace();
4664 
4665  Optional<ConstantEmitter> emitter;
4666  llvm::Constant *InitialValue = nullptr;
4667  bool Constant = false;
4668  llvm::Type *Type;
4669  if (Value) {
4670  // The temporary has a constant initializer, use it.
4671  emitter.emplace(*this);
4672  InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
4673  MaterializedType);
4674  Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
4675  Type = InitialValue->getType();
4676  } else {
4677  // No initializer, the initialization will be provided when we
4678  // initialize the declaration which performed lifetime extension.
4679  Type = getTypes().ConvertTypeForMem(MaterializedType);
4680  }
4681 
4682  // Create a global variable for this lifetime-extended temporary.
4683  llvm::GlobalValue::LinkageTypes Linkage =
4684  getLLVMLinkageVarDefinition(VD, Constant);
4685  if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
4686  const VarDecl *InitVD;
4687  if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
4688  isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
4689  // Temporaries defined inside a class get linkonce_odr linkage because the
4690  // class can be defined in multiple translation units.
4691  Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
4692  } else {
4693  // There is no need for this temporary to have external linkage if the
4694  // VarDecl has external linkage.
4696  }
4697  }
4698  auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
4699  auto *GV = new llvm::GlobalVariable(
4700  getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
4701  /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
4702  if (emitter) emitter->finalize(GV);
4703  setGVProperties(GV, VD);
4704  GV->setAlignment(Align.getQuantity());
4705  if (supportsCOMDAT() && GV->isWeakForLinker())
4706  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4707  if (VD->getTLSKind())
4708  setTLSMode(GV, *VD);
4709  llvm::Constant *CV = GV;
4710  if (AddrSpace != LangAS::Default)
4712  *this, GV, AddrSpace, LangAS::Default,
4713  Type->getPointerTo(
4714  getContext().getTargetAddressSpace(LangAS::Default)));
4715  MaterializedGlobalTemporaryMap[E] = CV;
4716  return ConstantAddress(CV, Align);
4717 }
4718 
4719 /// EmitObjCPropertyImplementations - Emit information for synthesized
4720 /// properties for an implementation.
4721 void CodeGenModule::EmitObjCPropertyImplementations(const
4723  for (const auto *PID : D->property_impls()) {
4724  // Dynamic is just for type-checking.
4725  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
4726  ObjCPropertyDecl *PD = PID->getPropertyDecl();
4727 
4728  // Determine which methods need to be implemented, some may have
4729  // been overridden. Note that ::isPropertyAccessor is not the method
4730  // we want, that just indicates if the decl came from a
4731  // property. What we want to know is if the method is defined in
4732  // this implementation.
4733  if (!D->getInstanceMethod(PD->getGetterName()))
4735  const_cast<ObjCImplementationDecl *>(D), PID);
4736  if (!PD->isReadOnly() &&
4737  !D->getInstanceMethod(PD->getSetterName()))
4739  const_cast<ObjCImplementationDecl *>(D), PID);
4740  }
4741  }
4742 }
4743 
4745  const ObjCInterfaceDecl *iface = impl->getClassInterface();
4746  for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
4747  ivar; ivar = ivar->getNextIvar())
4748  if (ivar->getType().isDestructedType())
4749  return true;
4750 
4751  return false;
4752 }
4753 
4756  CodeGenFunction CGF(CGM);
4758  E = D->init_end(); B != E; ++B) {
4759  CXXCtorInitializer *CtorInitExp = *B;
4760  Expr *Init = CtorInitExp->getInit();
4761  if (!CGF.isTrivialInitializer(Init))
4762  return false;
4763  }
4764  return true;
4765 }
4766 
4767 /// EmitObjCIvarInitializations - Emit information for ivar initialization
4768 /// for an implementation.
4769 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
4770  // We might need a .cxx_destruct even if we don't have any ivar initializers.
4771  if (needsDestructMethod(D)) {
4772  IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
4773  Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
4774  ObjCMethodDecl *DTORMethod =
4776  cxxSelector, getContext().VoidTy, nullptr, D,
4777  /*isInstance=*/true, /*isVariadic=*/false,
4778  /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
4779  /*isDefined=*/false, ObjCMethodDecl::Required);
4780  D->addInstanceMethod(DTORMethod);
4781  CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
4782  D->setHasDestructors(true);
4783  }
4784 
4785  // If the implementation doesn't have any ivar initializers, we don't need
4786  // a .cxx_construct.
4787  if (D->getNumIvarInitializers() == 0 ||
4788  AllTrivialInitializers(*this, D))
4789  return;
4790 
4791  IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
4792  Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
4793  // The constructor returns 'self'.
4795  D->getLocation(),
4796  D->getLocation(),
4797  cxxSelector,
4799  nullptr, D, /*isInstance=*/true,
4800  /*isVariadic=*/false,
4801  /*isPropertyAccessor=*/true,
4802  /*isImplicitlyDeclared=*/true,
4803  /*isDefined=*/false,
4805  D->addInstanceMethod(CTORMethod);
4806  CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
4807  D->setHasNonZeroConstructors(true);
4808 }
4809 
4810 // EmitLinkageSpec - Emit all declarations in a linkage spec.
4811 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
4812  if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
4814  ErrorUnsupported(LSD, "linkage spec");
4815  return;
4816  }
4817 
4818  EmitDeclContext(LSD);
4819 }
4820 
4821 void CodeGenModule::EmitDeclContext(const DeclContext *DC) {
4822  for (auto *I : DC->decls()) {
4823  // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
4824  // are themselves considered "top-level", so EmitTopLevelDecl on an
4825  // ObjCImplDecl does not recursively visit them. We need to do that in
4826  // case they're nested inside another construct (LinkageSpecDecl /
4827  // ExportDecl) that does stop them from being considered "top-level".
4828  if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
4829  for (auto *M : OID->methods())
4830  EmitTopLevelDecl(M);
4831  }
4832 
4833  EmitTopLevelDecl(I);
4834  }
4835 }
4836 
4837 /// EmitTopLevelDecl - Emit code for a single top level declaration.
4839  // Ignore dependent declarations.
4840  if (D->isTemplated())
4841  return;
4842 
4843  switch (D->getKind()) {
4844  case Decl::CXXConversion:
4845  case Decl::CXXMethod:
4846  case Decl::Function:
4847  EmitGlobal(cast<FunctionDecl>(D));
4848  // Always provide some coverage mapping
4849  // even for the functions that aren't emitted.
4851  break;
4852 
4853  case Decl::CXXDeductionGuide:
4854  // Function-like, but does not result in code emission.
4855  break;
4856 
4857  case Decl::Var:
4858  case Decl::Decomposition:
4859  case Decl::VarTemplateSpecialization:
4860  EmitGlobal(cast<VarDecl>(D));
4861  if (auto *DD = dyn_cast<DecompositionDecl>(D))
4862  for (auto *B : DD->bindings())
4863  if (auto *HD = B->getHoldingVar())
4864  EmitGlobal(HD);
4865  break;
4866 
4867  // Indirect fields from global anonymous structs and unions can be
4868  // ignored; only the actual variable requires IR gen support.
4869  case Decl::IndirectField:
4870  break;
4871 
4872  // C++ Decls
4873  case Decl::Namespace:
4874  EmitDeclContext(cast<NamespaceDecl>(D));
4875  break;
4876  case Decl::ClassTemplateSpecialization: {
4877  const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
4878  if (DebugInfo &&
4879  Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
4880  Spec->hasDefinition())
4881  DebugInfo->completeTemplateDefinition(*Spec);
4882  } LLVM_FALLTHROUGH;
4883  case Decl::CXXRecord:
4884  if (DebugInfo) {
4885  if (auto *ES = D->getASTContext().getExternalSource())
4886  if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
4887  DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
4888  }
4889  // Emit any static data members, they may be definitions.
4890  for (auto *I : cast<CXXRecordDecl>(D)->decls())
4891  if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
4892  EmitTopLevelDecl(I);
4893  break;
4894  // No code generation needed.
4895  case Decl::UsingShadow:
4896  case Decl::ClassTemplate:
4897  case Decl::VarTemplate:
4898  case Decl::VarTemplatePartialSpecialization:
4899  case Decl::FunctionTemplate:
4900  case Decl::TypeAliasTemplate:
4901  case Decl::Block:
4902  case Decl::Empty:
4903  case Decl::Binding:
4904  break;
4905  case Decl::Using: // using X; [C++]
4906  if (CGDebugInfo *DI = getModuleDebugInfo())
4907  DI->EmitUsingDecl(cast<UsingDecl>(*D));
4908  return;
4909  case Decl::NamespaceAlias:
4910  if (CGDebugInfo *DI = getModuleDebugInfo())
4911  DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
4912  return;
4913  case Decl::UsingDirective: // using namespace X; [C++]
4914  if (CGDebugInfo *DI = getModuleDebugInfo())
4915  DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
4916  return;
4917  case Decl::CXXConstructor:
4918  getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
4919  break;
4920  case Decl::CXXDestructor:
4921  getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
4922  break;
4923 
4924  case Decl::StaticAssert:
4925  // Nothing to do.
4926  break;
4927 
4928  // Objective-C Decls
4929 
4930  // Forward declarations, no (immediate) code generation.
4931  case Decl::ObjCInterface:
4932  case Decl::ObjCCategory:
4933  break;
4934 
4935  case Decl::ObjCProtocol: {
4936  auto *Proto = cast<ObjCProtocolDecl>(D);
4937  if (Proto->isThisDeclarationADefinition())
4938  ObjCRuntime->GenerateProtocol(Proto);
4939  break;
4940  }
4941 
4942  case Decl::ObjCCategoryImpl:
4943  // Categories have properties but don't support synthesize so we
4944  // can ignore them here.
4945  ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
4946  break;
4947 
4948  case Decl::ObjCImplementation: {
4949  auto *OMD = cast<ObjCImplementationDecl>(D);
4950  EmitObjCPropertyImplementations(OMD);
4951  EmitObjCIvarInitializations(OMD);
4952  ObjCRuntime->GenerateClass(OMD);
4953  // Emit global variable debug information.
4954  if (CGDebugInfo *DI = getModuleDebugInfo())
4955  if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
4956  DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
4957  OMD->getClassInterface()), OMD->getLocation());
4958  break;
4959  }
4960  case Decl::ObjCMethod: {
4961  auto *OMD = cast<ObjCMethodDecl>(D);
4962  // If this is not a prototype, emit the body.
4963  if (OMD->getBody())
4964  CodeGenFunction(*this).GenerateObjCMethod(OMD);
4965  break;
4966  }
4967  case Decl::ObjCCompatibleAlias:
4968  ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
4969  break;
4970 
4971  case Decl::PragmaComment: {
4972  const auto *PCD = cast<PragmaCommentDecl>(D);
4973  switch (PCD->getCommentKind()) {
4974  case PCK_Unknown:
4975  llvm_unreachable("unexpected pragma comment kind");
4976  case PCK_Linker:
4977  AppendLinkerOptions(PCD->getArg());
4978  break;
4979  case PCK_Lib:
4980  if (getTarget().getTriple().isOSBinFormatELF() &&
4981  !getTarget().getTriple().isPS4())
4982  AddELFLibDirective(PCD->getArg());
4983  else
4984  AddDependentLib(PCD->getArg());
4985  break;
4986  case PCK_Compiler:
4987  case PCK_ExeStr:
4988  case PCK_User:
4989  break; // We ignore all of these.
4990  }
4991  break;
4992  }
4993 
4994  case Decl::PragmaDetectMismatch: {
4995  const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
4996  AddDetectMismatch(PDMD->getName(), PDMD->getValue());
4997  break;
4998  }
4999 
5000  case Decl::LinkageSpec:
5001  EmitLinkageSpec(cast<LinkageSpecDecl>(D));
5002  break;
5003 
5004  case Decl::FileScopeAsm: {
5005  // File-scope asm is ignored during device-side CUDA compilation.
5006  if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
5007  break;
5008  // File-scope asm is ignored during device-side OpenMP compilation.
5009  if (LangOpts.OpenMPIsDevice)
5010  break;
5011  auto *AD = cast<FileScopeAsmDecl>(D);
5012  getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
5013  break;
5014  }
5015 
5016  case Decl::Import: {
5017  auto *Import = cast<ImportDecl>(D);
5018 
5019  // If we've already imported this module, we're done.
5020  if (!ImportedModules.insert(Import->getImportedModule()))
5021  break;
5022 
5023  // Emit debug information for direct imports.
5024  if (!Import->getImportedOwningModule()) {
5025  if (CGDebugInfo *DI = getModuleDebugInfo())
5026  DI->EmitImportDecl(*Import);
5027  }
5028 
5029  // Find all of the submodules and emit the module initializers.
5030  llvm::SmallPtrSet<clang::Module *, 16> Visited;
5032  Visited.insert(Import->getImportedModule());
5033  Stack.push_back(Import->getImportedModule());
5034 
5035  while (!Stack.empty()) {
5036  clang::Module *Mod = Stack.pop_back_val();
5037  if (!EmittedModuleInitializers.insert(Mod).second)
5038  continue;
5039 
5040  for (auto *D : Context.getModuleInitializers(Mod))
5041  EmitTopLevelDecl(D);
5042 
5043  // Visit the submodules of this module.
5045  SubEnd = Mod->submodule_end();
5046  Sub != SubEnd; ++Sub) {
5047  // Skip explicit children; they need to be explicitly imported to emit
5048  // the initializers.
5049  if ((*Sub)->IsExplicit)
5050  continue;
5051 
5052  if (Visited.insert(*Sub).second)
5053  Stack.push_back(*Sub);
5054  }
5055  }
5056  break;
5057  }
5058 
5059  case Decl::Export:
5060  EmitDeclContext(cast<ExportDecl>(D));
5061  break;
5062 
5063  case Decl::OMPThreadPrivate:
5064  EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
5065  break;
5066 
5067  case Decl::OMPAllocate:
5068  break;
5069 
5070  case Decl::OMPDeclareReduction:
5071  EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(D));
5072  break;
5073 
5074  case Decl::OMPDeclareMapper:
5075  EmitOMPDeclareMapper(cast<OMPDeclareMapperDecl>(D));
5076  break;
5077 
5078  case Decl::OMPRequires:
5079  EmitOMPRequiresDecl(cast<OMPRequiresDecl>(D));
5080  break;
5081 
5082  default:
5083  // Make sure we handled everything we should, every other kind is a
5084  // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
5085  // function. Need to recode Decl::Kind to do that easily.
5086  assert(isa<TypeDecl>(D) && "Unsupported decl kind");
5087  break;
5088  }
5089 }
5090 
5092  // Do we need to generate coverage mapping?
5093  if (!CodeGenOpts.CoverageMapping)
5094  return;
5095  switch (D->getKind()) {
5096  case Decl::CXXConversion:
5097  case Decl::CXXMethod:
5098  case Decl::Function:
5099  case Decl::ObjCMethod:
5100  case Decl::CXXConstructor:
5101  case Decl::CXXDestructor: {
5102  if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
5103  return;
5105  if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getBeginLoc()))
5106  return;
5107  auto I = DeferredEmptyCoverageMappingDecls.find(D);
5108  if (I == DeferredEmptyCoverageMappingDecls.end())
5109  DeferredEmptyCoverageMappingDecls[D] = true;
5110  break;
5111  }
5112  default:
5113  break;
5114  };
5115 }
5116 
5118  // Do we need to generate coverage mapping?
5119  if (!CodeGenOpts.CoverageMapping)
5120  return;
5121  if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
5122  if (Fn->isTemplateInstantiation())
5123  ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
5124  }
5125  auto I = DeferredEmptyCoverageMappingDecls.find(D);
5126  if (I == DeferredEmptyCoverageMappingDecls.end())
5127  DeferredEmptyCoverageMappingDecls[D] = false;
5128  else
5129  I->second = false;
5130 }
5131 
5133  // We call takeVector() here to avoid use-after-free.
5134  // FIXME: DeferredEmptyCoverageMappingDecls is getting mutated because
5135  // we deserialize function bodies to emit coverage info for them, and that
5136  // deserializes more declarations. How should we handle that case?
5137  for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
5138  if (!Entry.second)
5139  continue;
5140  const Decl *D = Entry.first;
5141  switch (D->getKind()) {
5142  case Decl::CXXConversion:
5143  case Decl::CXXMethod:
5144  case Decl::Function:
5145  case Decl::ObjCMethod: {
5146  CodeGenPGO PGO(*this);
5147  GlobalDecl GD(cast<FunctionDecl>(D));
5149  getFunctionLinkage(GD));
5150  break;
5151  }
5152  case Decl::CXXConstructor: {
5153  CodeGenPGO PGO(*this);
5154  GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
5156  getFunctionLinkage(GD));
5157  break;
5158  }
5159  case Decl::CXXDestructor: {
5160  CodeGenPGO PGO(*this);
5161  GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
5163  getFunctionLinkage(GD));
5164  break;
5165  }
5166  default:
5167  break;
5168  };
5169  }
5170 }
5171 
5172 /// Turns the given pointer into a constant.
5173 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
5174  const void *Ptr) {
5175  uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
5176  llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
5177  return llvm::ConstantInt::get(i64, PtrInt);
5178 }
5179 
5181  llvm::NamedMDNode *&GlobalMetadata,
5182  GlobalDecl D,
5183  llvm::GlobalValue *Addr) {
5184  if (!GlobalMetadata)
5185  GlobalMetadata =
5186  CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
5187 
5188  // TODO: should we report variant information for ctors/dtors?
5189  llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
5190  llvm::ConstantAsMetadata::get(GetPointerConstant(
5191  CGM.getLLVMContext(), D.getDecl()))};
5192  GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
5193 }
5194 
5195 /// For each function which is declared within an extern "C" region and marked
5196 /// as 'used', but has internal linkage, create an alias from the unmangled
5197 /// name to the mangled name if possible. People expect to be able to refer
5198 /// to such functions with an unmangled name from inline assembly within the
5199 /// same translation unit.
5200 void CodeGenModule::EmitStaticExternCAliases() {
5201  if (!getTargetCodeGenInfo().shouldEmitStaticExternCAliases())
5202  return;
5203  for (auto &I : StaticExternCValues) {
5204  IdentifierInfo *Name = I.first;
5205  llvm::GlobalValue *Val = I.second;
5206  if (Val && !getModule().getNamedValue(Name->getName()))
5208  }
5209 }
5210 
5211 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
5212  GlobalDecl &Result) const {
5213  auto Res = Manglings.find(MangledName);
5214  if (Res == Manglings.end())
5215  return false;
5216  Result = Res->getValue();
5217  return true;
5218 }
5219 
5220 /// Emits metadata nodes associating all the global values in the
5221 /// current module with the Decls they came from. This is useful for
5222 /// projects using IR gen as a subroutine.
5223 ///
5224 /// Since there's currently no way to associate an MDNode directly
5225 /// with an llvm::GlobalValue, we create a global named metadata
5226 /// with the name 'clang.global.decl.ptrs'.
5227 void CodeGenModule::EmitDeclMetadata() {
5228  llvm::NamedMDNode *GlobalMetadata = nullptr;
5229 
5230  for (auto &I : MangledDeclNames) {
5231  llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
5232  // Some mangled names don't necessarily have an associated GlobalValue
5233  // in this module, e.g. if we mangled it for DebugInfo.
5234  if (Addr)
5235  EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
5236  }
5237 }
5238 
5239 /// Emits metadata nodes for all the local variables in the current
5240 /// function.
5241 void CodeGenFunction::EmitDeclMetadata() {
5242  if (LocalDeclMap.empty()) return;
5243 
5244  llvm::LLVMContext &Context = getLLVMContext();
5245 
5246  // Find the unique metadata ID for this name.
5247  unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
5248 
5249  llvm::NamedMDNode *GlobalMetadata = nullptr;
5250 
5251  for (auto &I : LocalDeclMap) {
5252  const Decl *D = I.first;
5253  llvm::Value *Addr = I.second.getPointer();
5254  if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
5256  Alloca->setMetadata(
5257  DeclPtrKind, llvm::MDNode::get(
5258  Context, llvm::ValueAsMetadata::getConstant(DAddr)));
5259  } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
5260  GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
5261  EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
5262  }
5263  }
5264 }
5265 
5266 void CodeGenModule::EmitVersionIdentMetadata() {
5267  llvm::NamedMDNode *IdentMetadata =
5268  TheModule.getOrInsertNamedMetadata("llvm.ident");
5269  std::string Version = getClangFullVersion();
5270  llvm::LLVMContext &Ctx = TheModule.getContext();
5271 
5272  llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
5273  IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
5274 }
5275 
5276 void CodeGenModule::EmitCommandLineMetadata() {
5277  llvm::NamedMDNode *CommandLineMetadata =
5278  TheModule.getOrInsertNamedMetadata("llvm.commandline");
5279  std::string CommandLine = getCodeGenOpts().RecordCommandLine;
5280  llvm::LLVMContext &Ctx = TheModule.getContext();
5281 
5282  llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
5283  CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
5284 }
5285 
5286 void CodeGenModule::EmitTargetMetadata() {
5287  // Warning, new MangledDeclNames may be appended within this loop.
5288  // We rely on MapVector insertions adding new elements to the end
5289  // of the container.
5290  // FIXME: Move this loop into the one target that needs it, and only
5291  // loop over those declarations for which we couldn't emit the target
5292  // metadata when we emitted the declaration.
5293  for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
5294  auto Val = *(MangledDeclNames.begin() + I);
5295  const Decl *D = Val.first.getDecl()->getMostRecentDecl();
5296  llvm::GlobalValue *GV = GetGlobalValue(Val.second);
5297  getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
5298  }
5299 }
5300 
5301 void CodeGenModule::EmitCoverageFile() {
5302  if (getCodeGenOpts().CoverageDataFile.empty() &&
5304  return;
5305 
5306  llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu");
5307  if (!CUNode)
5308  return;
5309 
5310  llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
5311  llvm::LLVMContext &Ctx = TheModule.getContext();
5312  auto *CoverageDataFile =
5313  llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile);
5314  auto *CoverageNotesFile =
5315  llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile);
5316  for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
5317  llvm::MDNode *CU = CUNode->getOperand(i);
5318  llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
5319  GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
5320  }
5321 }
5322 
5323 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
5324  // Sema has checked that all uuid strings are of the form
5325  // "12345678-1234-1234-1234-1234567890ab".
5326  assert(Uuid.size() == 36);
5327  for (unsigned i = 0; i < 36; ++i) {
5328  if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
5329  else assert(isHexDigit(Uuid[i]));
5330  }
5331 
5332  // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
5333  const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
5334 
5335  llvm::Constant *Field3[8];
5336  for (unsigned Idx = 0; Idx < 8; ++Idx)
5337  Field3[Idx] = llvm::ConstantInt::get(
5338  Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
5339 
5340  llvm::Constant *Fields[4] = {
5341  llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16),
5342  llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16),
5343  llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
5344  llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
5345  };
5346 
5347  return llvm::ConstantStruct::getAnon(Fields);
5348 }
5349 
5351  bool ForEH) {
5352  // Return a bogus pointer if RTTI is disabled, unless it's for EH.
5353  // FIXME: should we even be calling this method if RTTI is disabled
5354  // and it's not for EH?
5355  if ((!ForEH && !getLangOpts().RTTI) || getLangOpts().CUDAIsDevice)
5356  return llvm::Constant::getNullValue(Int8PtrTy);
5357 
5358  if (ForEH && Ty->isObjCObjectPointerType() &&
5359  LangOpts.ObjCRuntime.isGNUFamily())
5360  return ObjCRuntime->GetEHType(Ty);
5361 
5362  return getCXXABI().getAddrOfRTTIDescriptor(Ty);
5363 }
5364 
5366  // Do not emit threadprivates in simd-only mode.
5367  if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
5368  return;
5369  for (auto RefExpr : D->varlists()) {
5370  auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
5371  bool PerformInit =
5372  VD->getAnyInitializer() &&
5373  !VD->getAnyInitializer()->isConstantInitializer(getContext(),
5374  /*ForRef=*/false);
5375 
5377  if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
5378  VD, Addr, RefExpr->getBeginLoc(), PerformInit))
5379  CXXGlobalInits.push_back(InitFunction);
5380  }
5381 }
5382 
5383 llvm::Metadata *
5384 CodeGenModule::CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map,
5385  StringRef Suffix) {
5386  llvm::Metadata *&InternalId = Map[T.getCanonicalType()];
5387  if (InternalId)
5388  return InternalId;
5389 
5390  if (isExternallyVisible(T->getLinkage())) {
5391  std::string OutName;
5392  llvm::raw_string_ostream Out(OutName);
5394  Out << Suffix;
5395 
5396  InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
5397  } else {
5398  InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
5400  }
5401 
5402  return InternalId;
5403 }
5404 
5406  return CreateMetadataIdentifierImpl(T, MetadataIdMap, "");
5407 }
5408 
5409 llvm::Metadata *
5411  return CreateMetadataIdentifierImpl(T, VirtualMetadataIdMap, ".virtual");
5412 }
5413 
5414 // Generalize pointer types to a void pointer with the qualifiers of the
5415 // originally pointed-to type, e.g. 'const char *' and 'char * const *'
5416 // generalize to 'const void *' while 'char *' and 'const char **' generalize to
5417 // 'void *'.
5419  if (!Ty->isPointerType())
5420  return Ty;
5421 
5422  return Ctx.getPointerType(
5424  Ty->getPointeeType().getCVRQualifiers()));
5425 }
5426 
5427 // Apply type generalization to a FunctionType's return and argument types
5429  if (auto *FnType = Ty->getAs<FunctionProtoType>()) {
5430  SmallVector<QualType, 8> GeneralizedParams;
5431  for (auto &Param : FnType->param_types())
5432  GeneralizedParams.push_back(GeneralizeType(Ctx, Param));
5433 
5434  return Ctx.getFunctionType(
5435  GeneralizeType(Ctx, FnType->getReturnType()),
5436  GeneralizedParams, FnType->getExtProtoInfo());
5437  }
5438 
5439  if (auto *FnType = Ty->getAs<FunctionNoProtoType>())
5440  return Ctx.getFunctionNoProtoType(
5441  GeneralizeType(Ctx, FnType->getReturnType()));
5442 
5443  llvm_unreachable("Encountered unknown FunctionType");
5444 }
5445 
5447  return CreateMetadataIdentifierImpl(GeneralizeFunctionType(getContext(), T),
5448  GeneralizedMetadataIdMap, ".generalized");
5449 }
5450 
5451 /// Returns whether this module needs the "all-vtables" type identifier.
5453  // Returns true if at least one of vtable-based CFI checkers is enabled and
5454  // is not in the trapping mode.
5455  return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
5456  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
5457  (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
5458  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
5459  (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
5460  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
5461  (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
5462  !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
5463 }
5464 
5465 void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable,
5466  CharUnits Offset,
5467  const CXXRecordDecl *RD) {
5468  llvm::Metadata *MD =
5470  VTable->addTypeMetadata(Offset.getQuantity(), MD);
5471 
5472  if (CodeGenOpts.SanitizeCfiCrossDso)
5473  if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
5474  VTable->addTypeMetadata(Offset.getQuantity(),
5475  llvm::ConstantAsMetadata::get(CrossDsoTypeId));
5476 
5477  if (NeedAllVtablesTypeId()) {
5478  llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables");
5479  VTable->addTypeMetadata(Offset.getQuantity(), MD);
5480  }
5481 }
5482 
5483 TargetAttr::ParsedTargetAttr CodeGenModule::filterFunctionTargetAttrs(const TargetAttr *TD) {
5484  assert(TD != nullptr);
5485  TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
5486 
5487  ParsedAttr.Features.erase(
5488  llvm::remove_if(ParsedAttr.Features,
5489  [&](const std::string &Feat) {
5490  return !Target.isValidFeatureName(
5491  StringRef{Feat}.substr(1));
5492  }),
5493  ParsedAttr.Features.end());
5494  return ParsedAttr;
5495 }
5496 
5497 
5498 // Fills in the supplied string map with the set of target features for the
5499 // passed in function.
5500 void CodeGenModule::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
5501  GlobalDecl GD) {
5502  StringRef TargetCPU = Target.getTargetOpts().CPU;
5503  const FunctionDecl *FD = GD.getDecl()->getAsFunction();
5504  if (const auto *TD = FD->getAttr<TargetAttr>()) {
5505  TargetAttr::ParsedTargetAttr ParsedAttr = filterFunctionTargetAttrs(TD);
5506 
5507  // Make a copy of the features as passed on the command line into the
5508  // beginning of the additional features from the function to override.
5509  ParsedAttr.Features.insert(ParsedAttr.Features.begin(),
5510  Target.getTargetOpts().FeaturesAsWritten.begin(),
5511  Target.getTargetOpts().FeaturesAsWritten.end());
5512 
5513  if (ParsedAttr.Architecture != "" &&
5514  Target.isValidCPUName(ParsedAttr.Architecture))
5515  TargetCPU = ParsedAttr.Architecture;
5516 
5517  // Now populate the feature map, first with the TargetCPU which is either
5518  // the default or a new one from the target attribute string. Then we'll use
5519  // the passed in features (FeaturesAsWritten) along with the new ones from
5520  // the attribute.
5521  Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
5522  ParsedAttr.Features);
5523  } else if (const auto *SD = FD->getAttr<CPUSpecificAttr>()) {
5525  Target.getCPUSpecificCPUDispatchFeatures(
5526  SD->getCPUName(GD.getMultiVersionIndex())->getName(), FeaturesTmp);
5527  std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
5528  Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU, Features);
5529  } else {
5530  Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
5531  Target.getTargetOpts().Features);
5532  }
5533 }
5534 
5535 llvm::SanitizerStatReport &CodeGenModule::getSanStats() {
5536  if (!SanStats)
5537  SanStats = llvm::make_unique<llvm::SanitizerStatReport>(&getModule());
5538 
5539  return *SanStats;
5540 }
5541 llvm::Value *
5543  CodeGenFunction &CGF) {
5544  llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType());
5545  auto SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr());
5546  auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
5547  return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,
5548  "__translate_sampler_initializer"),
5549  {C});
5550 }
void setLinkage(Linkage L)
Definition: Visibility.h:87
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
virtual bool checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const
Check if the target supports CFProtection branch.
Definition: TargetInfo.cpp:145
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:83
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition: Decl.h:1954
TargetOptions & getTargetOpts() const
Retrieve the target options.
Definition: TargetInfo.h:216
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1249
Represents a function declaration or definition.
Definition: Decl.h:1737
llvm::IntegerType * IntTy
int
void CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2461
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:59
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:2023
void EmitDeferredUnusedCoverageMappings()
Emit all the deferred coverage mappings for the uninstrumented functions.
std::vector< const CXXRecordDecl * > getMostBaseClasses(const CXXRecordDecl *RD)
Return a vector of most-base classes for RD.
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1848
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F)
Set the LLVM function attributes (sext, zext, etc).
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:67
void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare mapper construct.
Definition: CGDecl.cpp:2490
Complete object ctor.
Definition: ABI.h:25
A (possibly-)qualified type.
Definition: Type.h:639
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:70
Static storage duration.
Definition: Specifiers.h:280
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty)
base_class_range bases()
Definition: DeclCXX.h:822
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:559
const CodeGenOptions & getCodeGenOpts() const
GlobalDecl getWithDecl(const Decl *D)
Definition: GlobalDecl.h:101
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))
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:816
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the &#39;opaque&#39; type we pr...
unsigned getLongWidth() const
getLongWidth/Align - Return the size of &#39;signed long&#39; and &#39;unsigned long&#39; for this target...
Definition: TargetInfo.h:398
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:192
llvm::LLVMContext & getLLVMContext()
GlobalDecl getWithMultiVersionIndex(unsigned Index)
Definition: GlobalDecl.h:121
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
Definition: Version.cpp:117
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:75
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
submodule_iterator submodule_begin()
Definition: Module.h:562
bool containsNonAsciiOrNull() const
Definition: Expr.h:1732
The standard implementation of ConstantInitBuilder used in Clang.
Stmt - This represents one statement.
Definition: Stmt.h:65
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3367
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:183
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:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:966
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...
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:289
bool isRecordType() const
Definition: Type.h:6381
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
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: