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