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