LLVM 20.0.0git
AArch64ELFStreamer.cpp
Go to the documentation of this file.
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"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/ADT/Twine.h"
24#include "llvm/MC/MCAssembler.h"
26#include "llvm/MC/MCContext.h"
28#include "llvm/MC/MCExpr.h"
29#include "llvm/MC/MCInst.h"
32#include "llvm/MC/MCStreamer.h"
34#include "llvm/MC/MCSymbolELF.h"
40
41using namespace llvm;
42
43namespace {
44
45class AArch64ELFStreamer;
46
47class AArch64TargetAsmStreamer : public AArch64TargetStreamer {
49
50 void emitInst(uint32_t Inst) override;
51
52 void emitDirectiveVariantPCS(MCSymbol *Symbol) override {
53 OS << "\t.variant_pcs\t" << Symbol->getName() << "\n";
54 }
55
56 void emitARM64WinCFIAllocStack(unsigned Size) override {
57 OS << "\t.seh_stackalloc\t" << Size << "\n";
58 }
59 void emitARM64WinCFISaveR19R20X(int Offset) override {
60 OS << "\t.seh_save_r19r20_x\t" << Offset << "\n";
61 }
62 void emitARM64WinCFISaveFPLR(int Offset) override {
63 OS << "\t.seh_save_fplr\t" << Offset << "\n";
64 }
65 void emitARM64WinCFISaveFPLRX(int Offset) override {
66 OS << "\t.seh_save_fplr_x\t" << Offset << "\n";
67 }
68 void emitARM64WinCFISaveReg(unsigned Reg, int Offset) override {
69 OS << "\t.seh_save_reg\tx" << Reg << ", " << Offset << "\n";
70 }
71 void emitARM64WinCFISaveRegX(unsigned Reg, int Offset) override {
72 OS << "\t.seh_save_reg_x\tx" << Reg << ", " << Offset << "\n";
73 }
74 void emitARM64WinCFISaveRegP(unsigned Reg, int Offset) override {
75 OS << "\t.seh_save_regp\tx" << Reg << ", " << Offset << "\n";
76 }
77 void emitARM64WinCFISaveRegPX(unsigned Reg, int Offset) override {
78 OS << "\t.seh_save_regp_x\tx" << Reg << ", " << Offset << "\n";
79 }
80 void emitARM64WinCFISaveLRPair(unsigned Reg, int Offset) override {
81 OS << "\t.seh_save_lrpair\tx" << Reg << ", " << Offset << "\n";
82 }
83 void emitARM64WinCFISaveFReg(unsigned Reg, int Offset) override {
84 OS << "\t.seh_save_freg\td" << Reg << ", " << Offset << "\n";
85 }
86 void emitARM64WinCFISaveFRegX(unsigned Reg, int Offset) override {
87 OS << "\t.seh_save_freg_x\td" << Reg << ", " << Offset << "\n";
88 }
89 void emitARM64WinCFISaveFRegP(unsigned Reg, int Offset) override {
90 OS << "\t.seh_save_fregp\td" << Reg << ", " << Offset << "\n";
91 }
92 void emitARM64WinCFISaveFRegPX(unsigned Reg, int Offset) override {
93 OS << "\t.seh_save_fregp_x\td" << Reg << ", " << Offset << "\n";
94 }
95 void emitARM64WinCFISetFP() override { OS << "\t.seh_set_fp\n"; }
96 void emitARM64WinCFIAddFP(unsigned Size) override {
97 OS << "\t.seh_add_fp\t" << Size << "\n";
98 }
99 void emitARM64WinCFINop() override { OS << "\t.seh_nop\n"; }
100 void emitARM64WinCFISaveNext() override { OS << "\t.seh_save_next\n"; }
101 void emitARM64WinCFIPrologEnd() override { OS << "\t.seh_endprologue\n"; }
102 void emitARM64WinCFIEpilogStart() override { OS << "\t.seh_startepilogue\n"; }
103 void emitARM64WinCFIEpilogEnd() override { OS << "\t.seh_endepilogue\n"; }
104 void emitARM64WinCFITrapFrame() override { OS << "\t.seh_trap_frame\n"; }
105 void emitARM64WinCFIMachineFrame() override { OS << "\t.seh_pushframe\n"; }
106 void emitARM64WinCFIContext() override { OS << "\t.seh_context\n"; }
107 void emitARM64WinCFIECContext() override { OS << "\t.seh_ec_context\n"; }
108 void emitARM64WinCFIClearUnwoundToCall() override {
109 OS << "\t.seh_clear_unwound_to_call\n";
110 }
111 void emitARM64WinCFIPACSignLR() override {
112 OS << "\t.seh_pac_sign_lr\n";
113 }
114
115 void emitARM64WinCFISaveAnyRegI(unsigned Reg, int Offset) override {
116 OS << "\t.seh_save_any_reg\tx" << Reg << ", " << Offset << "\n";
117 }
118 void emitARM64WinCFISaveAnyRegIP(unsigned Reg, int Offset) override {
119 OS << "\t.seh_save_any_reg_p\tx" << Reg << ", " << Offset << "\n";
120 }
121 void emitARM64WinCFISaveAnyRegD(unsigned Reg, int Offset) override {
122 OS << "\t.seh_save_any_reg\td" << Reg << ", " << Offset << "\n";
123 }
124 void emitARM64WinCFISaveAnyRegDP(unsigned Reg, int Offset) override {
125 OS << "\t.seh_save_any_reg_p\td" << Reg << ", " << Offset << "\n";
126 }
127 void emitARM64WinCFISaveAnyRegQ(unsigned Reg, int Offset) override {
128 OS << "\t.seh_save_any_reg\tq" << Reg << ", " << Offset << "\n";
129 }
130 void emitARM64WinCFISaveAnyRegQP(unsigned Reg, int Offset) override {
131 OS << "\t.seh_save_any_reg_p\tq" << Reg << ", " << Offset << "\n";
132 }
133 void emitARM64WinCFISaveAnyRegIX(unsigned Reg, int Offset) override {
134 OS << "\t.seh_save_any_reg_x\tx" << Reg << ", " << Offset << "\n";
135 }
136 void emitARM64WinCFISaveAnyRegIPX(unsigned Reg, int Offset) override {
137 OS << "\t.seh_save_any_reg_px\tx" << Reg << ", " << Offset << "\n";
138 }
139 void emitARM64WinCFISaveAnyRegDX(unsigned Reg, int Offset) override {
140 OS << "\t.seh_save_any_reg_x\td" << Reg << ", " << Offset << "\n";
141 }
142 void emitARM64WinCFISaveAnyRegDPX(unsigned Reg, int Offset) override {
143 OS << "\t.seh_save_any_reg_px\td" << Reg << ", " << Offset << "\n";
144 }
145 void emitARM64WinCFISaveAnyRegQX(unsigned Reg, int Offset) override {
146 OS << "\t.seh_save_any_reg_x\tq" << Reg << ", " << Offset << "\n";
147 }
148 void emitARM64WinCFISaveAnyRegQPX(unsigned Reg, int Offset) override {
149 OS << "\t.seh_save_any_reg_px\tq" << Reg << ", " << Offset << "\n";
150 }
151
152public:
153 AArch64TargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
154};
155
156AArch64TargetAsmStreamer::AArch64TargetAsmStreamer(MCStreamer &S,
158 : AArch64TargetStreamer(S), OS(OS) {}
159
160void AArch64TargetAsmStreamer::emitInst(uint32_t Inst) {
161 OS << "\t.inst\t0x" << Twine::utohexstr(Inst) << "\n";
162}
163
164/// Extend the generic ELFStreamer class so that it can emit mapping symbols at
165/// the appropriate points in the object files. These symbols are defined in the
166/// AArch64 ELF ABI:
167/// infocenter.arm.com/help/topic/com.arm.doc.ihi0056a/IHI0056A_aaelf64.pdf
168///
169/// In brief: $x or $d should be emitted at the start of each contiguous region
170/// of A64 code or data in a section. In practice, this emission does not rely
171/// on explicit assembler directives but on inherent properties of the
172/// directives doing the emission (e.g. ".byte" is data, "add x0, x0, x0" an
173/// instruction).
174///
175/// As a result this system is orthogonal to the DataRegion infrastructure used
176/// by MachO. Beware!
177class AArch64ELFStreamer : public MCELFStreamer {
178public:
179 AArch64ELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
180 std::unique_ptr<MCObjectWriter> OW,
181 std::unique_ptr<MCCodeEmitter> Emitter)
182 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
183 std::move(Emitter)),
184 LastEMS(EMS_None) {}
185
186 void changeSection(MCSection *Section, uint32_t Subsection = 0) override {
187 // We have to keep track of the mapping symbol state of any sections we
188 // use. Each one should start off as EMS_None, which is provided as the
189 // default constructor by DenseMap::lookup.
190 LastMappingSymbols[getCurrentSection().first] = LastEMS;
191 LastEMS = LastMappingSymbols.lookup(Section);
192
193 MCELFStreamer::changeSection(Section, Subsection);
194 }
195
196 // Reset state between object emissions
197 void reset() override {
199 LastMappingSymbols.clear();
200 LastEMS = EMS_None;
201 }
202
203 /// This function is the one used to emit instruction data into the ELF
204 /// streamer. We override it to add the appropriate mapping symbol if
205 /// necessary.
206 void emitInstruction(const MCInst &Inst,
207 const MCSubtargetInfo &STI) override {
208 emitA64MappingSymbol();
210 }
211
212 /// Emit a 32-bit value as an instruction. This is only used for the .inst
213 /// directive, EmitInstruction should be used in other cases.
214 void emitInst(uint32_t Inst) {
215 char Buffer[4];
216
217 // We can't just use EmitIntValue here, as that will emit a data mapping
218 // symbol, and swap the endianness on big-endian systems (instructions are
219 // always little-endian).
220 for (char &C : Buffer) {
221 C = uint8_t(Inst);
222 Inst >>= 8;
223 }
224
225 emitA64MappingSymbol();
227 }
228
229 /// This is one of the functions used to emit data into an ELF section, so the
230 /// AArch64 streamer overrides it to add the appropriate mapping symbol ($d)
231 /// if necessary.
232 void emitBytes(StringRef Data) override {
233 emitDataMappingSymbol();
235 }
236
237 /// This is one of the functions used to emit data into an ELF section, so the
238 /// AArch64 streamer overrides it to add the appropriate mapping symbol ($d)
239 /// if necessary.
240 void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
241 emitDataMappingSymbol();
243 }
244
245 void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
246 SMLoc Loc) override {
247 emitDataMappingSymbol();
248 MCObjectStreamer::emitFill(NumBytes, FillValue, Loc);
249 }
250
251private:
252 enum ElfMappingSymbol {
253 EMS_None,
254 EMS_A64,
255 EMS_Data
256 };
257
258 void emitDataMappingSymbol() {
259 if (LastEMS == EMS_Data)
260 return;
261 emitMappingSymbol("$d");
262 LastEMS = EMS_Data;
263 }
264
265 void emitA64MappingSymbol() {
266 if (LastEMS == EMS_A64)
267 return;
268 emitMappingSymbol("$x");
269 LastEMS = EMS_A64;
270 }
271
272 void emitMappingSymbol(StringRef Name) {
273 auto *Symbol = cast<MCSymbolELF>(getContext().createLocalSymbol(Name));
274 emitLabel(Symbol);
275 }
276
278 ElfMappingSymbol LastEMS;
279};
280} // end anonymous namespace
281
282AArch64ELFStreamer &AArch64TargetELFStreamer::getStreamer() {
283 return static_cast<AArch64ELFStreamer &>(Streamer);
284}
285
286void AArch64TargetELFStreamer::emitInst(uint32_t Inst) {
287 getStreamer().emitInst(Inst);
288}
289
290void AArch64TargetELFStreamer::emitDirectiveVariantPCS(MCSymbol *Symbol) {
291 getStreamer().getAssembler().registerSymbol(*Symbol);
292 cast<MCSymbolELF>(Symbol)->setOther(ELF::STO_AARCH64_VARIANT_PCS);
293}
294
295void AArch64TargetELFStreamer::finish() {
297 AArch64ELFStreamer &S = getStreamer();
298 MCContext &Ctx = S.getContext();
299 auto &Asm = S.getAssembler();
300 MCSectionELF *MemtagSec = nullptr;
301 for (const MCSymbol &Symbol : Asm.symbols()) {
302 const auto &Sym = cast<MCSymbolELF>(Symbol);
303 if (Sym.isMemtag()) {
304 MemtagSec = Ctx.getELFSection(".memtag.globals.static",
306 break;
307 }
308 }
309 if (!MemtagSec)
310 return;
311
312 // switchSection registers the section symbol and invalidates symbols(). We
313 // need a separate symbols() loop.
314 S.switchSection(MemtagSec);
315 const auto *Zero = MCConstantExpr::create(0, Ctx);
316 for (const MCSymbol &Symbol : Asm.symbols()) {
317 const auto &Sym = cast<MCSymbolELF>(Symbol);
318 if (!Sym.isMemtag())
319 continue;
321 (void)S.emitRelocDirective(*Zero, "BFD_RELOC_NONE", SRE, SMLoc(),
322 *Ctx.getSubtargetInfo());
323 }
324}
325
328 MCInstPrinter *InstPrint) {
329 return new AArch64TargetAsmStreamer(S, OS);
330}
331
334 std::unique_ptr<MCAsmBackend> TAB,
335 std::unique_ptr<MCObjectWriter> OW,
336 std::unique_ptr<MCCodeEmitter> Emitter) {
337 AArch64ELFStreamer *S = new AArch64ELFStreamer(
338 Context, std::move(TAB), std::move(OW), std::move(Emitter));
339 return S;
340}
dxil DXContainer Global Emitter
This file defines the DenseMap class.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
raw_pwrite_stream & OS
virtual void emitARM64WinCFISaveAnyRegIX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveRegP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegDPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegDX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveRegPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQ(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegD(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegI(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFRegPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveRegX(unsigned Reg, int Offset)
virtual void emitARM64WinCFIAllocStack(unsigned Size)
virtual void emitARM64WinCFISaveFPLRX(int Offset)
virtual void emitDirectiveVariantPCS(MCSymbol *Symbol)
Callback used to implement the .variant_pcs directive.
virtual void emitARM64WinCFISaveR19R20X(int Offset)
virtual void emitARM64WinCFIAddFP(unsigned Size)
virtual void emitARM64WinCFISaveFPLR(int Offset)
virtual void emitARM64WinCFIClearUnwoundToCall()
virtual void emitARM64WinCFISaveFRegP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFRegX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegDP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegIPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveLRPair(unsigned Reg, int Offset)
virtual void emitInst(uint32_t Inst)
Callback used to implement the .inst directive.
virtual void emitARM64WinCFISaveAnyRegIP(unsigned Reg, int Offset)
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:193
Context object for machine code objects.
Definition: MCContext.h:83
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:551
const MCSubtargetInfo * getSubtargetInfo() const
Definition: MCContext.h:418
void changeSection(MCSection *Section, uint32_t Subsection=0) override
This is called by popSection and switchSection, if the current section changes.
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void reset() override
state management
Definition: MCELFStreamer.h:41
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:45
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc=SMLoc()) override
Emit Size bytes worth of the value specified by FillValue.
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override
Emit the given Instruction into the current section.
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:27
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
Streaming machine code generation interface.
Definition: MCStreamer.h:213
MCContext & getContext() const
Definition: MCStreamer.h:300
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:393
Generic base class for all target subtargets.
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:393
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
Target specific streamer interface.
Definition: MCStreamer.h:94
MCStreamer & Streamer
Definition: MCStreamer.h:96
Represents a location in source code.
Definition: SMLoc.h:23
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
LLVM Value Representation.
Definition: Value.h:74
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ STO_AARCH64_VARIANT_PCS
Definition: ELF.h:433
@ SHT_AARCH64_MEMTAG_GLOBALS_STATIC
Definition: ELF.h:1156
Reg
All possible values of the reg field in the ModR/M byte.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
MCTargetStreamer * createAArch64AsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1856
MCELFStreamer * createAArch64ELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858