1 //===-- llvm/Target/TargetLoweringObjectFile.cpp - Object File Info -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements classes used to handle lowerings specific to common
10 // object file formats.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/Target/TargetLoweringObjectFile.h"
15 #include "llvm/BinaryFormat/Dwarf.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DataLayout.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/GlobalVariable.h"
21 #include "llvm/IR/Mangler.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCContext.h"
25 #include "llvm/MC/MCExpr.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/MC/SectionKind.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetOptions.h"
33 using namespace llvm;
34
35 //===----------------------------------------------------------------------===//
36 // Generic Code
37 //===----------------------------------------------------------------------===//
38
39 /// Initialize - this method must be called before any actual lowering is
40 /// done. This specifies the current context for codegen, and gives the
41 /// lowering implementations a chance to set up their default sections.
Initialize(MCContext & ctx,const TargetMachine & TM)42 void TargetLoweringObjectFile::Initialize(MCContext &ctx,
43 const TargetMachine &TM) {
44 // `Initialize` can be called more than once.
45 delete Mang;
46 Mang = new Mangler();
47 initMCObjectFileInfo(ctx, TM.isPositionIndependent(),
48 TM.getCodeModel() == CodeModel::Large);
49
50 // Reset various EH DWARF encodings.
51 PersonalityEncoding = LSDAEncoding = TTypeEncoding = dwarf::DW_EH_PE_absptr;
52 CallSiteEncoding = dwarf::DW_EH_PE_uleb128;
53
54 this->TM = &TM;
55 }
56
~TargetLoweringObjectFile()57 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
58 delete Mang;
59 }
60
getCallSiteEncoding() const61 unsigned TargetLoweringObjectFile::getCallSiteEncoding() const {
62 // If target does not have LEB128 directives, we would need the
63 // call site encoding to be udata4 so that the alternative path
64 // for not having LEB128 directives could work.
65 if (!getContext().getAsmInfo()->hasLEB128Directives())
66 return dwarf::DW_EH_PE_udata4;
67 return CallSiteEncoding;
68 }
69
isNullOrUndef(const Constant * C)70 static bool isNullOrUndef(const Constant *C) {
71 // Check that the constant isn't all zeros or undefs.
72 if (C->isNullValue() || isa<UndefValue>(C))
73 return true;
74 if (!isa<ConstantAggregate>(C))
75 return false;
76 for (auto Operand : C->operand_values()) {
77 if (!isNullOrUndef(cast<Constant>(Operand)))
78 return false;
79 }
80 return true;
81 }
82
isSuitableForBSS(const GlobalVariable * GV)83 static bool isSuitableForBSS(const GlobalVariable *GV) {
84 const Constant *C = GV->getInitializer();
85
86 // Must have zero initializer.
87 if (!isNullOrUndef(C))
88 return false;
89
90 // Leave constant zeros in readonly constant sections, so they can be shared.
91 if (GV->isConstant())
92 return false;
93
94 // If the global has an explicit section specified, don't put it in BSS.
95 if (GV->hasSection())
96 return false;
97
98 // Otherwise, put it in BSS!
99 return true;
100 }
101
102 /// IsNullTerminatedString - Return true if the specified constant (which is
103 /// known to have a type that is an array of 1/2/4 byte elements) ends with a
104 /// nul value and contains no other nuls in it. Note that this is more general
105 /// than ConstantDataSequential::isString because we allow 2 & 4 byte strings.
IsNullTerminatedString(const Constant * C)106 static bool IsNullTerminatedString(const Constant *C) {
107 // First check: is we have constant array terminated with zero
108 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) {
109 unsigned NumElts = CDS->getNumElements();
110 assert(NumElts != 0 && "Can't have an empty CDS");
111
112 if (CDS->getElementAsInteger(NumElts-1) != 0)
113 return false; // Not null terminated.
114
115 // Verify that the null doesn't occur anywhere else in the string.
116 for (unsigned i = 0; i != NumElts-1; ++i)
117 if (CDS->getElementAsInteger(i) == 0)
118 return false;
119 return true;
120 }
121
122 // Another possibility: [1 x i8] zeroinitializer
123 if (isa<ConstantAggregateZero>(C))
124 return cast<ArrayType>(C->getType())->getNumElements() == 1;
125
126 return false;
127 }
128
getSymbolWithGlobalValueBase(const GlobalValue * GV,StringRef Suffix,const TargetMachine & TM) const129 MCSymbol *TargetLoweringObjectFile::getSymbolWithGlobalValueBase(
130 const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const {
131 assert(!Suffix.empty());
132
133 SmallString<60> NameStr;
134 NameStr += GV->getParent()->getDataLayout().getPrivateGlobalPrefix();
135 TM.getNameWithPrefix(NameStr, GV, *Mang);
136 NameStr.append(Suffix.begin(), Suffix.end());
137 return getContext().getOrCreateSymbol(NameStr);
138 }
139
getCFIPersonalitySymbol(const GlobalValue * GV,const TargetMachine & TM,MachineModuleInfo * MMI) const140 MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol(
141 const GlobalValue *GV, const TargetMachine &TM,
142 MachineModuleInfo *MMI) const {
143 return TM.getSymbol(GV);
144 }
145
emitPersonalityValue(MCStreamer & Streamer,const DataLayout &,const MCSymbol * Sym) const146 void TargetLoweringObjectFile::emitPersonalityValue(MCStreamer &Streamer,
147 const DataLayout &,
148 const MCSymbol *Sym) const {
149 }
150
emitCGProfileMetadata(MCStreamer & Streamer,Module & M) const151 void TargetLoweringObjectFile::emitCGProfileMetadata(MCStreamer &Streamer,
152 Module &M) const {
153 MCContext &C = getContext();
154 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
155 M.getModuleFlagsMetadata(ModuleFlags);
156
157 MDNode *CFGProfile = nullptr;
158
159 for (const auto &MFE : ModuleFlags) {
160 StringRef Key = MFE.Key->getString();
161 if (Key == "CG Profile") {
162 CFGProfile = cast<MDNode>(MFE.Val);
163 break;
164 }
165 }
166
167 if (!CFGProfile)
168 return;
169
170 auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
171 if (!MDO)
172 return nullptr;
173 auto *V = cast<ValueAsMetadata>(MDO);
174 const Function *F = cast<Function>(V->getValue()->stripPointerCasts());
175 if (F->hasDLLImportStorageClass())
176 return nullptr;
177 return TM->getSymbol(F);
178 };
179
180 for (const auto &Edge : CFGProfile->operands()) {
181 MDNode *E = cast<MDNode>(Edge);
182 const MCSymbol *From = GetSym(E->getOperand(0));
183 const MCSymbol *To = GetSym(E->getOperand(1));
184 // Skip null functions. This can happen if functions are dead stripped after
185 // the CGProfile pass has been run.
186 if (!From || !To)
187 continue;
188 uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
189 ->getValue()
190 ->getUniqueInteger()
191 .getZExtValue();
192 Streamer.emitCGProfileEntry(
193 MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C),
194 MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count);
195 }
196 }
197
198 /// getKindForGlobal - This is a top-level target-independent classifier for
199 /// a global object. Given a global variable and information from the TM, this
200 /// function classifies the global in a target independent manner. This function
201 /// may be overridden by the target implementation.
getKindForGlobal(const GlobalObject * GO,const TargetMachine & TM)202 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
203 const TargetMachine &TM){
204 assert(!GO->isDeclarationForLinker() &&
205 "Can only be used for global definitions");
206
207 // Functions are classified as text sections.
208 if (isa<Function>(GO))
209 return SectionKind::getText();
210
211 // Basic blocks are classified as text sections.
212 if (isa<BasicBlock>(GO))
213 return SectionKind::getText();
214
215 // Global variables require more detailed analysis.
216 const auto *GVar = cast<GlobalVariable>(GO);
217
218 // Handle thread-local data first.
219 if (GVar->isThreadLocal()) {
220 if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) {
221 // Zero-initialized TLS variables with local linkage always get classified
222 // as ThreadBSSLocal.
223 if (GVar->hasLocalLinkage()) {
224 return SectionKind::getThreadBSSLocal();
225 }
226 return SectionKind::getThreadBSS();
227 }
228 return SectionKind::getThreadData();
229 }
230
231 // Variables with common linkage always get classified as common.
232 if (GVar->hasCommonLinkage())
233 return SectionKind::getCommon();
234
235 // Most non-mergeable zero data can be put in the BSS section unless otherwise
236 // specified.
237 if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) {
238 if (GVar->hasLocalLinkage())
239 return SectionKind::getBSSLocal();
240 else if (GVar->hasExternalLinkage())
241 return SectionKind::getBSSExtern();
242 return SectionKind::getBSS();
243 }
244
245 // If the global is marked constant, we can put it into a mergable section,
246 // a mergable string section, or general .data if it contains relocations.
247 if (GVar->isConstant()) {
248 // If the initializer for the global contains something that requires a
249 // relocation, then we may have to drop this into a writable data section
250 // even though it is marked const.
251 const Constant *C = GVar->getInitializer();
252 if (!C->needsRelocation()) {
253 // If the global is required to have a unique address, it can't be put
254 // into a mergable section: just drop it into the general read-only
255 // section instead.
256 if (!GVar->hasGlobalUnnamedAddr())
257 return SectionKind::getReadOnly();
258
259 // If initializer is a null-terminated string, put it in a "cstring"
260 // section of the right width.
261 if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
262 if (IntegerType *ITy =
263 dyn_cast<IntegerType>(ATy->getElementType())) {
264 if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
265 ITy->getBitWidth() == 32) &&
266 IsNullTerminatedString(C)) {
267 if (ITy->getBitWidth() == 8)
268 return SectionKind::getMergeable1ByteCString();
269 if (ITy->getBitWidth() == 16)
270 return SectionKind::getMergeable2ByteCString();
271
272 assert(ITy->getBitWidth() == 32 && "Unknown width");
273 return SectionKind::getMergeable4ByteCString();
274 }
275 }
276 }
277
278 // Otherwise, just drop it into a mergable constant section. If we have
279 // a section for this size, use it, otherwise use the arbitrary sized
280 // mergable section.
281 switch (
282 GVar->getParent()->getDataLayout().getTypeAllocSize(C->getType())) {
283 case 4: return SectionKind::getMergeableConst4();
284 case 8: return SectionKind::getMergeableConst8();
285 case 16: return SectionKind::getMergeableConst16();
286 case 32: return SectionKind::getMergeableConst32();
287 default:
288 return SectionKind::getReadOnly();
289 }
290
291 } else {
292 // In static, ROPI and RWPI relocation models, the linker will resolve
293 // all addresses, so the relocation entries will actually be constants by
294 // the time the app starts up. However, we can't put this into a
295 // mergable section, because the linker doesn't take relocations into
296 // consideration when it tries to merge entries in the section.
297 Reloc::Model ReloModel = TM.getRelocationModel();
298 if (ReloModel == Reloc::Static || ReloModel == Reloc::ROPI ||
299 ReloModel == Reloc::RWPI || ReloModel == Reloc::ROPI_RWPI ||
300 !C->needsDynamicRelocation())
301 return SectionKind::getReadOnly();
302
303 // Otherwise, the dynamic linker needs to fix it up, put it in the
304 // writable data.rel section.
305 return SectionKind::getReadOnlyWithRel();
306 }
307 }
308
309 // Okay, this isn't a constant.
310 return SectionKind::getData();
311 }
312
313 /// This method computes the appropriate section to emit the specified global
314 /// variable or function definition. This should not be passed external (or
315 /// available externally) globals.
SectionForGlobal(const GlobalObject * GO,SectionKind Kind,const TargetMachine & TM) const316 MCSection *TargetLoweringObjectFile::SectionForGlobal(
317 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
318 // Select section name.
319 if (GO->hasSection())
320 return getExplicitSectionGlobal(GO, Kind, TM);
321
322 if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
323 auto Attrs = GVar->getAttributes();
324 if ((Attrs.hasAttribute("bss-section") && Kind.isBSS()) ||
325 (Attrs.hasAttribute("data-section") && Kind.isData()) ||
326 (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) ||
327 (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly())) {
328 return getExplicitSectionGlobal(GO, Kind, TM);
329 }
330 }
331
332 if (auto *F = dyn_cast<Function>(GO)) {
333 if (F->hasFnAttribute("implicit-section-name"))
334 return getExplicitSectionGlobal(GO, Kind, TM);
335 }
336
337 // Use default section depending on the 'type' of global
338 return SelectSectionForGlobal(GO, Kind, TM);
339 }
340
341 /// This method computes the appropriate section to emit the specified global
342 /// variable or function definition. This should not be passed external (or
343 /// available externally) globals.
344 MCSection *
SectionForGlobal(const GlobalObject * GO,const TargetMachine & TM) const345 TargetLoweringObjectFile::SectionForGlobal(const GlobalObject *GO,
346 const TargetMachine &TM) const {
347 return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
348 }
349
getSectionForJumpTable(const Function & F,const TargetMachine & TM) const350 MCSection *TargetLoweringObjectFile::getSectionForJumpTable(
351 const Function &F, const TargetMachine &TM) const {
352 Align Alignment(1);
353 return getSectionForConstant(F.getParent()->getDataLayout(),
354 SectionKind::getReadOnly(), /*C=*/nullptr,
355 Alignment);
356 }
357
shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,const Function & F) const358 bool TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection(
359 bool UsesLabelDifference, const Function &F) const {
360 // In PIC mode, we need to emit the jump table to the same section as the
361 // function body itself, otherwise the label differences won't make sense.
362 // FIXME: Need a better predicate for this: what about custom entries?
363 if (UsesLabelDifference)
364 return true;
365
366 // We should also do if the section name is NULL or function is declared
367 // in discardable section
368 // FIXME: this isn't the right predicate, should be based on the MCSection
369 // for the function.
370 return F.isWeakForLinker();
371 }
372
373 /// Given a mergable constant with the specified size and relocation
374 /// information, return a section that it should be placed in.
getSectionForConstant(const DataLayout & DL,SectionKind Kind,const Constant * C,Align & Alignment) const375 MCSection *TargetLoweringObjectFile::getSectionForConstant(
376 const DataLayout &DL, SectionKind Kind, const Constant *C,
377 Align &Alignment) const {
378 if (Kind.isReadOnly() && ReadOnlySection != nullptr)
379 return ReadOnlySection;
380
381 return DataSection;
382 }
383
getSectionForMachineBasicBlock(const Function & F,const MachineBasicBlock & MBB,const TargetMachine & TM) const384 MCSection *TargetLoweringObjectFile::getSectionForMachineBasicBlock(
385 const Function &F, const MachineBasicBlock &MBB,
386 const TargetMachine &TM) const {
387 return nullptr;
388 }
389
getUniqueSectionForFunction(const Function & F,const TargetMachine & TM) const390 MCSection *TargetLoweringObjectFile::getUniqueSectionForFunction(
391 const Function &F, const TargetMachine &TM) const {
392 return nullptr;
393 }
394
395 /// getTTypeGlobalReference - Return an MCExpr to use for a
396 /// reference to the specified global variable from exception
397 /// handling information.
getTTypeGlobalReference(const GlobalValue * GV,unsigned Encoding,const TargetMachine & TM,MachineModuleInfo * MMI,MCStreamer & Streamer) const398 const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference(
399 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
400 MachineModuleInfo *MMI, MCStreamer &Streamer) const {
401 const MCSymbolRefExpr *Ref =
402 MCSymbolRefExpr::create(TM.getSymbol(GV), getContext());
403
404 return getTTypeReference(Ref, Encoding, Streamer);
405 }
406
407 const MCExpr *TargetLoweringObjectFile::
getTTypeReference(const MCSymbolRefExpr * Sym,unsigned Encoding,MCStreamer & Streamer) const408 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
409 MCStreamer &Streamer) const {
410 switch (Encoding & 0x70) {
411 default:
412 report_fatal_error("We do not support this DWARF encoding yet!");
413 case dwarf::DW_EH_PE_absptr:
414 // Do nothing special
415 return Sym;
416 case dwarf::DW_EH_PE_pcrel: {
417 // Emit a label to the streamer for the current position. This gives us
418 // .-foo addressing.
419 MCSymbol *PCSym = getContext().createTempSymbol();
420 Streamer.emitLabel(PCSym);
421 const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext());
422 return MCBinaryExpr::createSub(Sym, PC, getContext());
423 }
424 }
425 }
426
getDebugThreadLocalSymbol(const MCSymbol * Sym) const427 const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol *Sym) const {
428 // FIXME: It's not clear what, if any, default this should have - perhaps a
429 // null return could mean 'no location' & we should just do that here.
430 return MCSymbolRefExpr::create(Sym, getContext());
431 }
432
getNameWithPrefix(SmallVectorImpl<char> & OutName,const GlobalValue * GV,const TargetMachine & TM) const433 void TargetLoweringObjectFile::getNameWithPrefix(
434 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
435 const TargetMachine &TM) const {
436 Mang->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);
437 }
438