1//===- lib/MC/AArch64ELFStreamer.cpp - ELF Object Output for AArch64 ------===//
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 assembles .s files and emits AArch64 ELF .o object files. Different
10// from generic ELF streamer in emitting mapping symbols ($x and $d) to delimit
11// regions of data and code.
12//
13//===----------------------------------------------------------------------===//
14
15#include "AArch64ELFStreamer.h"
16#include "AArch64MCTargetDesc.h"
17#include "AArch64TargetStreamer.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/BinaryFormat/ELF.h"
22#include "llvm/MC/MCAsmBackend.h"
23#include "llvm/MC/MCAssembler.h"
24#include "llvm/MC/MCCodeEmitter.h"
25#include "llvm/MC/MCContext.h"
26#include "llvm/MC/MCELFObjectWriter.h"
27#include "llvm/MC/MCELFStreamer.h"
28#include "llvm/MC/MCExpr.h"
29#include "llvm/MC/MCInst.h"
30#include "llvm/MC/MCObjectFileInfo.h"
31#include "llvm/MC/MCSectionELF.h"
32#include "llvm/MC/MCStreamer.h"
33#include "llvm/MC/MCSubtargetInfo.h"
34#include "llvm/MC/MCSymbolELF.h"
35#include "llvm/MC/MCTargetOptions.h"
36#include "llvm/MC/MCWinCOFFStreamer.h"
37#include "llvm/Support/AArch64BuildAttributes.h"
38#include "llvm/Support/FormattedStream.h"
39#include "llvm/Support/raw_ostream.h"
40
41using namespace llvm;
42
43namespace {
44
45class AArch64ELFStreamer;
46
47class AArch64TargetAsmStreamer : public AArch64TargetStreamer {
48 formatted_raw_ostream &OS;
49 std::string VendorTag;
50
51 void emitInst(uint32_t Inst) override;
52
53 void emitDirectiveVariantPCS(MCSymbol *Symbol) override {
54 OS << "\t.variant_pcs\t" << Symbol->getName() << "\n";
55 }
56
57 void emitDirectiveArch(StringRef Name) override {
58 OS << "\t.arch\t" << Name << "\n";
59 }
60
61 void emitDirectiveArchExtension(StringRef Name) override {
62 OS << "\t.arch_extension\t" << Name << "\n";
63 }
64
65 void emitARM64WinCFIAllocStack(unsigned Size) override {
66 OS << "\t.seh_stackalloc\t" << Size << "\n";
67 }
68 void emitARM64WinCFISaveR19R20X(int Offset) override {
69 OS << "\t.seh_save_r19r20_x\t" << Offset << "\n";
70 }
71 void emitARM64WinCFISaveFPLR(int Offset) override {
72 OS << "\t.seh_save_fplr\t" << Offset << "\n";
73 }
74 void emitARM64WinCFISaveFPLRX(int Offset) override {
75 OS << "\t.seh_save_fplr_x\t" << Offset << "\n";
76 }
77 void emitARM64WinCFISaveReg(unsigned Reg, int Offset) override {
78 OS << "\t.seh_save_reg\tx" << Reg << ", " << Offset << "\n";
79 }
80 void emitARM64WinCFISaveRegX(unsigned Reg, int Offset) override {
81 OS << "\t.seh_save_reg_x\tx" << Reg << ", " << Offset << "\n";
82 }
83 void emitARM64WinCFISaveRegP(unsigned Reg, int Offset) override {
84 OS << "\t.seh_save_regp\tx" << Reg << ", " << Offset << "\n";
85 }
86 void emitARM64WinCFISaveRegPX(unsigned Reg, int Offset) override {
87 OS << "\t.seh_save_regp_x\tx" << Reg << ", " << Offset << "\n";
88 }
89 void emitARM64WinCFISaveLRPair(unsigned Reg, int Offset) override {
90 OS << "\t.seh_save_lrpair\tx" << Reg << ", " << Offset << "\n";
91 }
92 void emitARM64WinCFISaveFReg(unsigned Reg, int Offset) override {
93 OS << "\t.seh_save_freg\td" << Reg << ", " << Offset << "\n";
94 }
95 void emitARM64WinCFISaveFRegX(unsigned Reg, int Offset) override {
96 OS << "\t.seh_save_freg_x\td" << Reg << ", " << Offset << "\n";
97 }
98 void emitARM64WinCFISaveFRegP(unsigned Reg, int Offset) override {
99 OS << "\t.seh_save_fregp\td" << Reg << ", " << Offset << "\n";
100 }
101 void emitARM64WinCFISaveFRegPX(unsigned Reg, int Offset) override {
102 OS << "\t.seh_save_fregp_x\td" << Reg << ", " << Offset << "\n";
103 }
104 void emitARM64WinCFISetFP() override { OS << "\t.seh_set_fp\n"; }
105 void emitARM64WinCFIAddFP(unsigned Size) override {
106 OS << "\t.seh_add_fp\t" << Size << "\n";
107 }
108 void emitARM64WinCFINop() override { OS << "\t.seh_nop\n"; }
109 void emitARM64WinCFISaveNext() override { OS << "\t.seh_save_next\n"; }
110 void emitARM64WinCFIPrologEnd() override { OS << "\t.seh_endprologue\n"; }
111 void emitARM64WinCFIEndC() override { OS << "\t.seh_end_c\n"; }
112 void emitARM64WinCFIEpilogStart() override { OS << "\t.seh_startepilogue\n"; }
113 void emitARM64WinCFIEpilogEnd() override { OS << "\t.seh_endepilogue\n"; }
114 void emitARM64WinCFITrapFrame() override { OS << "\t.seh_trap_frame\n"; }
115 void emitARM64WinCFIMachineFrame() override { OS << "\t.seh_pushframe\n"; }
116 void emitARM64WinCFIContext() override { OS << "\t.seh_context\n"; }
117 void emitARM64WinCFIECContext() override { OS << "\t.seh_ec_context\n"; }
118 void emitARM64WinCFIClearUnwoundToCall() override {
119 OS << "\t.seh_clear_unwound_to_call\n";
120 }
121 void emitARM64WinCFIPACSignLR() override {
122 OS << "\t.seh_pac_sign_lr\n";
123 }
124
125 void emitARM64WinCFISaveAnyRegI(unsigned Reg, int Offset) override {
126 OS << "\t.seh_save_any_reg\tx" << Reg << ", " << Offset << "\n";
127 }
128 void emitARM64WinCFISaveAnyRegIP(unsigned Reg, int Offset) override {
129 OS << "\t.seh_save_any_reg_p\tx" << Reg << ", " << Offset << "\n";
130 }
131 void emitARM64WinCFISaveAnyRegD(unsigned Reg, int Offset) override {
132 OS << "\t.seh_save_any_reg\td" << Reg << ", " << Offset << "\n";
133 }
134 void emitARM64WinCFISaveAnyRegDP(unsigned Reg, int Offset) override {
135 OS << "\t.seh_save_any_reg_p\td" << Reg << ", " << Offset << "\n";
136 }
137 void emitARM64WinCFISaveAnyRegQ(unsigned Reg, int Offset) override {
138 OS << "\t.seh_save_any_reg\tq" << Reg << ", " << Offset << "\n";
139 }
140 void emitARM64WinCFISaveAnyRegQP(unsigned Reg, int Offset) override {
141 OS << "\t.seh_save_any_reg_p\tq" << Reg << ", " << Offset << "\n";
142 }
143 void emitARM64WinCFISaveAnyRegIX(unsigned Reg, int Offset) override {
144 OS << "\t.seh_save_any_reg_x\tx" << Reg << ", " << Offset << "\n";
145 }
146 void emitARM64WinCFISaveAnyRegIPX(unsigned Reg, int Offset) override {
147 OS << "\t.seh_save_any_reg_px\tx" << Reg << ", " << Offset << "\n";
148 }
149 void emitARM64WinCFISaveAnyRegDX(unsigned Reg, int Offset) override {
150 OS << "\t.seh_save_any_reg_x\td" << Reg << ", " << Offset << "\n";
151 }
152 void emitARM64WinCFISaveAnyRegDPX(unsigned Reg, int Offset) override {
153 OS << "\t.seh_save_any_reg_px\td" << Reg << ", " << Offset << "\n";
154 }
155 void emitARM64WinCFISaveAnyRegQX(unsigned Reg, int Offset) override {
156 OS << "\t.seh_save_any_reg_x\tq" << Reg << ", " << Offset << "\n";
157 }
158 void emitARM64WinCFISaveAnyRegQPX(unsigned Reg, int Offset) override {
159 OS << "\t.seh_save_any_reg_px\tq" << Reg << ", " << Offset << "\n";
160 }
161 void emitARM64WinCFIAllocZ(int Offset) override {
162 OS << "\t.seh_allocz\t" << Offset << "\n";
163 }
164 void emitARM64WinCFISaveZReg(unsigned Reg, int Offset) override {
165 OS << "\t.seh_save_zreg\tz" << Reg << ", " << Offset << "\n";
166 }
167 void emitARM64WinCFISavePReg(unsigned Reg, int Offset) override {
168 OS << "\t.seh_save_preg\tp" << Reg << ", " << Offset << "\n";
169 }
170
171 void emitAttribute(StringRef VendorName, unsigned Tag, unsigned Value,
172 std::string String) override {
173
174 // AArch64 build attributes for assembly attribute form:
175 // .aeabi_attribute tag, value
176 if (unsigned(-1) == Value && "" == String) {
177 assert(0 && "Arguments error");
178 return;
179 }
180
181 unsigned VendorID = AArch64BuildAttributes::getVendorID(Vendor: VendorName);
182
183 switch (VendorID) {
184 case AArch64BuildAttributes::VENDOR_UNKNOWN:
185 if (unsigned(-1) != Value) {
186 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << Value;
187 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
188 }
189 if ("" != String) {
190 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << String;
191 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value: unsigned(-1),
192 String);
193 }
194 break;
195 // Note: AEABI_FEATURE_AND_BITS takes only unsigned values
196 case AArch64BuildAttributes::AEABI_FEATURE_AND_BITS:
197 switch (Tag) {
198 default: // allow emitting any attribute by number
199 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << Value;
200 // Keep the data structure consistent with the case of ELF emission
201 // (important for llvm-mc asm parsing)
202 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
203 break;
204 case AArch64BuildAttributes::TAG_FEATURE_BTI:
205 case AArch64BuildAttributes::TAG_FEATURE_GCS:
206 case AArch64BuildAttributes::TAG_FEATURE_PAC:
207 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << Value << "\t// "
208 << AArch64BuildAttributes::getFeatureAndBitsTagsStr(FeatureAndBitsTag: Tag);
209 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
210 break;
211 }
212 break;
213 // Note: AEABI_PAUTHABI takes only unsigned values
214 case AArch64BuildAttributes::AEABI_PAUTHABI:
215 switch (Tag) {
216 default: // allow emitting any attribute by number
217 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << Value;
218 // Keep the data structure consistent with the case of ELF emission
219 // (important for llvm-mc asm parsing)
220 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
221 break;
222 case AArch64BuildAttributes::TAG_PAUTH_PLATFORM:
223 case AArch64BuildAttributes::TAG_PAUTH_SCHEMA:
224 OS << "\t.aeabi_attribute" << "\t" << Tag << ", " << Value << "\t// "
225 << AArch64BuildAttributes::getPauthABITagsStr(PauthABITag: Tag);
226 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
227 break;
228 }
229 break;
230 }
231 OS << "\n";
232 }
233
234 void emitAttributesSubsection(
235 StringRef SubsectionName,
236 AArch64BuildAttributes::SubsectionOptional Optional,
237 AArch64BuildAttributes::SubsectionType ParameterType) override {
238 // The AArch64 build attributes assembly subsection header format:
239 // ".aeabi_subsection name, optional, parameter type"
240 // optional: required (0) optional (1)
241 // parameter type: uleb128 or ULEB128 (0) ntbs or NTBS (1)
242 unsigned SubsectionID = AArch64BuildAttributes::getVendorID(Vendor: SubsectionName);
243
244 assert((0 == Optional || 1 == Optional) &&
245 AArch64BuildAttributes::getSubsectionOptionalUnknownError().data());
246 assert((0 == ParameterType || 1 == ParameterType) &&
247 AArch64BuildAttributes::getSubsectionTypeUnknownError().data());
248
249 std::string SubsectionTag = ".aeabi_subsection";
250 StringRef OptionalStr = getOptionalStr(Optional);
251 StringRef ParameterStr = getTypeStr(Type: ParameterType);
252
253 switch (SubsectionID) {
254 case AArch64BuildAttributes::VENDOR_UNKNOWN: {
255 // Private subsection
256 break;
257 }
258 case AArch64BuildAttributes::AEABI_PAUTHABI: {
259 assert(AArch64BuildAttributes::REQUIRED == Optional &&
260 "subsection .aeabi-pauthabi should be marked as "
261 "required and not as optional");
262 assert(AArch64BuildAttributes::ULEB128 == ParameterType &&
263 "subsection .aeabi-pauthabi should be "
264 "marked as uleb128 and not as ntbs");
265 break;
266 }
267 case AArch64BuildAttributes::AEABI_FEATURE_AND_BITS: {
268 assert(AArch64BuildAttributes::OPTIONAL == Optional &&
269 "subsection .aeabi_feature_and_bits should be "
270 "marked as optional and not as required");
271 assert(AArch64BuildAttributes::ULEB128 == ParameterType &&
272 "subsection .aeabi_feature_and_bits should "
273 "be marked as uleb128 and not as ntbs");
274 break;
275 }
276 }
277 OS << "\t" << SubsectionTag << "\t" << SubsectionName << ", " << OptionalStr
278 << ", " << ParameterStr;
279 // Keep the data structure consistent with the case of ELF emission
280 // (important for llvm-mc asm parsing)
281 AArch64TargetStreamer::emitAttributesSubsection(VendorName: SubsectionName, IsOptional: Optional,
282 ParameterType);
283 OS << "\n";
284 }
285
286public:
287 AArch64TargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
288};
289
290AArch64TargetAsmStreamer::AArch64TargetAsmStreamer(MCStreamer &S,
291 formatted_raw_ostream &OS)
292 : AArch64TargetStreamer(S), OS(OS) {}
293
294void AArch64TargetAsmStreamer::emitInst(uint32_t Inst) {
295 OS << "\t.inst\t0x" << Twine::utohexstr(Val: Inst) << "\n";
296}
297
298/// Extend the generic ELFStreamer class so that it can emit mapping symbols at
299/// the appropriate points in the object files. These symbols are defined in the
300/// AArch64 ELF ABI:
301/// infocenter.arm.com/help/topic/com.arm.doc.ihi0056a/IHI0056A_aaelf64.pdf
302///
303/// In brief: $x or $d should be emitted at the start of each contiguous region
304/// of A64 code or data in a section. In practice, this emission does not rely
305/// on explicit assembler directives but on inherent properties of the
306/// directives doing the emission (e.g. ".byte" is data, "add x0, x0, x0" an
307/// instruction).
308///
309/// As a result this system is orthogonal to the DataRegion infrastructure used
310/// by MachO. Beware!
311class AArch64ELFStreamer : public MCELFStreamer {
312public:
313 friend AArch64TargetELFStreamer;
314 AArch64ELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
315 std::unique_ptr<MCObjectWriter> OW,
316 std::unique_ptr<MCCodeEmitter> Emitter)
317 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
318 std::move(Emitter)),
319 LastEMS(EMS_None) {
320 ImplicitMapSyms = getContext().getTargetOptions().ImplicitMapSyms;
321 }
322
323 void changeSection(MCSection *Section, uint32_t Subsection = 0) override {
324 // Save the mapping symbol state for potential reuse when revisiting the
325 // section. When ImplicitMapSyms is true, the initial state is
326 // EMS_A64 for text sections and EMS_Data for the others.
327 LastMappingSymbols[getCurrentSection().first] = LastEMS;
328 auto It = LastMappingSymbols.find(Val: Section);
329 if (It != LastMappingSymbols.end())
330 LastEMS = It->second;
331 else if (ImplicitMapSyms)
332 LastEMS = Section->isText() ? EMS_A64 : EMS_Data;
333 else
334 LastEMS = EMS_None;
335
336 MCELFStreamer::changeSection(Section, Subsection);
337
338 // Section alignment of 4 to match GNU Assembler
339 if (Section->isText())
340 Section->ensureMinAlignment(MinAlignment: Align(4));
341 }
342
343 // Reset state between object emissions
344 void reset() override {
345 MCELFStreamer::reset();
346 LastMappingSymbols.clear();
347 LastEMS = EMS_None;
348 }
349
350 /// This function is the one used to emit instruction data into the ELF
351 /// streamer. We override it to add the appropriate mapping symbol if
352 /// necessary.
353 void emitInstruction(const MCInst &Inst,
354 const MCSubtargetInfo &STI) override {
355 emitA64MappingSymbol();
356 MCELFStreamer::emitInstruction(Inst, STI);
357 }
358
359 /// Emit a 32-bit value as an instruction. This is only used for the .inst
360 /// directive, EmitInstruction should be used in other cases.
361 void emitInst(uint32_t Inst) {
362 char Buffer[4];
363
364 // We can't just use EmitIntValue here, as that will emit a data mapping
365 // symbol, and swap the endianness on big-endian systems (instructions are
366 // always little-endian).
367 for (char &C : Buffer) {
368 C = uint8_t(Inst);
369 Inst >>= 8;
370 }
371
372 emitA64MappingSymbol();
373 MCELFStreamer::emitBytes(Data: StringRef(Buffer, 4));
374 }
375
376 /// This is one of the functions used to emit data into an ELF section, so the
377 /// AArch64 streamer overrides it to add the appropriate mapping symbol ($d)
378 /// if necessary.
379 void emitBytes(StringRef Data) override {
380 emitDataMappingSymbol();
381 MCELFStreamer::emitBytes(Data);
382 }
383
384 /// This is one of the functions used to emit data into an ELF section, so the
385 /// AArch64 streamer overrides it to add the appropriate mapping symbol ($d)
386 /// if necessary.
387 void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
388 emitDataMappingSymbol();
389 MCELFStreamer::emitValueImpl(Value, Size, Loc);
390 }
391
392 void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
393 SMLoc Loc) override {
394 emitDataMappingSymbol();
395 MCObjectStreamer::emitFill(NumBytes, FillValue, Loc);
396 }
397
398private:
399 enum ElfMappingSymbol {
400 EMS_None,
401 EMS_A64,
402 EMS_Data
403 };
404
405 void emitDataMappingSymbol() {
406 if (LastEMS == EMS_Data)
407 return;
408 emitMappingSymbol(Name: "$d");
409 LastEMS = EMS_Data;
410 }
411
412 void emitA64MappingSymbol() {
413 if (LastEMS == EMS_A64)
414 return;
415 emitMappingSymbol(Name: "$x");
416 LastEMS = EMS_A64;
417 }
418
419 MCSymbol *emitMappingSymbol(StringRef Name) {
420 auto *Symbol =
421 static_cast<MCSymbolELF *>(getContext().createLocalSymbol(Name));
422 emitLabel(Symbol);
423 return Symbol;
424 }
425
426 DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
427 ElfMappingSymbol LastEMS;
428 bool ImplicitMapSyms;
429};
430} // end anonymous namespace
431
432AArch64ELFStreamer &AArch64TargetELFStreamer::getStreamer() {
433 return static_cast<AArch64ELFStreamer &>(Streamer);
434}
435
436void AArch64TargetELFStreamer::emitAttributesSubsection(
437 StringRef VendorName, AArch64BuildAttributes::SubsectionOptional IsOptional,
438 AArch64BuildAttributes::SubsectionType ParameterType) {
439 AArch64TargetStreamer::emitAttributesSubsection(VendorName, IsOptional,
440 ParameterType);
441}
442
443void AArch64TargetELFStreamer::emitAttribute(StringRef VendorName, unsigned Tag,
444 unsigned Value,
445 std::string String) {
446 if (unsigned(-1) != Value)
447 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value, String: "");
448 if ("" != String)
449 AArch64TargetStreamer::emitAttribute(VendorName, Tag, Value: unsigned(-1), String);
450}
451
452void AArch64TargetELFStreamer::emitInst(uint32_t Inst) {
453 getStreamer().emitInst(Inst);
454}
455
456void AArch64TargetELFStreamer::emitDirectiveVariantPCS(MCSymbol *Symbol) {
457 getStreamer().getAssembler().registerSymbol(Symbol: *Symbol);
458 static_cast<MCSymbolELF *>(Symbol)->setOther(ELF::STO_AARCH64_VARIANT_PCS);
459}
460
461void AArch64TargetELFStreamer::finish() {
462 AArch64TargetStreamer::finish();
463 AArch64ELFStreamer &S = getStreamer();
464 MCContext &Ctx = S.getContext();
465 auto &Asm = S.getAssembler();
466
467 S.emitAttributesSection(AttributeSection, Section: ".ARM.attributes",
468 Type: ELF::SHT_AARCH64_ATTRIBUTES, SubSectionVec&: AttributeSubSections);
469
470 // If ImplicitMapSyms is specified, ensure that text sections end with
471 // the A64 state while non-text sections end with the data state. When
472 // sections are combined by the linker, the subsequent section will start with
473 // the right state. The ending mapping symbol is added right after the last
474 // symbol relative to the section. When a dumb linker combines (.text.0; .word
475 // 0) and (.text.1; .word 0), the ending $x of .text.0 precedes the $d of
476 // .text.1, even if they have the same address.
477 if (S.ImplicitMapSyms) {
478 auto &Syms = Asm.getSymbols();
479 const size_t NumSyms = Syms.size();
480 DenseMap<MCSection *, std::pair<size_t, MCSymbol *>> EndMapSym;
481 for (MCSection &Sec : Asm) {
482 S.switchSection(Section: &Sec);
483 if (S.LastEMS == (Sec.isText() ? AArch64ELFStreamer::EMS_Data
484 : AArch64ELFStreamer::EMS_A64))
485 EndMapSym.insert(
486 KV: {&Sec, {NumSyms, S.emitMappingSymbol(Name: Sec.isText() ? "$x" : "$d")}});
487 }
488 if (Syms.size() != NumSyms) {
489 SmallVector<const MCSymbol *, 0> NewSyms;
490 Syms.truncate(N: NumSyms);
491 // Find the last symbol index for each candidate section.
492 for (auto [I, Sym] : llvm::enumerate(First&: Syms)) {
493 if (!Sym->isInSection())
494 continue;
495 auto It = EndMapSym.find(Val: &Sym->getSection());
496 if (It != EndMapSym.end())
497 It->second.first = I;
498 }
499 SmallVector<size_t, 0> Idx;
500 for (auto [I, Sym] : llvm::enumerate(First&: Syms)) {
501 NewSyms.push_back(Elt: Sym);
502 if (!Sym->isInSection())
503 continue;
504 auto It = EndMapSym.find(Val: &Sym->getSection());
505 // If `Sym` is the last symbol relative to the section, add the ending
506 // mapping symbol after `Sym`.
507 if (It != EndMapSym.end() && I == It->second.first) {
508 NewSyms.push_back(Elt: It->second.second);
509 Idx.push_back(Elt: I);
510 }
511 }
512 Syms = std::move(NewSyms);
513 // F.second holds the number of symbols added before the FILE symbol.
514 // Take into account the inserted mapping symbols.
515 for (auto &F : S.getWriter().getFileNames())
516 F.second += llvm::lower_bound(Range&: Idx, Value&: F.second) - Idx.begin();
517 }
518 }
519
520 // The mix of execute-only and non-execute-only at link time is
521 // non-execute-only. To avoid the empty implicitly created .text
522 // section from making the whole .text section non-execute-only, we
523 // mark it execute-only if it is empty and there is at least one
524 // execute-only section in the object.
525 if (any_of(Range&: Asm, P: [](const MCSection &Sec) {
526 return static_cast<const MCSectionELF &>(Sec).getFlags() &
527 ELF::SHF_AARCH64_PURECODE;
528 })) {
529 auto *Text =
530 static_cast<MCSectionELF *>(Ctx.getObjectFileInfo()->getTextSection());
531 bool Empty = true;
532 for (auto &F : *Text) {
533 if (F.getSize()) {
534 Empty = false;
535 break;
536 }
537 }
538 if (Empty)
539 Text->setFlags(Text->getFlags() | ELF::SHF_AARCH64_PURECODE);
540 }
541
542 MCSectionELF *MemtagSec = nullptr;
543 for (const MCSymbol &Symbol : Asm.symbols()) {
544 auto &Sym = static_cast<const MCSymbolELF &>(Symbol);
545 if (Sym.isMemtag()) {
546 MemtagSec = Ctx.getELFSection(Section: ".memtag.globals.static",
547 Type: ELF::SHT_AARCH64_MEMTAG_GLOBALS_STATIC, Flags: 0);
548 break;
549 }
550 }
551 if (!MemtagSec)
552 return;
553
554 // switchSection registers the section symbol and invalidates symbols(). We
555 // need a separate symbols() loop.
556 S.switchSection(Section: MemtagSec);
557 const auto *Zero = MCConstantExpr::create(Value: 0, Ctx);
558 for (const MCSymbol &Symbol : Asm.symbols()) {
559 auto &Sym = static_cast<const MCSymbolELF &>(Symbol);
560 if (!Sym.isMemtag())
561 continue;
562 auto *SRE = MCSymbolRefExpr::create(Symbol: &Sym, Ctx);
563 S.emitRelocDirective(Offset: *Zero, Name: "BFD_RELOC_NONE", Expr: SRE);
564 }
565}
566
567MCTargetStreamer *
568llvm::createAArch64AsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
569 MCInstPrinter *InstPrint) {
570 return new AArch64TargetAsmStreamer(S, OS);
571}
572
573MCStreamer *
574llvm::createAArch64ELFStreamer(const Triple &, MCContext &Context,
575 std::unique_ptr<MCAsmBackend> &&TAB,
576 std::unique_ptr<MCObjectWriter> &&OW,
577 std::unique_ptr<MCCodeEmitter> &&Emitter) {
578 return new AArch64ELFStreamer(Context, std::move(TAB), std::move(OW),
579 std::move(Emitter));
580}
581