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