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