Bug Summary

File:build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/clang/lib/CodeGen/CodeGenModule.cpp
Warning:line 3767, column 27
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CodeGenModule.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-03-20-232535-108605-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/clang/lib/CodeGen/CodeGenModule.cpp

/build/llvm-toolchain-snapshot-15~++20220320100729+487629cc61b5/clang/lib/CodeGen/CodeGenModule.cpp

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