blob: b157f5aff2240f1e859d538607dab02890e5bf1a [file] [log] [blame]
Chris Lattnerbed31442007-05-28 01:07:47 +00001//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-module state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
John McCall7f416cc2015-09-08 08:05:57 +000015#include "CGBlocks.h"
Peter Collingbournefe883422011-10-06 18:29:37 +000016#include "CGCUDARuntime.h"
John McCall5d865c322010-08-31 07:33:07 +000017#include "CGCXXABI.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "CGCall.h"
19#include "CGDebugInfo.h"
Daniel Dunbar89da6ad2008-08-13 00:59:25 +000020#include "CGObjCRuntime.h"
Peter Collingbourne2dbb7082011-09-19 21:14:35 +000021#include "CGOpenCLRuntime.h"
Alexey Bataev9959db52014-05-06 10:08:46 +000022#include "CGOpenMPRuntime.h"
Samuel Antao45bfe4c2016-02-08 15:59:20 +000023#include "CGOpenMPRuntimeNVPTX.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000024#include "CodeGenFunction.h"
Justin Bogneref512b92014-01-06 22:27:43 +000025#include "CodeGenPGO.h"
John McCallde0fe072017-08-15 21:42:52 +000026#include "ConstantEmitter.h"
Chandler Carruth0d9593d2015-01-14 11:29:14 +000027#include "CoverageMappingGen.h"
Anton Korobeynikov55bcea12010-01-10 12:58:08 +000028#include "TargetInfo.h"
Chris Lattner2ccb73b2007-06-16 00:16:26 +000029#include "clang/AST/ASTContext.h"
Ken Dyck98ca7942010-01-26 13:48:07 +000030#include "clang/AST/CharUnits.h"
Chris Lattnerb8c18fa2008-11-04 16:51:42 +000031#include "clang/AST/DeclCXX.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000032#include "clang/AST/DeclObjC.h"
Douglas Gregor5dd34742010-06-21 18:41:26 +000033#include "clang/AST/DeclTemplate.h"
Peter Collingbourne0ff0b372011-01-13 18:57:25 +000034#include "clang/AST/Mangle.h"
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +000035#include "clang/AST/RecordLayout.h"
Rafael Espindolac5941352011-10-26 20:41:06 +000036#include "clang/AST/RecursiveASTVisitor.h"
Rafael Espindola4fdc1752011-12-19 14:41:01 +000037#include "clang/Basic/Builtins.h"
Jordan Rosea7d03842013-02-08 22:30:41 +000038#include "clang/Basic/CharInfo.h"
Chris Lattnerd45aa2a2007-12-02 07:19:18 +000039#include "clang/Basic/Diagnostic.h"
Douglas Gregor6ddfca92013-01-14 17:21:00 +000040#include "clang/Basic/Module.h"
Nate Begemanfaae0812008-04-19 04:17:09 +000041#include "clang/Basic/SourceManager.h"
Chris Lattner09153c02007-06-22 18:48:09 +000042#include "clang/Basic/TargetInfo.h"
Rafael Espindola3bfa4682013-10-16 19:28:50 +000043#include "clang/Basic/Version.h"
John McCall5ad74072017-03-02 20:04:19 +000044#include "clang/CodeGen/ConstantInitBuilder.h"
Saleem Abdulrasool10a49722016-04-08 16:52:00 +000045#include "clang/Frontend/CodeGenOptions.h"
Rafael Espindola208b5c02013-10-22 19:26:13 +000046#include "clang/Sema/SemaDiagnostic.h"
John McCallbeec5a02010-03-06 00:35:14 +000047#include "llvm/ADT/Triple.h"
Matthias Brauna4519532017-05-20 01:29:55 +000048#include "llvm/Analysis/TargetLibraryInfo.h"
Chandler Carruthc80ceea2014-03-04 11:02:08 +000049#include "llvm/IR/CallSite.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000050#include "llvm/IR/CallingConv.h"
51#include "llvm/IR/DataLayout.h"
52#include "llvm/IR/Intrinsics.h"
53#include "llvm/IR/LLVMContext.h"
54#include "llvm/IR/Module.h"
Justin Bogner837a6f62014-04-18 21:52:00 +000055#include "llvm/ProfileData/InstrProfReader.h"
Dmitri Gribenko9feeef42013-01-30 12:06:08 +000056#include "llvm/Support/ConvertUTF.h"
Chris Lattner15275e52009-11-07 09:22:46 +000057#include "llvm/Support/ErrorHandling.h"
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +000058#include "llvm/Support/MD5.h"
Dmitri Gribenko9feeef42013-01-30 12:06:08 +000059
Chris Lattnerbed31442007-05-28 01:07:47 +000060using namespace clang;
61using namespace CodeGen;
62
Vedant Kumar0acf3432017-09-22 18:23:04 +000063static llvm::cl::opt<bool> LimitedCoverage(
Zachary Turner8065f0b2017-12-01 00:53:10 +000064 "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
Vedant Kumar0acf3432017-09-22 18:23:04 +000065 llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
66 llvm::cl::init(false));
67
Julien Lerouge5a6b6982011-09-09 22:41:49 +000068static const char AnnotationSection[] = "llvm.metadata";
69
Alp Toker82862252013-12-28 21:58:40 +000070static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
John McCallc8e01702013-04-16 22:48:15 +000071 switch (CGM.getTarget().getCXXABI().getKind()) {
Tim Northover9bb857a2013-01-31 12:13:10 +000072 case TargetCXXABI::GenericAArch64:
John McCall57625922013-01-25 23:36:14 +000073 case TargetCXXABI::GenericARM:
74 case TargetCXXABI::iOS:
Tim Northovera2ee4332014-03-29 15:09:45 +000075 case TargetCXXABI::iOS64:
Tim Northover756447a2015-10-30 16:30:36 +000076 case TargetCXXABI::WatchOS:
Zoran Jovanovic26a12162015-02-18 15:21:35 +000077 case TargetCXXABI::GenericMIPS:
John McCall57625922013-01-25 23:36:14 +000078 case TargetCXXABI::GenericItanium:
Dan Gohmanc2853072015-09-03 22:51:53 +000079 case TargetCXXABI::WebAssembly:
Alp Toker82862252013-12-28 21:58:40 +000080 return CreateItaniumCXXABI(CGM);
John McCall57625922013-01-25 23:36:14 +000081 case TargetCXXABI::Microsoft:
Alp Toker82862252013-12-28 21:58:40 +000082 return CreateMicrosoftCXXABI(CGM);
John McCall614dbdc2010-08-22 21:01:12 +000083 }
84
85 llvm_unreachable("invalid C++ ABI kind");
John McCall614dbdc2010-08-22 21:01:12 +000086}
87
Adrian Prantle74f5252015-06-30 02:26:03 +000088CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
89 const PreprocessorOptions &PPO,
90 const CodeGenOptions &CGO, llvm::Module &M,
Alex Lorenzee024992014-08-04 18:41:51 +000091 DiagnosticsEngine &diags,
92 CoverageSourceInfo *CoverageInfo)
Adrian Prantle74f5252015-06-30 02:26:03 +000093 : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
94 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
Mehdi Aminica3cf9e2015-07-24 16:04:29 +000095 Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
Reid Kleckner9305fd12016-04-13 23:37:17 +000096 VMContext(M.getContext()), Types(*this), VTables(*this),
Peter Collingbourne3afb2662016-04-28 17:09:37 +000097 SanitizerMD(new SanitizerMetadata(*this)) {
Will Dietzf54319c2013-01-18 11:30:38 +000098
Chris Lattnerece04092012-02-07 00:39:47 +000099 // Initialize the type cache.
100 llvm::LLVMContext &LLVMContext = M.getContext();
101 VoidTy = llvm::Type::getVoidTy(LLVMContext);
102 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
103 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
104 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
105 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
Abderrazek Zaafranif58a1322017-12-21 19:20:01 +0000106 HalfTy = llvm::Type::getHalfTy(LLVMContext);
Chris Lattnerece04092012-02-07 00:39:47 +0000107 FloatTy = llvm::Type::getFloatTy(LLVMContext);
108 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
109 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
110 PointerAlignInBytes =
John McCall7f416cc2015-09-08 08:05:57 +0000111 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
Yaxun Liu26f75662016-08-19 05:17:25 +0000112 SizeSizeInBytes =
113 C.toCharUnitsFromBits(C.getTargetInfo().getMaxPointerWidth()).getQuantity();
John McCall7f416cc2015-09-08 08:05:57 +0000114 IntAlignInBytes =
115 C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
Chris Lattnerece04092012-02-07 00:39:47 +0000116 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
Yaxun Liu26f75662016-08-19 05:17:25 +0000117 IntPtrTy = llvm::IntegerType::get(LLVMContext,
118 C.getTargetInfo().getMaxPointerWidth());
Chris Lattnerece04092012-02-07 00:39:47 +0000119 Int8PtrTy = Int8Ty->getPointerTo(0);
120 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
Yaxun Liu7f7f3232017-04-17 20:03:11 +0000121 AllocaInt8PtrTy = Int8Ty->getPointerTo(
122 M.getDataLayout().getAllocaAddrSpace());
Yaxun Liu6d96f1632017-05-18 18:51:09 +0000123 ASTAllocaAddressSpace = getTargetCodeGenInfo().getASTAllocaAddressSpace();
Chris Lattnerece04092012-02-07 00:39:47 +0000124
John McCall882987f2013-02-28 19:01:20 +0000125 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
Anton Korobeynikovd90dd792014-12-02 16:04:58 +0000126 BuiltinCC = getTargetCodeGenInfo().getABIInfo().getBuiltinCC();
John McCall882987f2013-02-28 19:01:20 +0000127
David Blaikiebbafb8a2012-03-11 07:00:24 +0000128 if (LangOpts.ObjC1)
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000129 createObjCRuntime();
David Blaikiebbafb8a2012-03-11 07:00:24 +0000130 if (LangOpts.OpenCL)
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000131 createOpenCLRuntime();
Alexey Bataev9959db52014-05-06 10:08:46 +0000132 if (LangOpts.OpenMP)
133 createOpenMPRuntime();
David Blaikiebbafb8a2012-03-11 07:00:24 +0000134 if (LangOpts.CUDA)
Peter Collingbournefe883422011-10-06 18:29:37 +0000135 createCUDARuntime();
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000136
Kostya Serebryany5dd2cfc2012-04-24 06:57:01 +0000137 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
Alexey Samsonovedf99a92014-11-07 22:29:38 +0000138 if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
Kostya Serebryany5dd2cfc2012-04-24 06:57:01 +0000139 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
Ivan A. Kosarev4e50e702017-11-27 09:39:29 +0000140 TBAA.reset(new CodeGenTBAA(Context, TheModule, CodeGenOpts, getLangOpts(),
Reid Kleckner9305fd12016-04-13 23:37:17 +0000141 getCXXABI().getMangleContext()));
Dan Gohman947c9af2010-10-14 23:06:10 +0000142
Nick Lewycky207bce32011-04-21 23:44:07 +0000143 // If debug info or coverage generation is enabled, create the CGDebugInfo
144 // object.
Benjamin Kramer8c305922016-02-02 11:06:51 +0000145 if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo ||
146 CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
Reid Kleckner9305fd12016-04-13 23:37:17 +0000147 DebugInfo.reset(new CGDebugInfo(*this));
John McCallad7c5c12011-02-08 08:22:06 +0000148
149 Block.GlobalUniqueCount = 0;
John McCalle3dc1702011-02-15 09:22:45 +0000150
John McCallb04ecb72015-10-21 18:06:43 +0000151 if (C.getLangOpts().ObjC1)
Reid Kleckner9305fd12016-04-13 23:37:17 +0000152 ObjCData.reset(new ObjCEntrypoints());
Justin Bogneref512b92014-01-06 22:27:43 +0000153
Rong Xu9c6f1532016-03-02 20:59:36 +0000154 if (CodeGenOpts.hasProfileClangUse()) {
155 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
156 CodeGenOpts.ProfileInstrumentUsePath);
Vedant Kumarfa2d5952016-05-19 03:54:54 +0000157 if (auto E = ReaderOrErr.takeError()) {
Justin Bogner837a6f62014-04-18 21:52:00 +0000158 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
Diego Novillo5aecacb2015-06-25 22:56:00 +0000159 "Could not read profile %0: %1");
Vedant Kumarfa2d5952016-05-19 03:54:54 +0000160 llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
161 getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath
162 << EI.message();
163 });
Nico Weber176efac2015-04-06 04:16:48 +0000164 } else
165 PGOReader = std::move(ReaderOrErr.get());
Justin Bogner837a6f62014-04-18 21:52:00 +0000166 }
Alex Lorenzee024992014-08-04 18:41:51 +0000167
168 // If coverage mapping generation is enabled, create the
169 // CoverageMappingModuleGen object.
170 if (CodeGenOpts.CoverageMapping)
171 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
Chris Lattnera087ff92008-03-01 08:45:05 +0000172}
173
Reid Kleckner9305fd12016-04-13 23:37:17 +0000174CodeGenModule::~CodeGenModule() {}
Ted Kremenek2c674f62008-08-05 18:50:11 +0000175
David Chisnall481e3a82010-01-23 02:40:42 +0000176void CodeGenModule::createObjCRuntime() {
John McCall5fb5df92012-06-20 06:18:46 +0000177 // This is just isGNUFamily(), but we want to force implementors of
178 // new ABIs to decide how best to do this.
179 switch (LangOpts.ObjCRuntime.getKind()) {
David Chisnallb601c962012-07-03 20:49:52 +0000180 case ObjCRuntime::GNUstep:
181 case ObjCRuntime::GCC:
John McCall775086e2012-07-12 02:07:58 +0000182 case ObjCRuntime::ObjFW:
Reid Kleckner9305fd12016-04-13 23:37:17 +0000183 ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
John McCall5fb5df92012-06-20 06:18:46 +0000184 return;
185
186 case ObjCRuntime::FragileMacOSX:
187 case ObjCRuntime::MacOSX:
188 case ObjCRuntime::iOS:
Tim Northover756447a2015-10-30 16:30:36 +0000189 case ObjCRuntime::WatchOS:
Reid Kleckner9305fd12016-04-13 23:37:17 +0000190 ObjCRuntime.reset(CreateMacObjCRuntime(*this));
John McCall5fb5df92012-06-20 06:18:46 +0000191 return;
192 }
193 llvm_unreachable("bad runtime kind");
David Chisnall481e3a82010-01-23 02:40:42 +0000194}
195
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000196void CodeGenModule::createOpenCLRuntime() {
Reid Kleckner9305fd12016-04-13 23:37:17 +0000197 OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000198}
199
Alexey Bataev9959db52014-05-06 10:08:46 +0000200void CodeGenModule::createOpenMPRuntime() {
Samuel Antao45bfe4c2016-02-08 15:59:20 +0000201 // Select a specialized code generation class based on the target, if any.
202 // If it does not exist use the default implementation.
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +0000203 switch (getTriple().getArch()) {
Samuel Antao45bfe4c2016-02-08 15:59:20 +0000204 case llvm::Triple::nvptx:
205 case llvm::Triple::nvptx64:
206 assert(getLangOpts().OpenMPIsDevice &&
207 "OpenMP NVPTX is only prepared to deal with device code.");
Reid Kleckner9305fd12016-04-13 23:37:17 +0000208 OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this));
Samuel Antao45bfe4c2016-02-08 15:59:20 +0000209 break;
210 default:
Alexey Bataeva8a9153a2017-12-29 18:07:07 +0000211 if (LangOpts.OpenMPSimd)
212 OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
213 else
214 OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
Samuel Antao45bfe4c2016-02-08 15:59:20 +0000215 break;
216 }
Alexey Bataev9959db52014-05-06 10:08:46 +0000217}
218
Peter Collingbournefe883422011-10-06 18:29:37 +0000219void CodeGenModule::createCUDARuntime() {
Reid Kleckner9305fd12016-04-13 23:37:17 +0000220 CUDARuntime.reset(CreateNVCUDARuntime(*this));
Peter Collingbournefe883422011-10-06 18:29:37 +0000221}
222
Rafael Espindola1e4df922014-09-16 15:18:21 +0000223void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
224 Replacements[Name] = C;
225}
226
Rafael Espindola2e2995b2013-11-05 21:37:29 +0000227void CodeGenModule::applyReplacements() {
Yaron Kerenb54db522015-06-11 12:33:25 +0000228 for (auto &I : Replacements) {
229 StringRef MangledName = I.first();
230 llvm::Constant *Replacement = I.second;
Rafael Espindola2e2995b2013-11-05 21:37:29 +0000231 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
232 if (!Entry)
233 continue;
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000234 auto *OldF = cast<llvm::Function>(Entry);
235 auto *NewF = dyn_cast<llvm::Function>(Replacement);
Rafael Espindola0196a1d2013-11-12 04:53:19 +0000236 if (!NewF) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000237 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
Rafael Espindola0fcad882014-05-16 22:20:18 +0000238 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
Reid Klecknerb78257d2014-02-03 18:54:51 +0000239 } else {
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000240 auto *CE = cast<llvm::ConstantExpr>(Replacement);
Reid Klecknerb78257d2014-02-03 18:54:51 +0000241 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
242 CE->getOpcode() == llvm::Instruction::GetElementPtr);
243 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
244 }
Rafael Espindola0196a1d2013-11-12 04:53:19 +0000245 }
246
247 // Replace old with new, but keep the old order.
248 OldF->replaceAllUsesWith(Replacement);
249 if (NewF) {
250 NewF->removeFromParent();
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +0000251 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
252 NewF);
Rafael Espindola0196a1d2013-11-12 04:53:19 +0000253 }
254 OldF->eraseFromParent();
Rafael Espindola2e2995b2013-11-05 21:37:29 +0000255 }
256}
257
Andrey Bokhankocab58582015-08-31 13:20:44 +0000258void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
259 GlobalValReplacements.push_back(std::make_pair(GV, C));
260}
261
262void CodeGenModule::applyGlobalValReplacements() {
263 for (auto &I : GlobalValReplacements) {
264 llvm::GlobalValue *GV = I.first;
265 llvm::Constant *C = I.second;
266
267 GV->replaceAllUsesWith(C);
268 GV->eraseFromParent();
269 }
270}
271
Rafael Espindola27c60b52014-06-03 02:42:01 +0000272// This is only used in aliases that we created and we know they have a
273// linear structure.
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000274static const llvm::GlobalObject *getAliasedGlobal(
275 const llvm::GlobalIndirectSymbol &GIS) {
276 llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
277 const llvm::Constant *C = &GIS;
Rafael Espindola27c60b52014-06-03 02:42:01 +0000278 for (;;) {
Rafael Espindolae11f40a2014-06-04 19:03:20 +0000279 C = C->stripPointerCasts();
Rafael Espindola27c60b52014-06-03 02:42:01 +0000280 if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
281 return GO;
282 // stripPointerCasts will not walk over weak aliases.
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000283 auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C);
284 if (!GIS2)
Rafael Espindola27c60b52014-06-03 02:42:01 +0000285 return nullptr;
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000286 if (!Visited.insert(GIS2).second)
Rafael Espindola27c60b52014-06-03 02:42:01 +0000287 return nullptr;
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000288 C = GIS2->getIndirectSymbol();
Rafael Espindola27c60b52014-06-03 02:42:01 +0000289 }
290}
291
Rafael Espindola208b5c02013-10-22 19:26:13 +0000292void CodeGenModule::checkAliases() {
Rafael Espindolaa39fc6d2014-03-27 15:27:20 +0000293 // Check if the constructed aliases are well formed. It is really unfortunate
294 // that we have to do this in CodeGen, but we only construct mangled names
295 // and aliases during codegen.
Rafael Espindola208b5c02013-10-22 19:26:13 +0000296 bool Error = false;
Rafael Espindolac67b8152014-05-05 19:33:09 +0000297 DiagnosticsEngine &Diags = getDiags();
Yaron Kerenb54db522015-06-11 12:33:25 +0000298 for (const GlobalDecl &GD : Aliases) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000299 const auto *D = cast<ValueDecl>(GD.getDecl());
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000300 SourceLocation Location;
301 bool IsIFunc = D->hasAttr<IFuncAttr>();
302 if (const Attr *A = D->getDefiningAttr())
303 Location = A->getLocation();
304 else
305 llvm_unreachable("Not an alias or ifunc?");
Rafael Espindola208b5c02013-10-22 19:26:13 +0000306 StringRef MangledName = getMangledName(GD);
307 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000308 auto *Alias = cast<llvm::GlobalIndirectSymbol>(Entry);
Rafael Espindola27c60b52014-06-03 02:42:01 +0000309 const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
310 if (!GV) {
311 Error = true;
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000312 Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
Rafael Espindola27c60b52014-06-03 02:42:01 +0000313 } else if (GV->isDeclaration()) {
Rafael Espindola93c7a652014-03-13 15:47:50 +0000314 Error = true;
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000315 Diags.Report(Location, diag::err_alias_to_undefined)
316 << IsIFunc << IsIFunc;
317 } else if (IsIFunc) {
318 // Check resolver function type.
319 llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
320 GV->getType()->getPointerElementType());
321 assert(FTy);
322 if (!FTy->getReturnType()->isPointerTy())
323 Diags.Report(Location, diag::err_ifunc_resolver_return);
324 if (FTy->getNumParams())
325 Diags.Report(Location, diag::err_ifunc_resolver_params);
Rafael Espindola208b5c02013-10-22 19:26:13 +0000326 }
Rafael Espindolaa39fc6d2014-03-27 15:27:20 +0000327
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000328 llvm::Constant *Aliasee = Alias->getIndirectSymbol();
Rafael Espindola27c60b52014-06-03 02:42:01 +0000329 llvm::GlobalValue *AliaseeGV;
330 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
331 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
332 else
333 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
334
Rafael Espindola502f65a2014-05-05 20:21:03 +0000335 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
336 StringRef AliasSection = SA->getName();
Rafael Espindola27c60b52014-06-03 02:42:01 +0000337 if (AliasSection != AliaseeGV->getSection())
Rafael Espindola502f65a2014-05-05 20:21:03 +0000338 Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000339 << AliasSection << IsIFunc << IsIFunc;
Rafael Espindola502f65a2014-05-05 20:21:03 +0000340 }
Rafael Espindola27c60b52014-06-03 02:42:01 +0000341
342 // We have to handle alias to weak aliases in here. LLVM itself disallows
343 // this since the object semantics would not match the IL one. For
344 // compatibility with gcc we implement it by just pointing the alias
345 // to its aliasee's aliasee. We also warn, since the user is probably
346 // expecting the link to be weak.
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000347 if (auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) {
Sanjoy Dasf60a0d72016-04-08 01:31:02 +0000348 if (GA->isInterposable()) {
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000349 Diags.Report(Location, diag::warn_alias_to_weak_alias)
350 << GV->getName() << GA->getName() << IsIFunc;
Rafael Espindola27c60b52014-06-03 02:42:01 +0000351 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000352 GA->getIndirectSymbol(), Alias->getType());
353 Alias->setIndirectSymbol(Aliasee);
Rafael Espindola27c60b52014-06-03 02:42:01 +0000354 }
355 }
Rafael Espindola208b5c02013-10-22 19:26:13 +0000356 }
357 if (!Error)
358 return;
359
Yaron Kerenb54db522015-06-11 12:33:25 +0000360 for (const GlobalDecl &GD : Aliases) {
Rafael Espindola208b5c02013-10-22 19:26:13 +0000361 StringRef MangledName = getMangledName(GD);
362 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Dmitry Polukhin85eda122016-04-11 07:48:59 +0000363 auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
Rafael Espindola208b5c02013-10-22 19:26:13 +0000364 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
365 Alias->eraseFromParent();
366 }
367}
368
Rafael Espindolac0ff7442013-12-09 14:59:08 +0000369void CodeGenModule::clear() {
370 DeferredDeclsToEmit.clear();
Alexey Bataev91797552015-03-18 04:13:55 +0000371 if (OpenMPRuntime)
372 OpenMPRuntime->clear();
Rafael Espindolac0ff7442013-12-09 14:59:08 +0000373}
374
Justin Bogner40b8ba12014-06-26 01:45:07 +0000375void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags,
376 StringRef MainFile) {
377 if (!hasDiagnostics())
378 return;
379 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
380 if (MainFile.empty())
381 MainFile = "<stdin>";
382 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
Vedant Kumar96d6ca72017-04-27 17:30:58 +0000383 } else {
384 if (Mismatched > 0)
385 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
386
387 if (Missing > 0)
388 Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
389 }
Justin Bogner40b8ba12014-06-26 01:45:07 +0000390}
391
Ted Kremenek2c674f62008-08-05 18:50:11 +0000392void CodeGenModule::Release() {
Chris Lattnera5ae54a2009-03-22 21:21:57 +0000393 EmitDeferred();
Piotr Padlewskid3b1cbd2017-06-01 08:04:05 +0000394 EmitVTablesOpportunistically();
Andrey Bokhankocab58582015-08-31 13:20:44 +0000395 applyGlobalValReplacements();
Rafael Espindola2e2995b2013-11-05 21:37:29 +0000396 applyReplacements();
Rafael Espindola208b5c02013-10-22 19:26:13 +0000397 checkAliases();
Erich Keane281d20b2018-01-08 21:34:17 +0000398 emitMultiVersionFunctions();
Eli Friedman5866fe32010-01-08 00:50:11 +0000399 EmitCXXGlobalInitFunc();
Daniel Dunbarfe06df42010-03-20 04:15:41 +0000400 EmitCXXGlobalDtorFunc();
Richard Smith2fd1d7a2013-04-19 16:42:07 +0000401 EmitCXXThreadLocalInitFunc();
Peter Collingbournee1d20992011-07-27 20:29:46 +0000402 if (ObjCRuntime)
403 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar8d480592008-08-11 18:12:00 +0000404 AddGlobalCtor(ObjCInitFunction);
Artem Belevich52cc4872015-05-07 19:34:16 +0000405 if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
406 CUDARuntime) {
407 if (llvm::Function *CudaCtorFunction = CUDARuntime->makeModuleCtorFunction())
408 AddGlobalCtor(CudaCtorFunction);
409 if (llvm::Function *CudaDtorFunction = CUDARuntime->makeModuleDtorFunction())
410 AddGlobalDtor(CudaDtorFunction);
411 }
Samuel Antaoee8fb302016-01-06 13:42:12 +0000412 if (OpenMPRuntime)
413 if (llvm::Function *OpenMPRegistrationFunction =
George Rokos29d0f002017-05-27 03:03:13 +0000414 OpenMPRuntime->emitRegistrationFunction()) {
415 auto ComdatKey = OpenMPRegistrationFunction->hasComdat() ?
416 OpenMPRegistrationFunction : nullptr;
417 AddGlobalCtor(OpenMPRegistrationFunction, 0, ComdatKey);
418 }
Easwaran Raman695890c2015-12-17 19:14:27 +0000419 if (PGOReader) {
Easwaran Raman81608122016-03-24 21:32:25 +0000420 getModule().setProfileSummary(PGOReader->getSummary().getMD(VMContext));
Easwaran Raman695890c2015-12-17 19:14:27 +0000421 if (PGOStats.hasDiagnostics())
422 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
423 }
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000424 EmitCtorList(GlobalCtors, "llvm.global_ctors");
425 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000426 EmitGlobalAnnotations();
Richard Smithdf931ce2013-04-06 05:00:46 +0000427 EmitStaticExternCAliases();
Alex Lorenzee024992014-08-04 18:41:51 +0000428 EmitDeferredUnusedCoverageMappings();
429 if (CoverageMapping)
430 CoverageMapping->emit();
Evgeniy Stepanov1a8030e2017-04-07 23:00:38 +0000431 if (CodeGenOpts.SanitizeCfiCrossDso) {
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +0000432 CodeGenFunction(*this).EmitCfiCheckFail();
Evgeniy Stepanov1a8030e2017-04-07 23:00:38 +0000433 CodeGenFunction(*this).EmitCfiCheckStub();
434 }
Alex Lorenza8fbef42017-03-23 11:14:27 +0000435 emitAtAvailableLinkGuard();
Rafael Espindola060062a2014-03-06 22:15:10 +0000436 emitLLVMUsed();
Peter Collingbournedc134532016-01-16 00:31:22 +0000437 if (SanStats)
438 SanStats->finish();
Douglas Gregorc60437f2013-01-16 01:23:41 +0000439
Reid Klecknere43f0fe2013-05-08 13:44:39 +0000440 if (CodeGenOpts.Autolink &&
441 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
Douglas Gregorc60437f2013-01-16 01:23:41 +0000442 EmitModuleLinkOptions();
443 }
Nirav Dave8497ef42017-03-18 00:43:39 +0000444
Nirav Dave741dea02017-03-30 13:41:44 +0000445 // Record mregparm value now so it is visible through rest of codegen.
446 if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
447 getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
448 CodeGenOpts.NumRegisterParameters);
Jake Ehrlichc451cf22017-11-11 01:15:41 +0000449
Reid Kleckner124955a2015-08-05 18:51:13 +0000450 if (CodeGenOpts.DwarfVersion) {
Manman Ren9691f7f2013-06-19 01:46:49 +0000451 // We actually want the latest version when there are conflicts.
452 // We can change from Warning to Latest if such mode is supported.
453 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
454 CodeGenOpts.DwarfVersion);
Reid Kleckner124955a2015-08-05 18:51:13 +0000455 }
456 if (CodeGenOpts.EmitCodeView) {
457 // Indicate that we want CodeView in the metadata.
458 getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
459 }
Adrian McCarthydb2736d2018-01-09 23:49:30 +0000460 if (CodeGenOpts.ControlFlowGuard) {
461 // We want function ID tables for Control Flow Guard.
462 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 1);
463 }
Piotr Padlewski9d0ecf22015-09-15 21:46:50 +0000464 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
465 // We don't support LTO with 2 with different StrictVTablePointers
466 // FIXME: we could support it by stripping all the information introduced
467 // by StrictVTablePointers.
468
469 getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
470
471 llvm::Metadata *Ops[2] = {
472 llvm::MDString::get(VMContext, "StrictVTablePointers"),
473 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
474 llvm::Type::getInt32Ty(VMContext), 1))};
475
476 getModule().addModuleFlag(llvm::Module::Require,
477 "StrictVTablePointersRequirement",
478 llvm::MDNode::get(VMContext, Ops));
479 }
Manman Ren4b7f23d2013-11-22 19:42:45 +0000480 if (DebugInfo)
Adrian Prantl2dbdd202014-05-19 23:40:06 +0000481 // We support a single version in the linked module. The LLVM
482 // parser will drop debug info with a different version number
483 // (and warn about it, too).
484 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
Manman Ren61fd5942013-12-02 20:10:37 +0000485 llvm::DEBUG_METADATA_VERSION);
Douglas Gregorea02f262013-01-14 18:28:43 +0000486
Oliver Stannarde3a4fb62014-06-20 12:43:07 +0000487 // We need to record the widths of enums and wchar_t, so that we can generate
Matthias Brauna4519532017-05-20 01:29:55 +0000488 // the correct build attributes in the ARM backend. wchar_size is also used by
489 // TargetLibraryInfo.
Matthias Braunbffc1bb2017-09-26 02:37:23 +0000490 uint64_t WCharWidth =
491 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
Matthias Brauna4519532017-05-20 01:29:55 +0000492 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
493
Justin Bogner9bb7f152014-06-23 20:03:28 +0000494 llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
Oliver Stannarde3a4fb62014-06-20 12:43:07 +0000495 if ( Arch == llvm::Triple::arm
496 || Arch == llvm::Triple::armeb
497 || Arch == llvm::Triple::thumb
498 || Arch == llvm::Triple::thumbeb) {
Oliver Stannarde3a4fb62014-06-20 12:43:07 +0000499 // The minimum width of an enum in bytes
500 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
501 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
502 }
503
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +0000504 if (CodeGenOpts.SanitizeCfiCrossDso) {
505 // Indicate that we want cross-DSO control flow integrity checks.
506 getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
507 }
508
Oren Ben Simhon57cc1a52018-01-09 08:53:59 +0000509 if (CodeGenOpts.CFProtectionReturn &&
510 Target.checkCFProtectionReturnSupported(getDiags())) {
511 // Indicate that we want to instrument return control flow protection.
512 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-return",
513 1);
514 }
515
516 if (CodeGenOpts.CFProtectionBranch &&
517 Target.checkCFProtectionBranchSupported(getDiags())) {
518 // Indicate that we want to instrument branch control flow protection.
519 getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch",
520 1);
521 }
522
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +0000523 if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
Justin Lebard3a44f62016-04-05 18:26:20 +0000524 // Indicate whether __nvvm_reflect should be configured to flush denormal
525 // floating point values to 0. (This corresponds to its "__CUDA_FTZ"
526 // property.)
527 getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
528 LangOpts.CUDADeviceFlushDenormalsToZero ? 1 : 0);
529 }
530
Alexey Bader364a1162017-06-20 14:30:18 +0000531 // Emit OpenCL specific module metadata: OpenCL/SPIR version.
532 if (LangOpts.OpenCL) {
533 EmitOpenCLMetadata();
534 // Emit SPIR version.
535 if (getTriple().getArch() == llvm::Triple::spir ||
536 getTriple().getArch() == llvm::Triple::spir64) {
537 // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
538 // opencl.spir.version named metadata.
539 llvm::Metadata *SPIRVerElts[] = {
540 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
541 Int32Ty, LangOpts.OpenCLVersion / 100)),
542 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
543 Int32Ty, (LangOpts.OpenCLVersion / 100 > 1) ? 0 : 2))};
544 llvm::NamedMDNode *SPIRVerMD =
545 TheModule.getOrInsertNamedMetadata("opencl.spir.version");
546 llvm::LLVMContext &Ctx = TheModule.getContext();
547 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
548 }
549 }
550
Justin Hibbits90ca05e2014-11-18 06:17:20 +0000551 if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
Sriraman Tallam70e70e62016-04-28 22:34:00 +0000552 assert(PLevel < 3 && "Invalid PIC Level");
553 getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
Rafael Espindolac9d336e2016-06-23 15:07:32 +0000554 if (Context.getLangOpts().PIE)
555 getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
Justin Hibbits90ca05e2014-11-18 06:17:20 +0000556 }
557
Sriraman Tallam80af0052018-02-23 21:27:33 +0000558 if (CodeGenOpts.NoPLT)
559 getModule().setRtLibUseGOT();
560
John McCall0bdb1fd2010-09-16 06:16:50 +0000561 SimplifyPersonality();
562
John McCall09ae0322010-07-06 23:57:41 +0000563 if (getCodeGenOpts().EmitDeclMetadata)
564 EmitDeclMetadata();
Nick Lewycky480cb992011-05-04 20:46:58 +0000565
566 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky85c011d2011-05-05 00:08:20 +0000567 EmitCoverageFile();
Devang Patelffa30ab2011-08-16 20:58:22 +0000568
569 if (DebugInfo)
570 DebugInfo->finalize();
Rafael Espindola3bfa4682013-10-16 19:28:50 +0000571
572 EmitVersionIdentMetadata();
Robert Lytton57765d52014-07-03 09:30:33 +0000573
574 EmitTargetMetadata();
Daniel Dunbar23fd4622008-10-01 00:49:24 +0000575}
576
Alexey Bader364a1162017-06-20 14:30:18 +0000577void CodeGenModule::EmitOpenCLMetadata() {
578 // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
579 // opencl.ocl.version named metadata node.
580 llvm::Metadata *OCLVerElts[] = {
581 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
582 Int32Ty, LangOpts.OpenCLVersion / 100)),
583 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
584 Int32Ty, (LangOpts.OpenCLVersion % 100) / 10))};
585 llvm::NamedMDNode *OCLVerMD =
586 TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
587 llvm::LLVMContext &Ctx = TheModule.getContext();
588 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
589}
590
Devang Patel945b8ae2011-03-23 16:29:39 +0000591void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
592 // Make sure that this type is translated.
593 Types.UpdateCompletedType(TD);
Devang Patel945b8ae2011-03-23 16:29:39 +0000594}
595
David Majnemer929025d2016-01-26 19:30:26 +0000596void CodeGenModule::RefreshTypeCacheForClass(const CXXRecordDecl *RD) {
597 // Make sure that this type is translated.
598 Types.RefreshTypeCacheForClass(RD);
599}
600
Ivan A. Kosarev289574e2017-10-02 09:54:47 +0000601llvm::MDNode *CodeGenModule::getTBAATypeInfo(QualType QTy) {
Dan Gohman947c9af2010-10-14 23:06:10 +0000602 if (!TBAA)
Craig Topper8a13c412014-05-21 05:09:00 +0000603 return nullptr;
Ivan A. Kosarev289574e2017-10-02 09:54:47 +0000604 return TBAA->getTypeInfo(QTy);
Dan Gohman947c9af2010-10-14 23:06:10 +0000605}
606
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000607TBAAAccessInfo CodeGenModule::getTBAAAccessInfo(QualType AccessType) {
Ivan A. Kosarev124a2182018-02-20 12:33:04 +0000608 if (!TBAA)
609 return TBAAAccessInfo();
610 return TBAA->getAccessInfo(AccessType);
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000611}
612
Ivan A. Kosarev4e50e702017-11-27 09:39:29 +0000613TBAAAccessInfo
614CodeGenModule::getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType) {
Kostya Serebryany141e46f2012-03-26 17:03:51 +0000615 if (!TBAA)
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000616 return TBAAAccessInfo();
Ivan A. Kosarev4e50e702017-11-27 09:39:29 +0000617 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
Kostya Serebryany141e46f2012-03-26 17:03:51 +0000618}
619
Dan Gohman22695fc2012-09-28 21:58:29 +0000620llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
621 if (!TBAA)
Craig Topper8a13c412014-05-21 05:09:00 +0000622 return nullptr;
Dan Gohman22695fc2012-09-28 21:58:29 +0000623 return TBAA->getTBAAStructInfo(QTy);
624}
625
Ivan A. Kosarev383890b2017-10-06 08:17:48 +0000626llvm::MDNode *CodeGenModule::getTBAABaseTypeInfo(QualType QTy) {
627 if (!TBAA)
628 return nullptr;
629 return TBAA->getBaseTypeInfo(QTy);
630}
631
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000632llvm::MDNode *CodeGenModule::getTBAAAccessTagInfo(TBAAAccessInfo Info) {
Manman Renc451e572013-04-04 21:53:22 +0000633 if (!TBAA)
Craig Topper8a13c412014-05-21 05:09:00 +0000634 return nullptr;
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000635 return TBAA->getAccessTagInfo(Info);
Manman Renc451e572013-04-04 21:53:22 +0000636}
637
Ivan A. Kosareved141ba2017-10-17 09:12:13 +0000638TBAAAccessInfo CodeGenModule::mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,
639 TBAAAccessInfo TargetInfo) {
640 if (!TBAA)
641 return TBAAAccessInfo();
642 return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
643}
644
Ivan A. Kosarevb9c59f32017-10-31 11:05:34 +0000645TBAAAccessInfo
646CodeGenModule::mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,
647 TBAAAccessInfo InfoB) {
648 if (!TBAA)
649 return TBAAAccessInfo();
650 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
651}
652
Ivan A. Kosarev1860b522018-01-25 14:21:55 +0000653TBAAAccessInfo
654CodeGenModule::mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,
655 TBAAAccessInfo SrcInfo) {
656 if (!TBAA)
657 return TBAAAccessInfo();
658 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
659}
660
Piotr Padlewski4b1ac722015-09-15 21:46:55 +0000661void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst,
Ivan A. Kosarev3d68ce92017-10-05 11:08:17 +0000662 TBAAAccessInfo TBAAInfo) {
663 if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
664 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
Dan Gohman947c9af2010-10-14 23:06:10 +0000665}
666
Piotr Padlewski4b1ac722015-09-15 21:46:55 +0000667void CodeGenModule::DecorateInstructionWithInvariantGroup(
668 llvm::Instruction *I, const CXXRecordDecl *RD) {
Piotr Padlewski34046bd2017-04-24 12:58:43 +0000669 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
670 llvm::MDNode::get(getLLVMContext(), {}));
Piotr Padlewski4b1ac722015-09-15 21:46:55 +0000671}
672
Alp Toker29cb66b2014-01-26 06:17:37 +0000673void CodeGenModule::Error(SourceLocation loc, StringRef message) {
674 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
675 getDiags().Report(Context.getFullLoc(loc), diagID) << message;
John McCall7ef5cb32011-03-18 02:56:14 +0000676}
677
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000678/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000679/// specified stmt yet.
David Blaikie4a9ec7b2013-08-19 21:02:26 +0000680void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
David Blaikie9c902b52011-09-25 23:23:43 +0000681 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000682 "cannot compile this %0 yet");
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000683 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000684 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
685 << Msg << S->getSourceRange();
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000686}
Chris Lattner41af8182007-12-02 06:27:33 +0000687
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000688/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner38376f12008-01-12 07:05:38 +0000689/// specified decl yet.
David Blaikie4a9ec7b2013-08-19 21:02:26 +0000690void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
David Blaikie9c902b52011-09-25 23:23:43 +0000691 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000692 "cannot compile this %0 yet");
Chris Lattner38376f12008-01-12 07:05:38 +0000693 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000694 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattner38376f12008-01-12 07:05:38 +0000695}
696
John McCall23c29fe2011-06-24 21:55:10 +0000697llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
698 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
699}
700
Mike Stump11289f42009-09-09 15:08:12 +0000701void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Rafael Espindoladeb10be2018-02-07 19:04:41 +0000702 const NamedDecl *D) const {
Rafael Espindola123ce972018-01-24 18:58:32 +0000703 if (GV->hasDLLImportStorageClass())
704 return;
Daniel Dunbarf5f359f2009-04-14 06:00:08 +0000705 // Internal definitions always have default visibility.
Chris Lattner6a0f9072009-04-14 05:27:13 +0000706 if (GV->hasLocalLinkage()) {
Daniel Dunbard272cca2009-04-10 20:26:50 +0000707 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar15894b72009-04-07 05:48:37 +0000708 return;
Daniel Dunbard272cca2009-04-10 20:26:50 +0000709 }
Daniel Dunbar15894b72009-04-07 05:48:37 +0000710
John McCallc273f242010-10-30 11:50:40 +0000711 // Set visibility for definitions.
Rafael Espindolaa8fbdab2013-02-27 02:15:29 +0000712 LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindoladeb10be2018-02-07 19:04:41 +0000713 if (LV.isVisibilityExplicit() || !GV->isDeclarationForLinker())
Rafael Espindola4a5da442013-02-27 02:56:45 +0000714 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
Dan Gohman75d69da2008-05-22 00:50:06 +0000715}
716
Rafael Espindola699f5d62018-02-07 22:15:33 +0000717static bool shouldAssumeDSOLocal(const CodeGenModule &CGM,
Rafael Espindola3dd49812018-02-23 00:22:15 +0000718 llvm::GlobalValue *GV) {
Rafael Espindola922f2aa2018-02-23 19:30:48 +0000719 // DLLImport explicitly marks the GV as external.
720 if (GV->hasDLLImportStorageClass())
721 return false;
722
Rafael Espindola699f5d62018-02-07 22:15:33 +0000723 const llvm::Triple &TT = CGM.getTriple();
Rafael Espindola922f2aa2018-02-23 19:30:48 +0000724 // Every other GV is local on COFF.
725 // Make an exception for windows OS in the triple: Some firmware builds use
726 // *-win32-macho triples. This (accidentally?) produced windows relocations
727 // without GOT tables in older clang versions; Keep this behaviour.
728 // FIXME: even thread local variables?
729 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
730 return true;
731
732 // Only handle COFF and ELF for now.
Rafael Espindola699f5d62018-02-07 22:15:33 +0000733 if (!TT.isOSBinFormatELF())
734 return false;
735
736 // If this is not an executable, don't assume anything is local.
737 const auto &CGOpts = CGM.getCodeGenOpts();
738 llvm::Reloc::Model RM = CGOpts.RelocationModel;
739 const auto &LOpts = CGM.getLangOpts();
740 if (RM != llvm::Reloc::Static && !LOpts.PIE)
741 return false;
742
743 // A definition cannot be preempted from an executable.
744 if (!GV->isDeclarationForLinker())
745 return true;
746
747 // Most PIC code sequences that assume that a symbol is local cannot produce a
748 // 0 if it turns out the symbol is undefined. While this is ABI and relocation
749 // depended, it seems worth it to handle it here.
750 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
751 return false;
752
753 // PPC has no copy relocations and cannot use a plt entry as a symbol address.
754 llvm::Triple::ArchType Arch = TT.getArch();
755 if (Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
756 Arch == llvm::Triple::ppc64le)
757 return false;
758
759 // If we can use copy relocations we can assume it is local.
Rafael Espindola3dd49812018-02-23 00:22:15 +0000760 if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
761 if (!Var->isThreadLocal() &&
Rafael Espindola75e57362018-02-07 23:04:06 +0000762 (RM == llvm::Reloc::Static || CGOpts.PIECopyRelocations))
763 return true;
Rafael Espindola699f5d62018-02-07 22:15:33 +0000764
765 // If we can use a plt entry as the symbol address we can assume it
766 // is local.
767 // FIXME: This should work for PIE, but the gold linker doesn't support it.
Rafael Espindola3dd49812018-02-23 00:22:15 +0000768 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
Rafael Espindola699f5d62018-02-07 22:15:33 +0000769 return true;
770
771 // Otherwise don't assue it is local.
772 return false;
773}
774
Rafael Espindola3dd49812018-02-23 00:22:15 +0000775void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
776 if (shouldAssumeDSOLocal(*this, GV))
Rafael Espindola699f5d62018-02-07 22:15:33 +0000777 GV->setDSOLocal(true);
778}
779
780void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
781 const NamedDecl *D) const {
782 setGlobalVisibility(GV, D);
Rafael Espindola3dd49812018-02-23 00:22:15 +0000783 setDSOLocal(GV);
Rafael Espindola699f5d62018-02-07 22:15:33 +0000784}
785
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000786static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
787 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
788 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
789 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
790 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
791 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
792}
793
794static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
795 CodeGenOptions::TLSModel M) {
796 switch (M) {
797 case CodeGenOptions::GeneralDynamicTLSModel:
798 return llvm::GlobalVariable::GeneralDynamicTLSModel;
799 case CodeGenOptions::LocalDynamicTLSModel:
800 return llvm::GlobalVariable::LocalDynamicTLSModel;
801 case CodeGenOptions::InitialExecTLSModel:
802 return llvm::GlobalVariable::InitialExecTLSModel;
803 case CodeGenOptions::LocalExecTLSModel:
804 return llvm::GlobalVariable::LocalExecTLSModel;
805 }
806 llvm_unreachable("Invalid TLS model!");
807}
808
David Majnemerbb525f7c2014-10-15 22:38:23 +0000809void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
Richard Smithfd3834f2013-04-13 02:43:54 +0000810 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000811
David Majnemerbb525f7c2014-10-15 22:38:23 +0000812 llvm::GlobalValue::ThreadLocalMode TLM;
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000813 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000814
815 // Override the TLS model if it is explicitly specified.
Aaron Ballmanc4327992013-12-19 03:09:10 +0000816 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000817 TLM = GetLLVMTLSModel(Attr->getModel());
818 }
819
820 GV->setThreadLocalMode(TLM);
821}
822
Erich Keane281d20b2018-01-08 21:34:17 +0000823static void AppendTargetMangling(const CodeGenModule &CGM,
824 const TargetAttr *Attr, raw_ostream &Out) {
825 if (Attr->isDefaultVersion())
826 return;
827
828 Out << '.';
829 const auto &Target = CGM.getTarget();
830 TargetAttr::ParsedTargetAttr Info =
831 Attr->parse([&Target](StringRef LHS, StringRef RHS) {
George Burgess IV19131152018-01-17 04:46:04 +0000832 // Multiversioning doesn't allow "no-${feature}", so we can
833 // only have "+" prefixes here.
834 assert(LHS.startswith("+") && RHS.startswith("+") &&
835 "Features should always have a prefix.");
836 return Target.multiVersionSortPriority(LHS.substr(1)) >
837 Target.multiVersionSortPriority(RHS.substr(1));
Erich Keane281d20b2018-01-08 21:34:17 +0000838 });
839
840 bool IsFirst = true;
841
842 if (!Info.Architecture.empty()) {
843 IsFirst = false;
844 Out << "arch_" << Info.Architecture;
845 }
846
847 for (StringRef Feat : Info.Features) {
848 if (!IsFirst)
849 Out << '_';
850 IsFirst = false;
851 Out << Feat.substr(1);
852 }
853}
854
855static std::string getMangledNameImpl(const CodeGenModule &CGM, GlobalDecl GD,
856 const NamedDecl *ND,
857 bool OmitTargetMangling = false) {
858 SmallString<256> Buffer;
859 llvm::raw_svector_ostream Out(Buffer);
860 MangleContext &MC = CGM.getCXXABI().getMangleContext();
861 if (MC.shouldMangleDeclName(ND)) {
862 llvm::raw_svector_ostream Out(Buffer);
863 if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
864 MC.mangleCXXCtor(D, GD.getCtorType(), Out);
865 else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
866 MC.mangleCXXDtor(D, GD.getDtorType(), Out);
867 else
868 MC.mangleName(ND, Out);
869 } else {
870 IdentifierInfo *II = ND->getIdentifier();
871 assert(II && "Attempt to mangle unnamed decl.");
872 const auto *FD = dyn_cast<FunctionDecl>(ND);
873
874 if (FD &&
875 FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
876 llvm::raw_svector_ostream Out(Buffer);
877 Out << "__regcall3__" << II->getName();
878 } else {
879 Out << II->getName();
880 }
881 }
882
883 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
884 if (FD->isMultiVersion() && !OmitTargetMangling)
885 AppendTargetMangling(CGM, FD->getAttr<TargetAttr>(), Out);
886 return Out.str();
887}
888
889void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
890 const FunctionDecl *FD) {
891 if (!FD->isMultiVersion())
892 return;
893
894 // Get the name of what this would be without the 'target' attribute. This
895 // allows us to lookup the version that was emitted when this wasn't a
896 // multiversion function.
897 std::string NonTargetName =
898 getMangledNameImpl(*this, GD, FD, /*OmitTargetMangling=*/true);
899 GlobalDecl OtherGD;
900 if (lookupRepresentativeDecl(NonTargetName, OtherGD)) {
901 assert(OtherGD.getCanonicalDecl()
902 .getDecl()
903 ->getAsFunction()
904 ->isMultiVersion() &&
905 "Other GD should now be a multiversioned function");
906 // OtherFD is the version of this function that was mangled BEFORE
907 // becoming a MultiVersion function. It potentially needs to be updated.
908 const FunctionDecl *OtherFD =
909 OtherGD.getCanonicalDecl().getDecl()->getAsFunction();
910 std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD);
911 // This is so that if the initial version was already the 'default'
912 // version, we don't try to update it.
913 if (OtherName != NonTargetName) {
Erich Keanebc40c5c2018-01-09 01:09:12 +0000914 // Remove instead of erase, since others may have stored the StringRef
915 // to this.
916 const auto ExistingRecord = Manglings.find(NonTargetName);
917 if (ExistingRecord != std::end(Manglings))
918 Manglings.remove(&(*ExistingRecord));
Erich Keane281d20b2018-01-08 21:34:17 +0000919 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
920 MangledDeclNames[OtherGD.getCanonicalDecl()] = Result.first->first();
921 if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName))
922 Entry->setName(OtherName);
923 }
924 }
925}
926
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000927StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
David Majnemerd2385c02016-01-08 20:48:26 +0000928 GlobalDecl CanonicalGD = GD.getCanonicalDecl();
929
930 // Some ABIs don't have constructor variants. Make sure that base and
931 // complete constructors get mangled the same.
932 if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
933 if (!getTarget().getCXXABI().hasConstructorVariants()) {
934 CXXCtorType OrigCtorType = GD.getCtorType();
935 assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
936 if (OrigCtorType == Ctor_Base)
937 CanonicalGD = GlobalDecl(CD, Ctor_Complete);
938 }
939 }
940
NAKAMURA Takumi6e4d7742017-07-30 05:06:26 +0000941 auto FoundName = MangledDeclNames.find(CanonicalGD);
942 if (FoundName != MangledDeclNames.end())
943 return FoundName->second;
Alp Tokerfb8d02b2014-06-05 22:10:59 +0000944
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000945
Richard Smith6d0e97a2014-08-02 00:50:16 +0000946 // Keep the first result in the case of a mangling collision.
Erich Keane281d20b2018-01-08 21:34:17 +0000947 const auto *ND = cast<NamedDecl>(GD.getDecl());
948 auto Result =
949 Manglings.insert(std::make_pair(getMangledNameImpl(*this, GD, ND), GD));
NAKAMURA Takumi6e4d7742017-07-30 05:06:26 +0000950 return MangledDeclNames[CanonicalGD] = Result.first->first();
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000951}
952
Alp Tokerfb8d02b2014-06-05 22:10:59 +0000953StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD,
954 const BlockDecl *BD) {
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000955 MangleContext &MangleCtx = getCXXABI().getMangleContext();
956 const Decl *D = GD.getDecl();
Alp Toker0e64e0d2014-06-03 02:13:57 +0000957
Alp Tokerfb8d02b2014-06-05 22:10:59 +0000958 SmallString<256> Buffer;
959 llvm::raw_svector_ostream Out(Buffer);
Craig Topper8a13c412014-05-21 05:09:00 +0000960 if (!D)
Jake Ehrlichc451cf22017-11-11 01:15:41 +0000961 MangleCtx.mangleGlobalBlock(BD,
Fariborz Jahanian63628032012-06-26 16:06:38 +0000962 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000963 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000964 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Rafael Espindola2ae250c2014-05-09 00:08:36 +0000965 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000966 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000967 else
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000968 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Alp Toker0e64e0d2014-06-03 02:13:57 +0000969
Richard Smith6d0e97a2014-08-02 00:50:16 +0000970 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
971 return Result.first->first();
Anders Carlsson635186a2010-06-09 02:36:32 +0000972}
973
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000974llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCall7ec50432010-03-19 23:29:14 +0000975 return getModule().getNamedValue(Name);
Douglas Gregor5fec5b02009-02-13 00:10:09 +0000976}
977
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000978/// AddGlobalCtor - Add a function to the list that will be called before
979/// main() runs.
Reid Kleckner563f0e82014-05-23 21:13:45 +0000980void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
981 llvm::Constant *AssociatedData) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000982 // FIXME: Type coercion of void()* types.
Reid Kleckner563f0e82014-05-23 21:13:45 +0000983 GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000984}
985
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000986/// AddGlobalDtor - Add a function to the list that will be called
987/// when the module is unloaded.
Reid Kleckner563f0e82014-05-23 21:13:45 +0000988void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000989 // FIXME: Type coercion of void()* types.
Craig Topper4b566922014-06-09 02:04:02 +0000990 GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000991}
992
Vassil Vassilev188ad3a2016-10-27 09:12:20 +0000993void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
John McCall6c9f1fdb2016-11-19 08:17:24 +0000994 if (Fns.empty()) return;
995
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000996 // Ctor function type is void()*.
John McCall9dc0db22011-05-15 01:53:33 +0000997 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000998 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000999
Reid Kleckner563f0e82014-05-23 21:13:45 +00001000 // Get the type of a ctor entry, { i32, void ()*, i8* }.
1001 llvm::StructType *CtorStructTy = llvm::StructType::get(
Serge Guelton1d993272017-05-09 19:31:30 +00001002 Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy);
Chris Lattner5ff2d5d2008-03-14 17:18:18 +00001003
Daniel Dunbar74aa7e12008-08-01 00:01:51 +00001004 // Construct the constructor and destructor arrays.
John McCall23c9dc62016-11-28 22:18:27 +00001005 ConstantInitBuilder builder(*this);
John McCall6c9f1fdb2016-11-19 08:17:24 +00001006 auto ctors = builder.beginArray(CtorStructTy);
Yaron Kerenb54db522015-06-11 12:33:25 +00001007 for (const auto &I : Fns) {
John McCall6c9f1fdb2016-11-19 08:17:24 +00001008 auto ctor = ctors.beginStruct(CtorStructTy);
1009 ctor.addInt(Int32Ty, I.Priority);
1010 ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
1011 if (I.AssociatedData)
1012 ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy));
1013 else
1014 ctor.addNullPointer(VoidPtrTy);
John McCallf1788632016-11-28 22:18:30 +00001015 ctor.finishAndAddTo(ctors);
Chris Lattner5ff2d5d2008-03-14 17:18:18 +00001016 }
Daniel Dunbar74aa7e12008-08-01 00:01:51 +00001017
John McCall18081af2016-11-19 20:12:25 +00001018 auto list =
1019 ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
1020 /*constant*/ false,
1021 llvm::GlobalValue::AppendingLinkage);
1022
1023 // The LTO linker doesn't seem to like it when we set an alignment
1024 // on appending variables. Take it off as a workaround.
1025 list->setAlignment(0);
1026
Vassil Vassilev188ad3a2016-10-27 09:12:20 +00001027 Fns.clear();
Chris Lattner5ff2d5d2008-03-14 17:18:18 +00001028}
1029
John McCalld4324142010-02-19 01:32:20 +00001030llvm::GlobalValue::LinkageTypes
Peter Collingbourne4d90dba2013-06-05 17:49:37 +00001031CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001032 const auto *D = cast<FunctionDecl>(GD.getDecl());
Reid Klecknere7de47e2013-07-22 13:51:44 +00001033
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00001034 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar38932572009-04-14 08:05:55 +00001035
Hans Wennborg275efb92014-05-28 01:52:23 +00001036 if (isa<CXXDestructorDecl>(D) &&
Reid Klecknera283e482017-12-21 19:44:23 +00001037 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
1038 GD.getDtorType())) {
1039 // Destructor variants in the Microsoft C++ ABI are always internal or
1040 // linkonce_odr thunks emitted on an as-needed basis.
1041 return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage
1042 : llvm::GlobalValue::LinkOnceODRLinkage;
Hans Wennborg275efb92014-05-28 01:52:23 +00001043 }
Reid Klecknera283e482017-12-21 19:44:23 +00001044
Richard Smith5179eb72016-06-28 19:03:57 +00001045 if (isa<CXXConstructorDecl>(D) &&
1046 cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
1047 Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1048 // Our approach to inheriting constructors is fundamentally different from
1049 // that used by the MS ABI, so keep our inheriting constructor thunks
1050 // internal rather than trying to pick an unambiguous mangling for them.
1051 return llvm::GlobalValue::InternalLinkage;
1052 }
1053
Hans Wennborg275efb92014-05-28 01:52:23 +00001054 return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
John McCalld4324142010-02-19 01:32:20 +00001055}
Nuno Lopesb6f79532008-06-08 15:45:52 +00001056
Hans Wennborgbb4f9622015-05-28 17:44:56 +00001057void CodeGenModule::setFunctionDLLStorageClass(GlobalDecl GD, llvm::Function *F) {
1058 const auto *FD = cast<FunctionDecl>(GD.getDecl());
1059
Reid Klecknera283e482017-12-21 19:44:23 +00001060 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) {
1061 if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
Hans Wennborgbb4f9622015-05-28 17:44:56 +00001062 // Don't dllexport/import destructor thunks.
1063 F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1064 return;
1065 }
1066 }
1067
1068 if (FD->hasAttr<DLLImportAttr>())
1069 F->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1070 else if (FD->hasAttr<DLLExportAttr>())
1071 F->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1072 else
1073 F->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
1074}
1075
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00001076llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001077 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
1078 if (!MDS) return nullptr;
1079
Benjamin Kramer630cf8c2016-11-23 11:20:27 +00001080 return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001081}
1082
Daniel Dunbaraeddffc2009-04-14 07:08:30 +00001083void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump11289f42009-09-09 15:08:12 +00001084 const CGFunctionInfo &Info,
Daniel Dunbaraeddffc2009-04-14 07:08:30 +00001085 llvm::Function *F) {
Daniel Dunbar0ef34792009-09-12 00:59:20 +00001086 unsigned CallingConv;
Reid Klecknercdd26792017-04-18 23:50:03 +00001087 llvm::AttributeList PAL;
1088 ConstructAttributeList(F->getName(), Info, D, PAL, CallingConv, false);
1089 F->setAttributes(PAL);
Daniel Dunbar0ef34792009-09-12 00:59:20 +00001090 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbar449a3392008-09-04 23:41:35 +00001091}
1092
John McCall9b0a7ce2011-10-02 01:16:38 +00001093/// Determines whether the language options require us to model
1094/// unwind exceptions. We treat -fexceptions as mandating this
1095/// except under the fragile ObjC ABI with only ObjC exceptions
1096/// enabled. This means, for example, that C with -fexceptions
1097/// enables this.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001098static bool hasUnwindExceptions(const LangOptions &LangOpts) {
John McCall9b0a7ce2011-10-02 01:16:38 +00001099 // If exceptions are completely disabled, obviously this is false.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001100 if (!LangOpts.Exceptions) return false;
John McCall9b0a7ce2011-10-02 01:16:38 +00001101
1102 // If C++ exceptions are enabled, this is true.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001103 if (LangOpts.CXXExceptions) return true;
John McCall9b0a7ce2011-10-02 01:16:38 +00001104
1105 // If ObjC exceptions are enabled, this depends on the ABI.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001106 if (LangOpts.ObjCExceptions) {
David Chisnallb601c962012-07-03 20:49:52 +00001107 return LangOpts.ObjCRuntime.hasUnwindExceptions();
John McCall9b0a7ce2011-10-02 01:16:38 +00001108 }
1109
1110 return true;
1111}
1112
Daniel Dunbar38932572009-04-14 08:05:55 +00001113void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
1114 llvm::Function *F) {
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001115 llvm::AttrBuilder B;
1116
Rafael Espindolac1ee12c2011-05-25 03:44:55 +00001117 if (CodeGenOpts.UnwindTables)
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001118 B.addAttribute(llvm::Attribute::UWTable);
Rafael Espindolac1ee12c2011-05-25 03:44:55 +00001119
David Blaikiebbafb8a2012-03-11 07:00:24 +00001120 if (!hasUnwindExceptions(LangOpts))
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001121 B.addAttribute(llvm::Attribute::NoUnwind);
Daniel Dunbar03a38442008-10-28 00:17:57 +00001122
Akira Hatanaka200500d2015-10-08 19:30:57 +00001123 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1124 B.addAttribute(llvm::Attribute::StackProtect);
1125 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1126 B.addAttribute(llvm::Attribute::StackProtectStrong);
1127 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1128 B.addAttribute(llvm::Attribute::StackProtectReq);
1129
1130 if (!D) {
Chandler Carruthfcd33142016-12-23 01:24:49 +00001131 // If we don't have a declaration to control inlining, the function isn't
1132 // explicitly marked as alwaysinline for semantic reasons, and inlining is
1133 // disabled, mark the function as noinline.
1134 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1135 CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
1136 B.addAttribute(llvm::Attribute::NoInline);
1137
Reid Kleckneree4930b2017-05-02 22:07:37 +00001138 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
Akira Hatanaka200500d2015-10-08 19:30:57 +00001139 return;
1140 }
1141
Mehdi Amini6aa9e9b2017-05-29 05:38:20 +00001142 // Track whether we need to add the optnone LLVM attribute,
1143 // starting with the default for this optimization level.
1144 bool ShouldAddOptNone =
1145 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
1146 // We can't add optnone in the following cases, it won't pass the verifier.
1147 ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
1148 ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
1149 ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
1150
1151 if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) {
Chandler Carruthfcd33142016-12-23 01:24:49 +00001152 B.addAttribute(llvm::Attribute::OptimizeNone);
1153
1154 // OptimizeNone implies noinline; we should not be inlining such functions.
1155 B.addAttribute(llvm::Attribute::NoInline);
1156 assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1157 "OptimizeNone and AlwaysInline on same function!");
1158
1159 // We still need to handle naked functions even though optnone subsumes
1160 // much of their semantics.
1161 if (D->hasAttr<NakedAttr>())
1162 B.addAttribute(llvm::Attribute::Naked);
1163
1164 // OptimizeNone wins over OptimizeForSize and MinSize.
1165 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
1166 F->removeFnAttr(llvm::Attribute::MinSize);
1167 } else if (D->hasAttr<NakedAttr>()) {
Eli Friedmanc55efe42011-08-22 23:55:33 +00001168 // Naked implies noinline: we should not be inlining such functions.
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001169 B.addAttribute(llvm::Attribute::Naked);
1170 B.addAttribute(llvm::Attribute::NoInline);
Aaron Ballman7c19ab12014-02-22 16:59:24 +00001171 } else if (D->hasAttr<NoDuplicateAttr>()) {
1172 B.addAttribute(llvm::Attribute::NoDuplicate);
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001173 } else if (D->hasAttr<NoInlineAttr>()) {
1174 B.addAttribute(llvm::Attribute::NoInline);
David Majnemer67e541e1c2014-02-25 09:53:29 +00001175 } else if (D->hasAttr<AlwaysInlineAttr>() &&
Chandler Carruthfcd33142016-12-23 01:24:49 +00001176 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001177 // (noinline wins over always_inline, and we can't specify both in IR)
Evgeniy Stepanov6b2a61d2015-09-14 21:35:16 +00001178 B.addAttribute(llvm::Attribute::AlwaysInline);
Chandler Carruthfcd33142016-12-23 01:24:49 +00001179 } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
1180 // If we're not inlining, then force everything that isn't always_inline to
1181 // carry an explicit noinline attribute.
1182 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
1183 B.addAttribute(llvm::Attribute::NoInline);
1184 } else {
1185 // Otherwise, propagate the inline hint attribute and potentially use its
1186 // absence to mark things as noinline.
1187 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
1188 if (any_of(FD->redecls(), [&](const FunctionDecl *Redecl) {
1189 return Redecl->isInlineSpecified();
1190 })) {
1191 B.addAttribute(llvm::Attribute::InlineHint);
1192 } else if (CodeGenOpts.getInlining() ==
1193 CodeGenOptions::OnlyHintInlining &&
1194 !FD->isInlined() &&
1195 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
1196 B.addAttribute(llvm::Attribute::NoInline);
1197 }
1198 }
Eli Friedmanc55efe42011-08-22 23:55:33 +00001199 }
Daniel Dunbar8caf6412010-09-29 18:20:25 +00001200
Chandler Carruthfcd33142016-12-23 01:24:49 +00001201 // Add other optimization related attributes if we are optimizing this
1202 // function.
1203 if (!D->hasAttr<OptimizeNoneAttr>()) {
1204 if (D->hasAttr<ColdAttr>()) {
Mehdi Amini6aa9e9b2017-05-29 05:38:20 +00001205 if (!ShouldAddOptNone)
1206 B.addAttribute(llvm::Attribute::OptimizeForSize);
Chandler Carruthfcd33142016-12-23 01:24:49 +00001207 B.addAttribute(llvm::Attribute::Cold);
1208 }
Benjamin Kramer29c2b432012-05-12 21:10:52 +00001209
Chandler Carruthfcd33142016-12-23 01:24:49 +00001210 if (D->hasAttr<MinSizeAttr>())
1211 B.addAttribute(llvm::Attribute::MinSize);
1212 }
Richard Smithb555a762012-09-28 22:46:07 +00001213
Reid Kleckneree4930b2017-05-02 22:07:37 +00001214 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
Benjamin Kramer2960dbd2013-05-11 12:45:37 +00001215
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001216 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
1217 if (alignment)
1218 F->setAlignment(alignment);
1219
Dan Gohmanc2853072015-09-03 22:51:53 +00001220 // Some C++ ABIs require 2-byte alignment for member functions, in order to
1221 // reserve a bit for differentiating between virtual and non-virtual member
1222 // functions. If the current target's C++ ABI requires this and this is a
1223 // member function, set its alignment accordingly.
1224 if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
1225 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
1226 F->setAlignment(2);
1227 }
Evgeniy Stepanovf7543092016-10-31 22:28:10 +00001228
1229 // In the cross-dso CFI mode, we want !type attributes on definitions only.
1230 if (CodeGenOpts.SanitizeCfiCrossDso)
1231 if (auto *FD = dyn_cast<FunctionDecl>(D))
1232 CreateFunctionTypeMetadata(FD, F);
Daniel Dunbar449a3392008-09-04 23:41:35 +00001233}
1234
Rafael Espindola75c649c2018-03-01 00:06:55 +00001235void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
1236 const Decl *D = GD.getDecl();
Akira Hatanakaaec6b2c2015-10-08 20:26:34 +00001237 if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
Rafael Espindola699f5d62018-02-07 22:15:33 +00001238 setGVProperties(GV, ND);
John McCall457a04e2010-10-22 21:05:15 +00001239 else
1240 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar38932572009-04-14 08:05:55 +00001241
Akira Hatanakaaec6b2c2015-10-08 20:26:34 +00001242 if (D && D->hasAttr<UsedAttr>())
Rafael Espindola060062a2014-03-06 22:15:10 +00001243 addUsedGlobal(GV);
Rafael Espindola502f65a2014-05-05 20:21:03 +00001244}
1245
Rafael Espindolafa2fc902018-02-28 00:06:01 +00001246void CodeGenModule::setAliasAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
1247 const Decl *D = GD.getDecl();
Rafael Espindola75c649c2018-03-01 00:06:55 +00001248 SetCommonAttributes(GD, GV);
Dario Domiziolic4fb8ca72014-09-19 22:06:24 +00001249
1250 // Process the dllexport attribute based on whether the original definition
1251 // (not necessarily the aliasee) was exported.
1252 if (D->hasAttr<DLLExportAttr>())
1253 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1254}
1255
Erich Keane93e58662018-02-12 17:01:41 +00001256bool CodeGenModule::GetCPUAndFeaturesAttributes(const Decl *D,
1257 llvm::AttrBuilder &Attrs) {
1258 // Add target-cpu and target-features attributes to functions. If
1259 // we have a decl for the function and it has a target attribute then
1260 // parse that and add it to the feature set.
1261 StringRef TargetCPU = getTarget().getTargetOpts().CPU;
1262 std::vector<std::string> Features;
1263 const auto *FD = dyn_cast_or_null<FunctionDecl>(D);
1264 FD = FD ? FD->getMostRecentDecl() : FD;
1265 const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
1266 bool AddedAttr = false;
1267 if (TD) {
1268 llvm::StringMap<bool> FeatureMap;
1269 getFunctionFeatureMap(FeatureMap, FD);
1270
1271 // Produce the canonical string for this set of features.
1272 for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
1273 Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
1274
1275 // Now add the target-cpu and target-features to the function.
1276 // While we populated the feature map above, we still need to
1277 // get and parse the target attribute so we can get the cpu for
1278 // the function.
1279 TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
1280 if (ParsedAttr.Architecture != "" &&
1281 getTarget().isValidCPUName(ParsedAttr.Architecture))
1282 TargetCPU = ParsedAttr.Architecture;
1283 } else {
1284 // Otherwise just add the existing target cpu and target features to the
1285 // function.
1286 Features = getTarget().getTargetOpts().Features;
1287 }
1288
1289 if (TargetCPU != "") {
1290 Attrs.addAttribute("target-cpu", TargetCPU);
1291 AddedAttr = true;
1292 }
1293 if (!Features.empty()) {
1294 std::sort(Features.begin(), Features.end());
1295 Attrs.addAttribute("target-features", llvm::join(Features, ","));
1296 AddedAttr = true;
1297 }
1298
1299 return AddedAttr;
1300}
1301
Rafael Espindola285271c2018-02-28 23:54:23 +00001302void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
Rafael Espindolaee076a22014-05-13 18:45:53 +00001303 llvm::GlobalObject *GO) {
Rafael Espindola285271c2018-02-28 23:54:23 +00001304 const Decl *D = GD.getDecl();
Rafael Espindola75c649c2018-03-01 00:06:55 +00001305 SetCommonAttributes(GD, GO);
Daniel Dunbar38932572009-04-14 08:05:55 +00001306
Javed Absar2a67c9e2017-06-05 10:11:57 +00001307 if (D) {
1308 if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
1309 if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
1310 GV->addAttribute("bss-section", SA->getName());
1311 if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
1312 GV->addAttribute("data-section", SA->getName());
1313 if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
1314 GV->addAttribute("rodata-section", SA->getName());
1315 }
1316
1317 if (auto *F = dyn_cast<llvm::Function>(GO)) {
1318 if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
Erich Keane30994d22018-02-08 20:04:22 +00001319 if (!D->getAttr<SectionAttr>())
1320 F->addFnAttr("implicit-section-name", SA->getName());
Erich Keane93e58662018-02-12 17:01:41 +00001321
1322 llvm::AttrBuilder Attrs;
1323 if (GetCPUAndFeaturesAttributes(D, Attrs)) {
1324 // We know that GetCPUAndFeaturesAttributes will always have the
1325 // newest set, since it has the newest possible FunctionDecl, so the
1326 // new ones should replace the old.
1327 F->removeFnAttr("target-cpu");
1328 F->removeFnAttr("target-features");
1329 F->addAttributes(llvm::AttributeList::FunctionIndex, Attrs);
1330 }
Javed Absar2a67c9e2017-06-05 10:11:57 +00001331 }
1332
Akira Hatanakaaec6b2c2015-10-08 20:26:34 +00001333 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
1334 GO->setSection(SA->getName());
Javed Absar2a67c9e2017-06-05 10:11:57 +00001335 }
Anton Korobeynikov55bcea12010-01-10 12:58:08 +00001336
Rafael Espindoladeb10be2018-02-07 19:04:41 +00001337 getTargetCodeGenInfo().setTargetAttributes(D, GO, *this);
Daniel Dunbar38932572009-04-14 08:05:55 +00001338}
1339
Rafael Espindola51ec5a92018-02-28 23:46:35 +00001340void CodeGenModule::SetInternalFunctionAttributes(GlobalDecl GD,
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +00001341 llvm::Function *F,
1342 const CGFunctionInfo &FI) {
Rafael Espindola51ec5a92018-02-28 23:46:35 +00001343 const Decl *D = GD.getDecl();
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +00001344 SetLLVMFunctionAttributes(D, FI, F);
1345 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar38932572009-04-14 08:05:55 +00001346
1347 F->setLinkage(llvm::Function::InternalLinkage);
1348
Rafael Espindola285271c2018-02-28 23:54:23 +00001349 setNonAliasAttributes(GD, F);
Daniel Dunbar449a3392008-09-04 23:41:35 +00001350}
1351
Jake Ehrlichba874ad2017-11-29 00:54:20 +00001352static void setLinkageForGV(llvm::GlobalValue *GV,
1353 const NamedDecl *ND) {
David Majnemerf6acb762014-04-25 17:07:16 +00001354 // Set linkage and visibility in case we never see a definition.
1355 LinkageInfo LV = ND->getLinkageAndVisibility();
Richard Smith1283e982017-07-07 20:04:28 +00001356 if (!isExternallyVisible(LV.getLinkage())) {
David Majnemerf6acb762014-04-25 17:07:16 +00001357 // Don't set internal linkage on declarations.
1358 } else {
1359 if (ND->hasAttr<DLLImportAttr>()) {
1360 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
1361 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1362 } else if (ND->hasAttr<DLLExportAttr>()) {
1363 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
David Majnemerf6acb762014-04-25 17:07:16 +00001364 } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) {
1365 // "extern_weak" is overloaded in LLVM; we probably should have
1366 // separate linkage types for this.
1367 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1368 }
David Majnemerf6acb762014-04-25 17:07:16 +00001369 }
1370}
1371
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00001372void CodeGenModule::CreateFunctionTypeMetadata(const FunctionDecl *FD,
1373 llvm::Function *F) {
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001374 // Only if we are checking indirect calls.
1375 if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
1376 return;
1377
1378 // Non-static class methods are handled via vtable pointer checks elsewhere.
1379 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
1380 return;
1381
1382 // Additionally, if building with cross-DSO support...
1383 if (CodeGenOpts.SanitizeCfiCrossDso) {
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001384 // Skip available_externally functions. They won't be codegen'ed in the
1385 // current module anyway.
1386 if (getContext().GetGVALinkageForFunction(FD) == GVA_AvailableExternally)
1387 return;
1388 }
1389
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001390 llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType());
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00001391 F->addTypeMetadata(0, MD);
Vlad Tsyrklevich634c6012017-10-31 22:39:44 +00001392 F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001393
1394 // Emit a hash-based bit set entry for cross-DSO calls.
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00001395 if (CodeGenOpts.SanitizeCfiCrossDso)
1396 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
1397 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00001398}
1399
David Majnemerb9bd6fb2014-11-01 05:42:23 +00001400void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1401 bool IsIncompleteFunction,
Rafael Espindoladeb10be2018-02-07 19:04:41 +00001402 bool IsThunk) {
Simon Atanasyan1a116db2017-07-20 20:34:18 +00001403
Pete Cooper2f1637a2015-05-20 17:17:45 +00001404 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
Peter Collingbourneeafa4e42011-04-06 12:29:04 +00001405 // If this is an intrinsic function, set the function's attributes
1406 // to the intrinsic's attributes.
Pete Cooper2f1637a2015-05-20 17:17:45 +00001407 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
Peter Collingbourneeafa4e42011-04-06 12:29:04 +00001408 return;
1409 }
1410
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001411 const auto *FD = cast<FunctionDecl>(GD.getDecl());
Anders Carlsson6710c532010-02-06 02:44:09 +00001412
Simon Atanasyan1a116db2017-07-20 20:34:18 +00001413 if (!IsIncompleteFunction) {
John McCalla729c622012-02-17 03:33:10 +00001414 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
Simon Atanasyan1a116db2017-07-20 20:34:18 +00001415 // Setup target-specific attributes.
Rafael Espindoladeb10be2018-02-07 19:04:41 +00001416 if (F->isDeclaration())
1417 getTargetCodeGenInfo().setTargetAttributes(FD, F, *this);
Simon Atanasyan1a116db2017-07-20 20:34:18 +00001418 }
Mike Stump11289f42009-09-09 15:08:12 +00001419
Bob Wilsonfc6297f2014-04-01 01:38:16 +00001420 // Add the Returned attribute for "this", except for iOS 5 and earlier
1421 // where substantial code, including the libstdc++ dylib, was compiled with
1422 // GCC and does not actually return "this".
David Majnemerb9bd6fb2014-11-01 05:42:23 +00001423 if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +00001424 !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
Stephen Lin9dc6eef2013-06-30 20:40:16 +00001425 assert(!F->arg_empty() &&
1426 F->arg_begin()->getType()
1427 ->canLosslesslyBitCastTo(F->getReturnType()) &&
1428 "unexpected this return");
1429 F->addAttribute(1, llvm::Attribute::Returned);
1430 }
1431
Daniel Dunbar38932572009-04-14 08:05:55 +00001432 // Only a few attributes are set on declarations; these may later be
1433 // overridden by a definition.
Mike Stump11289f42009-09-09 15:08:12 +00001434
Jake Ehrlichba874ad2017-11-29 00:54:20 +00001435 setLinkageForGV(F, FD);
Rafael Espindola699f5d62018-02-07 22:15:33 +00001436 setGVProperties(F, FD);
Daniel Dunbar38932572009-04-14 08:05:55 +00001437
Javed Absar2a67c9e2017-06-05 10:11:57 +00001438 if (FD->getAttr<PragmaClangTextSectionAttr>()) {
1439 F->addFnAttr("implicit-section-name");
1440 }
1441
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001442 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +00001443 F->setSection(SA->getName());
Richard Smith8d0dc312013-07-21 23:12:18 +00001444
Richard Smith351241c2016-04-07 21:46:12 +00001445 if (FD->isReplaceableGlobalAllocationFunction()) {
1446 // A replaceable global allocation function does not act like a builtin by
1447 // default, only if it is invoked by a new-expression or delete-expression.
Reid Klecknerde864822017-03-21 16:57:30 +00001448 F->addAttribute(llvm::AttributeList::FunctionIndex,
Richard Smith8d0dc312013-07-21 23:12:18 +00001449 llvm::Attribute::NoBuiltin);
Peter Collingbourne2c7f7e32015-09-10 02:17:40 +00001450
Richard Smith351241c2016-04-07 21:46:12 +00001451 // A sane operator new returns a non-aliasing pointer.
1452 // FIXME: Also add NonNull attribute to the return value
1453 // for the non-nothrow forms?
1454 auto Kind = FD->getDeclName().getCXXOverloadedOperator();
1455 if (getCodeGenOpts().AssumeSaneOperatorNew &&
1456 (Kind == OO_New || Kind == OO_Array_New))
Reid Klecknerde864822017-03-21 16:57:30 +00001457 F->addAttribute(llvm::AttributeList::ReturnIndex,
Richard Smith351241c2016-04-07 21:46:12 +00001458 llvm::Attribute::NoAlias);
1459 }
1460
Peter Collingbourne0446e7c2016-03-14 18:41:59 +00001461 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
Peter Collingbournebcf909d2016-06-14 21:02:05 +00001462 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
Peter Collingbourne0446e7c2016-03-14 18:41:59 +00001463 else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1464 if (MD->isVirtual())
Peter Collingbournebcf909d2016-06-14 21:02:05 +00001465 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
Peter Collingbourne0446e7c2016-03-14 18:41:59 +00001466
Evgeniy Stepanovf7543092016-10-31 22:28:10 +00001467 // Don't emit entries for function declarations in the cross-DSO mode. This
1468 // is handled with better precision by the receiving DSO.
1469 if (!CodeGenOpts.SanitizeCfiCrossDso)
1470 CreateFunctionTypeMetadata(FD, F);
Alexey Bataevb952e632017-12-15 16:28:31 +00001471
1472 if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
1473 getOpenMPRuntime().emitDeclareSimdFunction(FD, F);
Daniel Dunbar0beedc12008-09-08 23:44:31 +00001474}
1475
Rafael Espindola060062a2014-03-06 22:15:10 +00001476void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump11289f42009-09-09 15:08:12 +00001477 assert(!GV->isDeclaration() &&
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001478 "Only globals with definition can force usage.");
Benjamin Kramer3204b152015-05-29 19:42:19 +00001479 LLVMUsed.emplace_back(GV);
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001480}
1481
Rafael Espindola060062a2014-03-06 22:15:10 +00001482void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
1483 assert(!GV->isDeclaration() &&
1484 "Only globals with definition can force usage.");
Benjamin Kramer3204b152015-05-29 19:42:19 +00001485 LLVMCompilerUsed.emplace_back(GV);
Rafael Espindola060062a2014-03-06 22:15:10 +00001486}
1487
1488static void emitUsed(CodeGenModule &CGM, StringRef Name,
Sanjoy Dase369bd92017-05-01 17:08:00 +00001489 std::vector<llvm::WeakTrackingVH> &List) {
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001490 // Don't create llvm.used if there is no need.
Rafael Espindola060062a2014-03-06 22:15:10 +00001491 if (List.empty())
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001492 return;
1493
Rafael Espindola060062a2014-03-06 22:15:10 +00001494 // Convert List to what ConstantArray needs.
Chris Lattner3def9ae2012-02-06 22:16:34 +00001495 SmallVector<llvm::Constant*, 8> UsedArray;
Rafael Espindola060062a2014-03-06 22:15:10 +00001496 UsedArray.resize(List.size());
1497 for (unsigned i = 0, e = List.size(); i != e; ++i) {
Mike Stump11289f42009-09-09 15:08:12 +00001498 UsedArray[i] =
Justin Holewinskif37f3d32015-02-02 21:05:49 +00001499 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1500 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
Chris Lattnerf41e87f2009-03-31 22:37:52 +00001501 }
Mike Stump11289f42009-09-09 15:08:12 +00001502
Fariborz Jahanian248c7192009-06-23 21:47:46 +00001503 if (UsedArray.empty())
1504 return;
Rafael Espindola060062a2014-03-06 22:15:10 +00001505 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
Mike Stump11289f42009-09-09 15:08:12 +00001506
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001507 auto *GV = new llvm::GlobalVariable(
1508 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
1509 llvm::ConstantArray::get(ATy, UsedArray), Name);
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001510
1511 GV->setSection("llvm.metadata");
1512}
1513
Rafael Espindola060062a2014-03-06 22:15:10 +00001514void CodeGenModule::emitLLVMUsed() {
1515 emitUsed(*this, "llvm.used", LLVMUsed);
1516 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
1517}
1518
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001519void CodeGenModule::AppendLinkerOptions(StringRef Opts) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001520 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001521 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1522}
1523
Aaron Ballman5d041be2013-06-04 02:07:14 +00001524void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
1525 llvm::SmallString<32> Opt;
1526 getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001527 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
Aaron Ballman5d041be2013-06-04 02:07:14 +00001528 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1529}
1530
Saleem Abdulrasoolfd4db532018-02-07 01:46:46 +00001531void CodeGenModule::AddELFLibDirective(StringRef Lib) {
1532 auto &C = getLLVMContext();
1533 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
1534 C, {llvm::MDString::get(C, "lib"), llvm::MDString::get(C, Lib)}));
1535}
1536
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001537void CodeGenModule::AddDependentLib(StringRef Lib) {
1538 llvm::SmallString<24> Opt;
1539 getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001540 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001541 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1542}
1543
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001544/// \brief Add link options implied by the given module, including modules
1545/// it depends on, using a postorder walk.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001546static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod,
Peter Collingbourne89061b22017-06-12 20:10:48 +00001547 SmallVectorImpl<llvm::MDNode *> &Metadata,
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001548 llvm::SmallPtrSet<Module *, 16> &Visited) {
1549 // Import this module's parent.
David Blaikie82e95a32014-11-19 07:49:47 +00001550 if (Mod->Parent && Visited.insert(Mod->Parent).second) {
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001551 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001552 }
1553
1554 // Import this module's dependencies.
1555 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
David Blaikie82e95a32014-11-19 07:49:47 +00001556 if (Visited.insert(Mod->Imports[I - 1]).second)
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001557 addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001558 }
1559
1560 // Add linker options to link against the libraries/frameworks
1561 // described by this module.
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001562 llvm::LLVMContext &Context = CGM.getLLVMContext();
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001563 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001564 // Link against a framework. Frameworks are currently Darwin only, so we
1565 // don't to ask TargetCodeGenInfo for the spelling of the linker option.
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001566 if (Mod->LinkLibraries[I-1].IsFramework) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001567 llvm::Metadata *Args[2] = {
1568 llvm::MDString::get(Context, "-framework"),
1569 llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001570
1571 Metadata.push_back(llvm::MDNode::get(Context, Args));
1572 continue;
1573 }
1574
1575 // Link against a library.
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001576 llvm::SmallString<24> Opt;
1577 CGM.getTargetCodeGenInfo().getDependentLibraryOption(
1578 Mod->LinkLibraries[I-1].Library, Opt);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001579 auto *OptString = llvm::MDString::get(Context, Opt);
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001580 Metadata.push_back(llvm::MDNode::get(Context, OptString));
1581 }
1582}
1583
1584void CodeGenModule::EmitModuleLinkOptions() {
1585 // Collect the set of all of the modules we want to visit to emit link
1586 // options, which is essentially the imported modules and all of their
1587 // non-explicit child modules.
1588 llvm::SetVector<clang::Module *> LinkModules;
1589 llvm::SmallPtrSet<clang::Module *, 16> Visited;
1590 SmallVector<clang::Module *, 16> Stack;
1591
1592 // Seed the stack with imported modules.
Manman Ren9803ee82017-01-11 18:47:38 +00001593 for (Module *M : ImportedModules) {
1594 // Do not add any link flags when an implementation TU of a module imports
1595 // a header of that same module.
1596 if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
1597 !getLangOpts().isCompilingModule())
1598 continue;
Yaron Kerenb54db522015-06-11 12:33:25 +00001599 if (Visited.insert(M).second)
1600 Stack.push_back(M);
Manman Ren9803ee82017-01-11 18:47:38 +00001601 }
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001602
1603 // Find all of the modules to import, making a little effort to prune
1604 // non-leaf modules.
1605 while (!Stack.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00001606 clang::Module *Mod = Stack.pop_back_val();
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001607
1608 bool AnyChildren = false;
1609
1610 // Visit the submodules of this module.
1611 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
1612 SubEnd = Mod->submodule_end();
1613 Sub != SubEnd; ++Sub) {
1614 // Skip explicit children; they need to be explicitly imported to be
1615 // linked against.
1616 if ((*Sub)->IsExplicit)
1617 continue;
1618
David Blaikie82e95a32014-11-19 07:49:47 +00001619 if (Visited.insert(*Sub).second) {
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001620 Stack.push_back(*Sub);
1621 AnyChildren = true;
1622 }
1623 }
1624
1625 // We didn't find any children, so add this module to the list of
1626 // modules to link against.
1627 if (!AnyChildren) {
1628 LinkModules.insert(Mod);
1629 }
1630 }
1631
1632 // Add link options for all of the imported modules in reverse topological
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001633 // order. We don't do anything to try to order import link flags with respect
1634 // to linker options inserted by things like #pragma comment().
Peter Collingbourne89061b22017-06-12 20:10:48 +00001635 SmallVector<llvm::MDNode *, 16> MetadataArgs;
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001636 Visited.clear();
Yaron Kerenb54db522015-06-11 12:33:25 +00001637 for (Module *M : LinkModules)
1638 if (Visited.insert(M).second)
1639 addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
Daniel Dunbar69e47462013-01-17 01:35:06 +00001640 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
Reid Klecknere43f0fe2013-05-08 13:44:39 +00001641 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001642
Daniel Dunbar69e47462013-01-17 01:35:06 +00001643 // Add the linker options metadata flag.
Peter Collingbourne89061b22017-06-12 20:10:48 +00001644 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
1645 for (auto *MD : LinkerOptionsMetadata)
1646 NMD->addOperand(MD);
Douglas Gregorbc25ff42013-01-14 20:53:57 +00001647}
1648
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001649void CodeGenModule::EmitDeferred() {
Chris Lattner45470942009-03-21 09:44:56 +00001650 // Emit code for any potentially referenced deferred decls. Since a
1651 // previously unused static decl may become used during the generation of code
Nick Lewycky26da4dd2011-07-18 05:26:13 +00001652 // for a static function, iterate until no changes are made.
Rafael Espindolae7113ca2010-03-10 02:19:29 +00001653
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001654 if (!DeferredVTables.empty()) {
1655 EmitDeferredVTables();
John McCall6bd2a892013-01-25 22:31:03 +00001656
Eric Christopherd160c502016-01-29 01:35:53 +00001657 // Emitting a vtable doesn't directly cause more vtables to
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001658 // become deferred, although it can cause functions to be
Eric Christopherd160c502016-01-29 01:35:53 +00001659 // emitted that then need those vtables.
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001660 assert(DeferredVTables.empty());
1661 }
Rafael Espindolae7113ca2010-03-10 02:19:29 +00001662
Eric Christopherd160c502016-01-29 01:35:53 +00001663 // Stop if we're out of both deferred vtables and deferred declarations.
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001664 if (DeferredDeclsToEmit.empty())
1665 return;
John McCall6bd2a892013-01-25 22:31:03 +00001666
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001667 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1668 // work, it will not interfere with this.
Sanjoy Das70a60512017-05-01 06:12:13 +00001669 std::vector<GlobalDecl> CurDeclsToEmit;
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001670 CurDeclsToEmit.swap(DeferredDeclsToEmit);
1671
Sanjoy Das70a60512017-05-01 06:12:13 +00001672 for (GlobalDecl &D : CurDeclsToEmit) {
Andrey Bokhankocab58582015-08-31 13:20:44 +00001673 // We should call GetAddrOfGlobal with IsForDefinition set to true in order
1674 // to get GlobalValue with exactly the type we need, not something that
1675 // might had been created for another decl with the same mangled name but
1676 // different type.
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00001677 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
John McCalld195d4c2016-11-30 23:25:13 +00001678 GetAddrOfGlobal(D, ForDefinition));
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00001679
1680 // In case of different address spaces, we may still get a cast, even with
1681 // IsForDefinition equal to true. Query mangled names table to get
1682 // GlobalValue.
1683 if (!GV)
1684 GV = GetGlobalValue(getMangledName(D));
1685
1686 // Make sure GetGlobalValue returned non-null.
1687 assert(GV);
Hans Wennborg43a0f992015-01-10 01:19:48 +00001688
John McCallc2af9392010-05-27 01:45:30 +00001689 // Check to see if we've already emitted this. This is necessary
1690 // for a couple of reasons: first, decls can end up in the
1691 // deferred-decls queue multiple times, and second, decls can end
1692 // up with definitions in unusual ways (e.g. by an extern inline
1693 // function acquiring a strong function redefinition). Just
1694 // ignore these cases.
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00001695 if (!GV->isDeclaration())
Chris Lattner45470942009-03-21 09:44:56 +00001696 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001697
Chris Lattner45470942009-03-21 09:44:56 +00001698 // Otherwise, emit the definition and move on to the next one.
Rafael Espindolacd7743b2013-12-09 16:01:03 +00001699 EmitGlobalDefinition(D, GV);
Rafael Espindolae5df59f2015-01-22 00:24:57 +00001700
1701 // If we found out that we need to emit more decls, do that recursively.
1702 // This has the advantage that the decls are emitted in a DFS and related
1703 // ones are close together, which is convenient for testing.
1704 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1705 EmitDeferred();
1706 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1707 }
Chris Lattner45470942009-03-21 09:44:56 +00001708 }
Chris Lattnerbed31442007-05-28 01:07:47 +00001709}
Chris Lattner09153c02007-06-22 18:48:09 +00001710
Piotr Padlewskid3b1cbd2017-06-01 08:04:05 +00001711void CodeGenModule::EmitVTablesOpportunistically() {
1712 // Try to emit external vtables as available_externally if they have emitted
1713 // all inlined virtual functions. It runs after EmitDeferred() and therefore
1714 // is not allowed to create new references to things that need to be emitted
1715 // lazily. Note that it also uses fact that we eagerly emitting RTTI.
1716
Piotr Padlewski05547742017-06-01 09:24:36 +00001717 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
1718 && "Only emit opportunistic vtables with optimizations");
Piotr Padlewskid3b1cbd2017-06-01 08:04:05 +00001719
1720 for (const CXXRecordDecl *RD : OpportunisticVTables) {
1721 assert(getVTables().isVTableExternal(RD) &&
1722 "This queue should only contain external vtables");
1723 if (getCXXABI().canSpeculativelyEmitVTable(RD))
1724 VTables.GenerateClassData(RD);
1725 }
1726 OpportunisticVTables.clear();
1727}
1728
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001729void CodeGenModule::EmitGlobalAnnotations() {
1730 if (Annotations.empty())
1731 return;
1732
1733 // Create a new global variable for the ConstantStruct in the Module.
1734 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1735 Annotations[0]->getType(), Annotations.size()), Annotations);
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001736 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1737 llvm::GlobalValue::AppendingLinkage,
1738 Array, "llvm.global.annotations");
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001739 gv->setSection(AnnotationSection);
1740}
1741
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001742llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
Benjamin Kramereed80612013-11-10 16:55:11 +00001743 llvm::Constant *&AStr = AnnotationStrings[Str];
1744 if (AStr)
1745 return AStr;
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001746
1747 // Not found yet, create a new global.
Chris Lattner9c818332012-02-05 02:30:40 +00001748 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001749 auto *gv =
1750 new llvm::GlobalVariable(getModule(), s->getType(), true,
1751 llvm::GlobalValue::PrivateLinkage, s, ".str");
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001752 gv->setSection(AnnotationSection);
Peter Collingbournebcf909d2016-06-14 21:02:05 +00001753 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
Benjamin Kramereed80612013-11-10 16:55:11 +00001754 AStr = gv;
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001755 return gv;
1756}
1757
1758llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
1759 SourceManager &SM = getContext().getSourceManager();
1760 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1761 if (PLoc.isValid())
1762 return EmitAnnotationString(PLoc.getFilename());
1763 return EmitAnnotationString(SM.getBufferName(Loc));
1764}
1765
1766llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
1767 SourceManager &SM = getContext().getSourceManager();
1768 PresumedLoc PLoc = SM.getPresumedLoc(L);
1769 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1770 SM.getExpansionLineNumber(L);
1771 return llvm::ConstantInt::get(Int32Ty, LineNo);
1772}
1773
Mike Stump11289f42009-09-09 15:08:12 +00001774llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begemanfaae0812008-04-19 04:17:09 +00001775 const AnnotateAttr *AA,
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001776 SourceLocation L) {
1777 // Get the globals for file name, annotation, and the line number.
1778 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1779 *UnitGV = EmitAnnotationUnit(L),
1780 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begemanfaae0812008-04-19 04:17:09 +00001781
Daniel Dunbar346892a2009-04-14 22:41:13 +00001782 // Create the ConstantStruct for the global annotation.
Nate Begemanfaae0812008-04-19 04:17:09 +00001783 llvm::Constant *Fields[4] = {
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001784 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1785 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1786 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1787 LineNoCst
Nate Begemanfaae0812008-04-19 04:17:09 +00001788 };
Chris Lattnere64d7ba2011-06-20 04:01:35 +00001789 return llvm::ConstantStruct::getAnon(Fields);
Nate Begemanfaae0812008-04-19 04:17:09 +00001790}
1791
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001792void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
1793 llvm::GlobalValue *GV) {
1794 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1795 // Get the struct elements for these annotations.
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00001796 for (const auto *I : D->specific_attrs<AnnotateAttr>())
1797 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001798}
1799
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001800bool CodeGenModule::isInSanitizerBlacklist(SanitizerMask Kind,
1801 llvm::Function *Fn,
Alexey Samsonov1444bb92014-10-17 00:20:19 +00001802 SourceLocation Loc) const {
1803 const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1804 // Blacklist by function name.
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001805 if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
Alexey Samsonov1444bb92014-10-17 00:20:19 +00001806 return true;
1807 // Blacklist by location.
Yaron Kerened1fe5d2015-10-03 05:15:57 +00001808 if (Loc.isValid())
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001809 return SanitizerBL.isBlacklistedLocation(Kind, Loc);
Alexey Samsonov1444bb92014-10-17 00:20:19 +00001810 // If location is unknown, this may be a compiler-generated function. Assume
1811 // it's located in the main file.
1812 auto &SM = Context.getSourceManager();
1813 if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001814 return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
Alexey Samsonov1444bb92014-10-17 00:20:19 +00001815 }
1816 return false;
1817}
1818
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00001819bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
1820 SourceLocation Loc, QualType Ty,
1821 StringRef Category) const {
Alexander Potapenkob9b73ef2015-06-19 12:19:07 +00001822 // For now globals can be blacklisted only in ASan and KASan.
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001823 const SanitizerMask EnabledAsanMask = LangOpts.Sanitize.Mask &
Evgeniy Stepanov12817e52017-12-09 01:32:07 +00001824 (SanitizerKind::Address | SanitizerKind::KernelAddress | SanitizerKind::HWAddress);
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001825 if (!EnabledAsanMask)
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00001826 return false;
1827 const auto &SanitizerBL = getContext().getSanitizerBlacklist();
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001828 if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category))
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00001829 return true;
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001830 if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00001831 return true;
1832 // Check global type.
1833 if (!Ty.isNull()) {
1834 // Drill down the array types: if global variable of a fixed type is
1835 // blacklisted, we also don't instrument arrays of them.
1836 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
1837 Ty = AT->getElementType();
1838 Ty = Ty.getCanonicalType().getUnqualifiedType();
1839 // We allow to blacklist only record types (classes, structs etc.)
1840 if (Ty->isRecordType()) {
1841 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
Vlad Tsyrklevich2eccdab2017-09-25 22:11:12 +00001842 if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00001843 return true;
1844 }
1845 }
1846 return false;
1847}
1848
Dean Michael Berris835832d2017-03-30 00:29:36 +00001849bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
1850 StringRef Category) const {
1851 if (!LangOpts.XRayInstrument)
1852 return false;
1853 const auto &XRayFilter = getContext().getXRayFilter();
1854 using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
1855 auto Attr = XRayFunctionFilter::ImbueAttribute::NONE;
1856 if (Loc.isValid())
1857 Attr = XRayFilter.shouldImbueLocation(Loc, Category);
1858 if (Attr == ImbueAttr::NONE)
1859 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
1860 switch (Attr) {
1861 case ImbueAttr::NONE:
1862 return false;
1863 case ImbueAttr::ALWAYS:
1864 Fn->addFnAttr("function-instrument", "xray-always");
1865 break;
Dean Michael Berris170429e2017-05-24 05:46:36 +00001866 case ImbueAttr::ALWAYS_ARG1:
1867 Fn->addFnAttr("function-instrument", "xray-always");
1868 Fn->addFnAttr("xray-log-args", "1");
1869 break;
Dean Michael Berris835832d2017-03-30 00:29:36 +00001870 case ImbueAttr::NEVER:
1871 Fn->addFnAttr("function-instrument", "xray-never");
1872 break;
1873 }
1874 return true;
1875}
1876
Hans Wennborg43a0f992015-01-10 01:19:48 +00001877bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00001878 // Never defer when EmitAllDecls is specified.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001879 if (LangOpts.EmitAllDecls)
Hans Wennborg43a0f992015-01-10 01:19:48 +00001880 return true;
Daniel Dunbar9c426522008-07-29 23:18:29 +00001881
Hans Wennborg43a0f992015-01-10 01:19:48 +00001882 return getContext().DeclMustBeEmitted(Global);
1883}
1884
1885bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
1886 if (const auto *FD = dyn_cast<FunctionDecl>(Global))
1887 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1888 // Implicit template instantiations may change linkage if they are later
1889 // explicitly instantiated, so they should not be emitted eagerly.
1890 return false;
Richard Smithd9b90092016-07-02 01:32:16 +00001891 if (const auto *VD = dyn_cast<VarDecl>(Global))
1892 if (Context.getInlineVariableDefinitionKind(VD) ==
1893 ASTContext::InlineVariableDefinitionKind::WeakUnknown)
1894 // A definition of an inline constexpr static data member may change
1895 // linkage later if it's redeclared outside the class.
1896 return false;
Samuel Antaof8b50122015-07-13 22:54:53 +00001897 // If OpenMP is enabled and threadprivates must be generated like TLS, delay
1898 // codegen for global variables, because they may be marked as threadprivate.
1899 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
1900 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global))
1901 return false;
Hans Wennborg43a0f992015-01-10 01:19:48 +00001902
1903 return true;
Daniel Dunbar6b8720e2009-02-13 21:18:01 +00001904}
1905
John McCall7f416cc2015-09-08 08:05:57 +00001906ConstantAddress CodeGenModule::GetAddrOfUuidDescriptor(
Nico Webercf4ff5862012-10-11 10:13:44 +00001907 const CXXUuidofExpr* E) {
1908 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
1909 // well-formed.
David Majnemer2041b462016-03-28 03:19:50 +00001910 StringRef Uuid = E->getUuidStr();
David Majnemercf963ce2013-08-09 08:35:59 +00001911 std::string Name = "_GUID_" + Uuid.lower();
1912 std::replace(Name.begin(), Name.end(), '-', '_');
Nico Webercf4ff5862012-10-11 10:13:44 +00001913
David Majnemer65687602016-03-27 04:46:14 +00001914 // The UUID descriptor should be pointer aligned.
1915 CharUnits Alignment = CharUnits::fromQuantity(PointerAlignInBytes);
John McCall7f416cc2015-09-08 08:05:57 +00001916
Nico Webercf4ff5862012-10-11 10:13:44 +00001917 // Look for an existing global.
1918 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
John McCall7f416cc2015-09-08 08:05:57 +00001919 return ConstantAddress(GV, Alignment);
Nico Webercf4ff5862012-10-11 10:13:44 +00001920
Nico Weber17d3a2c2014-09-08 16:26:36 +00001921 llvm::Constant *Init = EmitUuidofInitializer(Uuid);
Nico Webercf4ff5862012-10-11 10:13:44 +00001922 assert(Init && "failed to initialize as constant");
1923
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001924 auto *GV = new llvm::GlobalVariable(
David Majnemerbbecd092013-08-15 19:59:14 +00001925 getModule(), Init->getType(),
Reid Klecknerb9921df2013-09-03 21:49:32 +00001926 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
NAKAMURA Takumic7da6da2015-05-09 21:10:07 +00001927 if (supportsCOMDAT())
1928 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
John McCall7f416cc2015-09-08 08:05:57 +00001929 return ConstantAddress(GV, Alignment);
Nico Webercf4ff5862012-10-11 10:13:44 +00001930}
1931
John McCall7f416cc2015-09-08 08:05:57 +00001932ConstantAddress CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001933 const AliasAttr *AA = VD->getAttr<AliasAttr>();
1934 assert(AA && "No alias?");
1935
John McCall7f416cc2015-09-08 08:05:57 +00001936 CharUnits Alignment = getContext().getDeclAlign(VD);
Chris Lattner2192fe52011-07-18 04:24:23 +00001937 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001938
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001939 // See if there is already something with the target's name in the module.
John McCall7ec50432010-03-19 23:29:14 +00001940 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001941 if (Entry) {
1942 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
John McCall7f416cc2015-09-08 08:05:57 +00001943 auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1944 return ConstantAddress(Ptr, Alignment);
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001945 }
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001946
1947 llvm::Constant *Aliasee;
1948 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergba036122012-10-05 23:12:53 +00001949 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1950 GlobalDecl(cast<FunctionDecl>(VD)),
Anders Carlsson3c239482011-02-05 04:35:53 +00001951 /*ForVTable=*/false);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001952 else
John McCall7ec50432010-03-19 23:29:14 +00001953 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Craig Topper8a13c412014-05-21 05:09:00 +00001954 llvm::PointerType::getUnqual(DeclTy),
1955 nullptr);
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001956
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001957 auto *F = cast<llvm::GlobalValue>(Aliasee);
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001958 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1959 WeakRefReferences.insert(F);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001960
John McCall7f416cc2015-09-08 08:05:57 +00001961 return ConstantAddress(Aliasee, Alignment);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001962}
1963
Chris Lattnere0be0df2009-05-12 21:21:08 +00001964void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00001965 const auto *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00001966
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001967 // Weak references don't produce any output by themselves.
1968 if (Global->hasAttr<WeakRefAttr>())
1969 return;
1970
Chris Lattner54041692009-03-22 21:47:11 +00001971 // If this is an alias definition (which otherwise looks like a declaration)
1972 // emit it now.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001973 if (Global->hasAttr<AliasAttr>())
Rafael Espindola6956d582013-10-22 14:23:09 +00001974 return EmitAliasDefinition(GD);
Daniel Dunbar0beedc12008-09-08 23:44:31 +00001975
Dmitry Polukhin85eda122016-04-11 07:48:59 +00001976 // IFunc like an alias whose value is resolved at runtime by calling resolver.
1977 if (Global->hasAttr<IFuncAttr>())
1978 return emitIFuncDefinition(GD);
1979
Peter Collingbournea9455ec2011-10-06 18:29:46 +00001980 // If this is CUDA, be selective about which declarations we emit.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001981 if (LangOpts.CUDA) {
Artem Belevichf3d3db62015-03-19 18:58:18 +00001982 if (LangOpts.CUDAIsDevice) {
Peter Collingbournea9455ec2011-10-06 18:29:46 +00001983 if (!Global->hasAttr<CUDADeviceAttr>() &&
1984 !Global->hasAttr<CUDAGlobalAttr>() &&
1985 !Global->hasAttr<CUDAConstantAttr>() &&
1986 !Global->hasAttr<CUDASharedAttr>())
1987 return;
1988 } else {
Artem Belevich42e19492016-03-02 18:28:50 +00001989 // We need to emit host-side 'shadows' for all global
1990 // device-side variables because the CUDA runtime needs their
1991 // size and host-side address in order to provide access to
1992 // their device-side incarnations.
1993
1994 // So device-only functions are the only things we skip.
1995 if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() &&
1996 Global->hasAttr<CUDADeviceAttr>())
Peter Collingbournea9455ec2011-10-06 18:29:46 +00001997 return;
Artem Belevich42e19492016-03-02 18:28:50 +00001998
1999 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
2000 "Expected Variable or Function");
Peter Collingbournea9455ec2011-10-06 18:29:46 +00002001 }
2002 }
2003
Alexey Bataevc5b1d322016-03-04 09:22:22 +00002004 if (LangOpts.OpenMP) {
2005 // If this is OpenMP device, check if it is legal to emit this global
2006 // normally.
2007 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
2008 return;
2009 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
2010 if (MustBeEmitted(Global))
2011 EmitOMPDeclareReduction(DRD);
2012 return;
2013 }
2014 }
Samuel Antaoee8fb302016-01-06 13:42:12 +00002015
Chris Lattner45470942009-03-21 09:44:56 +00002016 // Ignore declarations, they will be emitted on their first use.
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002017 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar6b8720e2009-02-13 21:18:01 +00002018 // Forward declarations are emitted lazily on first use.
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002019 if (!FD->doesThisDeclarationHaveABody()) {
2020 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
2021 return;
2022
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002023 StringRef MangledName = getMangledName(GD);
David Majnemeraf369802014-03-29 14:19:55 +00002024
2025 // Compute the function info and LLVM type.
2026 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2027 llvm::Type *Ty = getTypes().GetFunctionType(FI);
2028
2029 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
2030 /*DontDefer=*/false);
Daniel Dunbar6b8720e2009-02-13 21:18:01 +00002031 return;
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002032 }
Daniel Dunbar08b26a02009-02-13 20:29:50 +00002033 } else {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002034 const auto *VD = cast<VarDecl>(Global);
Daniel Dunbar9c426522008-07-29 23:18:29 +00002035 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
Artem Belevich42e19492016-03-02 18:28:50 +00002036 // We need to emit device-side global CUDA variables even if a
2037 // variable does not have a definition -- we still need to define
2038 // host-side shadow for it.
2039 bool MustEmitForCuda = LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
2040 !VD->hasDefinition() &&
2041 (VD->hasAttr<CUDAConstantAttr>() ||
2042 VD->hasAttr<CUDADeviceAttr>());
2043 if (!MustEmitForCuda &&
2044 VD->isThisDeclarationADefinition() != VarDecl::Definition &&
Richard Smithd9b90092016-07-02 01:32:16 +00002045 !Context.isMSStaticDataMemberInlineDefinition(VD)) {
2046 // If this declaration may have caused an inline variable definition to
2047 // change linkage, make sure that it's emitted.
2048 if (Context.getInlineVariableDefinitionKind(VD) ==
2049 ASTContext::InlineVariableDefinitionKind::Strong)
2050 GetAddrOfGlobalVar(VD);
Douglas Gregorbeecd582009-04-21 17:11:58 +00002051 return;
Richard Smithd9b90092016-07-02 01:32:16 +00002052 }
Nate Begeman8e8d4982008-04-20 06:29:50 +00002053 }
2054
Hans Wennborg43a0f992015-01-10 01:19:48 +00002055 // Defer code generation to first use when possible, e.g. if this is an inline
2056 // function. If the global must always be emitted, do it eagerly if possible
2057 // to benefit from cache locality.
2058 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
Chris Lattner7a4a29f2010-04-13 17:39:09 +00002059 // Emit the definition if it can't be deferred.
2060 EmitGlobalDefinition(GD);
Daniel Dunbar9c426522008-07-29 23:18:29 +00002061 return;
2062 }
John McCall70013b62010-07-15 23:40:35 +00002063
2064 // If we're deferring emission of a C++ variable with an
2065 // initializer, remember the order in which it appeared in the file.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002066 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
John McCall70013b62010-07-15 23:40:35 +00002067 cast<VarDecl>(Global)->hasInit()) {
2068 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
Craig Topper8a13c412014-05-21 05:09:00 +00002069 CXXGlobalInits.push_back(nullptr);
John McCall70013b62010-07-15 23:40:35 +00002070 }
Hans Wennborg43a0f992015-01-10 01:19:48 +00002071
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002072 StringRef MangledName = getMangledName(GD);
Sanjoy Das70a60512017-05-01 06:12:13 +00002073 if (GetGlobalValue(MangledName) != nullptr) {
Hans Wennborg43a0f992015-01-10 01:19:48 +00002074 // The value has already been used and should therefore be emitted.
Sanjoy Das70a60512017-05-01 06:12:13 +00002075 addDeferredDeclToEmit(GD);
Hans Wennborg43a0f992015-01-10 01:19:48 +00002076 } else if (MustBeEmitted(Global)) {
2077 // The value must be emitted, but cannot be emitted eagerly.
2078 assert(!MayBeEmittedEagerly(Global));
Sanjoy Das70a60512017-05-01 06:12:13 +00002079 addDeferredDeclToEmit(GD);
Hans Wennborg43a0f992015-01-10 01:19:48 +00002080 } else {
Chris Lattner7a4a29f2010-04-13 17:39:09 +00002081 // Otherwise, remember that we saw a deferred decl with this name. The
2082 // first use of the mangled name will cause it to move into
2083 // DeferredDeclsToEmit.
2084 DeferredDecls[MangledName] = GD;
2085 }
Nate Begeman8e8d4982008-04-20 06:29:50 +00002086}
2087
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002088// Check if T is a class type with a destructor that's not dllimport.
2089static bool HasNonDllImportDtor(QualType T) {
2090 if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>())
2091 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2092 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
2093 return true;
2094
2095 return false;
2096}
2097
Rafael Espindolac5941352011-10-26 20:41:06 +00002098namespace {
2099 struct FunctionIsDirectlyRecursive :
2100 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
2101 const StringRef Name;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002102 const Builtin::Context &BI;
Rafael Espindolac5941352011-10-26 20:41:06 +00002103 bool Result;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002104 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
2105 Name(N), BI(C), Result(false) {
Rafael Espindolac5941352011-10-26 20:41:06 +00002106 }
2107 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
2108
2109 bool TraverseCallExpr(CallExpr *E) {
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002110 const FunctionDecl *FD = E->getDirectCallee();
2111 if (!FD)
Rafael Espindolac5941352011-10-26 20:41:06 +00002112 return true;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002113 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2114 if (Attr && Name == Attr->getLabel()) {
2115 Result = true;
2116 return false;
2117 }
2118 unsigned BuiltinID = FD->getBuiltinID();
David Majnemer41011f62015-06-25 23:50:40 +00002119 if (!BuiltinID || !BI.isLibFunction(BuiltinID))
Rafael Espindolac5941352011-10-26 20:41:06 +00002120 return true;
Eric Christopher02d5d862015-08-06 01:01:12 +00002121 StringRef BuiltinName = BI.getName(BuiltinID);
Nick Lewycky9ed5b152012-01-18 03:41:19 +00002122 if (BuiltinName.startswith("__builtin_") &&
2123 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
Rafael Espindolac5941352011-10-26 20:41:06 +00002124 Result = true;
2125 return false;
2126 }
2127 return true;
2128 }
2129 };
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002130
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002131 // Make sure we're not referencing non-imported vars or functions.
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002132 struct DLLImportFunctionVisitor
2133 : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
2134 bool SafeToInline = true;
2135
Hans Wennborg1b3aee72016-09-13 22:51:42 +00002136 bool shouldVisitImplicitCode() const { return true; }
2137
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002138 bool VisitVarDecl(VarDecl *VD) {
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002139 if (VD->getTLSKind()) {
2140 // A thread-local variable cannot be imported.
2141 SafeToInline = false;
2142 return SafeToInline;
2143 }
2144
2145 // A variable definition might imply a destructor call.
2146 if (VD->isThisDeclarationADefinition())
2147 SafeToInline = !HasNonDllImportDtor(VD->getType());
2148
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002149 return SafeToInline;
2150 }
2151
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002152 bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
2153 if (const auto *D = E->getTemporary()->getDestructor())
2154 SafeToInline = D->hasAttr<DLLImportAttr>();
2155 return SafeToInline;
2156 }
2157
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002158 bool VisitDeclRefExpr(DeclRefExpr *E) {
2159 ValueDecl *VD = E->getDecl();
2160 if (isa<FunctionDecl>(VD))
2161 SafeToInline = VD->hasAttr<DLLImportAttr>();
2162 else if (VarDecl *V = dyn_cast<VarDecl>(VD))
2163 SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
2164 return SafeToInline;
2165 }
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002166
Hans Wennborg1b3aee72016-09-13 22:51:42 +00002167 bool VisitCXXConstructExpr(CXXConstructExpr *E) {
2168 SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
2169 return SafeToInline;
2170 }
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002171
Hans Wennborg251c2042017-01-23 23:57:50 +00002172 bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2173 CXXMethodDecl *M = E->getMethodDecl();
2174 if (!M) {
2175 // Call through a pointer to member function. This is safe to inline.
2176 SafeToInline = true;
2177 } else {
2178 SafeToInline = M->hasAttr<DLLImportAttr>();
2179 }
2180 return SafeToInline;
2181 }
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002182
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002183 bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2184 SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
2185 return SafeToInline;
2186 }
Hans Wennborgcac8ce02017-02-15 23:28:10 +00002187
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002188 bool VisitCXXNewExpr(CXXNewExpr *E) {
2189 SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
2190 return SafeToInline;
2191 }
2192 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002193}
Rafael Espindolac5941352011-10-26 20:41:06 +00002194
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002195// isTriviallyRecursive - Check if this function calls another
2196// decl that, because of the asm attribute or the other decl being a builtin,
2197// ends up pointing to itself.
Rafael Espindolac5941352011-10-26 20:41:06 +00002198bool
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002199CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
2200 StringRef Name;
2201 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
Nick Lewycky72cd2292012-01-18 01:50:13 +00002202 // asm labels are a special kind of mangling we have to support.
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002203 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2204 if (!Attr)
2205 return false;
2206 Name = Attr->getLabel();
2207 } else {
2208 Name = FD->getName();
2209 }
Rafael Espindolac5941352011-10-26 20:41:06 +00002210
David Majnemer64b0bdf2015-06-30 04:41:18 +00002211 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002212 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
Rafael Espindolac5941352011-10-26 20:41:06 +00002213 return Walker.Result;
2214}
2215
Hans Wennborg93f75472016-09-13 21:08:20 +00002216bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
Peter Collingbourne4d90dba2013-06-05 17:49:37 +00002217 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
Rafael Espindolac5941352011-10-26 20:41:06 +00002218 return true;
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002219 const auto *F = cast<FunctionDecl>(GD.getDecl());
David Majnemer67e541e1c2014-02-25 09:53:29 +00002220 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
Rafael Espindolac5941352011-10-26 20:41:06 +00002221 return false;
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002222
2223 if (F->hasAttr<DLLImportAttr>()) {
2224 // Check whether it would be safe to inline this dllimport function.
2225 DLLImportFunctionVisitor Visitor;
2226 Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
2227 if (!Visitor.SafeToInline)
2228 return false;
Hans Wennborg93f75472016-09-13 21:08:20 +00002229
2230 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
2231 // Implicit destructor invocations aren't captured in the AST, so the
2232 // check above can't see them. Check for them manually here.
2233 for (const Decl *Member : Dtor->getParent()->decls())
2234 if (isa<FieldDecl>(Member))
2235 if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType()))
2236 return false;
2237 for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
2238 if (HasNonDllImportDtor(B.getType()))
2239 return false;
2240 }
Hans Wennborg6eaa8322015-08-28 21:47:01 +00002241 }
2242
Rafael Espindolac5941352011-10-26 20:41:06 +00002243 // PR9614. Avoid cases where the source code is lying to us. An available
2244 // externally function should have an equivalent function somewhere else,
2245 // but a function that calls itself is clearly not equivalent to the real
2246 // implementation.
2247 // This happens in glibc's btowc and in some configure checks.
Rafael Espindola4fdc1752011-12-19 14:41:01 +00002248 return !isTriviallyRecursive(F);
Rafael Espindolac5941352011-10-26 20:41:06 +00002249}
2250
Piotr Padlewskid3b1cbd2017-06-01 08:04:05 +00002251bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
2252 return CodeGenOpts.OptimizationLevel > 0;
2253}
2254
Rafael Espindolacd7743b2013-12-09 16:01:03 +00002255void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002256 const auto *D = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00002257
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002258 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson29295bf2009-10-27 14:32:27 +00002259 Context.getSourceManager(),
2260 "Generating code for declaration");
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002261
Peter Collingbourne4d90dba2013-06-05 17:49:37 +00002262 if (isa<FunctionDecl>(D)) {
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002263 // At -O0, don't generate IR for functions with available_externally
Douglas Gregora700f682010-07-13 06:02:28 +00002264 // linkage.
Peter Collingbourne4d90dba2013-06-05 17:49:37 +00002265 if (!shouldEmitFunction(GD))
Douglas Gregora700f682010-07-13 06:02:28 +00002266 return;
Anders Carlssonaf82f632010-03-23 04:31:31 +00002267
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002268 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
Eli Friedman49a94b12011-05-06 17:27:27 +00002269 // Make sure to emit the definition(s) before we emit the thunks.
2270 // This is necessary for the generation of certain thunks.
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002271 if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
Rafael Espindola91f68b42014-09-15 19:20:10 +00002272 ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002273 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
Rafael Espindola91f68b42014-09-15 19:20:10 +00002274 ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
Eli Friedman49a94b12011-05-06 17:27:27 +00002275 else
Rafael Espindolacd7743b2013-12-09 16:01:03 +00002276 EmitGlobalFunctionDefinition(GD, GV);
Eli Friedman49a94b12011-05-06 17:27:27 +00002277
Douglas Gregora700f682010-07-13 06:02:28 +00002278 if (Method->isVirtual())
2279 getVTables().EmitThunks(GD);
2280
Eli Friedman49a94b12011-05-06 17:27:27 +00002281 return;
Douglas Gregora700f682010-07-13 06:02:28 +00002282 }
Chris Lattnerd8d760c2010-04-13 17:57:11 +00002283
Rafael Espindolacd7743b2013-12-09 16:01:03 +00002284 return EmitGlobalFunctionDefinition(GD, GV);
Douglas Gregora700f682010-07-13 06:02:28 +00002285 }
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002286
2287 if (const auto *VD = dyn_cast<VarDecl>(D))
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002288 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002289
David Blaikie83d382b2011-09-23 05:06:16 +00002290 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
Daniel Dunbar9c426522008-07-29 23:18:29 +00002291}
2292
Andrey Bokhankocab58582015-08-31 13:20:44 +00002293static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2294 llvm::Function *NewFn);
2295
Erich Keane281d20b2018-01-08 21:34:17 +00002296void CodeGenModule::emitMultiVersionFunctions() {
2297 for (GlobalDecl GD : MultiVersionFuncs) {
2298 SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
2299 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
2300 getContext().forEachMultiversionedFunctionVersion(
2301 FD, [this, &GD, &Options](const FunctionDecl *CurFD) {
2302 GlobalDecl CurGD{
2303 (CurFD->isDefined() ? CurFD->getDefinition() : CurFD)};
2304 StringRef MangledName = getMangledName(CurGD);
2305 llvm::Constant *Func = GetGlobalValue(MangledName);
2306 if (!Func) {
2307 if (CurFD->isDefined()) {
2308 EmitGlobalFunctionDefinition(CurGD, nullptr);
2309 Func = GetGlobalValue(MangledName);
2310 } else {
2311 const CGFunctionInfo &FI =
2312 getTypes().arrangeGlobalDeclaration(GD);
2313 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2314 Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
2315 /*DontDefer=*/false, ForDefinition);
2316 }
2317 assert(Func && "This should have just been created");
2318 }
2319 Options.emplace_back(getTarget(), cast<llvm::Function>(Func),
2320 CurFD->getAttr<TargetAttr>()->parse());
2321 });
2322
2323 llvm::Function *ResolverFunc = cast<llvm::Function>(
2324 GetGlobalValue((getMangledName(GD) + ".resolver").str()));
Erich Keane0a6fde42018-01-16 19:49:52 +00002325 if (supportsCOMDAT())
2326 ResolverFunc->setComdat(
2327 getModule().getOrInsertComdat(ResolverFunc->getName()));
Erich Keane281d20b2018-01-08 21:34:17 +00002328 std::stable_sort(
2329 Options.begin(), Options.end(),
2330 std::greater<CodeGenFunction::MultiVersionResolverOption>());
2331 CodeGenFunction CGF(*this);
2332 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2333 }
2334}
2335
2336/// If an ifunc for the specified mangled name is not in the module, create and
2337/// return an llvm IFunc Function with the specified type.
2338llvm::Constant *
2339CodeGenModule::GetOrCreateMultiVersionIFunc(GlobalDecl GD, llvm::Type *DeclTy,
2340 StringRef MangledName,
2341 const FunctionDecl *FD) {
2342 std::string IFuncName = (MangledName + ".ifunc").str();
2343 if (llvm::GlobalValue *IFuncGV = GetGlobalValue(IFuncName))
2344 return IFuncGV;
2345
2346 // Since this is the first time we've created this IFunc, make sure
2347 // that we put this multiversioned function into the list to be
2348 // replaced later.
2349 MultiVersionFuncs.push_back(GD);
2350
2351 std::string ResolverName = (MangledName + ".resolver").str();
2352 llvm::Type *ResolverType = llvm::FunctionType::get(
2353 llvm::PointerType::get(DeclTy,
2354 Context.getTargetAddressSpace(FD->getType())),
2355 false);
2356 llvm::Constant *Resolver =
2357 GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{},
2358 /*ForVTable=*/false);
2359 llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
2360 DeclTy, 0, llvm::Function::ExternalLinkage, "", Resolver, &getModule());
2361 GIF->setName(IFuncName);
2362 SetCommonAttributes(FD, GIF);
2363
2364 return GIF;
2365}
2366
Chris Lattnerd4808922009-03-22 21:03:39 +00002367/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
2368/// module, create and return an llvm Function with the specified type. If there
2369/// is something in the module with the specified name, return it potentially
2370/// bitcasted to the right type.
2371///
2372/// If D is non-null, it specifies a decl that correspond to this. This is used
2373/// to set the attributes on the function when it is first created.
Reid Klecknerde864822017-03-21 16:57:30 +00002374llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
2375 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
2376 bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
2377 ForDefinition_t IsForDefinition) {
Reid Klecknerf6ce2b52013-07-22 13:07:10 +00002378 const Decl *D = GD.getDecl();
2379
Erich Keane281d20b2018-01-08 21:34:17 +00002380 // Any attempts to use a MultiVersion function should result in retrieving
2381 // the iFunc instead. Name Mangling will handle the rest of the changes.
2382 if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
2383 if (FD->isMultiVersion() && FD->getAttr<TargetAttr>()->isDefaultVersion()) {
2384 UpdateMultiVersionNames(GD, FD);
2385 if (!IsForDefinition)
2386 return GetOrCreateMultiVersionIFunc(GD, Ty, MangledName, FD);
2387 }
2388 }
2389
Chris Lattnera85d68e2009-03-21 09:25:43 +00002390 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +00002391 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattnera85d68e2009-03-21 09:25:43 +00002392 if (Entry) {
Benjamin Kramerfc6eb7d2012-08-22 15:37:55 +00002393 if (WeakRefReferences.erase(Entry)) {
Reid Klecknerf6ce2b52013-07-22 13:07:10 +00002394 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00002395 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +00002396 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00002397 }
2398
Hans Wennborg0a20f542014-08-29 00:16:06 +00002399 // Handle dropped DLL attributes.
2400 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
2401 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2402
Andrey Bokhankocab58582015-08-31 13:20:44 +00002403 // If there are two attempts to define the same mangled name, issue an
2404 // error.
2405 if (IsForDefinition && !Entry->isDeclaration()) {
2406 GlobalDecl OtherGD;
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002407 // Check that GD is not yet in DiagnosedConflictingDefinitions is required
2408 // to make sure that we issue an error only once.
Andrey Bokhankocab58582015-08-31 13:20:44 +00002409 if (lookupRepresentativeDecl(MangledName, OtherGD) &&
2410 (GD.getCanonicalDecl().getDecl() !=
2411 OtherGD.getCanonicalDecl().getDecl()) &&
2412 DiagnosedConflictingDefinitions.insert(GD).second) {
2413 getDiags().Report(D->getLocation(),
2414 diag::err_duplicate_mangled_name);
2415 getDiags().Report(OtherGD.getDecl()->getLocation(),
2416 diag::note_previous_definition);
2417 }
2418 }
2419
2420 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
2421 (Entry->getType()->getElementType() == Ty)) {
Chris Lattnera85d68e2009-03-21 09:25:43 +00002422 return Entry;
Andrey Bokhankocab58582015-08-31 13:20:44 +00002423 }
Mike Stump11289f42009-09-09 15:08:12 +00002424
Chris Lattnera85d68e2009-03-21 09:25:43 +00002425 // Make sure the result is of the correct type.
Andrey Bokhankocab58582015-08-31 13:20:44 +00002426 // (If function is requested for a definition, we always need to create a new
2427 // function, not just return a bitcast.)
2428 if (!IsForDefinition)
2429 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattnera85d68e2009-03-21 09:25:43 +00002430 }
Mike Stump11289f42009-09-09 15:08:12 +00002431
Eli Friedmancc522d92009-11-09 05:07:37 +00002432 // This function doesn't have a complete type (for example, the return
2433 // type is an incomplete struct). Use a fake type instead, and make
2434 // sure not to try to set attributes.
2435 bool IsIncompleteFunction = false;
John McCalld06fb862010-04-28 00:00:30 +00002436
Chris Lattner2192fe52011-07-18 04:24:23 +00002437 llvm::FunctionType *FTy;
John McCalld06fb862010-04-28 00:00:30 +00002438 if (isa<llvm::FunctionType>(Ty)) {
2439 FTy = cast<llvm::FunctionType>(Ty);
2440 } else {
John McCall9dc0db22011-05-15 01:53:33 +00002441 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedmancc522d92009-11-09 05:07:37 +00002442 IsIncompleteFunction = true;
2443 }
Andrey Bokhankocab58582015-08-31 13:20:44 +00002444
2445 llvm::Function *F =
2446 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
2447 Entry ? StringRef() : MangledName, &getModule());
2448
2449 // If we already created a function with the same mangled name (but different
2450 // type) before, take its name and add it to the list of functions to be
2451 // replaced with F at the end of CodeGen.
2452 //
2453 // This happens if there is a prototype for a function (e.g. "int f()") and
2454 // then a definition of a different type (e.g. "int f(int x)").
2455 if (Entry) {
2456 F->takeName(Entry);
2457
2458 // This might be an implementation of a function without a prototype, in
2459 // which case, try to do special replacement of calls which match the new
2460 // prototype. The really key thing here is that we also potentially drop
2461 // arguments from the call site so as to make a direct call, which makes the
2462 // inliner happier and suppresses a number of optimizer warnings (!) about
2463 // dropping arguments.
2464 if (!Entry->use_empty()) {
2465 ReplaceUsesOfNonProtoTypeWithRealFunction(Entry, F);
2466 Entry->removeDeadConstantUsers();
2467 }
2468
2469 llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
2470 F, Entry->getType()->getElementType()->getPointerTo());
2471 addGlobalValReplacement(Entry, BC);
2472 }
2473
John McCall7ec50432010-03-19 23:29:14 +00002474 assert(F->getName() == MangledName && "name was uniqued!");
Reid Klecknerf6ce2b52013-07-22 13:07:10 +00002475 if (D)
Rafael Espindoladeb10be2018-02-07 19:04:41 +00002476 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
Reid Klecknerde864822017-03-21 16:57:30 +00002477 if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
2478 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
Reid Kleckneree4930b2017-05-02 22:07:37 +00002479 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
Bill Wendling9a677922013-01-23 00:21:06 +00002480 }
Eli Friedmancc522d92009-11-09 05:07:37 +00002481
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002482 if (!DontDefer) {
2483 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
2484 // each other bottoming out with the base dtor. Therefore we emit non-base
2485 // dtors on usage, even if there is no dtor definition in the TU.
2486 if (D && isa<CXXDestructorDecl>(D) &&
2487 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
2488 GD.getDtorType()))
Sanjoy Das70a60512017-05-01 06:12:13 +00002489 addDeferredDeclToEmit(GD);
John McCall357d0f32010-12-15 04:00:32 +00002490
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002491 // This is the first use or definition of a mangled name. If there is a
2492 // deferred decl with this name, remember that we need to emit it at the end
2493 // of the file.
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002494 auto DDI = DeferredDecls.find(MangledName);
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002495 if (DDI != DeferredDecls.end()) {
2496 // Move the potentially referenced deferred decl to the
2497 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
2498 // don't need it anymore).
Sanjoy Das70a60512017-05-01 06:12:13 +00002499 addDeferredDeclToEmit(DDI->second);
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002500 DeferredDecls.erase(DDI);
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002501
2502 // Otherwise, there are cases we have to worry about where we're
2503 // using a declaration for which we must emit a definition but where
2504 // we might not find a top-level definition:
2505 // - member functions defined inline in their classes
2506 // - friend functions defined inline in some class
2507 // - special member functions with implicit definitions
2508 // If we ever change our AST traversal to walk into class methods,
2509 // this will be unnecessary.
2510 //
2511 // We also don't emit a definition for a function if it's going to be an
Richard Smith46bb5812014-08-01 01:56:39 +00002512 // entry in a vtable, unless it's already marked as used.
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002513 } else if (getLangOpts().CPlusPlus && D) {
2514 // Look for a declaration that's lexically in a record.
Richard Smith46bb5812014-08-01 01:56:39 +00002515 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
2516 FD = FD->getPreviousDecl()) {
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002517 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Richard Smith46bb5812014-08-01 01:56:39 +00002518 if (FD->doesThisDeclarationHaveABody()) {
Sanjoy Das70a60512017-05-01 06:12:13 +00002519 addDeferredDeclToEmit(GD.getWithDecl(FD));
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002520 break;
2521 }
John McCall357d0f32010-12-15 04:00:32 +00002522 }
Richard Smith46bb5812014-08-01 01:56:39 +00002523 }
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002524 }
Chris Lattner45470942009-03-21 09:44:56 +00002525 }
Mike Stump11289f42009-09-09 15:08:12 +00002526
John McCalld06fb862010-04-28 00:00:30 +00002527 // Make sure the result is of the requested type.
2528 if (!IsIncompleteFunction) {
2529 assert(F->getType()->getElementType() == Ty);
2530 return F;
2531 }
2532
Chris Lattnera5f58b02011-07-09 17:41:47 +00002533 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCalld06fb862010-04-28 00:00:30 +00002534 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattnera85d68e2009-03-21 09:25:43 +00002535}
2536
Chris Lattnerd4808922009-03-22 21:03:39 +00002537/// GetAddrOfFunction - Return the address of the given function. If Ty is
2538/// non-null, then this function will use the specified type if it has to
2539/// create it (this occurs when we see a definition of the function).
Chris Lattnere0be0df2009-05-12 21:21:08 +00002540llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2192fe52011-07-18 04:24:23 +00002541 llvm::Type *Ty,
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002542 bool ForVTable,
Andrey Bokhankocab58582015-08-31 13:20:44 +00002543 bool DontDefer,
John McCalld195d4c2016-11-30 23:25:13 +00002544 ForDefinition_t IsForDefinition) {
Chris Lattnerd4808922009-03-22 21:03:39 +00002545 // If there was no specific requested type, just convert it now.
George Burgess IV3e3bb95b2015-12-02 21:58:08 +00002546 if (!Ty) {
2547 const auto *FD = cast<FunctionDecl>(GD.getDecl());
2548 auto CanonTy = Context.getCanonicalType(FD->getType());
2549 Ty = getTypes().ConvertFunctionType(CanonTy, FD);
2550 }
Andrey Bokhankocab58582015-08-31 13:20:44 +00002551
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002552 StringRef MangledName = getMangledName(GD);
Andrey Bokhankocab58582015-08-31 13:20:44 +00002553 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
Reid Klecknerde864822017-03-21 16:57:30 +00002554 /*IsThunk=*/false, llvm::AttributeList(),
Andrey Bokhankocab58582015-08-31 13:20:44 +00002555 IsForDefinition);
Chris Lattnerd4808922009-03-22 21:03:39 +00002556}
Eli Friedmanc18d9d52008-05-30 19:50:47 +00002557
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002558static const FunctionDecl *
2559GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) {
2560 TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
2561 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
2562
2563 IdentifierInfo &CII = C.Idents.get(Name);
2564 for (const auto &Result : DC->lookup(&CII))
2565 if (const auto FD = dyn_cast<FunctionDecl>(Result))
2566 return FD;
2567
2568 if (!C.getLangOpts().CPlusPlus)
2569 return nullptr;
2570
2571 // Demangle the premangled name from getTerminateFn()
2572 IdentifierInfo &CXXII =
2573 (Name == "_ZSt9terminatev" || Name == "\01?terminate@@YAXXZ")
2574 ? C.Idents.get("terminate")
2575 : C.Idents.get(Name);
2576
2577 for (const auto &N : {"__cxxabiv1", "std"}) {
2578 IdentifierInfo &NS = C.Idents.get(N);
2579 for (const auto &Result : DC->lookup(&NS)) {
2580 NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
2581 if (auto LSD = dyn_cast<LinkageSpecDecl>(Result))
2582 for (const auto &Result : LSD->lookup(&NS))
2583 if ((ND = dyn_cast<NamespaceDecl>(Result)))
2584 break;
2585
2586 if (ND)
2587 for (const auto &Result : ND->lookup(&CXXII))
2588 if (const auto *FD = dyn_cast<FunctionDecl>(Result))
2589 return FD;
2590 }
2591 }
2592
2593 return nullptr;
2594}
2595
Chris Lattnerd4808922009-03-22 21:03:39 +00002596/// CreateRuntimeFunction - Create a new runtime function with the specified
2597/// type and name.
2598llvm::Constant *
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002599CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
Reid Klecknerde864822017-03-21 16:57:30 +00002600 llvm::AttributeList ExtraAttrs,
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002601 bool Local) {
Rafael Espindola94abb8f2013-12-09 04:29:47 +00002602 llvm::Constant *C =
2603 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002604 /*DontDefer=*/false, /*IsThunk=*/false,
2605 ExtraAttrs);
2606
2607 if (auto *F = dyn_cast<llvm::Function>(C)) {
2608 if (F->empty()) {
John McCall882987f2013-02-28 19:01:20 +00002609 F->setCallingConv(getRuntimeCC());
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002610
2611 if (!Local && getTriple().isOSBinFormatCOFF() &&
Martell Maloneb22e6002017-11-04 02:15:49 +00002612 !getCodeGenOpts().LTOVisibilityPublicStd &&
2613 !getTriple().isWindowsGNUEnvironment()) {
Saleem Abdulrasool6cb07442016-12-15 06:59:05 +00002614 const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
2615 if (!FD || FD->hasAttr<DLLImportAttr>()) {
2616 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2617 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
2618 }
2619 }
2620 }
2621 }
2622
John McCall882987f2013-02-28 19:01:20 +00002623 return C;
Chris Lattnerd4808922009-03-22 21:03:39 +00002624}
Daniel Dunbar9c426522008-07-29 23:18:29 +00002625
Anton Korobeynikovd90dd792014-12-02 16:04:58 +00002626/// CreateBuiltinFunction - Create a new builtin function with the specified
2627/// type and name.
2628llvm::Constant *
Reid Klecknerde864822017-03-21 16:57:30 +00002629CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy, StringRef Name,
2630 llvm::AttributeList ExtraAttrs) {
Anton Korobeynikovd90dd792014-12-02 16:04:58 +00002631 llvm::Constant *C =
2632 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
2633 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
2634 if (auto *F = dyn_cast<llvm::Function>(C))
2635 if (F->empty())
2636 F->setCallingConv(getBuiltinCC());
2637 return C;
2638}
2639
Richard Smithe070fd22012-02-17 06:48:11 +00002640/// isTypeConstant - Determine whether an object of this type can be emitted
2641/// as a constant.
2642///
2643/// If ExcludeCtor is true, the duration when the object's constructor runs
2644/// will not be considered. The caller will need to verify that the object is
2645/// not written to during its construction.
2646bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
2647 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
Eli Friedmanb095e152009-12-11 21:23:03 +00002648 return false;
Richard Smithe070fd22012-02-17 06:48:11 +00002649
David Blaikiebbafb8a2012-03-11 07:00:24 +00002650 if (Context.getLangOpts().CPlusPlus) {
Richard Smithe070fd22012-02-17 06:48:11 +00002651 if (const CXXRecordDecl *Record
2652 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
2653 return ExcludeCtor && !Record->hasMutableFields() &&
2654 Record->hasTrivialDestructor();
Eli Friedmanb095e152009-12-11 21:23:03 +00002655 }
Richard Smithe070fd22012-02-17 06:48:11 +00002656
Eli Friedmanb095e152009-12-11 21:23:03 +00002657 return true;
2658}
2659
Chris Lattnerd4808922009-03-22 21:03:39 +00002660/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
2661/// create and return an llvm GlobalVariable with the specified type. If there
2662/// is something in the module with the specified name, return it potentially
2663/// bitcasted to the right type.
2664///
2665/// If D is non-null, it specifies a decl that correspond to this. This is used
2666/// to set the attributes on the global when it is first created.
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002667///
2668/// If IsForDefinition is true, it is guranteed that an actual global with
2669/// type Ty will be returned, not conversion of a variable with the same
2670/// mangled name but some other type.
John McCall7ec50432010-03-19 23:29:14 +00002671llvm::Constant *
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002672CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2192fe52011-07-18 04:24:23 +00002673 llvm::PointerType *Ty,
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002674 const VarDecl *D,
John McCalld195d4c2016-11-30 23:25:13 +00002675 ForDefinition_t IsForDefinition) {
Daniel Dunbar829e9882008-08-05 23:31:02 +00002676 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +00002677 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner3bfce182009-03-21 08:03:33 +00002678 if (Entry) {
Benjamin Kramerfc6eb7d2012-08-22 15:37:55 +00002679 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +00002680 if (D && !D->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +00002681 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00002682 }
2683
Hans Wennborg0a20f542014-08-29 00:16:06 +00002684 // Handle dropped DLL attributes.
2685 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
2686 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2687
Chris Lattnerd4808922009-03-22 21:03:39 +00002688 if (Entry->getType() == Ty)
Chris Lattner149927c2009-03-21 09:16:30 +00002689 return Entry;
Mike Stump11289f42009-09-09 15:08:12 +00002690
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002691 // If there are two attempts to define the same mangled name, issue an
2692 // error.
2693 if (IsForDefinition && !Entry->isDeclaration()) {
2694 GlobalDecl OtherGD;
2695 const VarDecl *OtherD;
2696
2697 // Check that D is not yet in DiagnosedConflictingDefinitions is required
2698 // to make sure that we issue an error only once.
Artem Belevich2c323a02016-05-19 18:00:18 +00002699 if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002700 (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
2701 (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
2702 OtherD->hasInit() &&
2703 DiagnosedConflictingDefinitions.insert(D).second) {
2704 getDiags().Report(D->getLocation(),
2705 diag::err_duplicate_mangled_name);
2706 getDiags().Report(OtherGD.getDecl()->getLocation(),
2707 diag::note_previous_definition);
2708 }
2709 }
2710
Chris Lattner3bfce182009-03-21 08:03:33 +00002711 // Make sure the result is of the correct type.
Matt Arsenault00e65b22013-11-15 02:19:52 +00002712 if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
2713 return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
2714
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002715 // (If global is requested for a definition, we always need to create a new
2716 // global, not just return a bitcast.)
2717 if (!IsForDefinition)
2718 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbardec798b2009-01-13 02:25:00 +00002719 }
Mike Stump11289f42009-09-09 15:08:12 +00002720
Yaxun Liucbf647c2017-07-08 13:24:52 +00002721 auto AddrSpace = GetGlobalVarAddressSpace(D);
2722 auto TargetAddrSpace = getContext().getTargetAddressSpace(AddrSpace);
2723
Rafael Espindola2ae250c2014-05-09 00:08:36 +00002724 auto *GV = new llvm::GlobalVariable(
2725 getModule(), Ty->getElementType(), false,
Craig Topper8a13c412014-05-21 05:09:00 +00002726 llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
Yaxun Liucbf647c2017-07-08 13:24:52 +00002727 llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace);
Rafael Espindolac0ff7442013-12-09 14:59:08 +00002728
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002729 // If we already created a global with the same mangled name (but different
2730 // type) before, take its name and remove it from its parent.
2731 if (Entry) {
2732 GV->takeName(Entry);
2733
2734 if (!Entry->use_empty()) {
2735 llvm::Constant *NewPtrForOldDecl =
2736 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2737 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2738 }
2739
2740 Entry->eraseFromParent();
2741 }
2742
Chris Lattner45470942009-03-21 09:44:56 +00002743 // This is the first use or definition of a mangled name. If there is a
2744 // deferred decl with this name, remember that we need to emit it at the end
2745 // of the file.
Alp Tokerfb8d02b2014-06-05 22:10:59 +00002746 auto DDI = DeferredDecls.find(MangledName);
Chris Lattner45470942009-03-21 09:44:56 +00002747 if (DDI != DeferredDecls.end()) {
2748 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
2749 // list, and remove it from DeferredDecls (since we don't need it anymore).
Sanjoy Das70a60512017-05-01 06:12:13 +00002750 addDeferredDeclToEmit(DDI->second);
Chris Lattner45470942009-03-21 09:44:56 +00002751 DeferredDecls.erase(DDI);
2752 }
Mike Stump11289f42009-09-09 15:08:12 +00002753
Chris Lattner3bfce182009-03-21 08:03:33 +00002754 // Handle things which are present even on external declarations.
Chris Lattnerd4808922009-03-22 21:03:39 +00002755 if (D) {
Mike Stump18bb9282009-05-16 07:57:57 +00002756 // FIXME: This code is overly simple and should be merged with other global
2757 // handling.
Richard Smithe070fd22012-02-17 06:48:11 +00002758 GV->setConstant(isTypeConstant(D->getType(), false));
Chris Lattner3bfce182009-03-21 08:03:33 +00002759
Ulrich Weigand46084382015-04-21 17:27:59 +00002760 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
2761
Jake Ehrlichba874ad2017-11-29 00:54:20 +00002762 setLinkageForGV(GV, D);
Eli Friedman4f856742009-04-19 21:05:03 +00002763
Richard Smith2fd1d7a2013-04-19 16:42:07 +00002764 if (D->getTLSKind()) {
Richard Smith1847baa2013-04-22 08:06:17 +00002765 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
Richard Smith5a99c492015-12-01 01:10:48 +00002766 CXXThreadLocals.push_back(D);
Hans Wennborgf60f6af2012-06-28 08:01:44 +00002767 setTLSMode(GV, *D);
Richard Smith2fd1d7a2013-04-19 16:42:07 +00002768 }
Hans Wennborgfeedf852013-11-21 00:15:56 +00002769
Rafael Espindola3dd49812018-02-23 00:22:15 +00002770 setGVProperties(GV, D);
2771
Hans Wennborgfeedf852013-11-21 00:15:56 +00002772 // If required by the ABI, treat declarations of static data members with
2773 // inline initializers as definitions.
Hans Wennborg56fc62b2014-07-17 20:25:23 +00002774 if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
Hans Wennborgfeedf852013-11-21 00:15:56 +00002775 EmitGlobalVarDefinition(D);
Hans Wennborg56fc62b2014-07-17 20:25:23 +00002776 }
Robert Lyttonf80d6882014-05-02 09:33:30 +00002777
Erich Keane99fdfb62017-09-26 23:42:34 +00002778 // Emit section information for extern variables.
2779 if (D->hasExternalStorage()) {
2780 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
2781 GV->setSection(SA->getName());
2782 }
2783
Robert Lyttonf80d6882014-05-02 09:33:30 +00002784 // Handle XCore specific ABI requirements.
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +00002785 if (getTriple().getArch() == llvm::Triple::xcore &&
Robert Lyttonf80d6882014-05-02 09:33:30 +00002786 D->getLanguageLinkage() == CLanguageLinkage &&
2787 D->getType().isConstant(Context) &&
2788 isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
2789 GV->setSection(".cp.rodata");
Mehdi Amini7cb1b302017-09-05 03:58:35 +00002790
2791 // Check if we a have a const declaration with an initializer, we may be
2792 // able to emit it as available_externally to expose it's value to the
2793 // optimizer.
2794 if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
2795 D->getType().isConstQualified() && !GV->hasInitializer() &&
2796 !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
2797 const auto *Record =
2798 Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
2799 bool HasMutableFields = Record && Record->hasMutableFields();
2800 if (!HasMutableFields) {
2801 const VarDecl *InitDecl;
2802 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
2803 if (InitExpr) {
2804 ConstantEmitter emitter(*this);
2805 llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
2806 if (Init) {
2807 auto *InitType = Init->getType();
2808 if (GV->getType()->getElementType() != InitType) {
2809 // The type of the initializer does not match the definition.
2810 // This happens when an initializer has a different type from
2811 // the type of the global (because of padding at the end of a
2812 // structure for instance).
2813 GV->setName(StringRef());
2814 // Make a new global with the correct type, this is now guaranteed
2815 // to work.
2816 auto *NewGV = cast<llvm::GlobalVariable>(
2817 GetAddrOfGlobalVar(D, InitType, IsForDefinition));
2818
2819 // Erase the old global, since it is no longer used.
2820 cast<llvm::GlobalValue>(GV)->eraseFromParent();
2821 GV = NewGV;
2822 } else {
2823 GV->setInitializer(Init);
2824 GV->setConstant(true);
2825 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
2826 }
2827 emitter.finalize(GV);
2828 }
2829 }
2830 }
2831 }
Chris Lattnerd4808922009-03-22 21:03:39 +00002832 }
Mike Stump11289f42009-09-09 15:08:12 +00002833
Alexander Richardson6d989432017-10-15 18:48:14 +00002834 LangAS ExpectedAS =
Yaxun Liucbf647c2017-07-08 13:24:52 +00002835 D ? D->getType().getAddressSpace()
Alexander Richardson6d989432017-10-15 18:48:14 +00002836 : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
Benjamin Kramer6fbfdec2017-07-08 14:14:57 +00002837 assert(getContext().getTargetAddressSpace(ExpectedAS) ==
2838 Ty->getPointerAddressSpace());
Yaxun Liucbf647c2017-07-08 13:24:52 +00002839 if (AddrSpace != ExpectedAS)
2840 return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace,
2841 ExpectedAS, Ty);
Matt Arsenault00e65b22013-11-15 02:19:52 +00002842
2843 return GV;
Daniel Dunbar9c426522008-07-29 23:18:29 +00002844}
2845
Andrey Bokhankocab58582015-08-31 13:20:44 +00002846llvm::Constant *
2847CodeGenModule::GetAddrOfGlobal(GlobalDecl GD,
John McCalld195d4c2016-11-30 23:25:13 +00002848 ForDefinition_t IsForDefinition) {
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002849 const Decl *D = GD.getDecl();
2850 if (isa<CXXConstructorDecl>(D))
2851 return getAddrOfCXXStructor(cast<CXXConstructorDecl>(D),
Andrey Bokhankocab58582015-08-31 13:20:44 +00002852 getFromCtorType(GD.getCtorType()),
2853 /*FnInfo=*/nullptr, /*FnType=*/nullptr,
2854 /*DontDefer=*/false, IsForDefinition);
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002855 else if (isa<CXXDestructorDecl>(D))
2856 return getAddrOfCXXStructor(cast<CXXDestructorDecl>(D),
Andrey Bokhankocab58582015-08-31 13:20:44 +00002857 getFromDtorType(GD.getDtorType()),
2858 /*FnInfo=*/nullptr, /*FnType=*/nullptr,
2859 /*DontDefer=*/false, IsForDefinition);
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002860 else if (isa<CXXMethodDecl>(D)) {
Andrey Bokhankocab58582015-08-31 13:20:44 +00002861 auto FInfo = &getTypes().arrangeCXXMethodDeclaration(
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002862 cast<CXXMethodDecl>(D));
Andrey Bokhankocab58582015-08-31 13:20:44 +00002863 auto Ty = getTypes().GetFunctionType(*FInfo);
2864 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
2865 IsForDefinition);
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002866 } else if (isa<FunctionDecl>(D)) {
Andrey Bokhankocab58582015-08-31 13:20:44 +00002867 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2868 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2869 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
2870 IsForDefinition);
2871 } else
Yaron Keren1c4bbc92016-12-24 15:32:39 +00002872 return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr,
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002873 IsForDefinition);
Andrey Bokhankocab58582015-08-31 13:20:44 +00002874}
Chris Lattnerd4808922009-03-22 21:03:39 +00002875
Anders Carlssonda80af32011-01-29 18:20:20 +00002876llvm::GlobalVariable *
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002877CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2192fe52011-07-18 04:24:23 +00002878 llvm::Type *Ty,
Anders Carlssonda80af32011-01-29 18:20:20 +00002879 llvm::GlobalValue::LinkageTypes Linkage) {
2880 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
Craig Topper8a13c412014-05-21 05:09:00 +00002881 llvm::GlobalVariable *OldGV = nullptr;
Anders Carlssonda80af32011-01-29 18:20:20 +00002882
Anders Carlssonda80af32011-01-29 18:20:20 +00002883 if (GV) {
2884 // Check if the variable has the right type.
2885 if (GV->getType()->getElementType() == Ty)
2886 return GV;
2887
2888 // Because C++ name mangling, the only way we can end up with an already
2889 // existing global with the same name is if it has been declared extern "C".
Nico Webercf4ff5862012-10-11 10:13:44 +00002890 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlssonda80af32011-01-29 18:20:20 +00002891 OldGV = GV;
2892 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002893
Anders Carlssonda80af32011-01-29 18:20:20 +00002894 // Create a new variable.
2895 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
Craig Topper8a13c412014-05-21 05:09:00 +00002896 Linkage, nullptr, Name);
2897
Anders Carlssonda80af32011-01-29 18:20:20 +00002898 if (OldGV) {
2899 // Replace occurrences of the old variable if needed.
2900 GV->takeName(OldGV);
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002901
Anders Carlssonda80af32011-01-29 18:20:20 +00002902 if (!OldGV->use_empty()) {
2903 llvm::Constant *NewPtrForOldDecl =
2904 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
2905 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
2906 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00002907
Anders Carlssonda80af32011-01-29 18:20:20 +00002908 OldGV->eraseFromParent();
2909 }
Rafael Espindolacb92c192015-01-15 23:18:01 +00002910
NAKAMURA Takumic7da6da2015-05-09 21:10:07 +00002911 if (supportsCOMDAT() && GV->isWeakForLinker() &&
2912 !GV->hasAvailableExternallyLinkage())
2913 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
Rafael Espindolacb92c192015-01-15 23:18:01 +00002914
Anders Carlssonda80af32011-01-29 18:20:20 +00002915 return GV;
2916}
2917
Chris Lattnerd4808922009-03-22 21:03:39 +00002918/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
2919/// given global variable. If Ty is non-null and if the global doesn't exist,
Eric Christopher365e3092012-04-16 23:55:04 +00002920/// then it will be created with the specified type instead of whatever the
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002921/// normal requested type would be. If IsForDefinition is true, it is guranteed
2922/// that an actual global with type Ty will be returned, not conversion of a
2923/// variable with the same mangled name but some other type.
Chris Lattnerd4808922009-03-22 21:03:39 +00002924llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002925 llvm::Type *Ty,
John McCalld195d4c2016-11-30 23:25:13 +00002926 ForDefinition_t IsForDefinition) {
Chris Lattnerd4808922009-03-22 21:03:39 +00002927 assert(D->hasGlobalStorage() && "Not a global variable");
2928 QualType ASTTy = D->getType();
Craig Topper8a13c412014-05-21 05:09:00 +00002929 if (!Ty)
Chris Lattnerd4808922009-03-22 21:03:39 +00002930 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump11289f42009-09-09 15:08:12 +00002931
Chris Lattner2192fe52011-07-18 04:24:23 +00002932 llvm::PointerType *PTy =
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00002933 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCall7ec50432010-03-19 23:29:14 +00002934
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002935 StringRef MangledName = getMangledName(D);
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002936 return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition);
Chris Lattnerd4808922009-03-22 21:03:39 +00002937}
2938
2939/// CreateRuntimeVariable - Create a new runtime global variable with the
2940/// specified type and name.
2941llvm::Constant *
Chris Lattner2192fe52011-07-18 04:24:23 +00002942CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002943 StringRef Name) {
Rafael Espindolab73c9732014-05-22 23:33:27 +00002944 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
Chris Lattnerd4808922009-03-22 21:03:39 +00002945}
2946
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00002947void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
2948 assert(!D->getInit() && "Cannot emit definite definitions here!");
2949
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00002950 StringRef MangledName = getMangledName(D);
2951 llvm::GlobalValue *GV = GetGlobalValue(MangledName);
2952
2953 // We already have a definition, not declaration, with the same mangled name.
2954 // Emitting of declaration is not required (and actually overwrites emitted
2955 // definition).
2956 if (GV && !GV->isDeclaration())
2957 return;
2958
2959 // If we have not seen a reference to this variable yet, place it into the
2960 // deferred declarations table to be emitted if needed later.
2961 if (!MustBeEmitted(D) && !GV) {
Anders Carlssonecf9bf02009-09-10 23:43:36 +00002962 DeferredDecls[MangledName] = D;
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00002963 return;
Douglas Gregorfa9ab532009-04-21 19:28:58 +00002964 }
2965
2966 // The tentative definition is the only definition.
Reid Kleckner953fe032015-12-05 01:52:14 +00002967 EmitGlobalVarDefinition(D);
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00002968}
2969
Chris Lattner2192fe52011-07-18 04:24:23 +00002970CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Mehdi Aminica3cf9e2015-07-24 16:04:29 +00002971 return Context.toCharUnitsFromBits(
2972 getDataLayout().getTypeStoreSizeInBits(Ty));
Ken Dyck98ca7942010-01-26 13:48:07 +00002973}
2974
Alexander Richardson6d989432017-10-15 18:48:14 +00002975LangAS CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D) {
2976 LangAS AddrSpace = LangAS::Default;
Yaxun Liucbf647c2017-07-08 13:24:52 +00002977 if (LangOpts.OpenCL) {
Alexander Richardson6d989432017-10-15 18:48:14 +00002978 AddrSpace = D ? D->getType().getAddressSpace() : LangAS::opencl_global;
Yaxun Liucbf647c2017-07-08 13:24:52 +00002979 assert(AddrSpace == LangAS::opencl_global ||
2980 AddrSpace == LangAS::opencl_constant ||
2981 AddrSpace == LangAS::opencl_local ||
2982 AddrSpace >= LangAS::FirstTargetAddressSpace);
2983 return AddrSpace;
Peter Collingbournef44bdf92012-05-20 21:08:35 +00002984 }
2985
Yaxun Liucbf647c2017-07-08 13:24:52 +00002986 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
2987 if (D && D->hasAttr<CUDAConstantAttr>())
2988 return LangAS::cuda_constant;
2989 else if (D && D->hasAttr<CUDASharedAttr>())
2990 return LangAS::cuda_shared;
2991 else
2992 return LangAS::cuda_device;
2993 }
2994
2995 return getTargetCodeGenInfo().getGlobalVarAddressSpace(*this, D);
Peter Collingbournef44bdf92012-05-20 21:08:35 +00002996}
2997
Richard Smithdf931ce2013-04-06 05:00:46 +00002998template<typename SomeDecl>
2999void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D,
3000 llvm::GlobalValue *GV) {
3001 if (!getLangOpts().CPlusPlus)
3002 return;
3003
3004 // Must have 'used' attribute, or else inline assembly can't rely on
3005 // the name existing.
3006 if (!D->template hasAttr<UsedAttr>())
3007 return;
3008
3009 // Must have internal linkage and an ordinary name.
Rafael Espindola3ae00052013-05-13 00:12:11 +00003010 if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
Richard Smithdf931ce2013-04-06 05:00:46 +00003011 return;
3012
3013 // Must be in an extern "C" context. Entities declared directly within
3014 // a record are not extern "C" even if the record is in such a context.
Rafael Espindola8db352d2013-10-17 15:37:26 +00003015 const SomeDecl *First = D->getFirstDecl();
Rafael Espindola593537a2013-05-05 20:15:21 +00003016 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
Richard Smithdf931ce2013-04-06 05:00:46 +00003017 return;
3018
3019 // OK, this is an internal linkage entity inside an extern "C" linkage
3020 // specification. Make a note of that so we can give it the "expected"
3021 // mangled name if nothing else is using that name.
Richard Smith85465e62013-04-06 07:07:44 +00003022 std::pair<StaticExternCMap::iterator, bool> R =
3023 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
Richard Smithdf931ce2013-04-06 05:00:46 +00003024
3025 // If we have multiple internal linkage entities with the same name
3026 // in extern "C" regions, none of them gets that name.
Richard Smith85465e62013-04-06 07:07:44 +00003027 if (!R.second)
Craig Topper8a13c412014-05-21 05:09:00 +00003028 R.first->second = nullptr;
Richard Smithdf931ce2013-04-06 05:00:46 +00003029}
3030
Rafael Espindola0d4fb982015-01-12 22:13:53 +00003031static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
3032 if (!CGM.supportsCOMDAT())
3033 return false;
3034
3035 if (D.hasAttr<SelectAnyAttr>())
3036 return true;
3037
3038 GVALinkage Linkage;
3039 if (auto *VD = dyn_cast<VarDecl>(&D))
3040 Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
3041 else
3042 Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
3043
3044 switch (Linkage) {
3045 case GVA_Internal:
3046 case GVA_AvailableExternally:
3047 case GVA_StrongExternal:
3048 return false;
3049 case GVA_DiscardableODR:
3050 case GVA_StrongODR:
3051 return true;
3052 }
3053 llvm_unreachable("No such linkage");
3054}
3055
Rafael Espindoladbee8a72015-01-15 21:36:08 +00003056void CodeGenModule::maybeSetTrivialComdat(const Decl &D,
3057 llvm::GlobalObject &GO) {
3058 if (!shouldBeInCOMDAT(*this, D))
3059 return;
3060 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
3061}
3062
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00003063/// Pass IsTentative as true if you want to create a tentative definition.
3064void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
3065 bool IsTentative) {
Yaxun Liu0bc4b2d2016-07-28 19:26:30 +00003066 // OpenCL global variables of sampler type are translated to function calls,
3067 // therefore no need to be translated.
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003068 QualType ASTTy = D->getType();
Yaxun Liu0bc4b2d2016-07-28 19:26:30 +00003069 if (getLangOpts().OpenCL && ASTTy->isSamplerT())
3070 return;
3071
3072 llvm::Constant *Init = nullptr;
Richard Smith6331c402012-02-13 22:16:19 +00003073 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3074 bool NeedsGlobalCtor = false;
3075 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
Mike Stump11289f42009-09-09 15:08:12 +00003076
Richard Smithdafff942012-01-14 04:30:29 +00003077 const VarDecl *InitDecl;
3078 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
Sebastian Redl4a7eab22012-02-25 20:51:20 +00003079
John McCallde0fe072017-08-15 21:42:52 +00003080 Optional<ConstantEmitter> emitter;
3081
Artem Belevich97c01c32016-02-02 22:29:48 +00003082 // CUDA E.2.4.1 "__shared__ variables cannot have an initialization
3083 // as part of their declaration." Sema has already checked for
3084 // error cases, so we just need to set Init to UndefValue.
3085 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
3086 D->hasAttr<CUDASharedAttr>())
Jingyue Wu284ebe22015-08-22 05:49:28 +00003087 Init = llvm::UndefValue::get(getTypes().ConvertType(ASTTy));
Artem Belevich97c01c32016-02-02 22:29:48 +00003088 else if (!InitExpr) {
Eli Friedman6859a1b2008-05-30 20:39:54 +00003089 // This is a tentative definition; tentative definitions are
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00003090 // implicitly initialized with { 0 }.
3091 //
3092 // Note that tentative definitions are only emitted at the end of
3093 // a translation unit, so they should never have incomplete
3094 // type. In addition, EmitTentativeDefinition makes sure that we
3095 // never attempt to emit a tentative definition if a real one
3096 // exists. A use may still exists, however, so we still may need
3097 // to do a RAUW.
3098 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonf18318c2009-08-02 21:18:22 +00003099 Init = EmitNullConstant(D->getType());
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003100 } else {
Richard Smithcc1b96d2013-06-12 22:31:48 +00003101 initializedGlobalDecl = GlobalDecl(D);
John McCallde0fe072017-08-15 21:42:52 +00003102 emitter.emplace(*this);
3103 Init = emitter->tryEmitForInitializer(*InitDecl);
Sebastian Redl4a7eab22012-02-25 20:51:20 +00003104
Fariborz Jahanian63628032012-06-26 16:06:38 +00003105 if (!Init) {
Anders Carlssonca4a5452010-01-26 17:43:42 +00003106 QualType T = InitExpr->getType();
Douglas Gregord450f062010-05-05 20:15:55 +00003107 if (D->getType()->isReferenceType())
3108 T = D->getType();
Richard Smithdafff942012-01-14 04:30:29 +00003109
David Blaikiebbafb8a2012-03-11 07:00:24 +00003110 if (getLangOpts().CPlusPlus) {
Anders Carlssonb8be93f2009-08-08 23:24:23 +00003111 Init = EmitNullConstant(T);
Richard Smith6331c402012-02-13 22:16:19 +00003112 NeedsGlobalCtor = true;
Anders Carlssonb8be93f2009-08-08 23:24:23 +00003113 } else {
3114 ErrorUnsupported(D, "static initializer");
3115 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
3116 }
John McCall70013b62010-07-15 23:40:35 +00003117 } else {
3118 // We don't need an initializer, so remove the entry for the delayed
Richard Smith6331c402012-02-13 22:16:19 +00003119 // initializer position (just in case this entry was delayed) if we
3120 // also don't need to register a destructor.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003121 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
John McCall70013b62010-07-15 23:40:35 +00003122 DelayedCXXInitPosition.erase(D);
Eli Friedman719ed1a2009-02-20 01:18:21 +00003123 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003124 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003125
Chris Lattner2192fe52011-07-18 04:24:23 +00003126 llvm::Type* InitType = Init->getType();
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00003127 llvm::Constant *Entry =
John McCalld195d4c2016-11-30 23:25:13 +00003128 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative));
Mike Stump11289f42009-09-09 15:08:12 +00003129
Chris Lattner149927c2009-03-21 09:16:30 +00003130 // Strip off a bitcast if we got one back.
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003131 if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattneraa64ca22009-07-16 16:48:25 +00003132 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
Matt Arsenault00e65b22013-11-15 02:19:52 +00003133 CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
3134 // All zero index gep.
Chris Lattneraa64ca22009-07-16 16:48:25 +00003135 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner149927c2009-03-21 09:16:30 +00003136 Entry = CE->getOperand(0);
3137 }
Mike Stump11289f42009-09-09 15:08:12 +00003138
Chris Lattner149927c2009-03-21 09:16:30 +00003139 // Entry is now either a Function or GlobalVariable.
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003140 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00003141
Chris Lattner149927c2009-03-21 09:16:30 +00003142 // We have a definition after a declaration with the wrong type.
3143 // We must make a new GlobalVariable* and update everything that used OldGV
3144 // (a declaration or tentative definition) with the new GlobalVariable*
3145 // (which will be a definition).
3146 //
3147 // This happens if there is a prototype for a global (e.g.
3148 // "extern int x[];") and then a definition of a different type (e.g.
3149 // "int x[10];"). This also happens when an initializer has a different type
3150 // from the type of the global (this happens with unions).
Yaxun Liucbf647c2017-07-08 13:24:52 +00003151 if (!GV || GV->getType()->getElementType() != InitType ||
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00003152 GV->getType()->getAddressSpace() !=
Yaxun Liucbf647c2017-07-08 13:24:52 +00003153 getContext().getTargetAddressSpace(GetGlobalVarAddressSpace(D))) {
Mike Stump11289f42009-09-09 15:08:12 +00003154
John McCall7ec50432010-03-19 23:29:14 +00003155 // Move the old entry aside so that we'll create a new one.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003156 Entry->setName(StringRef());
Daniel Dunbarb2f4cdb2009-02-19 05:36:41 +00003157
Chris Lattner149927c2009-03-21 09:16:30 +00003158 // Make a new global with the correct type, this is now guaranteed to work.
Andrey Bokhanko7aa88ce2016-01-14 10:41:16 +00003159 GV = cast<llvm::GlobalVariable>(
John McCalld195d4c2016-11-30 23:25:13 +00003160 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative)));
Chris Lattnera85d68e2009-03-21 09:25:43 +00003161
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003162 // Replace all uses of the old global with the new global
Mike Stump11289f42009-09-09 15:08:12 +00003163 llvm::Constant *NewPtrForOldDecl =
Owen Andersonade90fd2009-07-29 18:54:39 +00003164 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner149927c2009-03-21 09:16:30 +00003165 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedmanc18d9d52008-05-30 19:50:47 +00003166
3167 // Erase the old global, since it is no longer used.
Chris Lattner149927c2009-03-21 09:16:30 +00003168 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner9d3b0e02007-07-14 00:23:28 +00003169 }
Devang Patel19c2b9a2007-10-26 16:31:40 +00003170
Richard Smithdf931ce2013-04-06 05:00:46 +00003171 MaybeHandleStaticInExternC(D, GV);
3172
Julien Lerouge5a6b6982011-09-09 22:41:49 +00003173 if (D->hasAttr<AnnotateAttr>())
3174 AddGlobalAnnotations(D, GV);
Nate Begemanfaae0812008-04-19 04:17:09 +00003175
Artem Belevich42e19492016-03-02 18:28:50 +00003176 // Set the llvm linkage type as appropriate.
3177 llvm::GlobalValue::LinkageTypes Linkage =
3178 getLLVMLinkageVarDefinition(D, GV->isConstant());
3179
Jingyue Wu284ebe22015-08-22 05:49:28 +00003180 // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
3181 // the device. [...]"
3182 // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
3183 // __device__, declares a variable that: [...]
3184 // Is accessible from all the threads within the grid and from the host
3185 // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize()
3186 // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())."
Artem Belevich42e19492016-03-02 18:28:50 +00003187 if (GV && LangOpts.CUDA) {
3188 if (LangOpts.CUDAIsDevice) {
3189 if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>())
3190 GV->setExternallyInitialized(true);
3191 } else {
3192 // Host-side shadows of external declarations of device-side
3193 // global variables become internal definitions. These have to
3194 // be internal in order to prevent name conflicts with global
3195 // host variables with the same name in a different TUs.
3196 if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) {
3197 Linkage = llvm::GlobalValue::InternalLinkage;
3198
3199 // Shadow variables and their properties must be registered
3200 // with CUDA runtime.
3201 unsigned Flags = 0;
3202 if (!D->hasDefinition())
3203 Flags |= CGCUDARuntime::ExternDeviceVar;
3204 if (D->hasAttr<CUDAConstantAttr>())
3205 Flags |= CGCUDARuntime::ConstantDeviceVar;
3206 getCUDARuntime().registerDeviceVar(*GV, Flags);
3207 } else if (D->hasAttr<CUDASharedAttr>())
3208 // __shared__ variables are odd. Shadows do get created, but
3209 // they are not registered with the CUDA runtime, so they
3210 // can't really be used to access their device-side
3211 // counterparts. It's not clear yet whether it's nvcc's bug or
3212 // a feature, but we've got to do the same for compatibility.
3213 Linkage = llvm::GlobalValue::InternalLinkage;
3214 }
Jingyue Wu284ebe22015-08-22 05:49:28 +00003215 }
John McCallde0fe072017-08-15 21:42:52 +00003216
Chris Lattnerd14bfa92007-07-13 05:13:43 +00003217 GV->setInitializer(Init);
John McCallde0fe072017-08-15 21:42:52 +00003218 if (emitter) emitter->finalize(GV);
Chris Lattnerf49573d2009-08-05 05:20:29 +00003219
3220 // If it is safe to mark the global 'constant', do so now.
Richard Smithe070fd22012-02-17 06:48:11 +00003221 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
3222 isTypeConstant(D->getType(), true));
Mike Stump11289f42009-09-09 15:08:12 +00003223
Hans Wennborg899ded92014-10-16 20:52:46 +00003224 // If it is in a read-only section, mark it 'constant'.
3225 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
3226 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
3227 if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
3228 GV->setConstant(true);
3229 }
3230
Ken Dyck160146e2010-01-27 17:10:57 +00003231 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Richard Smithe070fd22012-02-17 06:48:11 +00003232
David Majnemer35ab3282014-06-11 04:08:55 +00003233
Manman Ren68150262015-11-11 22:42:31 +00003234 // On Darwin, if the normal linkage of a C++ thread_local variable is
3235 // LinkOnce or Weak, we keep the normal linkage to prevent multiple
3236 // copies within a linkage unit; otherwise, the backing variable has
3237 // internal linkage and all accesses should just be calls to the
David Majnemer35ab3282014-06-11 04:08:55 +00003238 // Itanium-specified entry point, which has the normal linkage of the
Manman Ren68150262015-11-11 22:42:31 +00003239 // variable. This is to preserve the ability to change the implementation
3240 // behind the scenes.
David Majnemerbb525f7c2014-10-15 22:38:23 +00003241 if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
Manman Renf93fff22015-11-11 23:08:18 +00003242 Context.getTargetInfo().getTriple().isOSDarwin() &&
Manman Ren68150262015-11-11 22:42:31 +00003243 !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
3244 !llvm::GlobalVariable::isWeakLinkage(Linkage))
David Majnemerbb525f7c2014-10-15 22:38:23 +00003245 Linkage = llvm::GlobalValue::InternalLinkage;
David Majnemer35ab3282014-06-11 04:08:55 +00003246
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00003247 GV->setLinkage(Linkage);
Nico Rieckbb0554f2014-01-14 15:23:53 +00003248 if (D->hasAttr<DLLImportAttr>())
3249 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
3250 else if (D->hasAttr<DLLExportAttr>())
3251 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
Hans Wennborg606bd6d2014-11-03 14:24:45 +00003252 else
3253 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
Hans Wennborgfeedf852013-11-21 00:15:56 +00003254
Yaxun Liu402804b2016-12-15 08:09:08 +00003255 if (Linkage == llvm::GlobalVariable::CommonLinkage) {
Chris Lattnerf49573d2009-08-05 05:20:29 +00003256 // common vars aren't constant even if declared const.
3257 GV->setConstant(false);
Yaxun Liu402804b2016-12-15 08:09:08 +00003258 // Tentative definition of global variables may be initialized with
3259 // non-zero null pointers. In this case they should have weak linkage
3260 // since common linkage must have zero initializer and must not have
3261 // explicit section therefore cannot have non-zero initial value.
3262 if (!GV->getInitializer()->isNullValue())
3263 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
3264 }
Daniel Dunbard272cca2009-04-10 20:26:50 +00003265
Rafael Espindola502f65a2014-05-05 20:21:03 +00003266 setNonAliasAttributes(D, GV);
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00003267
David Majnemerbb525f7c2014-10-15 22:38:23 +00003268 if (D->getTLSKind() && !GV->isThreadLocal()) {
3269 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
Richard Smith5a99c492015-12-01 01:10:48 +00003270 CXXThreadLocals.push_back(D);
David Majnemerbb525f7c2014-10-15 22:38:23 +00003271 setTLSMode(GV, *D);
3272 }
3273
Rafael Espindoladbee8a72015-01-15 21:36:08 +00003274 maybeSetTrivialComdat(*D, *GV);
Rafael Espindola0d4fb982015-01-12 22:13:53 +00003275
John McCallcdf7ef52010-11-06 09:44:32 +00003276 // Emit the initializer function if necessary.
Richard Smith6331c402012-02-13 22:16:19 +00003277 if (NeedsGlobalCtor || NeedsGlobalDtor)
3278 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
John McCallcdf7ef52010-11-06 09:44:32 +00003279
Alexey Samsonov4b8de112014-08-01 21:35:28 +00003280 SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
Kostya Serebryany28a26c82012-08-21 06:53:28 +00003281
Sanjiv Gupta158143a2008-06-05 08:59:10 +00003282 // Emit global variable debug information.
Eric Christopher7cdf9482011-10-13 21:45:18 +00003283 if (CGDebugInfo *DI = getModuleDebugInfo())
Benjamin Kramer8c305922016-02-02 11:06:51 +00003284 if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
Alexey Samsonov74a38682012-05-04 07:39:27 +00003285 DI->EmitGlobalVariable(GV, D);
Chris Lattnerd14bfa92007-07-13 05:13:43 +00003286}
Chris Lattner09153c02007-06-22 18:48:09 +00003287
David Majnemerc017d362014-08-05 00:01:13 +00003288static bool isVarDeclStrongDefinition(const ASTContext &Context,
Nico Weber608e7682015-04-15 23:04:24 +00003289 CodeGenModule &CGM, const VarDecl *D,
3290 bool NoCommon) {
David Majnemer9832a3d2014-04-10 16:53:16 +00003291 // Don't give variables common linkage if -fno-common was specified unless it
3292 // was overridden by a NoCommon attribute.
3293 if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
3294 return true;
3295
3296 // C11 6.9.2/2:
3297 // A declaration of an identifier for an object that has file scope without
3298 // an initializer, and without a storage-class specifier or with the
3299 // storage-class specifier static, constitutes a tentative definition.
3300 if (D->getInit() || D->hasExternalStorage())
3301 return true;
3302
3303 // A variable cannot be both common and exist in a section.
3304 if (D->hasAttr<SectionAttr>())
3305 return true;
3306
Javed Absar2a67c9e2017-06-05 10:11:57 +00003307 // A variable cannot be both common and exist in a section.
3308 // We dont try to determine which is the right section in the front-end.
3309 // If no specialized section name is applicable, it will resort to default.
3310 if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
3311 D->hasAttr<PragmaClangDataSectionAttr>() ||
3312 D->hasAttr<PragmaClangRodataSectionAttr>())
3313 return true;
3314
David Majnemer9832a3d2014-04-10 16:53:16 +00003315 // Thread local vars aren't considered common linkage.
3316 if (D->getTLSKind())
3317 return true;
3318
3319 // Tentative definitions marked with WeakImportAttr are true definitions.
3320 if (D->hasAttr<WeakImportAttr>())
3321 return true;
3322
Nico Weber608e7682015-04-15 23:04:24 +00003323 // A variable cannot be both common and exist in a comdat.
3324 if (shouldBeInCOMDAT(CGM, *D))
3325 return true;
3326
Sanjay Patel2f9303a2016-06-30 21:02:40 +00003327 // Declarations with a required alignment do not have common linkage in MSVC
David Majnemerc017d362014-08-05 00:01:13 +00003328 // mode.
David Majnemer3f021502015-10-08 04:53:31 +00003329 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
David Majnemere1a0b2e2015-02-03 08:49:32 +00003330 if (D->hasAttr<AlignedAttr>())
3331 return true;
3332 QualType VarType = D->getType();
3333 if (Context.isAlignmentRequired(VarType))
3334 return true;
3335
3336 if (const auto *RT = VarType->getAs<RecordType>()) {
3337 const RecordDecl *RD = RT->getDecl();
3338 for (const FieldDecl *FD : RD->fields()) {
3339 if (FD->isBitField())
3340 continue;
3341 if (FD->hasAttr<AlignedAttr>())
3342 return true;
3343 if (Context.isAlignmentRequired(FD->getType()))
3344 return true;
3345 }
3346 }
3347 }
David Majnemerc017d362014-08-05 00:01:13 +00003348
David Majnemer9832a3d2014-04-10 16:53:16 +00003349 return false;
3350}
3351
Hans Wennborg1a3a0742014-05-14 19:54:53 +00003352llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
Hans Wennborg275efb92014-05-28 01:52:23 +00003353 const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00003354 if (Linkage == GVA_Internal)
3355 return llvm::Function::InternalLinkage;
David Majnemer27d69db2014-04-28 22:17:59 +00003356
3357 if (D->hasAttr<WeakAttr>()) {
3358 if (IsConstantVariable)
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00003359 return llvm::GlobalVariable::WeakODRLinkage;
3360 else
3361 return llvm::GlobalVariable::WeakAnyLinkage;
David Majnemer27d69db2014-04-28 22:17:59 +00003362 }
3363
3364 // We are guaranteed to have a strong definition somewhere else,
3365 // so we can use available_externally linkage.
3366 if (Linkage == GVA_AvailableExternally)
David Blaikie9ffe5a32017-01-30 05:00:26 +00003367 return llvm::GlobalValue::AvailableExternallyLinkage;
David Majnemer27d69db2014-04-28 22:17:59 +00003368
David Majnemer27d69db2014-04-28 22:17:59 +00003369 // Note that Apple's kernel linker doesn't support symbol
3370 // coalescing, so we need to avoid linkonce and weak linkages there.
3371 // Normally, this means we just map to internal, but for explicit
3372 // instantiations we'll map to external.
3373
3374 // In C++, the compiler has to emit a definition in every translation unit
3375 // that references the function. We should use linkonce_odr because
3376 // a) if all references in this translation unit are optimized away, we
3377 // don't need to codegen it. b) if the function persists, it needs to be
3378 // merged with other definitions. c) C++ has the ODR, so we know the
3379 // definition is dependable.
3380 if (Linkage == GVA_DiscardableODR)
Hans Wennborgb0f2f142014-05-15 22:07:49 +00003381 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
David Majnemer27d69db2014-04-28 22:17:59 +00003382 : llvm::Function::InternalLinkage;
3383
3384 // An explicit instantiation of a template has weak linkage, since
3385 // explicit instantiations can occur in multiple translation units
3386 // and must all be equivalent. However, we are not allowed to
3387 // throw away these explicit instantiations.
Justin Lebar27ee1302016-06-30 18:41:33 +00003388 //
3389 // We don't currently support CUDA device code spread out across multiple TUs,
3390 // so say that CUDA templates are either external (for kernels) or internal.
3391 // This lets llvm perform aggressive inter-procedural optimizations.
3392 if (Linkage == GVA_StrongODR) {
3393 if (Context.getLangOpts().AppleKext)
3394 return llvm::Function::ExternalLinkage;
3395 if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice)
3396 return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
3397 : llvm::Function::InternalLinkage;
3398 return llvm::Function::WeakODRLinkage;
3399 }
David Majnemer27d69db2014-04-28 22:17:59 +00003400
David Majnemer27d69db2014-04-28 22:17:59 +00003401 // C++ doesn't have tentative definitions and thus cannot have common
3402 // linkage.
3403 if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
Nico Weber608e7682015-04-15 23:04:24 +00003404 !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
David Majnemerc017d362014-08-05 00:01:13 +00003405 CodeGenOpts.NoCommon))
David Majnemer9832a3d2014-04-10 16:53:16 +00003406 return llvm::GlobalVariable::CommonLinkage;
3407
David Majnemer27d69db2014-04-28 22:17:59 +00003408 // selectany symbols are externally visible, so use weak instead of
3409 // linkonce. MSVC optimizes away references to const selectany globals, so
3410 // all definitions should be the same and ODR linkage should be used.
3411 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
3412 if (D->hasAttr<SelectAnyAttr>())
3413 return llvm::GlobalVariable::WeakODRLinkage;
3414
3415 // Otherwise, we have strong external linkage.
3416 assert(Linkage == GVA_StrongExternal);
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00003417 return llvm::GlobalVariable::ExternalLinkage;
3418}
3419
David Majnemer27d69db2014-04-28 22:17:59 +00003420llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
3421 const VarDecl *VD, bool IsConstant) {
3422 GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD);
Hans Wennborg275efb92014-05-28 01:52:23 +00003423 return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
David Majnemer27d69db2014-04-28 22:17:59 +00003424}
3425
John McCall49954ca2012-12-12 22:21:47 +00003426/// Replace the uses of a function that was declared with a non-proto type.
3427/// We want to silently drop extra arguments from call sites
3428static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
3429 llvm::Function *newFn) {
3430 // Fast path.
3431 if (old->use_empty()) return;
3432
3433 llvm::Type *newRetTy = newFn->getReturnType();
3434 SmallVector<llvm::Value*, 4> newArgs;
David Majnemer0b17d442015-12-15 21:27:59 +00003435 SmallVector<llvm::OperandBundleDef, 1> newBundles;
John McCall49954ca2012-12-12 22:21:47 +00003436
3437 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
3438 ui != ue; ) {
3439 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
Chandler Carruth4d01fff2014-03-09 03:16:50 +00003440 llvm::User *user = use->getUser();
John McCall49954ca2012-12-12 22:21:47 +00003441
3442 // Recognize and replace uses of bitcasts. Most calls to
3443 // unprototyped functions will use bitcasts.
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003444 if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
John McCall49954ca2012-12-12 22:21:47 +00003445 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
3446 replaceUsesOfNonProtoConstant(bitcast, newFn);
3447 continue;
3448 }
3449
3450 // Recognize calls to the function.
3451 llvm::CallSite callSite(user);
3452 if (!callSite) continue;
Chandler Carruth4d01fff2014-03-09 03:16:50 +00003453 if (!callSite.isCallee(&*use)) continue;
John McCall49954ca2012-12-12 22:21:47 +00003454
3455 // If the return types don't match exactly, then we can't
3456 // transform this call unless it's dead.
3457 if (callSite->getType() != newRetTy && !callSite->use_empty())
3458 continue;
3459
3460 // Get the call site's attribute list.
Reid Kleckner7f720332017-04-13 00:58:09 +00003461 SmallVector<llvm::AttributeSet, 8> newArgAttrs;
Reid Klecknerde864822017-03-21 16:57:30 +00003462 llvm::AttributeList oldAttrs = callSite.getAttributes();
John McCall49954ca2012-12-12 22:21:47 +00003463
John McCall49954ca2012-12-12 22:21:47 +00003464 // If the function was passed too few arguments, don't transform.
3465 unsigned newNumArgs = newFn->arg_size();
3466 if (callSite.arg_size() < newNumArgs) continue;
3467
3468 // If extra arguments were passed, we silently drop them.
3469 // If any of the types mismatch, we don't transform.
3470 unsigned argNo = 0;
3471 bool dontTransform = false;
Reid Kleckner7f720332017-04-13 00:58:09 +00003472 for (llvm::Argument &A : newFn->args()) {
3473 if (callSite.getArgument(argNo)->getType() != A.getType()) {
John McCall49954ca2012-12-12 22:21:47 +00003474 dontTransform = true;
3475 break;
3476 }
3477
3478 // Add any parameter attributes.
Reid Klecknerf021fab2017-04-13 23:12:13 +00003479 newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo));
Reid Kleckner7f720332017-04-13 00:58:09 +00003480 argNo++;
John McCall49954ca2012-12-12 22:21:47 +00003481 }
3482 if (dontTransform)
3483 continue;
3484
John McCall49954ca2012-12-12 22:21:47 +00003485 // Okay, we can transform this. Create the new call instruction and copy
3486 // over the required information.
3487 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
3488
David Majnemer0b17d442015-12-15 21:27:59 +00003489 // Copy over any operand bundles.
3490 callSite.getOperandBundlesAsDefs(newBundles);
3491
John McCall49954ca2012-12-12 22:21:47 +00003492 llvm::CallSite newCall;
3493 if (callSite.isCall()) {
David Majnemer0b17d442015-12-15 21:27:59 +00003494 newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "",
John McCall49954ca2012-12-12 22:21:47 +00003495 callSite.getInstruction());
3496 } else {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003497 auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction());
John McCall49954ca2012-12-12 22:21:47 +00003498 newCall = llvm::InvokeInst::Create(newFn,
3499 oldInvoke->getNormalDest(),
3500 oldInvoke->getUnwindDest(),
David Majnemer0b17d442015-12-15 21:27:59 +00003501 newArgs, newBundles, "",
John McCall49954ca2012-12-12 22:21:47 +00003502 callSite.getInstruction());
3503 }
3504 newArgs.clear(); // for the next iteration
3505
3506 if (!newCall->getType()->isVoidTy())
3507 newCall->takeName(callSite.getInstruction());
Reid Kleckner7f720332017-04-13 00:58:09 +00003508 newCall.setAttributes(llvm::AttributeList::get(
3509 newFn->getContext(), oldAttrs.getFnAttributes(),
3510 oldAttrs.getRetAttributes(), newArgAttrs));
John McCall49954ca2012-12-12 22:21:47 +00003511 newCall.setCallingConv(callSite.getCallingConv());
3512
3513 // Finally, remove the old call, replacing any uses with the new one.
3514 if (!callSite->use_empty())
3515 callSite->replaceAllUsesWith(newCall.getInstruction());
3516
3517 // Copy debug location attached to CI.
Duncan P. N. Exon Smith2809cc72015-03-30 20:01:41 +00003518 if (callSite->getDebugLoc())
John McCall49954ca2012-12-12 22:21:47 +00003519 newCall->setDebugLoc(callSite->getDebugLoc());
David Majnemer0b17d442015-12-15 21:27:59 +00003520
John McCall49954ca2012-12-12 22:21:47 +00003521 callSite->eraseFromParent();
3522 }
3523}
3524
Chris Lattner36797ab2009-05-05 06:16:31 +00003525/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
3526/// implement a function with no prototype, e.g. "int foo() {}". If there are
3527/// existing call uses of the old function in the module, this adjusts them to
3528/// call the new function directly.
3529///
3530/// This is not just a cleanup: the always_inline pass requires direct calls to
3531/// functions to be able to inline them. If there is a bitcast in the way, it
3532/// won't inline them. Instcombine normally deletes these calls, but it isn't
3533/// run at -O0.
3534static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
3535 llvm::Function *NewFn) {
3536 // If we're redefining a global as a function, don't transform it.
John McCall49954ca2012-12-12 22:21:47 +00003537 if (!isa<llvm::Function>(Old)) return;
Mike Stump11289f42009-09-09 15:08:12 +00003538
John McCall49954ca2012-12-12 22:21:47 +00003539 replaceUsesOfNonProtoConstant(Old, NewFn);
Chris Lattner36797ab2009-05-05 06:16:31 +00003540}
3541
Rafael Espindoladf88f6f2012-03-08 15:51:03 +00003542void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
David Majnemer60e5bdc2016-07-11 04:28:21 +00003543 auto DK = VD->isThisDeclarationADefinition();
3544 if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>())
3545 return;
3546
Rafael Espindoladf88f6f2012-03-08 15:51:03 +00003547 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
3548 // If we have a definition, this might be a deferred decl. If the
3549 // instantiation is explicit, make sure we emit it at the end.
3550 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
3551 GetAddrOfGlobalVar(VD);
Argyrios Kyrtzidis8a27b2b2013-02-24 00:05:01 +00003552
3553 EmitTopLevelDecl(VD);
Rafael Espindola189fa742012-03-05 10:54:55 +00003554}
Daniel Dunbar9c426522008-07-29 23:18:29 +00003555
Rafael Espindolacd7743b2013-12-09 16:01:03 +00003556void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
3557 llvm::GlobalValue *GV) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003558 const auto *D = cast<FunctionDecl>(GD.getDecl());
John McCalla738c252011-03-09 04:27:21 +00003559
John McCall46288ef2011-03-09 08:12:35 +00003560 // Compute the function info and LLVM type.
John McCalla729c622012-02-17 03:33:10 +00003561 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
3562 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
John McCalla738c252011-03-09 04:27:21 +00003563
Chris Lattnereb7466d2009-05-12 20:58:15 +00003564 // Get or create the prototype for the function.
Andrey Bokhankocab58582015-08-31 13:20:44 +00003565 if (!GV || (GV->getType()->getElementType() != Ty))
3566 GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
3567 /*DontDefer=*/true,
John McCalld195d4c2016-11-30 23:25:13 +00003568 ForDefinition));
Mike Stump11289f42009-09-09 15:08:12 +00003569
Andrey Bokhankocab58582015-08-31 13:20:44 +00003570 // Already emitted.
3571 if (!GV->isDeclaration())
Renato Golinc640ff62015-04-15 08:44:40 +00003572 return;
Mike Stump11289f42009-09-09 15:08:12 +00003573
John McCall8e7cb6d2010-11-02 21:04:24 +00003574 // We need to set linkage and visibility on the function before
3575 // generating code for it because various parts of IR generation
3576 // want to propagate this information down (e.g. to local static
3577 // declarations).
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003578 auto *Fn = cast<llvm::Function>(GV);
Peter Collingbourne4d90dba2013-06-05 17:49:37 +00003579 setFunctionLinkage(GD, Fn);
Hans Wennborgbb4f9622015-05-28 17:44:56 +00003580 setFunctionDLLStorageClass(GD, Fn);
Daniel Dunbar9c426522008-07-29 23:18:29 +00003581
Rafael Espindolae033c8c2014-05-08 15:26:12 +00003582 // FIXME: this is redundant with part of setFunctionDefinitionAttributes
Rafael Espindola699f5d62018-02-07 22:15:33 +00003583 setGVProperties(Fn, D);
John McCall8e7cb6d2010-11-02 21:04:24 +00003584
Richard Smithdf931ce2013-04-06 05:00:46 +00003585 MaybeHandleStaticInExternC(D, Fn);
3586
Rafael Espindoladbee8a72015-01-15 21:36:08 +00003587 maybeSetTrivialComdat(*D, *Fn);
Rafael Espindola0d4fb982015-01-12 22:13:53 +00003588
John McCalla738c252011-03-09 04:27:21 +00003589 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +00003590
Rafael Espindolae4e78132018-03-01 00:00:02 +00003591 setNonAliasAttributes(GD, Fn);
Daniel Dunbar38932572009-04-14 08:05:55 +00003592 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump11289f42009-09-09 15:08:12 +00003593
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00003594 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00003595 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00003596 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00003597 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge5a6b6982011-09-09 22:41:49 +00003598 if (D->hasAttr<AnnotateAttr>())
3599 AddGlobalAnnotations(D, Fn);
Daniel Dunbar9c426522008-07-29 23:18:29 +00003600}
3601
John McCall7ec50432010-03-19 23:29:14 +00003602void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003603 const auto *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00003604 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattner54041692009-03-22 21:47:11 +00003605 assert(AA && "Not an alias?");
3606
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003607 StringRef MangledName = getMangledName(GD);
Mike Stump11289f42009-09-09 15:08:12 +00003608
Hal Finkel0e2b9752015-09-04 21:49:21 +00003609 if (AA->getAliasee() == MangledName) {
Dmitry Polukhin85eda122016-04-11 07:48:59 +00003610 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
Hal Finkel0e2b9752015-09-04 21:49:21 +00003611 return;
3612 }
3613
John McCall7ec50432010-03-19 23:29:14 +00003614 // If there is a definition in the module, then it wins over the alias.
3615 // This is dubious, but allow it to be safe. Just ignore the alias.
3616 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3617 if (Entry && !Entry->isDeclaration())
3618 return;
3619
Rafael Espindola208b5c02013-10-22 19:26:13 +00003620 Aliases.push_back(GD);
3621
Chris Lattner2192fe52011-07-18 04:24:23 +00003622 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattner54041692009-03-22 21:47:11 +00003623
3624 // Create a reference to the named value. This ensures that it is emitted
3625 // if a deferred decl.
3626 llvm::Constant *Aliasee;
3627 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergba036122012-10-05 23:12:53 +00003628 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
Anders Carlsson3c239482011-02-05 04:35:53 +00003629 /*ForVTable=*/false);
Chris Lattner54041692009-03-22 21:47:11 +00003630 else
John McCall7ec50432010-03-19 23:29:14 +00003631 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Craig Topper8a13c412014-05-21 05:09:00 +00003632 llvm::PointerType::getUnqual(DeclTy),
David Majnemerbb525f7c2014-10-15 22:38:23 +00003633 /*D=*/nullptr);
Chris Lattner54041692009-03-22 21:47:11 +00003634
3635 // Create the new alias itself, but don't set a name yet.
Rafael Espindola234405b2014-05-17 21:30:14 +00003636 auto *GA = llvm::GlobalAlias::create(
David Blaikie2a791d72015-09-14 18:38:22 +00003637 DeclTy, 0, llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
Mike Stump11289f42009-09-09 15:08:12 +00003638
Chris Lattner54041692009-03-22 21:47:11 +00003639 if (Entry) {
Rafael Espindolab2633b92014-05-16 19:35:48 +00003640 if (GA->getAliasee() == Entry) {
Dmitry Polukhin85eda122016-04-11 07:48:59 +00003641 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
Rafael Espindolab2633b92014-05-16 19:35:48 +00003642 return;
3643 }
3644
John McCall7ec50432010-03-19 23:29:14 +00003645 assert(Entry->isDeclaration());
3646
Chris Lattner54041692009-03-22 21:47:11 +00003647 // If there is a declaration in the module, then we had an extern followed
3648 // by the alias, as in:
3649 // extern int test6();
3650 // ...
3651 // int test6() __attribute__((alias("test7")));
3652 //
3653 // Remove it and replace uses of it with the alias.
John McCall7ec50432010-03-19 23:29:14 +00003654 GA->takeName(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00003655
Owen Andersonade90fd2009-07-29 18:54:39 +00003656 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattner54041692009-03-22 21:47:11 +00003657 Entry->getType()));
Chris Lattner54041692009-03-22 21:47:11 +00003658 Entry->eraseFromParent();
John McCall7ec50432010-03-19 23:29:14 +00003659 } else {
Anders Carlssonea836bc2010-06-22 16:16:50 +00003660 GA->setName(MangledName);
Chris Lattner54041692009-03-22 21:47:11 +00003661 }
Mike Stump11289f42009-09-09 15:08:12 +00003662
Daniel Dunbar38932572009-04-14 08:05:55 +00003663 // Set attributes which are particular to an alias; this is a
3664 // specialization of the attributes which may be set on a global
3665 // variable/function.
Rafael Espindolafcfbcc62014-10-08 00:00:09 +00003666 if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
3667 D->isWeakImported()) {
Daniel Dunbar38932572009-04-14 08:05:55 +00003668 GA->setLinkage(llvm::Function::WeakAnyLinkage);
3669 }
3670
David Majnemerbb525f7c2014-10-15 22:38:23 +00003671 if (const auto *VD = dyn_cast<VarDecl>(D))
3672 if (VD->getTLSKind())
3673 setTLSMode(GA, *VD);
3674
Rafael Espindolafa2fc902018-02-28 00:06:01 +00003675 setAliasAttributes(GD, GA);
Chris Lattner54041692009-03-22 21:47:11 +00003676}
3677
Dmitry Polukhin85eda122016-04-11 07:48:59 +00003678void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
3679 const auto *D = cast<ValueDecl>(GD.getDecl());
3680 const IFuncAttr *IFA = D->getAttr<IFuncAttr>();
3681 assert(IFA && "Not an ifunc?");
3682
3683 StringRef MangledName = getMangledName(GD);
3684
3685 if (IFA->getResolver() == MangledName) {
3686 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
3687 return;
3688 }
3689
3690 // Report an error if some definition overrides ifunc.
3691 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3692 if (Entry && !Entry->isDeclaration()) {
3693 GlobalDecl OtherGD;
3694 if (lookupRepresentativeDecl(MangledName, OtherGD) &&
3695 DiagnosedConflictingDefinitions.insert(GD).second) {
3696 Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name);
3697 Diags.Report(OtherGD.getDecl()->getLocation(),
3698 diag::note_previous_definition);
3699 }
3700 return;
3701 }
3702
3703 Aliases.push_back(GD);
3704
3705 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
3706 llvm::Constant *Resolver =
3707 GetOrCreateLLVMFunction(IFA->getResolver(), DeclTy, GD,
3708 /*ForVTable=*/false);
3709 llvm::GlobalIFunc *GIF =
3710 llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage,
3711 "", Resolver, &getModule());
3712 if (Entry) {
3713 if (GIF->getResolver() == Entry) {
3714 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
3715 return;
3716 }
3717 assert(Entry->isDeclaration());
3718
3719 // If there is a declaration in the module, then we had an extern followed
3720 // by the ifunc, as in:
3721 // extern int test();
3722 // ...
3723 // int test() __attribute__((ifunc("resolver")));
3724 //
3725 // Remove it and replace uses of it with the ifunc.
3726 GIF->takeName(Entry);
3727
3728 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF,
3729 Entry->getType()));
3730 Entry->eraseFromParent();
3731 } else
3732 GIF->setName(MangledName);
3733
Rafael Espindola75c649c2018-03-01 00:06:55 +00003734 SetCommonAttributes(GD, GIF);
Dmitry Polukhin85eda122016-04-11 07:48:59 +00003735}
3736
Benjamin Kramer8d375ce2011-07-14 17:45:50 +00003737llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner54b16772011-07-23 17:14:25 +00003738 ArrayRef<llvm::Type*> Tys) {
Jay Foadb804a2b2011-07-12 14:06:48 +00003739 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8d375ce2011-07-14 17:45:50 +00003740 Tys);
Chris Lattnerb8be97e2007-12-18 00:25:38 +00003741}
Chris Lattner1eec6602007-08-31 04:31:45 +00003742
David Blaikie2e804282015-04-05 22:47:07 +00003743static llvm::StringMapEntry<llvm::GlobalVariable *> &
3744GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
3745 const StringLiteral *Literal, bool TargetIsLSB,
3746 bool &IsUTF16, unsigned &StringLength) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003747 StringRef String = Literal->getString();
Benjamin Kramer35b077e2010-08-17 12:54:38 +00003748 unsigned NumBytes = String.size();
Daniel Dunbar64509b22009-07-23 22:52:48 +00003749
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00003750 // Check for simple case.
3751 if (!Literal->containsNonAsciiOrNull()) {
3752 StringLength = NumBytes;
David Blaikie13156b62014-11-19 03:06:06 +00003753 return *Map.insert(std::make_pair(String, nullptr)).first;
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00003754 }
3755
Bill Wendling82b87f12012-03-30 00:26:17 +00003756 // Otherwise, convert the UTF8 literals into a string of shorts.
3757 IsUTF16 = true;
3758
Justin Lebar90910552016-09-30 00:38:45 +00003759 SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
3760 const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
3761 llvm::UTF16 *ToPtr = &ToBuf[0];
Mike Stump11289f42009-09-09 15:08:12 +00003762
Justin Lebar90910552016-09-30 00:38:45 +00003763 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
3764 ToPtr + NumBytes, llvm::strictConversion);
Mike Stump11289f42009-09-09 15:08:12 +00003765
Daniel Dunbar91ade142009-07-23 23:41:22 +00003766 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar64509b22009-07-23 22:52:48 +00003767 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar91ade142009-07-23 23:41:22 +00003768
Bill Wendling82b87f12012-03-30 00:26:17 +00003769 // Add an explicit null.
3770 *ToPtr = 0;
David Blaikie13156b62014-11-19 03:06:06 +00003771 return *Map.insert(std::make_pair(
3772 StringRef(reinterpret_cast<const char *>(ToBuf.data()),
3773 (StringLength + 1) * 2),
3774 nullptr)).first;
Daniel Dunbar64509b22009-07-23 22:52:48 +00003775}
3776
John McCall7f416cc2015-09-08 08:05:57 +00003777ConstantAddress
Daniel Dunbar64509b22009-07-23 22:52:48 +00003778CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
3779 unsigned StringLength = 0;
3780 bool isUTF16 = false;
David Blaikie2e804282015-04-05 22:47:07 +00003781 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
3782 GetConstantCFStringEntry(CFConstantStringMap, Literal,
3783 getDataLayout().isLittleEndian(), isUTF16,
3784 StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00003785
David Blaikie13156b62014-11-19 03:06:06 +00003786 if (auto *C = Entry.second)
John McCall7f416cc2015-09-08 08:05:57 +00003787 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
Mike Stump11289f42009-09-09 15:08:12 +00003788
Chris Lattnerece04092012-02-07 00:39:47 +00003789 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Daniel Dunbard644ad62008-08-23 18:37:06 +00003790 llvm::Constant *Zeros[] = { Zero, Zero };
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003791
Chris Lattneraa64ca22009-07-16 16:48:25 +00003792 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonb04ea612007-08-21 00:21:21 +00003793 if (!CFConstantStringClassRef) {
Chris Lattner2192fe52011-07-18 04:24:23 +00003794 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003795 Ty = llvm::ArrayType::get(Ty, 0);
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003796 llvm::Constant *GV =
3797 CreateRuntimeVariable(Ty, "__CFConstantStringClassReference");
Saleem Abdulrasool49766342016-06-01 04:22:24 +00003798
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +00003799 if (getTriple().isOSBinFormatCOFF()) {
Saleem Abdulrasool49766342016-06-01 04:22:24 +00003800 IdentifierInfo &II = getContext().Idents.get(GV->getName());
3801 TranslationUnitDecl *TUDecl = getContext().getTranslationUnitDecl();
3802 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
3803 llvm::GlobalValue *CGV = cast<llvm::GlobalValue>(GV);
3804
3805 const VarDecl *VD = nullptr;
3806 for (const auto &Result : DC->lookup(&II))
3807 if ((VD = dyn_cast<VarDecl>(Result)))
3808 break;
3809
3810 if (!VD || !VD->hasAttr<DLLExportAttr>()) {
3811 CGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
3812 CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
3813 } else {
3814 CGV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
3815 CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
3816 }
3817 }
3818
Daniel Dunbard644ad62008-08-23 18:37:06 +00003819 // Decay array -> ptr
Saleem Abdulrasool4fab7452016-09-11 01:25:15 +00003820 CFConstantStringClassRef =
3821 llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros);
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003822 }
Mike Stump11289f42009-09-09 15:08:12 +00003823
Anders Carlssonc2480a52008-11-15 18:54:24 +00003824 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbard644ad62008-08-23 18:37:06 +00003825
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003826 auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
Anders Carlssonc2480a52008-11-15 18:54:24 +00003827
John McCall23c9dc62016-11-28 22:18:27 +00003828 ConstantInitBuilder Builder(*this);
John McCall6c9f1fdb2016-11-19 08:17:24 +00003829 auto Fields = Builder.beginStruct(STy);
Douglas Gregor91f84212008-12-11 16:49:14 +00003830
Anders Carlssonb04ea612007-08-21 00:21:21 +00003831 // Class pointer.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003832 Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef));
Mike Stump11289f42009-09-09 15:08:12 +00003833
Anders Carlssonb04ea612007-08-21 00:21:21 +00003834 // Flags.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003835 Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8);
Anders Carlsson157c3212009-08-16 05:55:31 +00003836
Anders Carlssonb04ea612007-08-21 00:21:21 +00003837 // String pointer.
Craig Topper8a13c412014-05-21 05:09:00 +00003838 llvm::Constant *C = nullptr;
Bill Wendling82b87f12012-03-30 00:26:17 +00003839 if (isUTF16) {
Craig Topperc005cc02015-09-27 03:44:08 +00003840 auto Arr = llvm::makeArrayRef(
David Blaikie13156b62014-11-19 03:06:06 +00003841 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
3842 Entry.first().size() / 2);
Bill Wendling82b87f12012-03-30 00:26:17 +00003843 C = llvm::ConstantDataArray::get(VMContext, Arr);
3844 } else {
David Blaikie13156b62014-11-19 03:06:06 +00003845 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
Bill Wendling82b87f12012-03-30 00:26:17 +00003846 }
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00003847
Bill Wendling86131f22012-01-10 08:46:39 +00003848 // Note: -fwritable-strings doesn't make the backing store strings of
3849 // CFStrings writable. (See <rdar://problem/10657500>)
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003850 auto *GV =
Rafael Espindolae1bd71f2014-01-21 02:57:56 +00003851 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
3852 llvm::GlobalValue::PrivateLinkage, C, ".str");
Peter Collingbournebcf909d2016-06-14 21:02:05 +00003853 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
Ulrich Weigandfa806422013-05-06 16:23:57 +00003854 // Don't enforce the target's minimum global alignment, since the only use
3855 // of the string is via this class initializer.
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003856 CharUnits Align = isUTF16
3857 ? getContext().getTypeAlignInChars(getContext().ShortTy)
3858 : getContext().getTypeAlignInChars(getContext().CharTy);
3859 GV->setAlignment(Align.getQuantity());
3860
3861 // FIXME: We set the section explicitly to avoid a bug in ld64 224.1.
3862 // Without it LLVM can merge the string with a non unnamed_addr one during
3863 // LTO. Doing that changes the section it ends in, which surprises ld64.
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +00003864 if (getTriple().isOSBinFormatMachO())
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003865 GV->setSection(isUTF16 ? "__TEXT,__ustring"
3866 : "__TEXT,__cstring,cstring_literals");
Bill Wendling82b87f12012-03-30 00:26:17 +00003867
3868 // String.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003869 llvm::Constant *Str =
David Blaikied3c127e2015-05-07 17:27:56 +00003870 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
Anders Carlsson157c3212009-08-16 05:55:31 +00003871
Bill Wendling82b87f12012-03-30 00:26:17 +00003872 if (isUTF16)
3873 // Cast the UTF16 string to the correct type.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003874 Str = llvm::ConstantExpr::getBitCast(Str, Int8PtrTy);
3875 Fields.add(Str);
Bill Wendling82b87f12012-03-30 00:26:17 +00003876
Anders Carlssonb04ea612007-08-21 00:21:21 +00003877 // String length.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003878 auto Ty = getTypes().ConvertType(getContext().LongTy);
3879 Fields.addInt(cast<llvm::IntegerType>(Ty), StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00003880
John McCall7f416cc2015-09-08 08:05:57 +00003881 CharUnits Alignment = getPointerAlign();
3882
Anders Carlssonb04ea612007-08-21 00:21:21 +00003883 // The struct.
John McCall6c9f1fdb2016-11-19 08:17:24 +00003884 GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
3885 /*isConstant=*/false,
3886 llvm::GlobalVariable::PrivateLinkage);
Saleem Abdulrasool7246dcc2016-09-14 15:17:46 +00003887 switch (getTriple().getObjectFormat()) {
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003888 case llvm::Triple::UnknownObjectFormat:
3889 llvm_unreachable("unknown file format");
3890 case llvm::Triple::COFF:
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003891 case llvm::Triple::ELF:
Dan Gohman839f2152017-01-17 21:46:38 +00003892 case llvm::Triple::Wasm:
Saleem Abdulrasool0295f8c2016-07-09 01:59:51 +00003893 GV->setSection("cfstring");
Saleem Abdulrasoolf7444e62016-05-30 16:23:07 +00003894 break;
3895 case llvm::Triple::MachO:
3896 GV->setSection("__DATA,__cfstring");
3897 break;
3898 }
David Blaikie13156b62014-11-19 03:06:06 +00003899 Entry.second = GV;
Mike Stump11289f42009-09-09 15:08:12 +00003900
John McCall7f416cc2015-09-08 08:05:57 +00003901 return ConstantAddress(GV, Alignment);
Anders Carlssonb04ea612007-08-21 00:21:21 +00003902}
Chris Lattnerfb300092007-11-28 05:34:05 +00003903
Bob Haarmanc6c9b8f2017-09-11 22:11:57 +00003904bool CodeGenModule::getExpressionLocationsEnabled() const {
3905 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
3906}
3907
Douglas Gregor636e2002011-08-09 17:23:49 +00003908QualType CodeGenModule::getObjCFastEnumerationStateType() {
3909 if (ObjCFastEnumerationStateType.isNull()) {
Alp Toker2dea15b2013-12-17 01:22:38 +00003910 RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
Douglas Gregor636e2002011-08-09 17:23:49 +00003911 D->startDefinition();
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003912
Douglas Gregor636e2002011-08-09 17:23:49 +00003913 QualType FieldTypes[] = {
3914 Context.UnsignedLongTy,
3915 Context.getPointerType(Context.getObjCIdType()),
3916 Context.getPointerType(Context.UnsignedLongTy),
3917 Context.getConstantArrayType(Context.UnsignedLongTy,
3918 llvm::APInt(32, 5), ArrayType::Normal, 0)
3919 };
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003920
Douglas Gregor636e2002011-08-09 17:23:49 +00003921 for (size_t i = 0; i < 4; ++i) {
3922 FieldDecl *Field = FieldDecl::Create(Context,
3923 D,
3924 SourceLocation(),
Craig Topper8a13c412014-05-21 05:09:00 +00003925 SourceLocation(), nullptr,
3926 FieldTypes[i], /*TInfo=*/nullptr,
3927 /*BitWidth=*/nullptr,
Douglas Gregor636e2002011-08-09 17:23:49 +00003928 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00003929 ICIS_NoInit);
Douglas Gregor636e2002011-08-09 17:23:49 +00003930 Field->setAccess(AS_public);
3931 D->addDecl(Field);
3932 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003933
Douglas Gregor636e2002011-08-09 17:23:49 +00003934 D->completeDefinition();
3935 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
3936 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003937
Douglas Gregor636e2002011-08-09 17:23:49 +00003938 return ObjCFastEnumerationStateType;
3939}
3940
Eli Friedmanfcec6302011-11-01 02:23:42 +00003941llvm::Constant *
3942CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
3943 assert(!E->getType()->isPointerType() && "Strings are always arrays");
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003944
Eli Friedmanfcec6302011-11-01 02:23:42 +00003945 // Don't emit it as the address of the string, emit the string data itself
3946 // as an inline array.
Chris Lattner00a10ca2012-02-06 22:47:00 +00003947 if (E->getCharByteWidth() == 1) {
3948 SmallString<64> Str(E->getString());
3949
3950 // Resize the string to the right size, which is indicated by its type.
3951 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
3952 Str.resize(CAT->getSize().getZExtValue());
3953 return llvm::ConstantDataArray::getString(VMContext, Str, false);
3954 }
Rafael Espindola2ae250c2014-05-09 00:08:36 +00003955
3956 auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
Chris Lattner9c818332012-02-05 02:30:40 +00003957 llvm::Type *ElemTy = AType->getElementType();
3958 unsigned NumElements = AType->getNumElements();
Chris Lattner02cb1712012-02-06 22:52:04 +00003959
3960 // Wide strings have either 2-byte or 4-byte elements.
3961 if (ElemTy->getPrimitiveSizeInBits() == 16) {
3962 SmallVector<uint16_t, 32> Elements;
3963 Elements.reserve(NumElements);
3964
3965 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
3966 Elements.push_back(E->getCodeUnit(i));
3967 Elements.resize(NumElements);
3968 return llvm::ConstantDataArray::get(VMContext, Elements);
Chris Lattner9c818332012-02-05 02:30:40 +00003969 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003970
Chris Lattner02cb1712012-02-06 22:52:04 +00003971 assert(ElemTy->getPrimitiveSizeInBits() == 32);
3972 SmallVector<uint32_t, 32> Elements;
3973 Elements.reserve(NumElements);
Jake Ehrlichc451cf22017-11-11 01:15:41 +00003974
Chris Lattner02cb1712012-02-06 22:52:04 +00003975 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
3976 Elements.push_back(E->getCodeUnit(i));
3977 Elements.resize(NumElements);
3978 return llvm::ConstantDataArray::get(VMContext, Elements);
Eli Friedmanfcec6302011-11-01 02:23:42 +00003979}
3980
Alexey Samsonov175e52f2014-06-04 19:56:57 +00003981static llvm::GlobalVariable *
3982GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
3983 CodeGenModule &CGM, StringRef GlobalName,
John McCall7f416cc2015-09-08 08:05:57 +00003984 CharUnits Alignment) {
Alexey Samsonov175e52f2014-06-04 19:56:57 +00003985 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
3986 unsigned AddrSpace = 0;
3987 if (CGM.getLangOpts().OpenCL)
3988 AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
3989
Rafael Espindolad9b26d52015-01-16 20:32:35 +00003990 llvm::Module &M = CGM.getModule();
Alexey Samsonov175e52f2014-06-04 19:56:57 +00003991 // Create a global variable for this string
3992 auto *GV = new llvm::GlobalVariable(
Rafael Espindolad9b26d52015-01-16 20:32:35 +00003993 M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
3994 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
John McCall7f416cc2015-09-08 08:05:57 +00003995 GV->setAlignment(Alignment.getQuantity());
Peter Collingbournebcf909d2016-06-14 21:02:05 +00003996 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
NAKAMURA Takumic7da6da2015-05-09 21:10:07 +00003997 if (GV->isWeakForLinker()) {
3998 assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
3999 GV->setComdat(M.getOrInsertComdat(GV->getName()));
4000 }
Rafael Espindolad9b26d52015-01-16 20:32:35 +00004001
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004002 return GV;
4003}
4004
Daniel Dunbarc4baa062008-08-13 23:20:05 +00004005/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
4006/// constant array for the given string literal.
John McCall7f416cc2015-09-08 08:05:57 +00004007ConstantAddress
Alexey Bataevec474782014-10-09 08:45:04 +00004008CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
4009 StringRef Name) {
John McCall7f416cc2015-09-08 08:05:57 +00004010 CharUnits Alignment = getContext().getAlignOfGlobalVarInChars(S->getType());
James Molloye735b2b2014-05-09 16:28:56 +00004011
Richard Smith00db2f12014-07-29 21:20:12 +00004012 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
4013 llvm::GlobalVariable **Entry = nullptr;
David Majnemer58e5bee2014-03-24 21:43:36 +00004014 if (!LangOpts.WritableStrings) {
Richard Smith00db2f12014-07-29 21:20:12 +00004015 Entry = &ConstantStringMap[C];
4016 if (auto GV = *Entry) {
John McCall7f416cc2015-09-08 08:05:57 +00004017 if (Alignment.getQuantity() > GV->getAlignment())
4018 GV->setAlignment(Alignment.getQuantity());
4019 return ConstantAddress(GV, Alignment);
David Majnemer58e5bee2014-03-24 21:43:36 +00004020 }
Eli Friedman49ddc5f2009-11-16 05:55:46 +00004021 }
Eli Friedmanfcec6302011-11-01 02:23:42 +00004022
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004023 SmallString<256> MangledNameBuffer;
4024 StringRef GlobalVariableName;
4025 llvm::GlobalValue::LinkageTypes LT;
David Majnemer3843a052014-03-23 17:47:16 +00004026
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004027 // Mangle the string literal if the ABI allows for it. However, we cannot
4028 // do this if we are compiling with ASan or -fwritable-strings because they
4029 // rely on strings having normal linkage.
Alexey Samsonovedf99a92014-11-07 22:29:38 +00004030 if (!LangOpts.WritableStrings &&
4031 !LangOpts.Sanitize.has(SanitizerKind::Address) &&
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004032 getCXXABI().getMangleContext().shouldMangleStringLiteral(S)) {
4033 llvm::raw_svector_ostream Out(MangledNameBuffer);
4034 getCXXABI().getMangleContext().mangleStringLiteral(S, Out);
David Majnemer58e5bee2014-03-24 21:43:36 +00004035
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004036 LT = llvm::GlobalValue::LinkOnceODRLinkage;
4037 GlobalVariableName = MangledNameBuffer;
4038 } else {
4039 LT = llvm::GlobalValue::PrivateLinkage;
Alexey Bataevec474782014-10-09 08:45:04 +00004040 GlobalVariableName = Name;
David Majnemer58e5bee2014-03-24 21:43:36 +00004041 }
4042
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004043 auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
4044 if (Entry)
Richard Smith00db2f12014-07-29 21:20:12 +00004045 *Entry = GV;
Alexey Samsonov4f319cc2014-07-02 16:54:41 +00004046
Alexey Samsonova0ac3c22014-10-17 22:37:33 +00004047 SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
4048 QualType());
John McCall7f416cc2015-09-08 08:05:57 +00004049 return ConstantAddress(GV, Alignment);
Daniel Dunbarc4baa062008-08-13 23:20:05 +00004050}
4051
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00004052/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
4053/// array for the given ObjCEncodeExpr node.
John McCall7f416cc2015-09-08 08:05:57 +00004054ConstantAddress
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00004055CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
4056 std::string Str;
4057 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedman4663a332009-03-07 20:17:55 +00004058
4059 return GetAddrOfConstantCString(Str);
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00004060}
4061
Alexey Samsonovadc90372014-06-04 20:25:57 +00004062/// GetAddrOfConstantCString - Returns a pointer to a character array containing
4063/// the literal and a terminating '\0' character.
Daniel Dunbarc4baa062008-08-13 23:20:05 +00004064/// The result has pointer to array type.
John McCall7f416cc2015-09-08 08:05:57 +00004065ConstantAddress CodeGenModule::GetAddrOfConstantCString(
4066 const std::string &Str, const char *GlobalName) {
Alexey Samsonovadc90372014-06-04 20:25:57 +00004067 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCall7f416cc2015-09-08 08:05:57 +00004068 CharUnits Alignment =
4069 getContext().getAlignOfGlobalVarInChars(getContext().CharTy);
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004070
Richard Smith00db2f12014-07-29 21:20:12 +00004071 llvm::Constant *C =
4072 llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
4073
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004074 // Don't share any string literals if strings aren't constant.
Richard Smith00db2f12014-07-29 21:20:12 +00004075 llvm::GlobalVariable **Entry = nullptr;
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004076 if (!LangOpts.WritableStrings) {
Richard Smith00db2f12014-07-29 21:20:12 +00004077 Entry = &ConstantStringMap[C];
4078 if (auto GV = *Entry) {
John McCall7f416cc2015-09-08 08:05:57 +00004079 if (Alignment.getQuantity() > GV->getAlignment())
4080 GV->setAlignment(Alignment.getQuantity());
4081 return ConstantAddress(GV, Alignment);
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004082 }
4083 }
4084
Daniel Dunbar08b216a2009-03-31 23:42:16 +00004085 // Get the default prefix if a name wasn't specified.
4086 if (!GlobalName)
Chris Lattner3afa3e12009-07-16 05:03:48 +00004087 GlobalName = ".str";
Chris Lattnerfb300092007-11-28 05:34:05 +00004088 // Create a global variable for this.
Alexey Samsonov175e52f2014-06-04 19:56:57 +00004089 auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
4090 GlobalName, Alignment);
4091 if (Entry)
Richard Smith00db2f12014-07-29 21:20:12 +00004092 *Entry = GV;
John McCall7f416cc2015-09-08 08:05:57 +00004093 return ConstantAddress(GV, Alignment);
Chris Lattnerfb300092007-11-28 05:34:05 +00004094}
Daniel Dunbarc4baa062008-08-13 23:20:05 +00004095
John McCall7f416cc2015-09-08 08:05:57 +00004096ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
Richard Smitha509f2f2013-06-14 03:07:01 +00004097 const MaterializeTemporaryExpr *E, const Expr *Init) {
Richard Smithe6c01442013-06-05 00:46:14 +00004098 assert((E->getStorageDuration() == SD_Static ||
4099 E->getStorageDuration() == SD_Thread) && "not a global temporary");
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004100 const auto *VD = cast<VarDecl>(E->getExtendingDecl());
Richard Smithe6c01442013-06-05 00:46:14 +00004101
4102 // If we're not materializing a subobject of the temporary, keep the
4103 // cv-qualifiers from the type of the MaterializeTemporaryExpr.
Richard Smitha509f2f2013-06-14 03:07:01 +00004104 QualType MaterializedType = Init->getType();
4105 if (Init == E->GetTemporaryExpr())
4106 MaterializedType = E->getType();
Richard Smithe6c01442013-06-05 00:46:14 +00004107
John McCall7f416cc2015-09-08 08:05:57 +00004108 CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
4109
David Majnemer2dcef9e2015-08-13 23:50:15 +00004110 if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
John McCall7f416cc2015-09-08 08:05:57 +00004111 return ConstantAddress(Slot, Align);
Richard Smithe6c01442013-06-05 00:46:14 +00004112
4113 // FIXME: If an externally-visible declaration extends multiple temporaries,
4114 // we need to give each temporary the same name in every translation unit (and
4115 // we also need to make the temporaries externally-visible).
4116 SmallString<256> Name;
4117 llvm::raw_svector_ostream Out(Name);
David Majnemerdaff3702014-05-01 17:50:17 +00004118 getCXXABI().getMangleContext().mangleReferenceTemporary(
4119 VD, E->getManglingNumber(), Out);
Richard Smithe6c01442013-06-05 00:46:14 +00004120
Craig Topper8a13c412014-05-21 05:09:00 +00004121 APValue *Value = nullptr;
Richard Smithe6c01442013-06-05 00:46:14 +00004122 if (E->getStorageDuration() == SD_Static) {
Richard Smitha509f2f2013-06-14 03:07:01 +00004123 // We might have a cached constant initializer for this temporary. Note
4124 // that this might have a different value from the value computed by
4125 // evaluating the initializer if the surrounding constant expression
4126 // modifies the temporary.
Richard Smithe6c01442013-06-05 00:46:14 +00004127 Value = getContext().getMaterializedTemporaryValue(E, false);
4128 if (Value && Value->isUninit())
Craig Topper8a13c412014-05-21 05:09:00 +00004129 Value = nullptr;
Richard Smithe6c01442013-06-05 00:46:14 +00004130 }
4131
Richard Smitha509f2f2013-06-14 03:07:01 +00004132 // Try evaluating it now, it might have a constant initializer.
4133 Expr::EvalResult EvalResult;
4134 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
4135 !EvalResult.hasSideEffects())
4136 Value = &EvalResult.Val;
4137
Alexander Richardson6d989432017-10-15 18:48:14 +00004138 LangAS AddrSpace =
John McCallde0fe072017-08-15 21:42:52 +00004139 VD ? GetGlobalVarAddressSpace(VD) : MaterializedType.getAddressSpace();
4140
4141 Optional<ConstantEmitter> emitter;
Craig Topper8a13c412014-05-21 05:09:00 +00004142 llvm::Constant *InitialValue = nullptr;
Richard Smitha509f2f2013-06-14 03:07:01 +00004143 bool Constant = false;
4144 llvm::Type *Type;
Richard Smithe6c01442013-06-05 00:46:14 +00004145 if (Value) {
4146 // The temporary has a constant initializer, use it.
John McCallde0fe072017-08-15 21:42:52 +00004147 emitter.emplace(*this);
4148 InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
4149 MaterializedType);
Richard Smitha509f2f2013-06-14 03:07:01 +00004150 Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
4151 Type = InitialValue->getType();
Richard Smithe6c01442013-06-05 00:46:14 +00004152 } else {
Richard Smitha509f2f2013-06-14 03:07:01 +00004153 // No initializer, the initialization will be provided when we
Richard Smithe6c01442013-06-05 00:46:14 +00004154 // initialize the declaration which performed lifetime extension.
Richard Smitha509f2f2013-06-14 03:07:01 +00004155 Type = getTypes().ConvertTypeForMem(MaterializedType);
Richard Smithe6c01442013-06-05 00:46:14 +00004156 }
4157
4158 // Create a global variable for this lifetime-extended temporary.
David Majnemer27d69db2014-04-28 22:17:59 +00004159 llvm::GlobalValue::LinkageTypes Linkage =
4160 getLLVMLinkageVarDefinition(VD, Constant);
David Majnemerc9a9c7a2015-02-19 19:25:17 +00004161 if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
4162 const VarDecl *InitVD;
4163 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
4164 isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
4165 // Temporaries defined inside a class get linkonce_odr linkage because the
4166 // class can be defined in multipe translation units.
4167 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
4168 } else {
4169 // There is no need for this temporary to have external linkage if the
4170 // VarDecl has external linkage.
4171 Linkage = llvm::GlobalVariable::InternalLinkage;
4172 }
4173 }
Yaxun Liucbf647c2017-07-08 13:24:52 +00004174 auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004175 auto *GV = new llvm::GlobalVariable(
David Majnemer27d69db2014-04-28 22:17:59 +00004176 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
Yaxun Liucbf647c2017-07-08 13:24:52 +00004177 /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
John McCallde0fe072017-08-15 21:42:52 +00004178 if (emitter) emitter->finalize(GV);
Rafael Espindola699f5d62018-02-07 22:15:33 +00004179 setGVProperties(GV, VD);
John McCall7f416cc2015-09-08 08:05:57 +00004180 GV->setAlignment(Align.getQuantity());
NAKAMURA Takumic7da6da2015-05-09 21:10:07 +00004181 if (supportsCOMDAT() && GV->isWeakForLinker())
4182 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
Richard Smithe6c01442013-06-05 00:46:14 +00004183 if (VD->getTLSKind())
4184 setTLSMode(GV, *VD);
Yaxun Liucbf647c2017-07-08 13:24:52 +00004185 llvm::Constant *CV = GV;
4186 if (AddrSpace != LangAS::Default)
4187 CV = getTargetCodeGenInfo().performAddrSpaceCast(
4188 *this, GV, AddrSpace, LangAS::Default,
4189 Type->getPointerTo(
4190 getContext().getTargetAddressSpace(LangAS::Default)));
4191 MaterializedGlobalTemporaryMap[E] = CV;
4192 return ConstantAddress(CV, Align);
Richard Smithe6c01442013-06-05 00:46:14 +00004193}
4194
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004195/// EmitObjCPropertyImplementations - Emit information for synthesized
4196/// properties for an implementation.
Mike Stump11289f42009-09-09 15:08:12 +00004197void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004198 ObjCImplementationDecl *D) {
Aaron Ballmand85eff42014-03-14 15:02:45 +00004199 for (const auto *PID : D->property_impls()) {
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004200 // Dynamic is just for type-checking.
4201 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
4202 ObjCPropertyDecl *PD = PID->getPropertyDecl();
4203
4204 // Determine which methods need to be implemented, some may have
Jordan Rosed01e83a2012-10-10 16:42:25 +00004205 // been overridden. Note that ::isPropertyAccessor is not the method
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004206 // we want, that just indicates if the decl came from a
4207 // property. What we want to know is if the method is defined in
4208 // this implementation.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004209 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00004210 CodeGenFunction(*this).GenerateObjCGetter(
4211 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004212 if (!PD->isReadOnly() &&
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004213 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00004214 CodeGenFunction(*this).GenerateObjCSetter(
4215 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004216 }
4217 }
4218}
4219
John McCall6a4fa522011-03-22 07:05:39 +00004220static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosea91768e2011-07-22 02:08:32 +00004221 const ObjCInterfaceDecl *iface = impl->getClassInterface();
4222 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCall6a4fa522011-03-22 07:05:39 +00004223 ivar; ivar = ivar->getNextIvar())
4224 if (ivar->getType().isDestructedType())
4225 return true;
4226
4227 return false;
4228}
4229
Fariborz Jahanian800821a2014-11-12 22:37:43 +00004230static bool AllTrivialInitializers(CodeGenModule &CGM,
4231 ObjCImplementationDecl *D) {
4232 CodeGenFunction CGF(CGM);
4233 for (ObjCImplementationDecl::init_iterator B = D->init_begin(),
4234 E = D->init_end(); B != E; ++B) {
4235 CXXCtorInitializer *CtorInitExp = *B;
4236 Expr *Init = CtorInitExp->getInit();
4237 if (!CGF.isTrivialInitializer(Init))
4238 return false;
4239 }
4240 return true;
4241}
4242
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004243/// EmitObjCIvarInitializations - Emit information for ivar initialization
4244/// for an implementation.
4245void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCall6a4fa522011-03-22 07:05:39 +00004246 // We might need a .cxx_destruct even if we don't have any ivar initializers.
4247 if (needsDestructMethod(D)) {
4248 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
4249 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
4250 ObjCMethodDecl *DTORMethod =
4251 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Craig Topper8a13c412014-05-21 05:09:00 +00004252 cxxSelector, getContext().VoidTy, nullptr, D,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00004253 /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rosed01e83a2012-10-10 16:42:25 +00004254 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00004255 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCall6a4fa522011-03-22 07:05:39 +00004256 D->addInstanceMethod(DTORMethod);
4257 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCall0d54a172012-10-17 04:53:31 +00004258 D->setHasDestructors(true);
John McCall6a4fa522011-03-22 07:05:39 +00004259 }
4260
4261 // If the implementation doesn't have any ivar initializers, we don't need
4262 // a .cxx_construct.
Fariborz Jahanian800821a2014-11-12 22:37:43 +00004263 if (D->getNumIvarInitializers() == 0 ||
4264 AllTrivialInitializers(*this, D))
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004265 return;
Jake Ehrlichc451cf22017-11-11 01:15:41 +00004266
John McCall6a4fa522011-03-22 07:05:39 +00004267 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
4268 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004269 // The constructor returns 'self'.
Jake Ehrlichc451cf22017-11-11 01:15:41 +00004270 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004271 D->getLocation(),
Argyrios Kyrtzidisdfd65702011-10-03 06:36:36 +00004272 D->getLocation(),
Argyrios Kyrtzidisdfd65702011-10-03 06:36:36 +00004273 cxxSelector,
Craig Topper8a13c412014-05-21 05:09:00 +00004274 getContext().getObjCIdType(),
4275 nullptr, D, /*isInstance=*/true,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00004276 /*isVariadic=*/false,
Jordan Rosed01e83a2012-10-10 16:42:25 +00004277 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00004278 /*isImplicitlyDeclared=*/true,
4279 /*isDefined=*/false,
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004280 ObjCMethodDecl::Required);
4281 D->addInstanceMethod(CTORMethod);
4282 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCall0d54a172012-10-17 04:53:31 +00004283 D->setHasNonZeroConstructors(true);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004284}
4285
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00004286// EmitLinkageSpec - Emit all declarations in a linkage spec.
4287void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmane480ce32009-08-01 20:48:04 +00004288 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
4289 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00004290 ErrorUnsupported(LSD, "linkage spec");
4291 return;
4292 }
4293
Richard Smith8df390f2016-09-08 23:14:54 +00004294 EmitDeclContext(LSD);
4295}
4296
4297void CodeGenModule::EmitDeclContext(const DeclContext *DC) {
4298 for (auto *I : DC->decls()) {
4299 // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
4300 // are themselves considered "top-level", so EmitTopLevelDecl on an
4301 // ObjCImplDecl does not recursively visit them. We need to do that in
4302 // case they're nested inside another construct (LinkageSpecDecl /
4303 // ExportDecl) that does stop them from being considered "top-level".
Aaron Ballman629afae2014-03-07 19:56:05 +00004304 if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
Aaron Ballmanaff18c02014-03-13 19:03:34 +00004305 for (auto *M : OID->methods())
4306 EmitTopLevelDecl(M);
Fariborz Jahanian2d26c292012-10-26 20:22:11 +00004307 }
Richard Smith8df390f2016-09-08 23:14:54 +00004308
Aaron Ballman629afae2014-03-07 19:56:05 +00004309 EmitTopLevelDecl(I);
Fariborz Jahanian2d26c292012-10-26 20:22:11 +00004310 }
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00004311}
4312
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004313/// EmitTopLevelDecl - Emit code for a single top level declaration.
4314void CodeGenModule::EmitTopLevelDecl(Decl *D) {
Douglas Gregor70d83e22009-06-29 17:30:29 +00004315 // Ignore dependent declarations.
Richard Smith32b615c2018-02-01 00:28:36 +00004316 if (D->isTemplated())
Douglas Gregor70d83e22009-06-29 17:30:29 +00004317 return;
Mike Stump11289f42009-09-09 15:08:12 +00004318
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004319 switch (D->getKind()) {
Anders Carlsson6c0a6e42009-08-25 13:14:46 +00004320 case Decl::CXXConversion:
Anders Carlsson468fa632009-04-04 20:47:02 +00004321 case Decl::CXXMethod:
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004322 case Decl::Function:
Anders Carlssonecf9bf02009-09-10 23:43:36 +00004323 EmitGlobal(cast<FunctionDecl>(D));
Alex Lorenzee024992014-08-04 18:41:51 +00004324 // Always provide some coverage mapping
4325 // even for the functions that aren't emitted.
4326 AddDeferredUnusedCoverageMapping(D);
Anders Carlssonecf9bf02009-09-10 23:43:36 +00004327 break;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004328
Richard Smithada08882017-04-19 21:15:45 +00004329 case Decl::CXXDeductionGuide:
4330 // Function-like, but does not result in code emission.
4331 break;
4332
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004333 case Decl::Var:
Richard Smithbdb84f32016-07-22 23:36:59 +00004334 case Decl::Decomposition:
Larisse Voufo39a1e502013-08-06 01:03:05 +00004335 case Decl::VarTemplateSpecialization:
Anders Carlssonecf9bf02009-09-10 23:43:36 +00004336 EmitGlobal(cast<VarDecl>(D));
Richard Smithda383632016-08-15 01:33:41 +00004337 if (auto *DD = dyn_cast<DecompositionDecl>(D))
4338 for (auto *B : DD->bindings())
4339 if (auto *HD = B->getHoldingVar())
4340 EmitGlobal(HD);
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004341 break;
4342
John McCall32f44bd2011-04-12 01:01:22 +00004343 // Indirect fields from global anonymous structs and unions can be
4344 // ignored; only the actual variable requires IR gen support.
4345 case Decl::IndirectField:
4346 break;
4347
Anders Carlssonf7475242009-04-15 15:55:24 +00004348 // C++ Decls
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004349 case Decl::Namespace:
Richard Smith8df390f2016-09-08 23:14:54 +00004350 EmitDeclContext(cast<NamespaceDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004351 break;
Richard Smithe1246122017-11-03 01:26:01 +00004352 case Decl::ClassTemplateSpecialization: {
4353 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
4354 if (DebugInfo &&
4355 Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
4356 Spec->hasDefinition())
4357 DebugInfo->completeTemplateDefinition(*Spec);
4358 } LLVM_FALLTHROUGH;
Richard Smith62f19e72016-06-25 00:15:56 +00004359 case Decl::CXXRecord:
David Blaikie1ac9c982017-04-11 21:13:37 +00004360 if (DebugInfo) {
4361 if (auto *ES = D->getASTContext().getExternalSource())
4362 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
4363 DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
4364 }
Richard Smith62f19e72016-06-25 00:15:56 +00004365 // Emit any static data members, they may be definitions.
4366 for (auto *I : cast<CXXRecordDecl>(D)->decls())
4367 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
4368 EmitTopLevelDecl(I);
4369 break;
Douglas Gregorfec52632009-06-20 00:51:54 +00004370 // No code generation needed.
John McCall1e9de052009-11-17 09:33:40 +00004371 case Decl::UsingShadow:
Douglas Gregor8f5d4422009-06-29 20:59:39 +00004372 case Decl::ClassTemplate:
Larisse Voufo39a1e502013-08-06 01:03:05 +00004373 case Decl::VarTemplate:
4374 case Decl::VarTemplatePartialSpecialization:
Douglas Gregor8f5d4422009-06-29 20:59:39 +00004375 case Decl::FunctionTemplate:
Richard Smith3f1b5d02011-05-05 21:57:07 +00004376 case Decl::TypeAliasTemplate:
Douglas Gregor0aa91e02011-06-05 05:04:23 +00004377 case Decl::Block:
Michael Han84324352013-02-22 17:15:32 +00004378 case Decl::Empty:
Douglas Gregorfec52632009-06-20 00:51:54 +00004379 break;
David Blaikie3e65d36a2014-02-15 21:03:07 +00004380 case Decl::Using: // using X; [C++]
4381 if (CGDebugInfo *DI = getModuleDebugInfo())
4382 DI->EmitUsingDecl(cast<UsingDecl>(*D));
4383 return;
David Blaikief121b932013-05-20 22:50:41 +00004384 case Decl::NamespaceAlias:
4385 if (CGDebugInfo *DI = getModuleDebugInfo())
4386 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
4387 return;
David Blaikie60a9fbf2013-04-26 05:41:06 +00004388 case Decl::UsingDirective: // using namespace X; [C++]
4389 if (CGDebugInfo *DI = getModuleDebugInfo())
4390 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
4391 return;
Anders Carlssonf7475242009-04-15 15:55:24 +00004392 case Decl::CXXConstructor:
Timur Iskhodzhanov40f2fa92013-08-04 17:30:04 +00004393 getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
Anders Carlssonf7475242009-04-15 15:55:24 +00004394 break;
Anders Carlssoneaa28f72009-04-17 01:58:57 +00004395 case Decl::CXXDestructor:
Reid Klecknere7de47e2013-07-22 13:51:44 +00004396 getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
Anders Carlssoneaa28f72009-04-17 01:58:57 +00004397 break;
Anders Carlsson87835432009-06-11 21:22:55 +00004398
4399 case Decl::StaticAssert:
4400 // Nothing to do.
4401 break;
4402
Anders Carlssonf7475242009-04-15 15:55:24 +00004403 // Objective-C Decls
Mike Stump11289f42009-09-09 15:08:12 +00004404
Fariborz Jahanian3654e652009-03-18 22:33:24 +00004405 // Forward declarations, no (immediate) code generation.
Chris Lattnerd18136a2009-04-01 02:36:43 +00004406 case Decl::ObjCInterface:
Eric Christopherf8378ca2012-07-19 22:22:55 +00004407 case Decl::ObjCCategory:
Chris Lattnerd18136a2009-04-01 02:36:43 +00004408 break;
4409
Douglas Gregorf6102672012-01-01 21:23:57 +00004410 case Decl::ObjCProtocol: {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004411 auto *Proto = cast<ObjCProtocolDecl>(D);
Douglas Gregorf6102672012-01-01 21:23:57 +00004412 if (Proto->isThisDeclarationADefinition())
4413 ObjCRuntime->GenerateProtocol(Proto);
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004414 break;
Douglas Gregorf6102672012-01-01 21:23:57 +00004415 }
Jake Ehrlichc451cf22017-11-11 01:15:41 +00004416
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004417 case Decl::ObjCCategoryImpl:
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004418 // Categories have properties but don't support synthesize so we
4419 // can ignore them here.
Peter Collingbournee1d20992011-07-27 20:29:46 +00004420 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004421 break;
4422
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004423 case Decl::ObjCImplementation: {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004424 auto *OMD = cast<ObjCImplementationDecl>(D);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00004425 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004426 EmitObjCIvarInitializations(OMD);
Peter Collingbournee1d20992011-07-27 20:29:46 +00004427 ObjCRuntime->GenerateClass(OMD);
Eric Christopher3d19de92012-04-11 05:56:05 +00004428 // Emit global variable debug information.
4429 if (CGDebugInfo *DI = getModuleDebugInfo())
Benjamin Kramer8c305922016-02-02 11:06:51 +00004430 if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
Alexey Samsonov9c1b9f62012-12-03 18:28:12 +00004431 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
4432 OMD->getClassInterface()), OMD->getLocation());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004433 break;
Mike Stump11289f42009-09-09 15:08:12 +00004434 }
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004435 case Decl::ObjCMethod: {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004436 auto *OMD = cast<ObjCMethodDecl>(D);
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004437 // If this is not a prototype, emit the body.
Argyrios Kyrtzidisddcd1322009-06-30 02:35:26 +00004438 if (OMD->getBody())
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004439 CodeGenFunction(*this).GenerateObjCMethod(OMD);
4440 break;
4441 }
Mike Stump11289f42009-09-09 15:08:12 +00004442 case Decl::ObjCCompatibleAlias:
David Chisnall92d436b2012-01-31 18:59:20 +00004443 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004444 break;
4445
Nico Weber66220292016-03-02 17:28:48 +00004446 case Decl::PragmaComment: {
4447 const auto *PCD = cast<PragmaCommentDecl>(D);
4448 switch (PCD->getCommentKind()) {
4449 case PCK_Unknown:
4450 llvm_unreachable("unexpected pragma comment kind");
4451 case PCK_Linker:
4452 AppendLinkerOptions(PCD->getArg());
4453 break;
4454 case PCK_Lib:
Saleem Abdulrasoolfd4db532018-02-07 01:46:46 +00004455 if (getTarget().getTriple().isOSBinFormatELF() &&
4456 !getTarget().getTriple().isPS4())
4457 AddELFLibDirective(PCD->getArg());
4458 else
4459 AddDependentLib(PCD->getArg());
Nico Weber66220292016-03-02 17:28:48 +00004460 break;
4461 case PCK_Compiler:
4462 case PCK_ExeStr:
4463 case PCK_User:
4464 break; // We ignore all of these.
4465 }
4466 break;
4467 }
4468
Nico Webercbbaeb12016-03-02 19:28:54 +00004469 case Decl::PragmaDetectMismatch: {
4470 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
4471 AddDetectMismatch(PDMD->getName(), PDMD->getValue());
4472 break;
4473 }
4474
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00004475 case Decl::LinkageSpec:
4476 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004477 break;
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004478
4479 case Decl::FileScopeAsm: {
Artem Belevich0488d1e2015-04-27 18:52:00 +00004480 // File-scope asm is ignored during device-side CUDA compilation.
4481 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
4482 break;
Samuel Antaoee8fb302016-01-06 13:42:12 +00004483 // File-scope asm is ignored during device-side OpenMP compilation.
4484 if (LangOpts.OpenMPIsDevice)
4485 break;
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004486 auto *AD = cast<FileScopeAsmDecl>(D);
Joerg Sonnenbergerdfd511e2015-03-13 00:54:30 +00004487 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004488 break;
4489 }
Mike Stump11289f42009-09-09 15:08:12 +00004490
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004491 case Decl::Import: {
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004492 auto *Import = cast<ImportDecl>(D);
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004493
Richard Smithdc1f0422016-07-20 19:10:16 +00004494 // If we've already imported this module, we're done.
4495 if (!ImportedModules.insert(Import->getImportedModule()))
Richard Smithc52efa72015-08-19 02:30:28 +00004496 break;
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004497
Richard Smithdc1f0422016-07-20 19:10:16 +00004498 // Emit debug information for direct imports.
4499 if (!Import->getImportedOwningModule()) {
4500 if (CGDebugInfo *DI = getModuleDebugInfo())
4501 DI->EmitImportDecl(*Import);
4502 }
4503
Manman Ren3b5dbf22016-10-14 18:55:44 +00004504 // Find all of the submodules and emit the module initializers.
4505 llvm::SmallPtrSet<clang::Module *, 16> Visited;
4506 SmallVector<clang::Module *, 16> Stack;
4507 Visited.insert(Import->getImportedModule());
4508 Stack.push_back(Import->getImportedModule());
4509
4510 while (!Stack.empty()) {
4511 clang::Module *Mod = Stack.pop_back_val();
4512 if (!EmittedModuleInitializers.insert(Mod).second)
4513 continue;
4514
4515 for (auto *D : Context.getModuleInitializers(Mod))
4516 EmitTopLevelDecl(D);
4517
4518 // Visit the submodules of this module.
4519 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
4520 SubEnd = Mod->submodule_end();
4521 Sub != SubEnd; ++Sub) {
4522 // Skip explicit children; they need to be explicitly imported to emit
4523 // the initializers.
4524 if ((*Sub)->IsExplicit)
4525 continue;
4526
4527 if (Visited.insert(*Sub).second)
4528 Stack.push_back(*Sub);
4529 }
4530 }
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004531 break;
David Blaikie0e716b42014-03-03 23:48:23 +00004532 }
4533
Richard Smith8df390f2016-09-08 23:14:54 +00004534 case Decl::Export:
4535 EmitDeclContext(cast<ExportDecl>(D));
4536 break;
4537
Alexey Bataev97720002014-11-11 04:05:39 +00004538 case Decl::OMPThreadPrivate:
4539 EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
4540 break;
4541
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00004542 case Decl::OMPDeclareReduction:
4543 EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(D));
4544 break;
4545
Mike Stump11289f42009-09-09 15:08:12 +00004546 default:
Mike Stump18bb9282009-05-16 07:57:57 +00004547 // Make sure we handled everything we should, every other kind is a
4548 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
4549 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004550 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
Richard Smitha634ff22014-12-01 18:59:10 +00004551 break;
Daniel Dunbarfce4be82008-08-15 23:26:23 +00004552 }
4553}
John McCall09ae0322010-07-06 23:57:41 +00004554
Alex Lorenzee024992014-08-04 18:41:51 +00004555void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) {
4556 // Do we need to generate coverage mapping?
4557 if (!CodeGenOpts.CoverageMapping)
4558 return;
4559 switch (D->getKind()) {
4560 case Decl::CXXConversion:
4561 case Decl::CXXMethod:
4562 case Decl::Function:
4563 case Decl::ObjCMethod:
4564 case Decl::CXXConstructor:
4565 case Decl::CXXDestructor: {
Justin Bogner203f0922015-07-28 00:41:51 +00004566 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
Alex Lorenzee024992014-08-04 18:41:51 +00004567 return;
Vedant Kumar0acf3432017-09-22 18:23:04 +00004568 SourceManager &SM = getContext().getSourceManager();
4569 if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getLocStart()))
4570 return;
Alex Lorenzee024992014-08-04 18:41:51 +00004571 auto I = DeferredEmptyCoverageMappingDecls.find(D);
4572 if (I == DeferredEmptyCoverageMappingDecls.end())
4573 DeferredEmptyCoverageMappingDecls[D] = true;
4574 break;
4575 }
4576 default:
4577 break;
4578 };
4579}
4580
4581void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) {
4582 // Do we need to generate coverage mapping?
4583 if (!CodeGenOpts.CoverageMapping)
4584 return;
4585 if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
4586 if (Fn->isTemplateInstantiation())
4587 ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
4588 }
4589 auto I = DeferredEmptyCoverageMappingDecls.find(D);
4590 if (I == DeferredEmptyCoverageMappingDecls.end())
4591 DeferredEmptyCoverageMappingDecls[D] = false;
4592 else
4593 I->second = false;
4594}
4595
4596void CodeGenModule::EmitDeferredUnusedCoverageMappings() {
Eli Friedman8516b7f2017-12-19 01:54:09 +00004597 // We call takeVector() here to avoid use-after-free.
4598 // FIXME: DeferredEmptyCoverageMappingDecls is getting mutated because
4599 // we deserialize function bodies to emit coverage info for them, and that
4600 // deserializes more declarations. How should we handle that case?
4601 for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
Eli Friedmandbcfade2017-12-13 00:14:17 +00004602 if (!Entry.second)
Alex Lorenzee024992014-08-04 18:41:51 +00004603 continue;
Eli Friedmandbcfade2017-12-13 00:14:17 +00004604 const Decl *D = Entry.first;
Alex Lorenzee024992014-08-04 18:41:51 +00004605 switch (D->getKind()) {
4606 case Decl::CXXConversion:
4607 case Decl::CXXMethod:
4608 case Decl::Function:
4609 case Decl::ObjCMethod: {
4610 CodeGenPGO PGO(*this);
4611 GlobalDecl GD(cast<FunctionDecl>(D));
4612 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4613 getFunctionLinkage(GD));
4614 break;
4615 }
4616 case Decl::CXXConstructor: {
4617 CodeGenPGO PGO(*this);
4618 GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
4619 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4620 getFunctionLinkage(GD));
4621 break;
4622 }
4623 case Decl::CXXDestructor: {
4624 CodeGenPGO PGO(*this);
4625 GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
4626 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4627 getFunctionLinkage(GD));
4628 break;
4629 }
4630 default:
4631 break;
4632 };
4633 }
4634}
4635
John McCall09ae0322010-07-06 23:57:41 +00004636/// Turns the given pointer into a constant.
4637static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
4638 const void *Ptr) {
4639 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2192fe52011-07-18 04:24:23 +00004640 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall09ae0322010-07-06 23:57:41 +00004641 return llvm::ConstantInt::get(i64, PtrInt);
4642}
4643
4644static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
4645 llvm::NamedMDNode *&GlobalMetadata,
4646 GlobalDecl D,
4647 llvm::GlobalValue *Addr) {
4648 if (!GlobalMetadata)
4649 GlobalMetadata =
4650 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
4651
4652 // TODO: should we report variant information for ctors/dtors?
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004653 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
4654 llvm::ConstantAsMetadata::get(GetPointerConstant(
4655 CGM.getLLVMContext(), D.getDecl()))};
Jay Foadea324f12011-04-21 19:59:12 +00004656 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall09ae0322010-07-06 23:57:41 +00004657}
4658
Richard Smithdf931ce2013-04-06 05:00:46 +00004659/// For each function which is declared within an extern "C" region and marked
4660/// as 'used', but has internal linkage, create an alias from the unmangled
4661/// name to the mangled name if possible. People expect to be able to refer
4662/// to such functions with an unmangled name from inline assembly within the
4663/// same translation unit.
4664void CodeGenModule::EmitStaticExternCAliases() {
Justin Lebarcd2f6bb2016-01-25 22:36:37 +00004665 // Don't do anything if we're generating CUDA device code -- the NVPTX
4666 // assembly target doesn't support aliases.
4667 if (Context.getTargetInfo().getTriple().isNVPTX())
4668 return;
Yaron Kerenb54db522015-06-11 12:33:25 +00004669 for (auto &I : StaticExternCValues) {
4670 IdentifierInfo *Name = I.first;
4671 llvm::GlobalValue *Val = I.second;
Richard Smith85465e62013-04-06 07:07:44 +00004672 if (Val && !getModule().getNamedValue(Name->getName()))
Rafael Espindola27c60b52014-06-03 02:42:01 +00004673 addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val));
Richard Smith85465e62013-04-06 07:07:44 +00004674 }
Richard Smithdf931ce2013-04-06 05:00:46 +00004675}
4676
Alp Tokerfb8d02b2014-06-05 22:10:59 +00004677bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
4678 GlobalDecl &Result) const {
4679 auto Res = Manglings.find(MangledName);
4680 if (Res == Manglings.end())
4681 return false;
4682 Result = Res->getValue();
4683 return true;
4684}
4685
John McCall09ae0322010-07-06 23:57:41 +00004686/// Emits metadata nodes associating all the global values in the
4687/// current module with the Decls they came from. This is useful for
4688/// projects using IR gen as a subroutine.
4689///
4690/// Since there's currently no way to associate an MDNode directly
4691/// with an llvm::GlobalValue, we create a global named metadata
4692/// with the name 'clang.global.decl.ptrs'.
4693void CodeGenModule::EmitDeclMetadata() {
Craig Topper8a13c412014-05-21 05:09:00 +00004694 llvm::NamedMDNode *GlobalMetadata = nullptr;
John McCall09ae0322010-07-06 23:57:41 +00004695
Robert Lytton5b88f78f2014-07-03 09:30:29 +00004696 for (auto &I : MangledDeclNames) {
4697 llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
Keno Fischer0e2d4222015-11-05 23:18:44 +00004698 // Some mangled names don't necessarily have an associated GlobalValue
4699 // in this module, e.g. if we mangled it for DebugInfo.
4700 if (Addr)
4701 EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
John McCall09ae0322010-07-06 23:57:41 +00004702 }
4703}
4704
4705/// Emits metadata nodes for all the local variables in the current
4706/// function.
4707void CodeGenFunction::EmitDeclMetadata() {
4708 if (LocalDeclMap.empty()) return;
4709
4710 llvm::LLVMContext &Context = getLLVMContext();
4711
4712 // Find the unique metadata ID for this name.
4713 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
4714
Craig Topper8a13c412014-05-21 05:09:00 +00004715 llvm::NamedMDNode *GlobalMetadata = nullptr;
John McCall09ae0322010-07-06 23:57:41 +00004716
Robert Lytton5b88f78f2014-07-03 09:30:29 +00004717 for (auto &I : LocalDeclMap) {
4718 const Decl *D = I.first;
John McCall7f416cc2015-09-08 08:05:57 +00004719 llvm::Value *Addr = I.second.getPointer();
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004720 if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
John McCall09ae0322010-07-06 23:57:41 +00004721 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004722 Alloca->setMetadata(
4723 DeclPtrKind, llvm::MDNode::get(
4724 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
Rafael Espindola2ae250c2014-05-09 00:08:36 +00004725 } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
John McCall09ae0322010-07-06 23:57:41 +00004726 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
4727 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
4728 }
4729 }
4730}
Daniel Dunbar900546d2010-07-16 00:00:15 +00004731
Rafael Espindola3bfa4682013-10-16 19:28:50 +00004732void CodeGenModule::EmitVersionIdentMetadata() {
4733 llvm::NamedMDNode *IdentMetadata =
4734 TheModule.getOrInsertNamedMetadata("llvm.ident");
4735 std::string Version = getClangFullVersion();
4736 llvm::LLVMContext &Ctx = TheModule.getContext();
4737
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004738 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
Rafael Espindola3bfa4682013-10-16 19:28:50 +00004739 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
4740}
4741
Robert Lytton57765d52014-07-03 09:30:33 +00004742void CodeGenModule::EmitTargetMetadata() {
Richard Smith1ba0a072014-08-01 20:39:36 +00004743 // Warning, new MangledDeclNames may be appended within this loop.
4744 // We rely on MapVector insertions adding new elements to the end
4745 // of the container.
4746 // FIXME: Move this loop into the one target that needs it, and only
4747 // loop over those declarations for which we couldn't emit the target
4748 // metadata when we emitted the declaration.
4749 for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
Richard Smith570706d2014-08-01 22:17:28 +00004750 auto Val = *(MangledDeclNames.begin() + I);
Richard Smith1ba0a072014-08-01 20:39:36 +00004751 const Decl *D = Val.first.getDecl()->getMostRecentDecl();
4752 llvm::GlobalValue *GV = GetGlobalValue(Val.second);
Robert Lytton57765d52014-07-03 09:30:33 +00004753 getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
4754 }
4755}
4756
Nick Lewycky85c011d2011-05-05 00:08:20 +00004757void CodeGenModule::EmitCoverageFile() {
Nick Lewycky97e49ac2016-08-31 23:04:32 +00004758 if (getCodeGenOpts().CoverageDataFile.empty() &&
4759 getCodeGenOpts().CoverageNotesFile.empty())
4760 return;
4761
4762 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu");
4763 if (!CUNode)
4764 return;
4765
4766 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
4767 llvm::LLVMContext &Ctx = TheModule.getContext();
4768 auto *CoverageDataFile =
4769 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile);
4770 auto *CoverageNotesFile =
4771 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile);
4772 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
4773 llvm::MDNode *CU = CUNode->getOperand(i);
4774 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
4775 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
Nick Lewycky480cb992011-05-04 20:46:58 +00004776 }
4777}
Nico Webercf4ff5862012-10-11 10:13:44 +00004778
Nico Weber17d3a2c2014-09-08 16:26:36 +00004779llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
Nico Webercf4ff5862012-10-11 10:13:44 +00004780 // Sema has checked that all uuid strings are of the form
4781 // "12345678-1234-1234-1234-1234567890ab".
4782 assert(Uuid.size() == 36);
David Majnemerbbecd092013-08-15 19:59:14 +00004783 for (unsigned i = 0; i < 36; ++i) {
4784 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
4785 else assert(isHexDigit(Uuid[i]));
Nico Webercf4ff5862012-10-11 10:13:44 +00004786 }
Nico Webercf4ff5862012-10-11 10:13:44 +00004787
Nico Weberdfa274e2014-09-08 16:11:15 +00004788 // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
David Majnemerbbecd092013-08-15 19:59:14 +00004789 const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
Nico Webercf4ff5862012-10-11 10:13:44 +00004790
David Majnemerbbecd092013-08-15 19:59:14 +00004791 llvm::Constant *Field3[8];
4792 for (unsigned Idx = 0; Idx < 8; ++Idx)
4793 Field3[Idx] = llvm::ConstantInt::get(
4794 Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
4795
4796 llvm::Constant *Fields[4] = {
4797 llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16),
4798 llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16),
4799 llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
4800 llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
4801 };
4802
4803 return llvm::ConstantStruct::getAnon(Fields);
Nico Webercf4ff5862012-10-11 10:13:44 +00004804}
David Majnemere2cb8d12014-07-07 06:20:47 +00004805
4806llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty,
4807 bool ForEH) {
4808 // Return a bogus pointer if RTTI is disabled, unless it's for EH.
4809 // FIXME: should we even be calling this method if RTTI is disabled
4810 // and it's not for EH?
4811 if (!ForEH && !getLangOpts().RTTI)
4812 return llvm::Constant::getNullValue(Int8PtrTy);
Jake Ehrlichc451cf22017-11-11 01:15:41 +00004813
David Majnemere2cb8d12014-07-07 06:20:47 +00004814 if (ForEH && Ty->isObjCObjectPointerType() &&
4815 LangOpts.ObjCRuntime.isGNUFamily())
4816 return ObjCRuntime->GetEHType(Ty);
4817
David Majnemer443250f2015-03-17 20:35:00 +00004818 return getCXXABI().getAddrOfRTTIDescriptor(Ty);
David Majnemere2cb8d12014-07-07 06:20:47 +00004819}
4820
Alexey Bataev97720002014-11-11 04:05:39 +00004821void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
Alexey Bataeva8a9153a2017-12-29 18:07:07 +00004822 // Do not emit threadprivates in simd-only mode.
4823 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
4824 return;
Alexey Bataev97720002014-11-11 04:05:39 +00004825 for (auto RefExpr : D->varlists()) {
4826 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
4827 bool PerformInit =
4828 VD->getAnyInitializer() &&
4829 !VD->getAnyInitializer()->isConstantInitializer(getContext(),
4830 /*ForRef=*/false);
John McCall7f416cc2015-09-08 08:05:57 +00004831
4832 Address Addr(GetAddrOfGlobalVar(VD), getContext().getDeclAlign(VD));
Alexey Bataev3eff5f42015-02-25 08:32:46 +00004833 if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
John McCall7f416cc2015-09-08 08:05:57 +00004834 VD, Addr, RefExpr->getLocStart(), PerformInit))
Alexey Bataev97720002014-11-11 04:05:39 +00004835 CXXGlobalInits.push_back(InitFunction);
4836 }
4837}
Peter Collingbourne86d34a72015-06-17 19:08:05 +00004838
Peter Collingbourne25a80bf2015-09-08 23:01:30 +00004839llvm::Metadata *CodeGenModule::CreateMetadataIdentifierForType(QualType T) {
4840 llvm::Metadata *&InternalId = MetadataIdMap[T.getCanonicalType()];
4841 if (InternalId)
4842 return InternalId;
4843
4844 if (isExternallyVisible(T->getLinkage())) {
4845 std::string OutName;
4846 llvm::raw_string_ostream Out(OutName);
4847 getCXXABI().getMangleContext().mangleTypeName(T, Out);
4848
4849 InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
4850 } else {
4851 InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
4852 llvm::ArrayRef<llvm::Metadata *>());
4853 }
4854
4855 return InternalId;
4856}
4857
Vlad Tsyrklevich634c6012017-10-31 22:39:44 +00004858// Generalize pointer types to a void pointer with the qualifiers of the
4859// originally pointed-to type, e.g. 'const char *' and 'char * const *'
4860// generalize to 'const void *' while 'char *' and 'const char **' generalize to
4861// 'void *'.
4862static QualType GeneralizeType(ASTContext &Ctx, QualType Ty) {
4863 if (!Ty->isPointerType())
4864 return Ty;
4865
4866 return Ctx.getPointerType(
4867 QualType(Ctx.VoidTy).withCVRQualifiers(
4868 Ty->getPointeeType().getCVRQualifiers()));
4869}
4870
4871// Apply type generalization to a FunctionType's return and argument types
4872static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty) {
4873 if (auto *FnType = Ty->getAs<FunctionProtoType>()) {
4874 SmallVector<QualType, 8> GeneralizedParams;
4875 for (auto &Param : FnType->param_types())
4876 GeneralizedParams.push_back(GeneralizeType(Ctx, Param));
4877
4878 return Ctx.getFunctionType(
4879 GeneralizeType(Ctx, FnType->getReturnType()),
4880 GeneralizedParams, FnType->getExtProtoInfo());
4881 }
4882
4883 if (auto *FnType = Ty->getAs<FunctionNoProtoType>())
4884 return Ctx.getFunctionNoProtoType(
4885 GeneralizeType(Ctx, FnType->getReturnType()));
4886
4887 llvm_unreachable("Encountered unknown FunctionType");
4888}
4889
4890llvm::Metadata *CodeGenModule::CreateMetadataIdentifierGeneralized(QualType T) {
4891 T = GeneralizeFunctionType(getContext(), T);
4892
4893 llvm::Metadata *&InternalId = GeneralizedMetadataIdMap[T.getCanonicalType()];
4894 if (InternalId)
4895 return InternalId;
4896
4897 if (isExternallyVisible(T->getLinkage())) {
4898 std::string OutName;
4899 llvm::raw_string_ostream Out(OutName);
4900 getCXXABI().getMangleContext().mangleTypeName(T, Out);
4901 Out << ".generalized";
4902
4903 InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
4904 } else {
4905 InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
4906 llvm::ArrayRef<llvm::Metadata *>());
4907 }
4908
4909 return InternalId;
4910}
4911
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004912/// Returns whether this module needs the "all-vtables" type identifier.
4913bool CodeGenModule::NeedAllVtablesTypeId() const {
Evgeniy Stepanovf31ea302016-02-03 22:18:55 +00004914 // Returns true if at least one of vtable-based CFI checkers is enabled and
4915 // is not in the trapping mode.
4916 return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
4917 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
4918 (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
4919 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
4920 (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
4921 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
4922 (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
4923 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
4924}
4925
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004926void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable,
4927 CharUnits Offset,
4928 const CXXRecordDecl *RD) {
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00004929 llvm::Metadata *MD =
4930 CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004931 VTable->addTypeMetadata(Offset.getQuantity(), MD);
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00004932
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004933 if (CodeGenOpts.SanitizeCfiCrossDso)
4934 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
4935 VTable->addTypeMetadata(Offset.getQuantity(),
4936 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
Evgeniy Stepanovf31ea302016-02-03 22:18:55 +00004937
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004938 if (NeedAllVtablesTypeId()) {
Evgeniy Stepanovf31ea302016-02-03 22:18:55 +00004939 llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables");
Peter Collingbourne8dd14da2016-06-24 21:21:46 +00004940 VTable->addTypeMetadata(Offset.getQuantity(), MD);
Evgeniy Stepanovf31ea302016-02-03 22:18:55 +00004941 }
Peter Collingbourne86d34a72015-06-17 19:08:05 +00004942}
Eric Christopher2b90a642015-11-11 23:05:08 +00004943
4944// Fills in the supplied string map with the set of target features for the
4945// passed in function.
4946void CodeGenModule::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
4947 const FunctionDecl *FD) {
4948 StringRef TargetCPU = Target.getTargetOpts().CPU;
4949 if (const auto *TD = FD->getAttr<TargetAttr>()) {
4950 // If we have a TargetAttr build up the feature map based on that.
4951 TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
4952
Erich Keanecf8807c2017-10-27 18:32:23 +00004953 ParsedAttr.Features.erase(
4954 llvm::remove_if(ParsedAttr.Features,
4955 [&](const std::string &Feat) {
4956 return !Target.isValidFeatureName(
4957 StringRef{Feat}.substr(1));
4958 }),
4959 ParsedAttr.Features.end());
4960
Eric Christopher2b90a642015-11-11 23:05:08 +00004961 // Make a copy of the features as passed on the command line into the
4962 // beginning of the additional features from the function to override.
Erich Keaneb0d44232017-07-18 20:41:02 +00004963 ParsedAttr.Features.insert(ParsedAttr.Features.begin(),
Eric Christopher2b90a642015-11-11 23:05:08 +00004964 Target.getTargetOpts().FeaturesAsWritten.begin(),
4965 Target.getTargetOpts().FeaturesAsWritten.end());
4966
Erich Keanecf8807c2017-10-27 18:32:23 +00004967 if (ParsedAttr.Architecture != "" &&
4968 Target.isValidCPUName(ParsedAttr.Architecture))
4969 TargetCPU = ParsedAttr.Architecture;
Eric Christopher2b90a642015-11-11 23:05:08 +00004970
4971 // Now populate the feature map, first with the TargetCPU which is either
4972 // the default or a new one from the target attribute string. Then we'll use
4973 // the passed in features (FeaturesAsWritten) along with the new ones from
4974 // the attribute.
Erich Keaneb0d44232017-07-18 20:41:02 +00004975 Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
4976 ParsedAttr.Features);
Eric Christopher2b90a642015-11-11 23:05:08 +00004977 } else {
4978 Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
4979 Target.getTargetOpts().Features);
4980 }
4981}
Peter Collingbournedc134532016-01-16 00:31:22 +00004982
4983llvm::SanitizerStatReport &CodeGenModule::getSanStats() {
4984 if (!SanStats)
4985 SanStats = llvm::make_unique<llvm::SanitizerStatReport>(&getModule());
4986
4987 return *SanStats;
4988}
Yaxun Liu0bc4b2d2016-07-28 19:26:30 +00004989llvm::Value *
4990CodeGenModule::createOpenCLIntToSamplerConversion(const Expr *E,
4991 CodeGenFunction &CGF) {
John McCallde0fe072017-08-15 21:42:52 +00004992 llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType());
Sven van Haastregtefb4d4c2017-08-15 09:38:18 +00004993 auto SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr());
Yaxun Liu0bc4b2d2016-07-28 19:26:30 +00004994 auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
4995 return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,
4996 "__translate_sampler_initializer"),
4997 {C});
4998}