1	//===- llvm/CodeGen/TargetLoweringObjectFileImpl.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/CodeGen/TargetLoweringObjectFileImpl.h"
15	#include "llvm/ADT/SmallString.h"
16	#include "llvm/ADT/SmallVector.h"
17	#include "llvm/ADT/StringExtras.h"
18	#include "llvm/ADT/StringRef.h"
19	#include "llvm/BinaryFormat/COFF.h"
20	#include "llvm/BinaryFormat/Dwarf.h"
21	#include "llvm/BinaryFormat/ELF.h"
22	#include "llvm/BinaryFormat/MachO.h"
23	#include "llvm/BinaryFormat/Wasm.h"
24	#include "llvm/CodeGen/BasicBlockSectionUtils.h"
25	#include "llvm/CodeGen/MachineBasicBlock.h"
26	#include "llvm/CodeGen/MachineFunction.h"
27	#include "llvm/CodeGen/MachineModuleInfo.h"
28	#include "llvm/CodeGen/MachineModuleInfoImpls.h"
29	#include "llvm/IR/Comdat.h"
30	#include "llvm/IR/Constants.h"
31	#include "llvm/IR/DataLayout.h"
32	#include "llvm/IR/DerivedTypes.h"
33	#include "llvm/IR/DiagnosticInfo.h"
34	#include "llvm/IR/DiagnosticPrinter.h"
35	#include "llvm/IR/Function.h"
36	#include "llvm/IR/GlobalAlias.h"
37	#include "llvm/IR/GlobalObject.h"
38	#include "llvm/IR/GlobalValue.h"
39	#include "llvm/IR/GlobalVariable.h"
40	#include "llvm/IR/Mangler.h"
41	#include "llvm/IR/Metadata.h"
42	#include "llvm/IR/Module.h"
43	#include "llvm/IR/PseudoProbe.h"
44	#include "llvm/IR/Type.h"
45	#include "llvm/MC/MCAsmInfo.h"
46	#include "llvm/MC/MCContext.h"
47	#include "llvm/MC/MCExpr.h"
48	#include "llvm/MC/MCSectionCOFF.h"
49	#include "llvm/MC/MCSectionELF.h"
50	#include "llvm/MC/MCSectionGOFF.h"
51	#include "llvm/MC/MCSectionMachO.h"
52	#include "llvm/MC/MCSectionWasm.h"
53	#include "llvm/MC/MCSectionXCOFF.h"
54	#include "llvm/MC/MCStreamer.h"
55	#include "llvm/MC/MCSymbol.h"
56	#include "llvm/MC/MCSymbolELF.h"
57	#include "llvm/MC/MCValue.h"
58	#include "llvm/MC/SectionKind.h"
59	#include "llvm/ProfileData/InstrProf.h"
60	#include "llvm/Support/Base64.h"
61	#include "llvm/Support/Casting.h"
62	#include "llvm/Support/CodeGen.h"
63	#include "llvm/Support/ErrorHandling.h"
64	#include "llvm/Support/Format.h"
65	#include "llvm/Support/raw_ostream.h"
66	#include "llvm/Target/TargetMachine.h"
67	#include "llvm/TargetParser/Triple.h"
68	#include <cassert>
69	#include <string>
70
71	using namespace llvm;
72	using namespace dwarf;
73
74	static cl::opt<bool> JumpTableInFunctionSection(
75	"jumptable-in-function-section", cl::Hidden, cl::init(Val: false),
76	cl::desc("Putting Jump Table in function section"));
77
78	static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
79	StringRef &Section) {
80	SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
81	M.getModuleFlagsMetadata(Flags&: ModuleFlags);
82
83	for (const auto &MFE: ModuleFlags) {
84	// Ignore flags with 'Require' behaviour.
85	if (MFE.Behavior == Module::Require)
86	continue;
87
88	StringRef Key = MFE.Key->getString();
89	if (Key == "Objective-C Image Info Version") {
90	Version = mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue();
91	} else if (Key == "Objective-C Garbage Collection" ||
92	Key == "Objective-C GC Only" ||
93	Key == "Objective-C Is Simulated" ||
94	Key == "Objective-C Class Properties" ||
95	Key == "Objective-C Image Swift Version") {
96	Flags |= mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue();
97	} else if (Key == "Objective-C Image Info Section") {
98	Section = cast<MDString>(Val: MFE.Val)->getString();
99	}
100	// Backend generates L_OBJC_IMAGE_INFO from Swift ABI version + major + minor +
101	// "Objective-C Garbage Collection".
102	else if (Key == "Swift ABI Version") {
103	Flags |= (mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue()) << 8;
104	} else if (Key == "Swift Major Version") {
105	Flags |= (mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue()) << 24;
106	} else if (Key == "Swift Minor Version") {
107	Flags |= (mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue()) << 16;
108	}
109	}
110	}
111
112	//===----------------------------------------------------------------------===//
113	// ELF
114	//===----------------------------------------------------------------------===//
115
116	TargetLoweringObjectFileELF::TargetLoweringObjectFileELF() {
117	SupportDSOLocalEquivalentLowering = true;
118	}
119
120	void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
121	const TargetMachine &TgtM) {
122	TargetLoweringObjectFile::Initialize(ctx&: Ctx, TM: TgtM);
123
124	CodeModel::Model CM = TgtM.getCodeModel();
125	InitializeELF(UseInitArray_: TgtM.Options.UseInitArray);
126
127	switch (TgtM.getTargetTriple().getArch()) {
128	case Triple::arm:
129	case Triple::armeb:
130	case Triple::thumb:
131	case Triple::thumbeb:
132	if (Ctx.getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM)
133	break;
134	// Fallthrough if not using EHABI
135	[[fallthrough]];
136	case Triple::ppc:
137	case Triple::ppcle:
138	case Triple::x86:
139	PersonalityEncoding = isPositionIndependent()
140	? dwarf::DW_EH_PE_indirect |
141	dwarf::DW_EH_PE_pcrel |
142	dwarf::DW_EH_PE_sdata4
143	: dwarf::DW_EH_PE_absptr;
144	LSDAEncoding = isPositionIndependent()
145	? dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
146	: dwarf::DW_EH_PE_absptr;
147	TTypeEncoding = isPositionIndependent()
148	? dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
149	dwarf::DW_EH_PE_sdata4
150	: dwarf::DW_EH_PE_absptr;
151	break;
152	case Triple::x86_64:
153	if (isPositionIndependent()) {
154	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
155	((CM == CodeModel::Small || CM == CodeModel::Medium)
156	? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
157	LSDAEncoding = dwarf::DW_EH_PE_pcrel |
158	(CM == CodeModel::Small
159	? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
160	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
161	((CM == CodeModel::Small || CM == CodeModel::Medium)
162	? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
163	} else {
164	PersonalityEncoding =
165	(CM == CodeModel::Small || CM == CodeModel::Medium)
166	? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
167	LSDAEncoding = (CM == CodeModel::Small)
168	? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
169	TTypeEncoding = (CM == CodeModel::Small)
170	? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
171	}
172	break;
173	case Triple::hexagon:
174	PersonalityEncoding = dwarf::DW_EH_PE_absptr;
175	LSDAEncoding = dwarf::DW_EH_PE_absptr;
176	TTypeEncoding = dwarf::DW_EH_PE_absptr;
177	if (isPositionIndependent()) {
178	PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
179	LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
180	TTypeEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
181	}
182	break;
183	case Triple::aarch64:
184	case Triple::aarch64_be:
185	case Triple::aarch64_32:
186	// The small model guarantees static code/data size < 4GB, but not where it
187	// will be in memory. Most of these could end up >2GB away so even a signed
188	// pc-relative 32-bit address is insufficient, theoretically.
189	//
190	// Use DW_EH_PE_indirect even for -fno-pic to avoid copy relocations.
191	LSDAEncoding = dwarf::DW_EH_PE_pcrel |
192	(TgtM.getTargetTriple().getEnvironment() == Triple::GNUILP32
193	? dwarf::DW_EH_PE_sdata4
194	: dwarf::DW_EH_PE_sdata8);
195	PersonalityEncoding = LSDAEncoding | dwarf::DW_EH_PE_indirect;
196	TTypeEncoding = LSDAEncoding | dwarf::DW_EH_PE_indirect;
197	break;
198	case Triple::lanai:
199	LSDAEncoding = dwarf::DW_EH_PE_absptr;
200	PersonalityEncoding = dwarf::DW_EH_PE_absptr;
201	TTypeEncoding = dwarf::DW_EH_PE_absptr;
202	break;
203	case Triple::mips:
204	case Triple::mipsel:
205	case Triple::mips64:
206	case Triple::mips64el:
207	// MIPS uses indirect pointer to refer personality functions and types, so
208	// that the eh_frame section can be read-only. DW.ref.personality will be
209	// generated for relocation.
210	PersonalityEncoding = dwarf::DW_EH_PE_indirect;
211	// FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
212	// identify N64 from just a triple.
213	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
214	dwarf::DW_EH_PE_sdata4;
215	// We don't support PC-relative LSDA references in GAS so we use the default
216	// DW_EH_PE_absptr for those.
217
218	// FreeBSD must be explicit about the data size and using pcrel since it's
219	// assembler/linker won't do the automatic conversion that the Linux tools
220	// do.
221	if (TgtM.getTargetTriple().isOSFreeBSD()) {
222	PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
223	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
224	}
225	break;
226	case Triple::ppc64:
227	case Triple::ppc64le:
228	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
229	dwarf::DW_EH_PE_udata8;
230	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8;
231	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
232	dwarf::DW_EH_PE_udata8;
233	break;
234	case Triple::sparcel:
235	case Triple::sparc:
236	if (isPositionIndependent()) {
237	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
238	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
239	dwarf::DW_EH_PE_sdata4;
240	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
241	dwarf::DW_EH_PE_sdata4;
242	} else {
243	LSDAEncoding = dwarf::DW_EH_PE_absptr;
244	PersonalityEncoding = dwarf::DW_EH_PE_absptr;
245	TTypeEncoding = dwarf::DW_EH_PE_absptr;
246	}
247	CallSiteEncoding = dwarf::DW_EH_PE_udata4;
248	break;
249	case Triple::riscv32:
250	case Triple::riscv64:
251	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
252	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
253	dwarf::DW_EH_PE_sdata4;
254	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
255	dwarf::DW_EH_PE_sdata4;
256	CallSiteEncoding = dwarf::DW_EH_PE_udata4;
257	break;
258	case Triple::sparcv9:
259	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
260	if (isPositionIndependent()) {
261	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
262	dwarf::DW_EH_PE_sdata4;
263	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
264	dwarf::DW_EH_PE_sdata4;
265	} else {
266	PersonalityEncoding = dwarf::DW_EH_PE_absptr;
267	TTypeEncoding = dwarf::DW_EH_PE_absptr;
268	}
269	break;
270	case Triple::systemz:
271	// All currently-defined code models guarantee that 4-byte PC-relative
272	// values will be in range.
273	if (isPositionIndependent()) {
274	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
275	dwarf::DW_EH_PE_sdata4;
276	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
277	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
278	dwarf::DW_EH_PE_sdata4;
279	} else {
280	PersonalityEncoding = dwarf::DW_EH_PE_absptr;
281	LSDAEncoding = dwarf::DW_EH_PE_absptr;
282	TTypeEncoding = dwarf::DW_EH_PE_absptr;
283	}
284	break;
285	case Triple::loongarch32:
286	case Triple::loongarch64:
287	LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
288	PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
289	dwarf::DW_EH_PE_sdata4;
290	TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
291	dwarf::DW_EH_PE_sdata4;
292	break;
293	default:
294	break;
295	}
296	}
297
298	void TargetLoweringObjectFileELF::getModuleMetadata(Module &M) {
299	SmallVector<GlobalValue *, 4> Vec;
300	collectUsedGlobalVariables(M, Vec, CompilerUsed: false);
301	for (GlobalValue *GV : Vec)
302	if (auto *GO = dyn_cast<GlobalObject>(Val: GV))
303	Used.insert(Ptr: GO);
304	}
305
306	void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer,
307	Module &M) const {
308	auto &C = getContext();
309
310	if (NamedMDNode *LinkerOptions = M.getNamedMetadata(Name: "llvm.linker.options")) {
311	auto *S = C.getELFSection(Section: ".linker-options", Type: ELF::SHT_LLVM_LINKER_OPTIONS,
312	Flags: ELF::SHF_EXCLUDE);
313
314	Streamer.switchSection(Section: S);
315
316	for (const auto *Operand : LinkerOptions->operands()) {
317	if (cast<MDNode>(Val: Operand)->getNumOperands() != 2)
318	report_fatal_error(reason: "invalid llvm.linker.options");
319	for (const auto &Option : cast<MDNode>(Val: Operand)->operands()) {
320	Streamer.emitBytes(Data: cast<MDString>(Val: Option)->getString());
321	Streamer.emitInt8(Value: 0);
322	}
323	}
324	}
325
326	if (NamedMDNode *DependentLibraries = M.getNamedMetadata(Name: "llvm.dependent-libraries")) {
327	auto *S = C.getELFSection(Section: ".deplibs", Type: ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
328	Flags: ELF::SHF_MERGE | ELF::SHF_STRINGS, EntrySize: 1);
329
330	Streamer.switchSection(Section: S);
331
332	for (const auto *Operand : DependentLibraries->operands()) {
333	Streamer.emitBytes(
334	Data: cast<MDString>(Val: cast<MDNode>(Val: Operand)->getOperand(I: 0))->getString());
335	Streamer.emitInt8(Value: 0);
336	}
337	}
338
339	if (NamedMDNode *FuncInfo = M.getNamedMetadata(Name: PseudoProbeDescMetadataName)) {
340	// Emit a descriptor for every function including functions that have an
341	// available external linkage. We may not want this for imported functions
342	// that has code in another thinLTO module but we don't have a good way to
343	// tell them apart from inline functions defined in header files. Therefore
344	// we put each descriptor in a separate comdat section and rely on the
345	// linker to deduplicate.
346	for (const auto *Operand : FuncInfo->operands()) {
347	const auto *MD = cast<MDNode>(Val: Operand);
348	auto *GUID = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: 0));
349	auto *Hash = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: 1));
350	auto *Name = cast<MDString>(Val: MD->getOperand(I: 2));
351	auto *S = C.getObjectFileInfo()->getPseudoProbeDescSection(
352	FuncName: TM->getFunctionSections() ? Name->getString() : StringRef());
353
354	Streamer.switchSection(Section: S);
355	Streamer.emitInt64(Value: GUID->getZExtValue());
356	Streamer.emitInt64(Value: Hash->getZExtValue());
357	Streamer.emitULEB128IntValue(Value: Name->getString().size());
358	Streamer.emitBytes(Data: Name->getString());
359	}
360	}
361
362	if (NamedMDNode *LLVMStats = M.getNamedMetadata(Name: "llvm.stats")) {
363	// Emit the metadata for llvm statistics into .llvm_stats section, which is
364	// formatted as a list of key/value pair, the value is base64 encoded.
365	auto *S = C.getObjectFileInfo()->getLLVMStatsSection();
366	Streamer.switchSection(Section: S);
367	for (const auto *Operand : LLVMStats->operands()) {
368	const auto *MD = cast<MDNode>(Val: Operand);
369	assert(MD->getNumOperands() % 2 == 0 &&
370	("Operand num should be even for a list of key/value pair"));
371	for (size_t I = 0; I < MD->getNumOperands(); I += 2) {
372	// Encode the key string size.
373	auto *Key = cast<MDString>(Val: MD->getOperand(I));
374	Streamer.emitULEB128IntValue(Value: Key->getString().size());
375	Streamer.emitBytes(Data: Key->getString());
376	// Encode the value into a Base64 string.
377	std::string Value = encodeBase64(
378	Bytes: Twine(mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: I + 1))
379	->getZExtValue())
380	.str());
381	Streamer.emitULEB128IntValue(Value: Value.size());
382	Streamer.emitBytes(Data: Value);
383	}
384	}
385	}
386
387	unsigned Version = 0;
388	unsigned Flags = 0;
389	StringRef Section;
390
391	GetObjCImageInfo(M, Version, Flags, Section);
392	if (!Section.empty()) {
393	auto *S = C.getELFSection(Section, Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC);
394	Streamer.switchSection(Section: S);
395	Streamer.emitLabel(Symbol: C.getOrCreateSymbol(Name: StringRef("OBJC_IMAGE_INFO")));
396	Streamer.emitInt32(Value: Version);
397	Streamer.emitInt32(Value: Flags);
398	Streamer.addBlankLine();
399	}
400
401	emitCGProfileMetadata(Streamer, M);
402	}
403
404	MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
405	const GlobalValue *GV, const TargetMachine &TM,
406	MachineModuleInfo *MMI) const {
407	unsigned Encoding = getPersonalityEncoding();
408	if ((Encoding & 0x80) == DW_EH_PE_indirect)
409	return getContext().getOrCreateSymbol(Name: StringRef("DW.ref.") +
410	TM.getSymbol(GV)->getName());
411	if ((Encoding & 0x70) == DW_EH_PE_absptr)
412	return TM.getSymbol(GV);
413	report_fatal_error(reason: "We do not support this DWARF encoding yet!");
414	}
415
416	void TargetLoweringObjectFileELF::emitPersonalityValue(
417	MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
418	SmallString<64> NameData("DW.ref.");
419	NameData += Sym->getName();
420	MCSymbolELF *Label =
421	cast<MCSymbolELF>(Val: getContext().getOrCreateSymbol(Name: NameData));
422	Streamer.emitSymbolAttribute(Symbol: Label, Attribute: MCSA_Hidden);
423	Streamer.emitSymbolAttribute(Symbol: Label, Attribute: MCSA_Weak);
424	unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
425	MCSection *Sec = getContext().getELFNamedSection(Prefix: ".data", Suffix: Label->getName(),
426	Type: ELF::SHT_PROGBITS, Flags, EntrySize: 0);
427	unsigned Size = DL.getPointerSize();
428	Streamer.switchSection(Section: Sec);
429	Streamer.emitValueToAlignment(Alignment: DL.getPointerABIAlignment(AS: 0));
430	Streamer.emitSymbolAttribute(Symbol: Label, Attribute: MCSA_ELF_TypeObject);
431	const MCExpr *E = MCConstantExpr::create(Value: Size, Ctx&: getContext());
432	Streamer.emitELFSize(Symbol: Label, Value: E);
433	Streamer.emitLabel(Symbol: Label);
434
435	Streamer.emitSymbolValue(Sym, Size);
436	}
437
438	const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
439	const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
440	MachineModuleInfo *MMI, MCStreamer &Streamer) const {
441	if (Encoding & DW_EH_PE_indirect) {
442	MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
443
444	MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, Suffix: ".DW.stub", TM);
445
446	// Add information about the stub reference to ELFMMI so that the stub
447	// gets emitted by the asmprinter.
448	MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(Sym: SSym);
449	if (!StubSym.getPointer()) {
450	MCSymbol *Sym = TM.getSymbol(GV);
451	StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
452	}
453
454	return TargetLoweringObjectFile::
455	getTTypeReference(Sym: MCSymbolRefExpr::create(Symbol: SSym, Ctx&: getContext()),
456	Encoding: Encoding & ~DW_EH_PE_indirect, Streamer);
457	}
458
459	return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
460	MMI, Streamer);
461	}
462
463	static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
464	// N.B.: The defaults used in here are not the same ones used in MC.
465	// We follow gcc, MC follows gas. For example, given ".section .eh_frame",
466	// both gas and MC will produce a section with no flags. Given
467	// section(".eh_frame") gcc will produce:
468	//
469	// .section .eh_frame,"a",@progbits
470
471	if (Name == getInstrProfSectionName(IPSK: IPSK_covmap, OF: Triple::ELF,
472	/*AddSegmentInfo=*/false) ||
473	Name == getInstrProfSectionName(IPSK: IPSK_covfun, OF: Triple::ELF,
474	/*AddSegmentInfo=*/false) ||
475	Name == getInstrProfSectionName(IPSK: IPSK_covdata, OF: Triple::ELF,
476	/*AddSegmentInfo=*/false) ||
477	Name == getInstrProfSectionName(IPSK: IPSK_covname, OF: Triple::ELF,
478	/*AddSegmentInfo=*/false) ||
479	Name == ".llvmbc" || Name == ".llvmcmd")
480	return SectionKind::getMetadata();
481
482	if (!Name.starts_with(Prefix: ".")) return K;
483
484	// Default implementation based on some magic section names.
485	if (Name == ".bss" || Name.starts_with(Prefix: ".bss.") ||
486	Name.starts_with(Prefix: ".gnu.linkonce.b.") ||
487	Name.starts_with(Prefix: ".llvm.linkonce.b.") || Name == ".sbss" ||
488	Name.starts_with(Prefix: ".sbss.") || Name.starts_with(Prefix: ".gnu.linkonce.sb.") ||
489	Name.starts_with(Prefix: ".llvm.linkonce.sb."))
490	return SectionKind::getBSS();
491
492	if (Name == ".tdata" || Name.starts_with(Prefix: ".tdata.") ||
493	Name.starts_with(Prefix: ".gnu.linkonce.td.") ||
494	Name.starts_with(Prefix: ".llvm.linkonce.td."))
495	return SectionKind::getThreadData();
496
497	if (Name == ".tbss" || Name.starts_with(Prefix: ".tbss.") ||
498	Name.starts_with(Prefix: ".gnu.linkonce.tb.") ||
499	Name.starts_with(Prefix: ".llvm.linkonce.tb."))
500	return SectionKind::getThreadBSS();
501
502	return K;
503	}
504
505	static bool hasPrefix(StringRef SectionName, StringRef Prefix) {
506	return SectionName.consume_front(Prefix) &&
507	(SectionName.empty() || SectionName[0] == '.');
508	}
509
510	static unsigned getELFSectionType(StringRef Name, SectionKind K) {
511	// Use SHT_NOTE for section whose name starts with ".note" to allow
512	// emitting ELF notes from C variable declaration.
513	// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
514	if (Name.starts_with(Prefix: ".note"))
515	return ELF::SHT_NOTE;
516
517	if (hasPrefix(SectionName: Name, Prefix: ".init_array"))
518	return ELF::SHT_INIT_ARRAY;
519
520	if (hasPrefix(SectionName: Name, Prefix: ".fini_array"))
521	return ELF::SHT_FINI_ARRAY;
522
523	if (hasPrefix(SectionName: Name, Prefix: ".preinit_array"))
524	return ELF::SHT_PREINIT_ARRAY;
525
526	if (hasPrefix(SectionName: Name, Prefix: ".llvm.offloading"))
527	return ELF::SHT_LLVM_OFFLOADING;
528
529	if (K.isBSS() || K.isThreadBSS())
530	return ELF::SHT_NOBITS;
531
532	return ELF::SHT_PROGBITS;
533	}
534
535	static unsigned getELFSectionFlags(SectionKind K) {
536	unsigned Flags = 0;
537
538	if (!K.isMetadata() && !K.isExclude())
539	Flags |= ELF::SHF_ALLOC;
540
541	if (K.isExclude())
542	Flags |= ELF::SHF_EXCLUDE;
543
544	if (K.isText())
545	Flags |= ELF::SHF_EXECINSTR;
546
547	if (K.isExecuteOnly())
548	Flags |= ELF::SHF_ARM_PURECODE;
549
550	if (K.isWriteable())
551	Flags |= ELF::SHF_WRITE;
552
553	if (K.isThreadLocal())
554	Flags |= ELF::SHF_TLS;
555
556	if (K.isMergeableCString() || K.isMergeableConst())
557	Flags |= ELF::SHF_MERGE;
558
559	if (K.isMergeableCString())
560	Flags |= ELF::SHF_STRINGS;
561
562	return Flags;
563	}
564
565	static const Comdat *getELFComdat(const GlobalValue *GV) {
566	const Comdat *C = GV->getComdat();
567	if (!C)
568	return nullptr;
569
570	if (C->getSelectionKind() != Comdat::Any &&
571	C->getSelectionKind() != Comdat::NoDeduplicate)
572	report_fatal_error(reason: "ELF COMDATs only support SelectionKind::Any and "
573	"SelectionKind::NoDeduplicate, '" +
574	C->getName() + "' cannot be lowered.");
575
576	return C;
577	}
578
579	static const MCSymbolELF *getLinkedToSymbol(const GlobalObject *GO,
580	const TargetMachine &TM) {
581	MDNode *MD = GO->getMetadata(KindID: LLVMContext::MD_associated);
582	if (!MD)
583	return nullptr;
584
585	auto *VM = cast<ValueAsMetadata>(Val: MD->getOperand(I: 0).get());
586	auto *OtherGV = dyn_cast<GlobalValue>(Val: VM->getValue());
587	return OtherGV ? dyn_cast<MCSymbolELF>(Val: TM.getSymbol(GV: OtherGV)) : nullptr;
588	}
589
590	static unsigned getEntrySizeForKind(SectionKind Kind) {
591	if (Kind.isMergeable1ByteCString())
592	return 1;
593	else if (Kind.isMergeable2ByteCString())
594	return 2;
595	else if (Kind.isMergeable4ByteCString())
596	return 4;
597	else if (Kind.isMergeableConst4())
598	return 4;
599	else if (Kind.isMergeableConst8())
600	return 8;
601	else if (Kind.isMergeableConst16())
602	return 16;
603	else if (Kind.isMergeableConst32())
604	return 32;
605	else {
606	// We shouldn't have mergeable C strings or mergeable constants that we
607	// didn't handle above.
608	assert(!Kind.isMergeableCString() && "unknown string width");
609	assert(!Kind.isMergeableConst() && "unknown data width");
610	return 0;
611	}
612	}
613
614	/// Return the section prefix name used by options FunctionsSections and
615	/// DataSections.
616	static StringRef getSectionPrefixForGlobal(SectionKind Kind, bool IsLarge) {
617	if (Kind.isText())
618	return IsLarge ? ".ltext" : ".text";
619	if (Kind.isReadOnly())
620	return IsLarge ? ".lrodata" : ".rodata";
621	if (Kind.isBSS())
622	return IsLarge ? ".lbss" : ".bss";
623	if (Kind.isThreadData())
624	return ".tdata";
625	if (Kind.isThreadBSS())
626	return ".tbss";
627	if (Kind.isData())
628	return IsLarge ? ".ldata" : ".data";
629	if (Kind.isReadOnlyWithRel())
630	return IsLarge ? ".ldata.rel.ro" : ".data.rel.ro";
631	llvm_unreachable("Unknown section kind");
632	}
633
634	static SmallString<128>
635	getELFSectionNameForGlobal(const GlobalObject *GO, SectionKind Kind,
636	Mangler &Mang, const TargetMachine &TM,
637	unsigned EntrySize, bool UniqueSectionName) {
638	SmallString<128> Name =
639	getSectionPrefixForGlobal(Kind, IsLarge: TM.isLargeGlobalValue(GV: GO));
640	if (Kind.isMergeableCString()) {
641	// We also need alignment here.
642	// FIXME: this is getting the alignment of the character, not the
643	// alignment of the global!
644	Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
645	GV: cast<GlobalVariable>(Val: GO));
646
647	Name += ".str";
648	Name += utostr(X: EntrySize);
649	Name += ".";
650	Name += utostr(X: Alignment.value());
651	} else if (Kind.isMergeableConst()) {
652	Name += ".cst";
653	Name += utostr(X: EntrySize);
654	}
655
656	bool HasPrefix = false;
657	if (const auto *F = dyn_cast<Function>(Val: GO)) {
658	if (std::optional<StringRef> Prefix = F->getSectionPrefix()) {
659	raw_svector_ostream(Name) << '.' << *Prefix;
660	HasPrefix = true;
661	}
662	}
663
664	if (UniqueSectionName) {
665	Name.push_back(Elt: '.');
666	TM.getNameWithPrefix(Name, GV: GO, Mang, /*MayAlwaysUsePrivate*/true);
667	} else if (HasPrefix)
668	// For distinguishing between .text.${text-section-prefix}. (with trailing
669	// dot) and .text.${function-name}
670	Name.push_back(Elt: '.');
671	return Name;
672	}
673
674	namespace {
675	class LoweringDiagnosticInfo : public DiagnosticInfo {
676	const Twine &Msg;
677
678	public:
679	LoweringDiagnosticInfo(const Twine &DiagMsg,
680	DiagnosticSeverity Severity = DS_Error)
681	: DiagnosticInfo(DK_Lowering, Severity), Msg(DiagMsg) {}
682	void print(DiagnosticPrinter &DP) const override { DP << Msg; }
683	};
684	}
685
686	/// Calculate an appropriate unique ID for a section, and update Flags,
687	/// EntrySize and NextUniqueID where appropriate.
688	static unsigned
689	calcUniqueIDUpdateFlagsAndSize(const GlobalObject *GO, StringRef SectionName,
690	SectionKind Kind, const TargetMachine &TM,
691	MCContext &Ctx, Mangler &Mang, unsigned &Flags,
692	unsigned &EntrySize, unsigned &NextUniqueID,
693	const bool Retain, const bool ForceUnique) {
694	// Increment uniqueID if we are forced to emit a unique section.
695	// This works perfectly fine with section attribute or pragma section as the
696	// sections with the same name are grouped together by the assembler.
697	if (ForceUnique)
698	return NextUniqueID++;
699
700	// A section can have at most one associated section. Put each global with
701	// MD_associated in a unique section.
702	const bool Associated = GO->getMetadata(KindID: LLVMContext::MD_associated);
703	if (Associated) {
704	Flags |= ELF::SHF_LINK_ORDER;
705	return NextUniqueID++;
706	}
707
708	if (Retain) {
709	if (TM.getTargetTriple().isOSSolaris())
710	Flags |= ELF::SHF_SUNW_NODISCARD;
711	else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
712	Ctx.getAsmInfo()->binutilsIsAtLeast(Major: 2, Minor: 36))
713	Flags |= ELF::SHF_GNU_RETAIN;
714	return NextUniqueID++;
715	}
716
717	// If two symbols with differing sizes end up in the same mergeable section
718	// that section can be assigned an incorrect entry size. To avoid this we
719	// usually put symbols of the same size into distinct mergeable sections with
720	// the same name. Doing so relies on the ",unique ," assembly feature. This
721	// feature is not avalible until bintuils version 2.35
722	// (https://sourceware.org/bugzilla/show_bug.cgi?id=25380).
723	const bool SupportsUnique = Ctx.getAsmInfo()->useIntegratedAssembler() ||
724	Ctx.getAsmInfo()->binutilsIsAtLeast(Major: 2, Minor: 35);
725	if (!SupportsUnique) {
726	Flags &= ~ELF::SHF_MERGE;
727	EntrySize = 0;
728	return MCContext::GenericSectionID;
729	}
730
731	const bool SymbolMergeable = Flags & ELF::SHF_MERGE;
732	const bool SeenSectionNameBefore =
733	Ctx.isELFGenericMergeableSection(Name: SectionName);
734	// If this is the first ocurrence of this section name, treat it as the
735	// generic section
736	if (!SymbolMergeable && !SeenSectionNameBefore)
737	return MCContext::GenericSectionID;
738
739	// Symbols must be placed into sections with compatible entry sizes. Generate
740	// unique sections for symbols that have not been assigned to compatible
741	// sections.
742	const auto PreviousID =
743	Ctx.getELFUniqueIDForEntsize(SectionName, Flags, EntrySize);
744	if (PreviousID)
745	return *PreviousID;
746
747	// If the user has specified the same section name as would be created
748	// implicitly for this symbol e.g. .rodata.str1.1, then we don't need
749	// to unique the section as the entry size for this symbol will be
750	// compatible with implicitly created sections.
751	SmallString<128> ImplicitSectionNameStem =
752	getELFSectionNameForGlobal(GO, Kind, Mang, TM, EntrySize, UniqueSectionName: false);
753	if (SymbolMergeable &&
754	Ctx.isELFImplicitMergeableSectionNamePrefix(Name: SectionName) &&
755	SectionName.starts_with(Prefix: ImplicitSectionNameStem))
756	return MCContext::GenericSectionID;
757
758	// We have seen this section name before, but with different flags or entity
759	// size. Create a new unique ID.
760	return NextUniqueID++;
761	}
762
763	static std::tuple<StringRef, bool, unsigned>
764	getGlobalObjectInfo(const GlobalObject *GO, const TargetMachine &TM) {
765	StringRef Group = "";
766	bool IsComdat = false;
767	unsigned Flags = 0;
768	if (const Comdat *C = getELFComdat(GV: GO)) {
769	Flags |= ELF::SHF_GROUP;
770	Group = C->getName();
771	IsComdat = C->getSelectionKind() == Comdat::Any;
772	}
773	if (TM.isLargeGlobalValue(GV: GO))
774	Flags |= ELF::SHF_X86_64_LARGE;
775	return {Group, IsComdat, Flags};
776	}
777
778	static MCSection *selectExplicitSectionGlobal(
779	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM,
780	MCContext &Ctx, Mangler &Mang, unsigned &NextUniqueID,
781	bool Retain, bool ForceUnique) {
782	StringRef SectionName = GO->getSection();
783
784	// Check if '#pragma clang section' name is applicable.
785	// Note that pragma directive overrides -ffunction-section, -fdata-section
786	// and so section name is exactly as user specified and not uniqued.
787	const GlobalVariable *GV = dyn_cast<GlobalVariable>(Val: GO);
788	if (GV && GV->hasImplicitSection()) {
789	auto Attrs = GV->getAttributes();
790	if (Attrs.hasAttribute(Kind: "bss-section") && Kind.isBSS()) {
791	SectionName = Attrs.getAttribute(Kind: "bss-section").getValueAsString();
792	} else if (Attrs.hasAttribute(Kind: "rodata-section") && Kind.isReadOnly()) {
793	SectionName = Attrs.getAttribute(Kind: "rodata-section").getValueAsString();
794	} else if (Attrs.hasAttribute(Kind: "relro-section") && Kind.isReadOnlyWithRel()) {
795	SectionName = Attrs.getAttribute(Kind: "relro-section").getValueAsString();
796	} else if (Attrs.hasAttribute(Kind: "data-section") && Kind.isData()) {
797	SectionName = Attrs.getAttribute(Kind: "data-section").getValueAsString();
798	}
799	}
800
801	// Infer section flags from the section name if we can.
802	Kind = getELFKindForNamedSection(Name: SectionName, K: Kind);
803
804	unsigned Flags = getELFSectionFlags(K: Kind);
805	auto [Group, IsComdat, ExtraFlags] = getGlobalObjectInfo(GO, TM);
806	Flags |= ExtraFlags;
807
808	unsigned EntrySize = getEntrySizeForKind(Kind);
809	const unsigned UniqueID = calcUniqueIDUpdateFlagsAndSize(
810	GO, SectionName, Kind, TM, Ctx, Mang, Flags, EntrySize, NextUniqueID,
811	Retain, ForceUnique);
812
813	const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
814	MCSectionELF *Section = Ctx.getELFSection(
815	Section: SectionName, Type: getELFSectionType(Name: SectionName, K: Kind), Flags, EntrySize,
816	Group, IsComdat, UniqueID, LinkedToSym);
817	// Make sure that we did not get some other section with incompatible sh_link.
818	// This should not be possible due to UniqueID code above.
819	assert(Section->getLinkedToSymbol() == LinkedToSym &&
820	"Associated symbol mismatch between sections");
821
822	if (!(Ctx.getAsmInfo()->useIntegratedAssembler() ||
823	Ctx.getAsmInfo()->binutilsIsAtLeast(Major: 2, Minor: 35))) {
824	// If we are using GNU as before 2.35, then this symbol might have
825	// been placed in an incompatible mergeable section. Emit an error if this
826	// is the case to avoid creating broken output.
827	if ((Section->getFlags() & ELF::SHF_MERGE) &&
828	(Section->getEntrySize() != getEntrySizeForKind(Kind)))
829	GO->getContext().diagnose(DI: LoweringDiagnosticInfo(
830	"Symbol '" + GO->getName() + "' from module '" +
831	(GO->getParent() ? GO->getParent()->getSourceFileName() : "unknown") +
832	"' required a section with entry-size=" +
833	Twine(getEntrySizeForKind(Kind)) + " but was placed in section '" +
834	SectionName + "' with entry-size=" + Twine(Section->getEntrySize()) +
835	": Explicit assignment by pragma or attribute of an incompatible "
836	"symbol to this section?"));
837	}
838
839	return Section;
840	}
841
842	MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
843	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
844	return selectExplicitSectionGlobal(GO, Kind, TM, Ctx&: getContext(), Mang&: getMangler(),
845	NextUniqueID, Retain: Used.count(Ptr: GO),
846	/* ForceUnique = */false);
847	}
848
849	static MCSectionELF *selectELFSectionForGlobal(
850	MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
851	const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
852	unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
853
854	auto [Group, IsComdat, ExtraFlags] = getGlobalObjectInfo(GO, TM);
855	Flags |= ExtraFlags;
856
857	// Get the section entry size based on the kind.
858	unsigned EntrySize = getEntrySizeForKind(Kind);
859
860	bool UniqueSectionName = false;
861	unsigned UniqueID = MCContext::GenericSectionID;
862	if (EmitUniqueSection) {
863	if (TM.getUniqueSectionNames()) {
864	UniqueSectionName = true;
865	} else {
866	UniqueID = *NextUniqueID;
867	(*NextUniqueID)++;
868	}
869	}
870	SmallString<128> Name = getELFSectionNameForGlobal(
871	GO, Kind, Mang, TM, EntrySize, UniqueSectionName);
872
873	// Use 0 as the unique ID for execute-only text.
874	if (Kind.isExecuteOnly())
875	UniqueID = 0;
876	return Ctx.getELFSection(Section: Name, Type: getELFSectionType(Name, K: Kind), Flags,
877	EntrySize, Group, IsComdat, UniqueID,
878	LinkedToSym: AssociatedSymbol);
879	}
880
881	static MCSection *selectELFSectionForGlobal(
882	MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
883	const TargetMachine &TM, bool Retain, bool EmitUniqueSection,
884	unsigned Flags, unsigned *NextUniqueID) {
885	const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
886	if (LinkedToSym) {
887	EmitUniqueSection = true;
888	Flags |= ELF::SHF_LINK_ORDER;
889	}
890	if (Retain) {
891	if (TM.getTargetTriple().isOSSolaris()) {
892	EmitUniqueSection = true;
893	Flags |= ELF::SHF_SUNW_NODISCARD;
894	} else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
895	Ctx.getAsmInfo()->binutilsIsAtLeast(Major: 2, Minor: 36)) {
896	EmitUniqueSection = true;
897	Flags |= ELF::SHF_GNU_RETAIN;
898	}
899	}
900
901	MCSectionELF *Section = selectELFSectionForGlobal(
902	Ctx, GO, Kind, Mang, TM, EmitUniqueSection, Flags,
903	NextUniqueID, AssociatedSymbol: LinkedToSym);
904	assert(Section->getLinkedToSymbol() == LinkedToSym);
905	return Section;
906	}
907
908	MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
909	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
910	unsigned Flags = getELFSectionFlags(K: Kind);
911
912	// If we have -ffunction-section or -fdata-section then we should emit the
913	// global value to a uniqued section specifically for it.
914	bool EmitUniqueSection = false;
915	if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
916	if (Kind.isText())
917	EmitUniqueSection = TM.getFunctionSections();
918	else
919	EmitUniqueSection = TM.getDataSections();
920	}
921	EmitUniqueSection |= GO->hasComdat();
922	return selectELFSectionForGlobal(Ctx&: getContext(), GO, Kind, Mang&: getMangler(), TM,
923	Retain: Used.count(Ptr: GO), EmitUniqueSection, Flags,
924	NextUniqueID: &NextUniqueID);
925	}
926
927	MCSection *TargetLoweringObjectFileELF::getUniqueSectionForFunction(
928	const Function &F, const TargetMachine &TM) const {
929	SectionKind Kind = SectionKind::getText();
930	unsigned Flags = getELFSectionFlags(K: Kind);
931	// If the function's section names is pre-determined via pragma or a
932	// section attribute, call selectExplicitSectionGlobal.
933	if (F.hasSection())
934	return selectExplicitSectionGlobal(
935	GO: &F, Kind, TM, Ctx&: getContext(), Mang&: getMangler(), NextUniqueID,
936	Retain: Used.count(Ptr: &F), /* ForceUnique = */true);
937	else
938	return selectELFSectionForGlobal(
939	Ctx&: getContext(), GO: &F, Kind, Mang&: getMangler(), TM, Retain: Used.count(Ptr: &F),
940	/*EmitUniqueSection=*/true, Flags, NextUniqueID: &NextUniqueID);
941	}
942
943	MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
944	const Function &F, const TargetMachine &TM) const {
945	// If the function can be removed, produce a unique section so that
946	// the table doesn't prevent the removal.
947	const Comdat *C = F.getComdat();
948	bool EmitUniqueSection = TM.getFunctionSections() || C;
949	if (!EmitUniqueSection)
950	return ReadOnlySection;
951
952	return selectELFSectionForGlobal(Ctx&: getContext(), GO: &F, Kind: SectionKind::getReadOnly(),
953	Mang&: getMangler(), TM, EmitUniqueSection,
954	Flags: ELF::SHF_ALLOC, NextUniqueID: &NextUniqueID,
955	/* AssociatedSymbol */ nullptr);
956	}
957
958	MCSection *TargetLoweringObjectFileELF::getSectionForLSDA(
959	const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
960	// If neither COMDAT nor function sections, use the monolithic LSDA section.
961	// Re-use this path if LSDASection is null as in the Arm EHABI.
962	if (!LSDASection || (!F.hasComdat() && !TM.getFunctionSections()))
963	return LSDASection;
964
965	const auto *LSDA = cast<MCSectionELF>(Val: LSDASection);
966	unsigned Flags = LSDA->getFlags();
967	const MCSymbolELF *LinkedToSym = nullptr;
968	StringRef Group;
969	bool IsComdat = false;
970	if (const Comdat *C = getELFComdat(GV: &F)) {
971	Flags |= ELF::SHF_GROUP;
972	Group = C->getName();
973	IsComdat = C->getSelectionKind() == Comdat::Any;
974	}
975	// Use SHF_LINK_ORDER to facilitate --gc-sections if we can use GNU ld>=2.36
976	// or LLD, which support mixed SHF_LINK_ORDER & non-SHF_LINK_ORDER.
977	if (TM.getFunctionSections() &&
978	(getContext().getAsmInfo()->useIntegratedAssembler() &&
979	getContext().getAsmInfo()->binutilsIsAtLeast(Major: 2, Minor: 36))) {
980	Flags |= ELF::SHF_LINK_ORDER;
981	LinkedToSym = cast<MCSymbolELF>(Val: &FnSym);
982	}
983
984	// Append the function name as the suffix like GCC, assuming
985	// -funique-section-names applies to .gcc_except_table sections.
986	return getContext().getELFSection(
987	Section: (TM.getUniqueSectionNames() ? LSDA->getName() + "." + F.getName()
988	: LSDA->getName()),
989	Type: LSDA->getType(), Flags, EntrySize: 0, Group, IsComdat, UniqueID: MCSection::NonUniqueID,
990	LinkedToSym);
991	}
992
993	bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
994	bool UsesLabelDifference, const Function &F) const {
995	// We can always create relative relocations, so use another section
996	// that can be marked non-executable.
997	return false;
998	}
999
1000	/// Given a mergeable constant with the specified size and relocation
1001	/// information, return a section that it should be placed in.
1002	MCSection *TargetLoweringObjectFileELF::getSectionForConstant(
1003	const DataLayout &DL, SectionKind Kind, const Constant *C,
1004	Align &Alignment) const {
1005	if (Kind.isMergeableConst4() && MergeableConst4Section)
1006	return MergeableConst4Section;
1007	if (Kind.isMergeableConst8() && MergeableConst8Section)
1008	return MergeableConst8Section;
1009	if (Kind.isMergeableConst16() && MergeableConst16Section)
1010	return MergeableConst16Section;
1011	if (Kind.isMergeableConst32() && MergeableConst32Section)
1012	return MergeableConst32Section;
1013	if (Kind.isReadOnly())
1014	return ReadOnlySection;
1015
1016	assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
1017	return DataRelROSection;
1018	}
1019
1020	/// Returns a unique section for the given machine basic block.
1021	MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock(
1022	const Function &F, const MachineBasicBlock &MBB,
1023	const TargetMachine &TM) const {
1024	assert(MBB.isBeginSection() && "Basic block does not start a section!");
1025	unsigned UniqueID = MCContext::GenericSectionID;
1026
1027	// For cold sections use the .text.split. prefix along with the parent
1028	// function name. All cold blocks for the same function go to the same
1029	// section. Similarly all exception blocks are grouped by symbol name
1030	// under the .text.eh prefix. For regular sections, we either use a unique
1031	// name, or a unique ID for the section.
1032	SmallString<128> Name;
1033	StringRef FunctionSectionName = MBB.getParent()->getSection()->getName();
1034	if (FunctionSectionName.equals(RHS: ".text") ||
1035	FunctionSectionName.starts_with(Prefix: ".text.")) {
1036	// Function is in a regular .text section.
1037	StringRef FunctionName = MBB.getParent()->getName();
1038	if (MBB.getSectionID() == MBBSectionID::ColdSectionID) {
1039	Name += BBSectionsColdTextPrefix;
1040	Name += FunctionName;
1041	} else if (MBB.getSectionID() == MBBSectionID::ExceptionSectionID) {
1042	Name += ".text.eh.";
1043	Name += FunctionName;
1044	} else {
1045	Name += FunctionSectionName;
1046	if (TM.getUniqueBasicBlockSectionNames()) {
1047	if (!Name.ends_with(Suffix: "."))
1048	Name += ".";
1049	Name += MBB.getSymbol()->getName();
1050	} else {
1051	UniqueID = NextUniqueID++;
1052	}
1053	}
1054	} else {
1055	// If the original function has a custom non-dot-text section, then emit
1056	// all basic block sections into that section too, each with a unique id.
1057	Name = FunctionSectionName;
1058	UniqueID = NextUniqueID++;
1059	}
1060
1061	unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
1062	std::string GroupName;
1063	if (F.hasComdat()) {
1064	Flags |= ELF::SHF_GROUP;
1065	GroupName = F.getComdat()->getName().str();
1066	}
1067	return getContext().getELFSection(Section: Name, Type: ELF::SHT_PROGBITS, Flags,
1068	EntrySize: 0 /* Entry Size */, Group: GroupName,
1069	IsComdat: F.hasComdat(), UniqueID, LinkedToSym: nullptr);
1070	}
1071
1072	static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
1073	bool IsCtor, unsigned Priority,
1074	const MCSymbol *KeySym) {
1075	std::string Name;
1076	unsigned Type;
1077	unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
1078	StringRef Comdat = KeySym ? KeySym->getName() : "";
1079
1080	if (KeySym)
1081	Flags |= ELF::SHF_GROUP;
1082
1083	if (UseInitArray) {
1084	if (IsCtor) {
1085	Type = ELF::SHT_INIT_ARRAY;
1086	Name = ".init_array";
1087	} else {
1088	Type = ELF::SHT_FINI_ARRAY;
1089	Name = ".fini_array";
1090	}
1091	if (Priority != 65535) {
1092	Name += '.';
1093	Name += utostr(X: Priority);
1094	}
1095	} else {
1096	// The default scheme is .ctor / .dtor, so we have to invert the priority
1097	// numbering.
1098	if (IsCtor)
1099	Name = ".ctors";
1100	else
1101	Name = ".dtors";
1102	if (Priority != 65535)
1103	raw_string_ostream(Name) << format(Fmt: ".%05u", Vals: 65535 - Priority);
1104	Type = ELF::SHT_PROGBITS;
1105	}
1106
1107	return Ctx.getELFSection(Section: Name, Type, Flags, EntrySize: 0, Group: Comdat, /*IsComdat=*/true);
1108	}
1109
1110	MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
1111	unsigned Priority, const MCSymbol *KeySym) const {
1112	return getStaticStructorSection(Ctx&: getContext(), UseInitArray, IsCtor: true, Priority,
1113	KeySym);
1114	}
1115
1116	MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
1117	unsigned Priority, const MCSymbol *KeySym) const {
1118	return getStaticStructorSection(Ctx&: getContext(), UseInitArray, IsCtor: false, Priority,
1119	KeySym);
1120	}
1121
1122	const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
1123	const GlobalValue *LHS, const GlobalValue *RHS,
1124	const TargetMachine &TM) const {
1125	// We may only use a PLT-relative relocation to refer to unnamed_addr
1126	// functions.
1127	if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1128	return nullptr;
1129
1130	// Basic correctness checks.
1131	if (LHS->getType()->getPointerAddressSpace() != 0 ||
1132	RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1133	RHS->isThreadLocal())
1134	return nullptr;
1135
1136	return MCBinaryExpr::createSub(
1137	LHS: MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV: LHS), Kind: PLTRelativeVariantKind,
1138	Ctx&: getContext()),
1139	RHS: MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV: RHS), Ctx&: getContext()), Ctx&: getContext());
1140	}
1141
1142	const MCExpr *TargetLoweringObjectFileELF::lowerDSOLocalEquivalent(
1143	const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
1144	assert(supportDSOLocalEquivalentLowering());
1145
1146	const auto *GV = Equiv->getGlobalValue();
1147
1148	// A PLT entry is not needed for dso_local globals.
1149	if (GV->isDSOLocal() || GV->isImplicitDSOLocal())
1150	return MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV), Ctx&: getContext());
1151
1152	return MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV), Kind: PLTRelativeVariantKind,
1153	Ctx&: getContext());
1154	}
1155
1156	MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const {
1157	// Use ".GCC.command.line" since this feature is to support clang's
1158	// -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
1159	// same name.
1160	return getContext().getELFSection(Section: ".GCC.command.line", Type: ELF::SHT_PROGBITS,
1161	Flags: ELF::SHF_MERGE | ELF::SHF_STRINGS, EntrySize: 1);
1162	}
1163
1164	void
1165	TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
1166	UseInitArray = UseInitArray_;
1167	MCContext &Ctx = getContext();
1168	if (!UseInitArray) {
1169	StaticCtorSection = Ctx.getELFSection(Section: ".ctors", Type: ELF::SHT_PROGBITS,
1170	Flags: ELF::SHF_ALLOC | ELF::SHF_WRITE);
1171
1172	StaticDtorSection = Ctx.getELFSection(Section: ".dtors", Type: ELF::SHT_PROGBITS,
1173	Flags: ELF::SHF_ALLOC | ELF::SHF_WRITE);
1174	return;
1175	}
1176
1177	StaticCtorSection = Ctx.getELFSection(Section: ".init_array", Type: ELF::SHT_INIT_ARRAY,
1178	Flags: ELF::SHF_WRITE | ELF::SHF_ALLOC);
1179	StaticDtorSection = Ctx.getELFSection(Section: ".fini_array", Type: ELF::SHT_FINI_ARRAY,
1180	Flags: ELF::SHF_WRITE | ELF::SHF_ALLOC);
1181	}
1182
1183	//===----------------------------------------------------------------------===//
1184	// MachO
1185	//===----------------------------------------------------------------------===//
1186
1187	TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO() {
1188	SupportIndirectSymViaGOTPCRel = true;
1189	}
1190
1191	void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
1192	const TargetMachine &TM) {
1193	TargetLoweringObjectFile::Initialize(ctx&: Ctx, TM);
1194	if (TM.getRelocationModel() == Reloc::Static) {
1195	StaticCtorSection = Ctx.getMachOSection(Segment: "__TEXT", Section: "__constructor", TypeAndAttributes: 0,
1196	K: SectionKind::getData());
1197	StaticDtorSection = Ctx.getMachOSection(Segment: "__TEXT", Section: "__destructor", TypeAndAttributes: 0,
1198	K: SectionKind::getData());
1199	} else {
1200	StaticCtorSection = Ctx.getMachOSection(Segment: "__DATA", Section: "__mod_init_func",
1201	TypeAndAttributes: MachO::S_MOD_INIT_FUNC_POINTERS,
1202	K: SectionKind::getData());
1203	StaticDtorSection = Ctx.getMachOSection(Segment: "__DATA", Section: "__mod_term_func",
1204	TypeAndAttributes: MachO::S_MOD_TERM_FUNC_POINTERS,
1205	K: SectionKind::getData());
1206	}
1207
1208	PersonalityEncoding =
1209	dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
1210	LSDAEncoding = dwarf::DW_EH_PE_pcrel;
1211	TTypeEncoding =
1212	dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
1213	}
1214
1215	MCSection *TargetLoweringObjectFileMachO::getStaticDtorSection(
1216	unsigned Priority, const MCSymbol *KeySym) const {
1217	return StaticDtorSection;
1218	// In userspace, we lower global destructors via atexit(), but kernel/kext
1219	// environments do not provide this function so we still need to support the
1220	// legacy way here.
1221	// See the -disable-atexit-based-global-dtor-lowering CodeGen flag for more
1222	// context.
1223	}
1224
1225	void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
1226	Module &M) const {
1227	// Emit the linker options if present.
1228	if (auto *LinkerOptions = M.getNamedMetadata(Name: "llvm.linker.options")) {
1229	for (const auto *Option : LinkerOptions->operands()) {
1230	SmallVector<std::string, 4> StrOptions;
1231	for (const auto &Piece : cast<MDNode>(Val: Option)->operands())
1232	StrOptions.push_back(Elt: std::string(cast<MDString>(Val: Piece)->getString()));
1233	Streamer.emitLinkerOptions(Kind: StrOptions);
1234	}
1235	}
1236
1237	unsigned VersionVal = 0;
1238	unsigned ImageInfoFlags = 0;
1239	StringRef SectionVal;
1240
1241	GetObjCImageInfo(M, Version&: VersionVal, Flags&: ImageInfoFlags, Section&: SectionVal);
1242	emitCGProfileMetadata(Streamer, M);
1243
1244	// The section is mandatory. If we don't have it, then we don't have GC info.
1245	if (SectionVal.empty())
1246	return;
1247
1248	StringRef Segment, Section;
1249	unsigned TAA = 0, StubSize = 0;
1250	bool TAAParsed;
1251	if (Error E = MCSectionMachO::ParseSectionSpecifier(
1252	Spec: SectionVal, Segment, Section, TAA, TAAParsed, StubSize)) {
1253	// If invalid, report the error with report_fatal_error.
1254	report_fatal_error(reason: "Invalid section specifier '" + Section +
1255	"': " + toString(E: std::move(E)) + ".");
1256	}
1257
1258	// Get the section.
1259	MCSectionMachO *S = getContext().getMachOSection(
1260	Segment, Section, TypeAndAttributes: TAA, Reserved2: StubSize, K: SectionKind::getData());
1261	Streamer.switchSection(Section: S);
1262	Streamer.emitLabel(Symbol: getContext().
1263	getOrCreateSymbol(Name: StringRef("L_OBJC_IMAGE_INFO")));
1264	Streamer.emitInt32(Value: VersionVal);
1265	Streamer.emitInt32(Value: ImageInfoFlags);
1266	Streamer.addBlankLine();
1267	}
1268
1269	static void checkMachOComdat(const GlobalValue *GV) {
1270	const Comdat *C = GV->getComdat();
1271	if (!C)
1272	return;
1273
1274	report_fatal_error(reason: "MachO doesn't support COMDATs, '" + C->getName() +
1275	"' cannot be lowered.");
1276	}
1277
1278	MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
1279	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1280
1281	StringRef SectionName = GO->getSection();
1282
1283	const GlobalVariable *GV = dyn_cast<GlobalVariable>(Val: GO);
1284	if (GV && GV->hasImplicitSection()) {
1285	auto Attrs = GV->getAttributes();
1286	if (Attrs.hasAttribute(Kind: "bss-section") && Kind.isBSS()) {
1287	SectionName = Attrs.getAttribute(Kind: "bss-section").getValueAsString();
1288	} else if (Attrs.hasAttribute(Kind: "rodata-section") && Kind.isReadOnly()) {
1289	SectionName = Attrs.getAttribute(Kind: "rodata-section").getValueAsString();
1290	} else if (Attrs.hasAttribute(Kind: "relro-section") && Kind.isReadOnlyWithRel()) {
1291	SectionName = Attrs.getAttribute(Kind: "relro-section").getValueAsString();
1292	} else if (Attrs.hasAttribute(Kind: "data-section") && Kind.isData()) {
1293	SectionName = Attrs.getAttribute(Kind: "data-section").getValueAsString();
1294	}
1295	}
1296
1297	// Parse the section specifier and create it if valid.
1298	StringRef Segment, Section;
1299	unsigned TAA = 0, StubSize = 0;
1300	bool TAAParsed;
1301
1302	checkMachOComdat(GV: GO);
1303
1304	if (Error E = MCSectionMachO::ParseSectionSpecifier(
1305	Spec: SectionName, Segment, Section, TAA, TAAParsed, StubSize)) {
1306	// If invalid, report the error with report_fatal_error.
1307	report_fatal_error(reason: "Global variable '" + GO->getName() +
1308	"' has an invalid section specifier '" +
1309	GO->getSection() + "': " + toString(E: std::move(E)) + ".");
1310	}
1311
1312	// Get the section.
1313	MCSectionMachO *S =
1314	getContext().getMachOSection(Segment, Section, TypeAndAttributes: TAA, Reserved2: StubSize, K: Kind);
1315
1316	// If TAA wasn't set by ParseSectionSpecifier() above,
1317	// use the value returned by getMachOSection() as a default.
1318	if (!TAAParsed)
1319	TAA = S->getTypeAndAttributes();
1320
1321	// Okay, now that we got the section, verify that the TAA & StubSize agree.
1322	// If the user declared multiple globals with different section flags, we need
1323	// to reject it here.
1324	if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
1325	// If invalid, report the error with report_fatal_error.
1326	report_fatal_error(reason: "Global variable '" + GO->getName() +
1327	"' section type or attributes does not match previous"
1328	" section specifier");
1329	}
1330
1331	return S;
1332	}
1333
1334	MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
1335	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1336	checkMachOComdat(GV: GO);
1337
1338	// Handle thread local data.
1339	if (Kind.isThreadBSS()) return TLSBSSSection;
1340	if (Kind.isThreadData()) return TLSDataSection;
1341
1342	if (Kind.isText())
1343	return GO->isWeakForLinker() ? TextCoalSection : TextSection;
1344
1345	// If this is weak/linkonce, put this in a coalescable section, either in text
1346	// or data depending on if it is writable.
1347	if (GO->isWeakForLinker()) {
1348	if (Kind.isReadOnly())
1349	return ConstTextCoalSection;
1350	if (Kind.isReadOnlyWithRel())
1351	return ConstDataCoalSection;
1352	return DataCoalSection;
1353	}
1354
1355	// FIXME: Alignment check should be handled by section classifier.
1356	if (Kind.isMergeable1ByteCString() &&
1357	GO->getParent()->getDataLayout().getPreferredAlign(
1358	GV: cast<GlobalVariable>(Val: GO)) < Align(32))
1359	return CStringSection;
1360
1361	// Do not put 16-bit arrays in the UString section if they have an
1362	// externally visible label, this runs into issues with certain linker
1363	// versions.
1364	if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1365	GO->getParent()->getDataLayout().getPreferredAlign(
1366	GV: cast<GlobalVariable>(Val: GO)) < Align(32))
1367	return UStringSection;
1368
1369	// With MachO only variables whose corresponding symbol starts with 'l' or
1370	// 'L' can be merged, so we only try merging GVs with private linkage.
1371	if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1372	if (Kind.isMergeableConst4())
1373	return FourByteConstantSection;
1374	if (Kind.isMergeableConst8())
1375	return EightByteConstantSection;
1376	if (Kind.isMergeableConst16())
1377	return SixteenByteConstantSection;
1378	}
1379
1380	// Otherwise, if it is readonly, but not something we can specially optimize,
1381	// just drop it in .const.
1382	if (Kind.isReadOnly())
1383	return ReadOnlySection;
1384
1385	// If this is marked const, put it into a const section. But if the dynamic
1386	// linker needs to write to it, put it in the data segment.
1387	if (Kind.isReadOnlyWithRel())
1388	return ConstDataSection;
1389
1390	// Put zero initialized globals with strong external linkage in the
1391	// DATA, __common section with the .zerofill directive.
1392	if (Kind.isBSSExtern())
1393	return DataCommonSection;
1394
1395	// Put zero initialized globals with local linkage in __DATA,__bss directive
1396	// with the .zerofill directive (aka .lcomm).
1397	if (Kind.isBSSLocal())
1398	return DataBSSSection;
1399
1400	// Otherwise, just drop the variable in the normal data section.
1401	return DataSection;
1402	}
1403
1404	MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
1405	const DataLayout &DL, SectionKind Kind, const Constant *C,
1406	Align &Alignment) const {
1407	// If this constant requires a relocation, we have to put it in the data
1408	// segment, not in the text segment.
1409	if (Kind.isData() || Kind.isReadOnlyWithRel())
1410	return ConstDataSection;
1411
1412	if (Kind.isMergeableConst4())
1413	return FourByteConstantSection;
1414	if (Kind.isMergeableConst8())
1415	return EightByteConstantSection;
1416	if (Kind.isMergeableConst16())
1417	return SixteenByteConstantSection;
1418	return ReadOnlySection; // .const
1419	}
1420
1421	MCSection *TargetLoweringObjectFileMachO::getSectionForCommandLines() const {
1422	return getContext().getMachOSection(Segment: "__TEXT", Section: "__command_line", TypeAndAttributes: 0,
1423	K: SectionKind::getReadOnly());
1424	}
1425
1426	const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
1427	const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1428	MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1429	// The mach-o version of this method defaults to returning a stub reference.
1430
1431	if (Encoding & DW_EH_PE_indirect) {
1432	MachineModuleInfoMachO &MachOMMI =
1433	MMI->getObjFileInfo<MachineModuleInfoMachO>();
1434
1435	MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, Suffix: "$non_lazy_ptr", TM);
1436
1437	// Add information about the stub reference to MachOMMI so that the stub
1438	// gets emitted by the asmprinter.
1439	MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Sym: SSym);
1440	if (!StubSym.getPointer()) {
1441	MCSymbol *Sym = TM.getSymbol(GV);
1442	StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1443	}
1444
1445	return TargetLoweringObjectFile::
1446	getTTypeReference(Sym: MCSymbolRefExpr::create(Symbol: SSym, Ctx&: getContext()),
1447	Encoding: Encoding & ~DW_EH_PE_indirect, Streamer);
1448	}
1449
1450	return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
1451	MMI, Streamer);
1452	}
1453
1454	MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
1455	const GlobalValue *GV, const TargetMachine &TM,
1456	MachineModuleInfo *MMI) const {
1457	// The mach-o version of this method defaults to returning a stub reference.
1458	MachineModuleInfoMachO &MachOMMI =
1459	MMI->getObjFileInfo<MachineModuleInfoMachO>();
1460
1461	MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, Suffix: "$non_lazy_ptr", TM);
1462
1463	// Add information about the stub reference to MachOMMI so that the stub
1464	// gets emitted by the asmprinter.
1465	MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Sym: SSym);
1466	if (!StubSym.getPointer()) {
1467	MCSymbol *Sym = TM.getSymbol(GV);
1468	StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1469	}
1470
1471	return SSym;
1472	}
1473
1474	const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
1475	const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
1476	int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1477	// Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1478	// as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1479	// through a non_lazy_ptr stub instead. One advantage is that it allows the
1480	// computation of deltas to final external symbols. Example:
1481	//
1482	// _extgotequiv:
1483	// .long _extfoo
1484	//
1485	// _delta:
1486	// .long _extgotequiv-_delta
1487	//
1488	// is transformed to:
1489	//
1490	// _delta:
1491	// .long L_extfoo$non_lazy_ptr-(_delta+0)
1492	//
1493	// .section __IMPORT,__pointers,non_lazy_symbol_pointers
1494	// L_extfoo$non_lazy_ptr:
1495	// .indirect_symbol _extfoo
1496	// .long 0
1497	//
1498	// The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1499	// may point to both local (same translation unit) and global (other
1500	// translation units) symbols. Example:
1501	//
1502	// .section __DATA,__pointers,non_lazy_symbol_pointers
1503	// L1:
1504	// .indirect_symbol _myGlobal
1505	// .long 0
1506	// L2:
1507	// .indirect_symbol _myLocal
1508	// .long _myLocal
1509	//
1510	// If the symbol is local, instead of the symbol's index, the assembler
1511	// places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1512	// Then the linker will notice the constant in the table and will look at the
1513	// content of the symbol.
1514	MachineModuleInfoMachO &MachOMMI =
1515	MMI->getObjFileInfo<MachineModuleInfoMachO>();
1516	MCContext &Ctx = getContext();
1517
1518	// The offset must consider the original displacement from the base symbol
1519	// since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1520	Offset = -MV.getConstant();
1521	const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1522
1523	// Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1524	// non_lazy_ptr stubs.
1525	SmallString<128> Name;
1526	StringRef Suffix = "$non_lazy_ptr";
1527	Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
1528	Name += Sym->getName();
1529	Name += Suffix;
1530	MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1531
1532	MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Sym: Stub);
1533
1534	if (!StubSym.getPointer())
1535	StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1536	!GV->hasLocalLinkage());
1537
1538	const MCExpr *BSymExpr =
1539	MCSymbolRefExpr::create(Symbol: BaseSym, Kind: MCSymbolRefExpr::VK_None, Ctx);
1540	const MCExpr *LHS =
1541	MCSymbolRefExpr::create(Symbol: Stub, Kind: MCSymbolRefExpr::VK_None, Ctx);
1542
1543	if (!Offset)
1544	return MCBinaryExpr::createSub(LHS, RHS: BSymExpr, Ctx);
1545
1546	const MCExpr *RHS =
1547	MCBinaryExpr::createAdd(LHS: BSymExpr, RHS: MCConstantExpr::create(Value: Offset, Ctx), Ctx);
1548	return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1549	}
1550
1551	static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1552	const MCSection &Section) {
1553	if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1554	return true;
1555
1556	// FIXME: we should be able to use private labels for sections that can't be
1557	// dead-stripped (there's no issue with blocking atomization there), but `ld
1558	// -r` sometimes drops the no_dead_strip attribute from sections so for safety
1559	// we don't allow it.
1560	return false;
1561	}
1562
1563	void TargetLoweringObjectFileMachO::getNameWithPrefix(
1564	SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1565	const TargetMachine &TM) const {
1566	bool CannotUsePrivateLabel = true;
1567	if (auto *GO = GV->getAliaseeObject()) {
1568	SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM);
1569	const MCSection *TheSection = SectionForGlobal(GO, Kind: GOKind, TM);
1570	CannotUsePrivateLabel =
1571	!canUsePrivateLabel(AsmInfo: *TM.getMCAsmInfo(), Section: *TheSection);
1572	}
1573	getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1574	}
1575
1576	//===----------------------------------------------------------------------===//
1577	// COFF
1578	//===----------------------------------------------------------------------===//
1579
1580	static unsigned
1581	getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
1582	unsigned Flags = 0;
1583	bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1584
1585	if (K.isMetadata())
1586	Flags |=
1587	COFF::IMAGE_SCN_MEM_DISCARDABLE;
1588	else if (K.isExclude())
1589	Flags |=
1590	COFF::IMAGE_SCN_LNK_REMOVE | COFF::IMAGE_SCN_MEM_DISCARDABLE;
1591	else if (K.isText())
1592	Flags |=
1593	COFF::IMAGE_SCN_MEM_EXECUTE |
1594	COFF::IMAGE_SCN_MEM_READ |
1595	COFF::IMAGE_SCN_CNT_CODE |
1596	(isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
1597	else if (K.isBSS())
1598	Flags |=
1599	COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1600	COFF::IMAGE_SCN_MEM_READ |
1601	COFF::IMAGE_SCN_MEM_WRITE;
1602	else if (K.isThreadLocal())
1603	Flags |=
1604	COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1605	COFF::IMAGE_SCN_MEM_READ |
1606	COFF::IMAGE_SCN_MEM_WRITE;
1607	else if (K.isReadOnly() || K.isReadOnlyWithRel())
1608	Flags |=
1609	COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1610	COFF::IMAGE_SCN_MEM_READ;
1611	else if (K.isWriteable())
1612	Flags |=
1613	COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1614	COFF::IMAGE_SCN_MEM_READ |
1615	COFF::IMAGE_SCN_MEM_WRITE;
1616
1617	return Flags;
1618	}
1619
1620	static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
1621	const Comdat *C = GV->getComdat();
1622	assert(C && "expected GV to have a Comdat!");
1623
1624	StringRef ComdatGVName = C->getName();
1625	const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(Name: ComdatGVName);
1626	if (!ComdatGV)
1627	report_fatal_error(reason: "Associative COMDAT symbol '" + ComdatGVName +
1628	"' does not exist.");
1629
1630	if (ComdatGV->getComdat() != C)
1631	report_fatal_error(reason: "Associative COMDAT symbol '" + ComdatGVName +
1632	"' is not a key for its COMDAT.");
1633
1634	return ComdatGV;
1635	}
1636
1637	static int getSelectionForCOFF(const GlobalValue *GV) {
1638	if (const Comdat *C = GV->getComdat()) {
1639	const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1640	if (const auto *GA = dyn_cast<GlobalAlias>(Val: ComdatKey))
1641	ComdatKey = GA->getAliaseeObject();
1642	if (ComdatKey == GV) {
1643	switch (C->getSelectionKind()) {
1644	case Comdat::Any:
1645	return COFF::IMAGE_COMDAT_SELECT_ANY;
1646	case Comdat::ExactMatch:
1647	return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
1648	case Comdat::Largest:
1649	return COFF::IMAGE_COMDAT_SELECT_LARGEST;
1650	case Comdat::NoDeduplicate:
1651	return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
1652	case Comdat::SameSize:
1653	return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
1654	}
1655	} else {
1656	return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
1657	}
1658	}
1659	return 0;
1660	}
1661
1662	MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
1663	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1664	StringRef Name = GO->getSection();
1665	if (Name == getInstrProfSectionName(IPSK: IPSK_covmap, OF: Triple::COFF,
1666	/*AddSegmentInfo=*/false) ||
1667	Name == getInstrProfSectionName(IPSK: IPSK_covfun, OF: Triple::COFF,
1668	/*AddSegmentInfo=*/false) ||
1669	Name == getInstrProfSectionName(IPSK: IPSK_covdata, OF: Triple::COFF,
1670	/*AddSegmentInfo=*/false) ||
1671	Name == getInstrProfSectionName(IPSK: IPSK_covname, OF: Triple::COFF,
1672	/*AddSegmentInfo=*/false))
1673	Kind = SectionKind::getMetadata();
1674	int Selection = 0;
1675	unsigned Characteristics = getCOFFSectionFlags(K: Kind, TM);
1676	StringRef COMDATSymName = "";
1677	if (GO->hasComdat()) {
1678	Selection = getSelectionForCOFF(GV: GO);
1679	const GlobalValue *ComdatGV;
1680	if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
1681	ComdatGV = getComdatGVForCOFF(GV: GO);
1682	else
1683	ComdatGV = GO;
1684
1685	if (!ComdatGV->hasPrivateLinkage()) {
1686	MCSymbol *Sym = TM.getSymbol(GV: ComdatGV);
1687	COMDATSymName = Sym->getName();
1688	Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1689	} else {
1690	Selection = 0;
1691	}
1692	}
1693
1694	return getContext().getCOFFSection(Section: Name, Characteristics, Kind, COMDATSymName,
1695	Selection);
1696	}
1697
1698	static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
1699	if (Kind.isText())
1700	return ".text";
1701	if (Kind.isBSS())
1702	return ".bss";
1703	if (Kind.isThreadLocal())
1704	return ".tls$";
1705	if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1706	return ".rdata";
1707	return ".data";
1708	}
1709
1710	MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
1711	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1712	// If we have -ffunction-sections then we should emit the global value to a
1713	// uniqued section specifically for it.
1714	bool EmitUniquedSection;
1715	if (Kind.isText())
1716	EmitUniquedSection = TM.getFunctionSections();
1717	else
1718	EmitUniquedSection = TM.getDataSections();
1719
1720	if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1721	SmallString<256> Name = getCOFFSectionNameForUniqueGlobal(Kind);
1722
1723	unsigned Characteristics = getCOFFSectionFlags(K: Kind, TM);
1724
1725	Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1726	int Selection = getSelectionForCOFF(GV: GO);
1727	if (!Selection)
1728	Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
1729	const GlobalValue *ComdatGV;
1730	if (GO->hasComdat())
1731	ComdatGV = getComdatGVForCOFF(GV: GO);
1732	else
1733	ComdatGV = GO;
1734
1735	unsigned UniqueID = MCContext::GenericSectionID;
1736	if (EmitUniquedSection)
1737	UniqueID = NextUniqueID++;
1738
1739	if (!ComdatGV->hasPrivateLinkage()) {
1740	MCSymbol *Sym = TM.getSymbol(GV: ComdatGV);
1741	StringRef COMDATSymName = Sym->getName();
1742
1743	if (const auto *F = dyn_cast<Function>(Val: GO))
1744	if (std::optional<StringRef> Prefix = F->getSectionPrefix())
1745	raw_svector_ostream(Name) << '$' << *Prefix;
1746
1747	// Append "$symbol" to the section name *before* IR-level mangling is
1748	// applied when targetting mingw. This is what GCC does, and the ld.bfd
1749	// COFF linker will not properly handle comdats otherwise.
1750	if (getContext().getTargetTriple().isWindowsGNUEnvironment())
1751	raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1752
1753	return getContext().getCOFFSection(Section: Name, Characteristics, Kind,
1754	COMDATSymName, Selection, UniqueID);
1755	} else {
1756	SmallString<256> TmpData;
1757	getMangler().getNameWithPrefix(OutName&: TmpData, GV: GO, /*CannotUsePrivateLabel=*/true);
1758	return getContext().getCOFFSection(Section: Name, Characteristics, Kind, COMDATSymName: TmpData,
1759	Selection, UniqueID);
1760	}
1761	}
1762
1763	if (Kind.isText())
1764	return TextSection;
1765
1766	if (Kind.isThreadLocal())
1767	return TLSDataSection;
1768
1769	if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1770	return ReadOnlySection;
1771
1772	// Note: we claim that common symbols are put in BSSSection, but they are
1773	// really emitted with the magic .comm directive, which creates a symbol table
1774	// entry but not a section.
1775	if (Kind.isBSS() || Kind.isCommon())
1776	return BSSSection;
1777
1778	return DataSection;
1779	}
1780
1781	void TargetLoweringObjectFileCOFF::getNameWithPrefix(
1782	SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1783	const TargetMachine &TM) const {
1784	bool CannotUsePrivateLabel = false;
1785	if (GV->hasPrivateLinkage() &&
1786	((isa<Function>(Val: GV) && TM.getFunctionSections()) ||
1787	(isa<GlobalVariable>(Val: GV) && TM.getDataSections())))
1788	CannotUsePrivateLabel = true;
1789
1790	getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1791	}
1792
1793	MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
1794	const Function &F, const TargetMachine &TM) const {
1795	// If the function can be removed, produce a unique section so that
1796	// the table doesn't prevent the removal.
1797	const Comdat *C = F.getComdat();
1798	bool EmitUniqueSection = TM.getFunctionSections() || C;
1799	if (!EmitUniqueSection)
1800	return ReadOnlySection;
1801
1802	// FIXME: we should produce a symbol for F instead.
1803	if (F.hasPrivateLinkage())
1804	return ReadOnlySection;
1805
1806	MCSymbol *Sym = TM.getSymbol(GV: &F);
1807	StringRef COMDATSymName = Sym->getName();
1808
1809	SectionKind Kind = SectionKind::getReadOnly();
1810	StringRef SecName = getCOFFSectionNameForUniqueGlobal(Kind);
1811	unsigned Characteristics = getCOFFSectionFlags(K: Kind, TM);
1812	Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1813	unsigned UniqueID = NextUniqueID++;
1814
1815	return getContext().getCOFFSection(
1816	Section: SecName, Characteristics, Kind, COMDATSymName,
1817	Selection: COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
1818	}
1819
1820	bool TargetLoweringObjectFileCOFF::shouldPutJumpTableInFunctionSection(
1821	bool UsesLabelDifference, const Function &F) const {
1822	if (TM->getTargetTriple().getArch() == Triple::x86_64) {
1823	if (!JumpTableInFunctionSection) {
1824	// We can always create relative relocations, so use another section
1825	// that can be marked non-executable.
1826	return false;
1827	}
1828	}
1829	return TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection(
1830	UsesLabelDifference, F);
1831	}
1832
1833	void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
1834	Module &M) const {
1835	emitLinkerDirectives(Streamer, M);
1836
1837	unsigned Version = 0;
1838	unsigned Flags = 0;
1839	StringRef Section;
1840
1841	GetObjCImageInfo(M, Version, Flags, Section);
1842	if (!Section.empty()) {
1843	auto &C = getContext();
1844	auto *S = C.getCOFFSection(Section,
1845	Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1846	COFF::IMAGE_SCN_MEM_READ,
1847	Kind: SectionKind::getReadOnly());
1848	Streamer.switchSection(Section: S);
1849	Streamer.emitLabel(Symbol: C.getOrCreateSymbol(Name: StringRef("OBJC_IMAGE_INFO")));
1850	Streamer.emitInt32(Value: Version);
1851	Streamer.emitInt32(Value: Flags);
1852	Streamer.addBlankLine();
1853	}
1854
1855	emitCGProfileMetadata(Streamer, M);
1856	}
1857
1858	void TargetLoweringObjectFileCOFF::emitLinkerDirectives(
1859	MCStreamer &Streamer, Module &M) const {
1860	if (NamedMDNode *LinkerOptions = M.getNamedMetadata(Name: "llvm.linker.options")) {
1861	// Emit the linker options to the linker .drectve section. According to the
1862	// spec, this section is a space-separated string containing flags for
1863	// linker.
1864	MCSection *Sec = getDrectveSection();
1865	Streamer.switchSection(Section: Sec);
1866	for (const auto *Option : LinkerOptions->operands()) {
1867	for (const auto &Piece : cast<MDNode>(Val: Option)->operands()) {
1868	// Lead with a space for consistency with our dllexport implementation.
1869	std::string Directive(" ");
1870	Directive.append(str: std::string(cast<MDString>(Val: Piece)->getString()));
1871	Streamer.emitBytes(Data: Directive);
1872	}
1873	}
1874	}
1875
1876	// Emit /EXPORT: flags for each exported global as necessary.
1877	std::string Flags;
1878	for (const GlobalValue &GV : M.global_values()) {
1879	raw_string_ostream OS(Flags);
1880	emitLinkerFlagsForGlobalCOFF(OS, GV: &GV, TT: getContext().getTargetTriple(),
1881	Mangler&: getMangler());
1882	OS.flush();
1883	if (!Flags.empty()) {
1884	Streamer.switchSection(Section: getDrectveSection());
1885	Streamer.emitBytes(Data: Flags);
1886	}
1887	Flags.clear();
1888	}
1889
1890	// Emit /INCLUDE: flags for each used global as necessary.
1891	if (const auto *LU = M.getNamedGlobal(Name: "llvm.used")) {
1892	assert(LU->hasInitializer() && "expected llvm.used to have an initializer");
1893	assert(isa<ArrayType>(LU->getValueType()) &&
1894	"expected llvm.used to be an array type");
1895	if (const auto *A = cast<ConstantArray>(Val: LU->getInitializer())) {
1896	for (const Value *Op : A->operands()) {
1897	const auto *GV = cast<GlobalValue>(Val: Op->stripPointerCasts());
1898	// Global symbols with internal or private linkage are not visible to
1899	// the linker, and thus would cause an error when the linker tried to
1900	// preserve the symbol due to the `/include:` directive.
1901	if (GV->hasLocalLinkage())
1902	continue;
1903
1904	raw_string_ostream OS(Flags);
1905	emitLinkerFlagsForUsedCOFF(OS, GV, T: getContext().getTargetTriple(),
1906	M&: getMangler());
1907	OS.flush();
1908
1909	if (!Flags.empty()) {
1910	Streamer.switchSection(Section: getDrectveSection());
1911	Streamer.emitBytes(Data: Flags);
1912	}
1913	Flags.clear();
1914	}
1915	}
1916	}
1917	}
1918
1919	void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
1920	const TargetMachine &TM) {
1921	TargetLoweringObjectFile::Initialize(ctx&: Ctx, TM);
1922	this->TM = &TM;
1923	const Triple &T = TM.getTargetTriple();
1924	if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1925	StaticCtorSection =
1926	Ctx.getCOFFSection(Section: ".CRT$XCU", Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1927	COFF::IMAGE_SCN_MEM_READ,
1928	Kind: SectionKind::getReadOnly());
1929	StaticDtorSection =
1930	Ctx.getCOFFSection(Section: ".CRT$XTX", Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1931	COFF::IMAGE_SCN_MEM_READ,
1932	Kind: SectionKind::getReadOnly());
1933	} else {
1934	StaticCtorSection = Ctx.getCOFFSection(
1935	Section: ".ctors", Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1936	COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
1937	Kind: SectionKind::getData());
1938	StaticDtorSection = Ctx.getCOFFSection(
1939	Section: ".dtors", Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1940	COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
1941	Kind: SectionKind::getData());
1942	}
1943	}
1944
1945	static MCSectionCOFF *getCOFFStaticStructorSection(MCContext &Ctx,
1946	const Triple &T, bool IsCtor,
1947	unsigned Priority,
1948	const MCSymbol *KeySym,
1949	MCSectionCOFF *Default) {
1950	if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1951	// If the priority is the default, use .CRT$XCU, possibly associative.
1952	if (Priority == 65535)
1953	return Ctx.getAssociativeCOFFSection(Sec: Default, KeySym, UniqueID: 0);
1954
1955	// Otherwise, we need to compute a new section name. Low priorities should
1956	// run earlier. The linker will sort sections ASCII-betically, and we need a
1957	// string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1958	// make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1959	// low priorities need to sort before 'L', since the CRT uses that
1960	// internally, so we use ".CRT$XCA00001" for them. We have a contract with
1961	// the frontend that "init_seg(compiler)" corresponds to priority 200 and
1962	// "init_seg(lib)" corresponds to priority 400, and those respectively use
1963	// 'C' and 'L' without the priority suffix. Priorities between 200 and 400
1964	// use 'C' with the priority as a suffix.
1965	SmallString<24> Name;
1966	char LastLetter = 'T';
1967	bool AddPrioritySuffix = Priority != 200 && Priority != 400;
1968	if (Priority < 200)
1969	LastLetter = 'A';
1970	else if (Priority < 400)
1971	LastLetter = 'C';
1972	else if (Priority == 400)
1973	LastLetter = 'L';
1974	raw_svector_ostream OS(Name);
1975	OS << ".CRT$X" << (IsCtor ? "C" : "T") << LastLetter;
1976	if (AddPrioritySuffix)
1977	OS << format(Fmt: "%05u", Vals: Priority);
1978	MCSectionCOFF *Sec = Ctx.getCOFFSection(
1979	Section: Name, Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
1980	Kind: SectionKind::getReadOnly());
1981	return Ctx.getAssociativeCOFFSection(Sec, KeySym, UniqueID: 0);
1982	}
1983
1984	std::string Name = IsCtor ? ".ctors" : ".dtors";
1985	if (Priority != 65535)
1986	raw_string_ostream(Name) << format(Fmt: ".%05u", Vals: 65535 - Priority);
1987
1988	return Ctx.getAssociativeCOFFSection(
1989	Sec: Ctx.getCOFFSection(Section: Name, Characteristics: COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1990	COFF::IMAGE_SCN_MEM_READ |
1991	COFF::IMAGE_SCN_MEM_WRITE,
1992	Kind: SectionKind::getData()),
1993	KeySym, UniqueID: 0);
1994	}
1995
1996	MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
1997	unsigned Priority, const MCSymbol *KeySym) const {
1998	return getCOFFStaticStructorSection(
1999	Ctx&: getContext(), T: getContext().getTargetTriple(), IsCtor: true, Priority, KeySym,
2000	Default: cast<MCSectionCOFF>(Val: StaticCtorSection));
2001	}
2002
2003	MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
2004	unsigned Priority, const MCSymbol *KeySym) const {
2005	return getCOFFStaticStructorSection(
2006	Ctx&: getContext(), T: getContext().getTargetTriple(), IsCtor: false, Priority, KeySym,
2007	Default: cast<MCSectionCOFF>(Val: StaticDtorSection));
2008	}
2009
2010	const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
2011	const GlobalValue *LHS, const GlobalValue *RHS,
2012	const TargetMachine &TM) const {
2013	const Triple &T = TM.getTargetTriple();
2014	if (T.isOSCygMing())
2015	return nullptr;
2016
2017	// Our symbols should exist in address space zero, cowardly no-op if
2018	// otherwise.
2019	if (LHS->getType()->getPointerAddressSpace() != 0 ||
2020	RHS->getType()->getPointerAddressSpace() != 0)
2021	return nullptr;
2022
2023	// Both ptrtoint instructions must wrap global objects:
2024	// - Only global variables are eligible for image relative relocations.
2025	// - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
2026	// We expect __ImageBase to be a global variable without a section, externally
2027	// defined.
2028	//
2029	// It should look something like this: @__ImageBase = external constant i8
2030	if (!isa<GlobalObject>(Val: LHS) || !isa<GlobalVariable>(Val: RHS) ||
2031	LHS->isThreadLocal() || RHS->isThreadLocal() ||
2032	RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
2033	cast<GlobalVariable>(Val: RHS)->hasInitializer() || RHS->hasSection())
2034	return nullptr;
2035
2036	return MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV: LHS),
2037	Kind: MCSymbolRefExpr::VK_COFF_IMGREL32,
2038	Ctx&: getContext());
2039	}
2040
2041	static std::string APIntToHexString(const APInt &AI) {
2042	unsigned Width = (AI.getBitWidth() / 8) * 2;
2043	std::string HexString = toString(I: AI, Radix: 16, /*Signed=*/false);
2044	llvm::transform(Range&: HexString, d_first: HexString.begin(), F: tolower);
2045	unsigned Size = HexString.size();
2046	assert(Width >= Size && "hex string is too large!");
2047	HexString.insert(p: HexString.begin(), n: Width - Size, c: '0');
2048
2049	return HexString;
2050	}
2051
2052	static std::string scalarConstantToHexString(const Constant *C) {
2053	Type *Ty = C->getType();
2054	if (isa<UndefValue>(Val: C)) {
2055	return APIntToHexString(AI: APInt::getZero(numBits: Ty->getPrimitiveSizeInBits()));
2056	} else if (const auto *CFP = dyn_cast<ConstantFP>(Val: C)) {
2057	return APIntToHexString(AI: CFP->getValueAPF().bitcastToAPInt());
2058	} else if (const auto *CI = dyn_cast<ConstantInt>(Val: C)) {
2059	return APIntToHexString(AI: CI->getValue());
2060	} else {
2061	unsigned NumElements;
2062	if (auto *VTy = dyn_cast<VectorType>(Val: Ty))
2063	NumElements = cast<FixedVectorType>(Val: VTy)->getNumElements();
2064	else
2065	NumElements = Ty->getArrayNumElements();
2066	std::string HexString;
2067	for (int I = NumElements - 1, E = -1; I != E; --I)
2068	HexString += scalarConstantToHexString(C: C->getAggregateElement(Elt: I));
2069	return HexString;
2070	}
2071	}
2072
2073	MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
2074	const DataLayout &DL, SectionKind Kind, const Constant *C,
2075	Align &Alignment) const {
2076	if (Kind.isMergeableConst() && C &&
2077	getContext().getAsmInfo()->hasCOFFComdatConstants()) {
2078	// This creates comdat sections with the given symbol name, but unless
2079	// AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
2080	// will be created with a null storage class, which makes GNU binutils
2081	// error out.
2082	const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
2083	COFF::IMAGE_SCN_MEM_READ |
2084	COFF::IMAGE_SCN_LNK_COMDAT;
2085	std::string COMDATSymName;
2086	if (Kind.isMergeableConst4()) {
2087	if (Alignment <= 4) {
2088	COMDATSymName = "__real@" + scalarConstantToHexString(C);
2089	Alignment = Align(4);
2090	}
2091	} else if (Kind.isMergeableConst8()) {
2092	if (Alignment <= 8) {
2093	COMDATSymName = "__real@" + scalarConstantToHexString(C);
2094	Alignment = Align(8);
2095	}
2096	} else if (Kind.isMergeableConst16()) {
2097	// FIXME: These may not be appropriate for non-x86 architectures.
2098	if (Alignment <= 16) {
2099	COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
2100	Alignment = Align(16);
2101	}
2102	} else if (Kind.isMergeableConst32()) {
2103	if (Alignment <= 32) {
2104	COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
2105	Alignment = Align(32);
2106	}
2107	}
2108
2109	if (!COMDATSymName.empty())
2110	return getContext().getCOFFSection(Section: ".rdata", Characteristics, Kind,
2111	COMDATSymName,
2112	Selection: COFF::IMAGE_COMDAT_SELECT_ANY);
2113	}
2114
2115	return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C,
2116	Alignment);
2117	}
2118
2119	//===----------------------------------------------------------------------===//
2120	// Wasm
2121	//===----------------------------------------------------------------------===//
2122
2123	static const Comdat *getWasmComdat(const GlobalValue *GV) {
2124	const Comdat *C = GV->getComdat();
2125	if (!C)
2126	return nullptr;
2127
2128	if (C->getSelectionKind() != Comdat::Any)
2129	report_fatal_error(reason: "WebAssembly COMDATs only support "
2130	"SelectionKind::Any, '" + C->getName() + "' cannot be "
2131	"lowered.");
2132
2133	return C;
2134	}
2135
2136	static unsigned getWasmSectionFlags(SectionKind K, bool Retain) {
2137	unsigned Flags = 0;
2138
2139	if (K.isThreadLocal())
2140	Flags |= wasm::WASM_SEG_FLAG_TLS;
2141
2142	if (K.isMergeableCString())
2143	Flags |= wasm::WASM_SEG_FLAG_STRINGS;
2144
2145	if (Retain)
2146	Flags |= wasm::WASM_SEG_FLAG_RETAIN;
2147
2148	// TODO(sbc): Add suport for K.isMergeableConst()
2149
2150	return Flags;
2151	}
2152
2153	void TargetLoweringObjectFileWasm::getModuleMetadata(Module &M) {
2154	SmallVector<GlobalValue *, 4> Vec;
2155	collectUsedGlobalVariables(M, Vec, CompilerUsed: false);
2156	for (GlobalValue *GV : Vec)
2157	if (auto *GO = dyn_cast<GlobalObject>(Val: GV))
2158	Used.insert(Ptr: GO);
2159	}
2160
2161	MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
2162	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2163	// We don't support explict section names for functions in the wasm object
2164	// format. Each function has to be in its own unique section.
2165	if (isa<Function>(Val: GO)) {
2166	return SelectSectionForGlobal(GO, Kind, TM);
2167	}
2168
2169	StringRef Name = GO->getSection();
2170
2171	// Certain data sections we treat as named custom sections rather than
2172	// segments within the data section.
2173	// This could be avoided if all data segements (the wasm sense) were
2174	// represented as their own sections (in the llvm sense).
2175	// TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
2176	if (Name == ".llvmcmd" || Name == ".llvmbc")
2177	Kind = SectionKind::getMetadata();
2178
2179	StringRef Group = "";
2180	if (const Comdat *C = getWasmComdat(GV: GO)) {
2181	Group = C->getName();
2182	}
2183
2184	unsigned Flags = getWasmSectionFlags(K: Kind, Retain: Used.count(Ptr: GO));
2185	MCSectionWasm *Section = getContext().getWasmSection(
2186	Section: Name, K: Kind, Flags, Group, UniqueID: MCContext::GenericSectionID);
2187
2188	return Section;
2189	}
2190
2191	static MCSectionWasm *
2192	selectWasmSectionForGlobal(MCContext &Ctx, const GlobalObject *GO,
2193	SectionKind Kind, Mangler &Mang,
2194	const TargetMachine &TM, bool EmitUniqueSection,
2195	unsigned *NextUniqueID, bool Retain) {
2196	StringRef Group = "";
2197	if (const Comdat *C = getWasmComdat(GV: GO)) {
2198	Group = C->getName();
2199	}
2200
2201	bool UniqueSectionNames = TM.getUniqueSectionNames();
2202	SmallString<128> Name = getSectionPrefixForGlobal(Kind, /*IsLarge=*/false);
2203
2204	if (const auto *F = dyn_cast<Function>(Val: GO)) {
2205	const auto &OptionalPrefix = F->getSectionPrefix();
2206	if (OptionalPrefix)
2207	raw_svector_ostream(Name) << '.' << *OptionalPrefix;
2208	}
2209
2210	if (EmitUniqueSection && UniqueSectionNames) {
2211	Name.push_back(Elt: '.');
2212	TM.getNameWithPrefix(Name, GV: GO, Mang, MayAlwaysUsePrivate: true);
2213	}
2214	unsigned UniqueID = MCContext::GenericSectionID;
2215	if (EmitUniqueSection && !UniqueSectionNames) {
2216	UniqueID = *NextUniqueID;
2217	(*NextUniqueID)++;
2218	}
2219
2220	unsigned Flags = getWasmSectionFlags(K: Kind, Retain);
2221	return Ctx.getWasmSection(Section: Name, K: Kind, Flags, Group, UniqueID);
2222	}
2223
2224	MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
2225	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2226
2227	if (Kind.isCommon())
2228	report_fatal_error(reason: "mergable sections not supported yet on wasm");
2229
2230	// If we have -ffunction-section or -fdata-section then we should emit the
2231	// global value to a uniqued section specifically for it.
2232	bool EmitUniqueSection = false;
2233	if (Kind.isText())
2234	EmitUniqueSection = TM.getFunctionSections();
2235	else
2236	EmitUniqueSection = TM.getDataSections();
2237	EmitUniqueSection |= GO->hasComdat();
2238	bool Retain = Used.count(Ptr: GO);
2239	EmitUniqueSection |= Retain;
2240
2241	return selectWasmSectionForGlobal(Ctx&: getContext(), GO, Kind, Mang&: getMangler(), TM,
2242	EmitUniqueSection, NextUniqueID: &NextUniqueID, Retain);
2243	}
2244
2245	bool TargetLoweringObjectFileWasm::shouldPutJumpTableInFunctionSection(
2246	bool UsesLabelDifference, const Function &F) const {
2247	// We can always create relative relocations, so use another section
2248	// that can be marked non-executable.
2249	return false;
2250	}
2251
2252	const MCExpr *TargetLoweringObjectFileWasm::lowerRelativeReference(
2253	const GlobalValue *LHS, const GlobalValue *RHS,
2254	const TargetMachine &TM) const {
2255	// We may only use a PLT-relative relocation to refer to unnamed_addr
2256	// functions.
2257	if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
2258	return nullptr;
2259
2260	// Basic correctness checks.
2261	if (LHS->getType()->getPointerAddressSpace() != 0 ||
2262	RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
2263	RHS->isThreadLocal())
2264	return nullptr;
2265
2266	return MCBinaryExpr::createSub(
2267	LHS: MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV: LHS), Kind: MCSymbolRefExpr::VK_None,
2268	Ctx&: getContext()),
2269	RHS: MCSymbolRefExpr::create(Symbol: TM.getSymbol(GV: RHS), Ctx&: getContext()), Ctx&: getContext());
2270	}
2271
2272	void TargetLoweringObjectFileWasm::InitializeWasm() {
2273	StaticCtorSection =
2274	getContext().getWasmSection(Section: ".init_array", K: SectionKind::getData());
2275
2276	// We don't use PersonalityEncoding and LSDAEncoding because we don't emit
2277	// .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
2278	TTypeEncoding = dwarf::DW_EH_PE_absptr;
2279	}
2280
2281	MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection(
2282	unsigned Priority, const MCSymbol *KeySym) const {
2283	return Priority == UINT16_MAX ?
2284	StaticCtorSection :
2285	getContext().getWasmSection(Section: ".init_array." + utostr(X: Priority),
2286	K: SectionKind::getData());
2287	}
2288
2289	MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
2290	unsigned Priority, const MCSymbol *KeySym) const {
2291	report_fatal_error(reason: "@llvm.global_dtors should have been lowered already");
2292	}
2293
2294	//===----------------------------------------------------------------------===//
2295	// XCOFF
2296	//===----------------------------------------------------------------------===//
2297	bool TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(
2298	const MachineFunction *MF) {
2299	if (!MF->getLandingPads().empty())
2300	return true;
2301
2302	const Function &F = MF->getFunction();
2303	if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
2304	return false;
2305
2306	const GlobalValue *Per =
2307	dyn_cast<GlobalValue>(Val: F.getPersonalityFn()->stripPointerCasts());
2308	assert(Per && "Personality routine is not a GlobalValue type.");
2309	if (isNoOpWithoutInvoke(Pers: classifyEHPersonality(Pers: Per)))
2310	return false;
2311
2312	return true;
2313	}
2314
2315	bool TargetLoweringObjectFileXCOFF::ShouldSetSSPCanaryBitInTB(
2316	const MachineFunction *MF) {
2317	const Function &F = MF->getFunction();
2318	if (!F.hasStackProtectorFnAttr())
2319	return false;
2320	// FIXME: check presence of canary word
2321	// There are cases that the stack protectors are not really inserted even if
2322	// the attributes are on.
2323	return true;
2324	}
2325
2326	MCSymbol *
2327	TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(const MachineFunction *MF) {
2328	MCSymbol *EHInfoSym = MF->getMMI().getContext().getOrCreateSymbol(
2329	Name: "__ehinfo." + Twine(MF->getFunctionNumber()));
2330	cast<MCSymbolXCOFF>(Val: EHInfoSym)->setEHInfo();
2331	return EHInfoSym;
2332	}
2333
2334	MCSymbol *
2335	TargetLoweringObjectFileXCOFF::getTargetSymbol(const GlobalValue *GV,
2336	const TargetMachine &TM) const {
2337	// We always use a qualname symbol for a GV that represents
2338	// a declaration, a function descriptor, or a common symbol.
2339	// If a GV represents a GlobalVariable and -fdata-sections is enabled, we
2340	// also return a qualname so that a label symbol could be avoided.
2341	// It is inherently ambiguous when the GO represents the address of a
2342	// function, as the GO could either represent a function descriptor or a
2343	// function entry point. We choose to always return a function descriptor
2344	// here.
2345	if (const GlobalObject *GO = dyn_cast<GlobalObject>(Val: GV)) {
2346	if (GO->isDeclarationForLinker())
2347	return cast<MCSectionXCOFF>(Val: getSectionForExternalReference(GO, TM))
2348	->getQualNameSymbol();
2349
2350	if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(Val: GV))
2351	if (GVar->hasAttribute(Kind: "toc-data"))
2352	return cast<MCSectionXCOFF>(
2353	Val: SectionForGlobal(GO: GVar, Kind: SectionKind::getData(), TM))
2354	->getQualNameSymbol();
2355
2356	SectionKind GOKind = getKindForGlobal(GO, TM);
2357	if (GOKind.isText())
2358	return cast<MCSectionXCOFF>(
2359	Val: getSectionForFunctionDescriptor(F: cast<Function>(Val: GO), TM))
2360	->getQualNameSymbol();
2361	if ((TM.getDataSections() && !GO->hasSection()) || GO->hasCommonLinkage() ||
2362	GOKind.isBSSLocal() || GOKind.isThreadBSSLocal())
2363	return cast<MCSectionXCOFF>(Val: SectionForGlobal(GO, Kind: GOKind, TM))
2364	->getQualNameSymbol();
2365	}
2366
2367	// For all other cases, fall back to getSymbol to return the unqualified name.
2368	return nullptr;
2369	}
2370
2371	MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal(
2372	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2373	if (!GO->hasSection())
2374	report_fatal_error(reason: "#pragma clang section is not yet supported");
2375
2376	StringRef SectionName = GO->getSection();
2377
2378	// Handle the XCOFF::TD case first, then deal with the rest.
2379	if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(Val: GO))
2380	if (GVar->hasAttribute(Kind: "toc-data"))
2381	return getContext().getXCOFFSection(
2382	Section: SectionName, K: Kind,
2383	CsectProp: XCOFF::CsectProperties(/*MappingClass*/ XCOFF::XMC_TD, XCOFF::XTY_SD),
2384	/* MultiSymbolsAllowed*/ true);
2385
2386	XCOFF::StorageMappingClass MappingClass;
2387	if (Kind.isText())
2388	MappingClass = XCOFF::XMC_PR;
2389	else if (Kind.isData() || Kind.isBSS())
2390	MappingClass = XCOFF::XMC_RW;
2391	else if (Kind.isReadOnlyWithRel())
2392	MappingClass =
2393	TM.Options.XCOFFReadOnlyPointers ? XCOFF::XMC_RO : XCOFF::XMC_RW;
2394	else if (Kind.isReadOnly())
2395	MappingClass = XCOFF::XMC_RO;
2396	else
2397	report_fatal_error(reason: "XCOFF other section types not yet implemented.");
2398
2399	return getContext().getXCOFFSection(
2400	Section: SectionName, K: Kind, CsectProp: XCOFF::CsectProperties(MappingClass, XCOFF::XTY_SD),
2401	/* MultiSymbolsAllowed*/ true);
2402	}
2403
2404	MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
2405	const GlobalObject *GO, const TargetMachine &TM) const {
2406	assert(GO->isDeclarationForLinker() &&
2407	"Tried to get ER section for a defined global.");
2408
2409	SmallString<128> Name;
2410	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2411
2412	// AIX TLS local-dynamic does not need the external reference for the
2413	// "_$TLSML" symbol.
2414	if (GO->getThreadLocalMode() == GlobalVariable::LocalDynamicTLSModel &&
2415	GO->hasName() && GO->getName() == "_$TLSML") {
2416	return getContext().getXCOFFSection(
2417	Section: Name, K: SectionKind::getData(),
2418	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_TC, XCOFF::XTY_SD));
2419	}
2420
2421	XCOFF::StorageMappingClass SMC =
2422	isa<Function>(Val: GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA;
2423	if (GO->isThreadLocal())
2424	SMC = XCOFF::XMC_UL;
2425
2426	if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(Val: GO))
2427	if (GVar->hasAttribute(Kind: "toc-data"))
2428	SMC = XCOFF::XMC_TD;
2429
2430	// Externals go into a csect of type ER.
2431	return getContext().getXCOFFSection(
2432	Section: Name, K: SectionKind::getMetadata(),
2433	CsectProp: XCOFF::CsectProperties(SMC, XCOFF::XTY_ER));
2434	}
2435
2436	MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
2437	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2438	// Handle the XCOFF::TD case first, then deal with the rest.
2439	if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(Val: GO))
2440	if (GVar->hasAttribute(Kind: "toc-data")) {
2441	SmallString<128> Name;
2442	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2443	XCOFF::SymbolType symType =
2444	GO->hasCommonLinkage() ? XCOFF::XTY_CM : XCOFF::XTY_SD;
2445	return getContext().getXCOFFSection(
2446	Section: Name, K: Kind, CsectProp: XCOFF::CsectProperties(XCOFF::XMC_TD, symType),
2447	/* MultiSymbolsAllowed*/ true);
2448	}
2449
2450	// Common symbols go into a csect with matching name which will get mapped
2451	// into the .bss section.
2452	// Zero-initialized local TLS symbols go into a csect with matching name which
2453	// will get mapped into the .tbss section.
2454	if (Kind.isBSSLocal() || GO->hasCommonLinkage() || Kind.isThreadBSSLocal()) {
2455	SmallString<128> Name;
2456	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2457	XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
2458	: Kind.isCommon() ? XCOFF::XMC_RW
2459	: XCOFF::XMC_UL;
2460	return getContext().getXCOFFSection(
2461	Section: Name, K: Kind, CsectProp: XCOFF::CsectProperties(SMC, XCOFF::XTY_CM));
2462	}
2463
2464	if (Kind.isText()) {
2465	if (TM.getFunctionSections()) {
2466	return cast<MCSymbolXCOFF>(Val: getFunctionEntryPointSymbol(Func: GO, TM))
2467	->getRepresentedCsect();
2468	}
2469	return TextSection;
2470	}
2471
2472	if (TM.Options.XCOFFReadOnlyPointers && Kind.isReadOnlyWithRel()) {
2473	if (!TM.getDataSections())
2474	report_fatal_error(
2475	reason: "ReadOnlyPointers is supported only if data sections is turned on");
2476
2477	SmallString<128> Name;
2478	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2479	return getContext().getXCOFFSection(
2480	Section: Name, K: SectionKind::getReadOnly(),
2481	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_RO, XCOFF::XTY_SD));
2482	}
2483
2484	// For BSS kind, zero initialized data must be emitted to the .data section
2485	// because external linkage control sections that get mapped to the .bss
2486	// section will be linked as tentative defintions, which is only appropriate
2487	// for SectionKind::Common.
2488	if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
2489	if (TM.getDataSections()) {
2490	SmallString<128> Name;
2491	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2492	return getContext().getXCOFFSection(
2493	Section: Name, K: SectionKind::getData(),
2494	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_RW, XCOFF::XTY_SD));
2495	}
2496	return DataSection;
2497	}
2498
2499	if (Kind.isReadOnly()) {
2500	if (TM.getDataSections()) {
2501	SmallString<128> Name;
2502	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2503	return getContext().getXCOFFSection(
2504	Section: Name, K: SectionKind::getReadOnly(),
2505	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_RO, XCOFF::XTY_SD));
2506	}
2507	return ReadOnlySection;
2508	}
2509
2510	// External/weak TLS data and initialized local TLS data are not eligible
2511	// to be put into common csect. If data sections are enabled, thread
2512	// data are emitted into separate sections. Otherwise, thread data
2513	// are emitted into the .tdata section.
2514	if (Kind.isThreadLocal()) {
2515	if (TM.getDataSections()) {
2516	SmallString<128> Name;
2517	getNameWithPrefix(OutName&: Name, GV: GO, TM);
2518	return getContext().getXCOFFSection(
2519	Section: Name, K: Kind, CsectProp: XCOFF::CsectProperties(XCOFF::XMC_TL, XCOFF::XTY_SD));
2520	}
2521	return TLSDataSection;
2522	}
2523
2524	report_fatal_error(reason: "XCOFF other section types not yet implemented.");
2525	}
2526
2527	MCSection *TargetLoweringObjectFileXCOFF::getSectionForJumpTable(
2528	const Function &F, const TargetMachine &TM) const {
2529	assert (!F.getComdat() && "Comdat not supported on XCOFF.");
2530
2531	if (!TM.getFunctionSections())
2532	return ReadOnlySection;
2533
2534	// If the function can be removed, produce a unique section so that
2535	// the table doesn't prevent the removal.
2536	SmallString<128> NameStr(".rodata.jmp..");
2537	getNameWithPrefix(OutName&: NameStr, GV: &F, TM);
2538	return getContext().getXCOFFSection(
2539	Section: NameStr, K: SectionKind::getReadOnly(),
2540	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_RO, XCOFF::XTY_SD));
2541	}
2542
2543	bool TargetLoweringObjectFileXCOFF::shouldPutJumpTableInFunctionSection(
2544	bool UsesLabelDifference, const Function &F) const {
2545	return false;
2546	}
2547
2548	/// Given a mergeable constant with the specified size and relocation
2549	/// information, return a section that it should be placed in.
2550	MCSection *TargetLoweringObjectFileXCOFF::getSectionForConstant(
2551	const DataLayout &DL, SectionKind Kind, const Constant *C,
2552	Align &Alignment) const {
2553	// TODO: Enable emiting constant pool to unique sections when we support it.
2554	if (Alignment > Align(16))
2555	report_fatal_error(reason: "Alignments greater than 16 not yet supported.");
2556
2557	if (Alignment == Align(8)) {
2558	assert(ReadOnly8Section && "Section should always be initialized.");
2559	return ReadOnly8Section;
2560	}
2561
2562	if (Alignment == Align(16)) {
2563	assert(ReadOnly16Section && "Section should always be initialized.");
2564	return ReadOnly16Section;
2565	}
2566
2567	return ReadOnlySection;
2568	}
2569
2570	void TargetLoweringObjectFileXCOFF::Initialize(MCContext &Ctx,
2571	const TargetMachine &TgtM) {
2572	TargetLoweringObjectFile::Initialize(ctx&: Ctx, TM: TgtM);
2573	TTypeEncoding =
2574	dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
2575	(TgtM.getTargetTriple().isArch32Bit() ? dwarf::DW_EH_PE_sdata4
2576	: dwarf::DW_EH_PE_sdata8);
2577	PersonalityEncoding = 0;
2578	LSDAEncoding = 0;
2579	CallSiteEncoding = dwarf::DW_EH_PE_udata4;
2580
2581	// AIX debug for thread local location is not ready. And for integrated as
2582	// mode, the relocatable address for the thread local variable will cause
2583	// linker error. So disable the location attribute generation for thread local
2584	// variables for now.
2585	// FIXME: when TLS debug on AIX is ready, remove this setting.
2586	SupportDebugThreadLocalLocation = false;
2587	}
2588
2589	MCSection *TargetLoweringObjectFileXCOFF::getStaticCtorSection(
2590	unsigned Priority, const MCSymbol *KeySym) const {
2591	report_fatal_error(reason: "no static constructor section on AIX");
2592	}
2593
2594	MCSection *TargetLoweringObjectFileXCOFF::getStaticDtorSection(
2595	unsigned Priority, const MCSymbol *KeySym) const {
2596	report_fatal_error(reason: "no static destructor section on AIX");
2597	}
2598
2599	const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference(
2600	const GlobalValue *LHS, const GlobalValue *RHS,
2601	const TargetMachine &TM) const {
2602	/* Not implemented yet, but don't crash, return nullptr. */
2603	return nullptr;
2604	}
2605
2606	XCOFF::StorageClass
2607	TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(const GlobalValue *GV) {
2608	assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
2609
2610	switch (GV->getLinkage()) {
2611	case GlobalValue::InternalLinkage:
2612	case GlobalValue::PrivateLinkage:
2613	return XCOFF::C_HIDEXT;
2614	case GlobalValue::ExternalLinkage:
2615	case GlobalValue::CommonLinkage:
2616	case GlobalValue::AvailableExternallyLinkage:
2617	return XCOFF::C_EXT;
2618	case GlobalValue::ExternalWeakLinkage:
2619	case GlobalValue::LinkOnceAnyLinkage:
2620	case GlobalValue::LinkOnceODRLinkage:
2621	case GlobalValue::WeakAnyLinkage:
2622	case GlobalValue::WeakODRLinkage:
2623	return XCOFF::C_WEAKEXT;
2624	case GlobalValue::AppendingLinkage:
2625	report_fatal_error(
2626	reason: "There is no mapping that implements AppendingLinkage for XCOFF.");
2627	}
2628	llvm_unreachable("Unknown linkage type!");
2629	}
2630
2631	MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
2632	const GlobalValue *Func, const TargetMachine &TM) const {
2633	assert((isa<Function>(Func) ||
2634	(isa<GlobalAlias>(Func) &&
2635	isa_and_nonnull<Function>(
2636	cast<GlobalAlias>(Func)->getAliaseeObject()))) &&
2637	"Func must be a function or an alias which has a function as base "
2638	"object.");
2639
2640	SmallString<128> NameStr;
2641	NameStr.push_back(Elt: '.');
2642	getNameWithPrefix(OutName&: NameStr, GV: Func, TM);
2643
2644	// When -function-sections is enabled and explicit section is not specified,
2645	// it's not necessary to emit function entry point label any more. We will use
2646	// function entry point csect instead. And for function delcarations, the
2647	// undefined symbols gets treated as csect with XTY_ER property.
2648	if (((TM.getFunctionSections() && !Func->hasSection()) ||
2649	Func->isDeclarationForLinker()) &&
2650	isa<Function>(Val: Func)) {
2651	return getContext()
2652	.getXCOFFSection(
2653	Section: NameStr, K: SectionKind::getText(),
2654	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_PR, Func->isDeclarationForLinker()
2655	? XCOFF::XTY_ER
2656	: XCOFF::XTY_SD))
2657	->getQualNameSymbol();
2658	}
2659
2660	return getContext().getOrCreateSymbol(Name: NameStr);
2661	}
2662
2663	MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
2664	const Function *F, const TargetMachine &TM) const {
2665	SmallString<128> NameStr;
2666	getNameWithPrefix(OutName&: NameStr, GV: F, TM);
2667	return getContext().getXCOFFSection(
2668	Section: NameStr, K: SectionKind::getData(),
2669	CsectProp: XCOFF::CsectProperties(XCOFF::XMC_DS, XCOFF::XTY_SD));
2670	}
2671
2672	MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
2673	const MCSymbol *Sym, const TargetMachine &TM) const {
2674	const XCOFF::StorageMappingClass SMC = [](const MCSymbol *Sym,
2675	const TargetMachine &TM) {
2676	const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(Val: Sym);
2677
2678	// The "_$TLSML" symbol for TLS local-dynamic mode requires XMC_TC,
2679	// otherwise the AIX assembler will complain.
2680	if (XSym->getSymbolTableName() == "_$TLSML")
2681	return XCOFF::XMC_TC;
2682
2683	// Use large code model toc entries for ehinfo symbols as they are
2684	// never referenced directly. The runtime loads their TOC entry
2685	// addresses from the trace-back table.
2686	if (XSym->isEHInfo())
2687	return XCOFF::XMC_TE;
2688
2689	// If the symbol does not have a code model specified use the module value.
2690	if (!XSym->hasPerSymbolCodeModel())
2691	return TM.getCodeModel() == CodeModel::Large ? XCOFF::XMC_TE
2692	: XCOFF::XMC_TC;
2693
2694	return XSym->getPerSymbolCodeModel() == MCSymbolXCOFF::CM_Large
2695	? XCOFF::XMC_TE
2696	: XCOFF::XMC_TC;
2697	}(Sym, TM);
2698
2699	return getContext().getXCOFFSection(
2700	Section: cast<MCSymbolXCOFF>(Val: Sym)->getSymbolTableName(), K: SectionKind::getData(),
2701	CsectProp: XCOFF::CsectProperties(SMC, XCOFF::XTY_SD));
2702	}
2703
2704	MCSection *TargetLoweringObjectFileXCOFF::getSectionForLSDA(
2705	const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2706	auto *LSDA = cast<MCSectionXCOFF>(Val: LSDASection);
2707	if (TM.getFunctionSections()) {
2708	// If option -ffunction-sections is on, append the function name to the
2709	// name of the LSDA csect so that each function has its own LSDA csect.
2710	// This helps the linker to garbage-collect EH info of unused functions.
2711	SmallString<128> NameStr = LSDA->getName();
2712	raw_svector_ostream(NameStr) << '.' << F.getName();
2713	LSDA = getContext().getXCOFFSection(Section: NameStr, K: LSDA->getKind(),
2714	CsectProp: LSDA->getCsectProp());
2715	}
2716	return LSDA;
2717	}
2718	//===----------------------------------------------------------------------===//
2719	// GOFF
2720	//===----------------------------------------------------------------------===//
2721	TargetLoweringObjectFileGOFF::TargetLoweringObjectFileGOFF() = default;
2722
2723	MCSection *TargetLoweringObjectFileGOFF::getExplicitSectionGlobal(
2724	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2725	return SelectSectionForGlobal(GO, Kind, TM);
2726	}
2727
2728	MCSection *TargetLoweringObjectFileGOFF::getSectionForLSDA(
2729	const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2730	std::string Name = ".gcc_exception_table." + F.getName().str();
2731	return getContext().getGOFFSection(Section: Name, Kind: SectionKind::getData(), Parent: nullptr,
2732	SubsectionId: nullptr);
2733	}
2734
2735	MCSection *TargetLoweringObjectFileGOFF::SelectSectionForGlobal(
2736	const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2737	auto *Symbol = TM.getSymbol(GV: GO);
2738	if (Kind.isBSS())
2739	return getContext().getGOFFSection(Section: Symbol->getName(), Kind: SectionKind::getBSS(),
2740	Parent: nullptr, SubsectionId: nullptr);
2741
2742	return getContext().getObjectFileInfo()->getTextSection();
2743	}
2744