LLVM 19.0.0git
MCAsmBackend.h
Go to the documentation of this file.
1//===- llvm/MC/MCAsmBackend.h - MC Asm Backend ------------------*- C++ -*-===//
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#ifndef LLVM_MC_MCASMBACKEND_H
10#define LLVM_MC_MCASMBACKEND_H
11
12#include "llvm/ADT/ArrayRef.h"
14#include "llvm/MC/MCFixup.h"
15#include "llvm/Support/Endian.h"
16#include <cstdint>
17
18namespace llvm {
19
20class MCAlignFragment;
21class MCDwarfCallFrameFragment;
22class MCDwarfLineAddrFragment;
23class MCFragment;
24class MCLEBFragment;
25class MCRelaxableFragment;
26class MCSymbol;
27class MCAsmLayout;
28class MCAssembler;
29class MCContext;
30struct MCDwarfFrameInfo;
31struct MCFixupKindInfo;
32class MCInst;
33class MCObjectStreamer;
34class MCObjectTargetWriter;
35class MCObjectWriter;
36class MCSubtargetInfo;
37class MCValue;
38class raw_pwrite_stream;
39class StringRef;
40class raw_ostream;
41
42/// Generic interface to target specific assembler backends.
44protected: // Can only create subclasses.
46
47public:
48 MCAsmBackend(const MCAsmBackend &) = delete;
50 virtual ~MCAsmBackend();
51
53
54 /// Fixup kind used for linker relaxation. Currently only used by RISC-V.
55 const unsigned RelaxFixupKind;
56
57 /// Return true if this target might automatically pad instructions and thus
58 /// need to emit padding enable/disable directives around sensative code.
59 virtual bool allowAutoPadding() const { return false; }
60 /// Return true if this target allows an unrelaxable instruction to be
61 /// emitted into RelaxableFragment and then we can increase its size in a
62 /// tricky way for optimization.
63 virtual bool allowEnhancedRelaxation() const { return false; }
64
65 /// Give the target a chance to manipulate state related to instruction
66 /// alignment (e.g. padding for optimization), instruction relaxablility, etc.
67 /// before and after actually emitting the instruction.
68 virtual void emitInstructionBegin(MCObjectStreamer &OS, const MCInst &Inst,
69 const MCSubtargetInfo &STI) {}
70 virtual void emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) {}
71
72 /// lifetime management
73 virtual void reset() {}
74
75 /// Create a new MCObjectWriter instance for use by the assembler backend to
76 /// emit the final object file.
77 std::unique_ptr<MCObjectWriter>
79
80 /// Create an MCObjectWriter that writes two object files: a .o file which is
81 /// linked into the final program and a .dwo file which is used by debuggers.
82 /// This function is only supported with ELF targets.
83 std::unique_ptr<MCObjectWriter>
85
86 virtual std::unique_ptr<MCObjectTargetWriter>
88
89 /// \name Target Fixup Interfaces
90 /// @{
91
92 /// Get the number of target specific fixup kinds.
93 virtual unsigned getNumFixupKinds() const = 0;
94
95 /// Map a relocation name used in .reloc to a fixup kind.
96 virtual std::optional<MCFixupKind> getFixupKind(StringRef Name) const;
97
98 /// Get information on a fixup kind.
99 virtual const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const;
100
101 /// Hook to check if a relocation is needed for some target specific reason.
102 virtual bool shouldForceRelocation(const MCAssembler &Asm,
103 const MCFixup &Fixup,
104 const MCValue &Target,
105 const MCSubtargetInfo *STI) {
106 return false;
107 }
108
109 /// Hook to check if extra nop bytes must be inserted for alignment directive.
110 /// For some targets this may be necessary in order to support linker
111 /// relaxation. The number of bytes to insert are returned in Size.
113 unsigned &Size) {
114 return false;
115 }
116
117 /// Hook which indicates if the target requires a fixup to be generated when
118 /// handling an align directive in an executable section
120 const MCAsmLayout &Layout,
121 MCAlignFragment &AF) {
122 return false;
123 }
124
125 virtual bool evaluateTargetFixup(const MCAssembler &Asm,
126 const MCAsmLayout &Layout,
127 const MCFixup &Fixup, const MCFragment *DF,
128 const MCValue &Target,
129 const MCSubtargetInfo *STI, uint64_t &Value,
130 bool &WasForced) {
131 llvm_unreachable("Need to implement hook if target has custom fixups");
132 }
133
134 virtual bool handleAddSubRelocations(const MCAsmLayout &Layout,
135 const MCFragment &F,
136 const MCFixup &Fixup,
137 const MCValue &Target,
138 uint64_t &FixedValue) const {
139 return false;
140 }
141
142 /// Apply the \p Value for given \p Fixup into the provided data fragment, at
143 /// the offset specified by the fixup and following the fixup kind as
144 /// appropriate. Errors (such as an out of range fixup value) should be
145 /// reported via \p Ctx.
146 /// The \p STI is present only for fragments of type MCRelaxableFragment and
147 /// MCDataFragment with hasInstructions() == true.
148 virtual void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
150 uint64_t Value, bool IsResolved,
151 const MCSubtargetInfo *STI) const = 0;
152
153 /// @}
154
155 /// \name Target Relaxation Interfaces
156 /// @{
157
158 /// Check whether the given instruction may need relaxation.
159 ///
160 /// \param Inst - The instruction to test.
161 /// \param STI - The MCSubtargetInfo in effect when the instruction was
162 /// encoded.
163 virtual bool mayNeedRelaxation(const MCInst &Inst,
164 const MCSubtargetInfo &STI) const {
165 return false;
166 }
167
168 /// Target specific predicate for whether a given fixup requires the
169 /// associated instruction to be relaxed.
170 virtual bool fixupNeedsRelaxationAdvanced(const MCFixup &Fixup, bool Resolved,
172 const MCRelaxableFragment *DF,
173 const MCAsmLayout &Layout,
174 const bool WasForced) const;
175
176 /// Simple predicate for targets where !Resolved implies requiring relaxation
178 const MCRelaxableFragment *DF,
179 const MCAsmLayout &Layout) const = 0;
180
181 /// Relax the instruction in the given fragment to the next wider instruction.
182 ///
183 /// \param [out] Inst The instruction to relax, which is also the relaxed
184 /// instruction.
185 /// \param STI the subtarget information for the associated instruction.
186 virtual void relaxInstruction(MCInst &Inst,
187 const MCSubtargetInfo &STI) const {};
188
190 MCAsmLayout &Layout, bool &WasRelaxed) const {
191 return false;
192 }
193
195 bool &WasRelaxed) const {
196 return false;
197 }
198
199 // Defined by linker relaxation targets to possibly emit LEB128 relocations
200 // and set Value at the relocated location.
201 virtual std::pair<bool, bool>
202 relaxLEB128(MCLEBFragment &LF, MCAsmLayout &Layout, int64_t &Value) const {
203 return std::make_pair(false, false);
204 }
205
206 /// @}
207
208 /// Returns the minimum size of a nop in bytes on this target. The assembler
209 /// will use this to emit excess padding in situations where the padding
210 /// required for simple alignment would be less than the minimum nop size.
211 ///
212 virtual unsigned getMinimumNopSize() const { return 1; }
213
214 /// Returns the maximum size of a nop in bytes on this target.
215 ///
216 virtual unsigned getMaximumNopSize(const MCSubtargetInfo &STI) const {
217 return 0;
218 }
219
220 /// Write an (optimal) nop sequence of Count bytes to the given output. If the
221 /// target cannot generate such a sequence, it should return an error.
222 ///
223 /// \return - True on success.
224 virtual bool writeNopData(raw_ostream &OS, uint64_t Count,
225 const MCSubtargetInfo *STI) const = 0;
226
227 /// Give backend an opportunity to finish layout after relaxation
228 virtual void finishLayout(MCAssembler const &Asm,
229 MCAsmLayout &Layout) const {}
230
231 /// Handle any target-specific assembler flags. By default, do nothing.
233
234 /// Generate the compact unwind encoding for the CFI instructions.
236 const MCContext *Ctxt) const {
237 return 0;
238 }
239
240 /// Check whether a given symbol has been flagged with MICROMIPS flag.
241 virtual bool isMicroMips(const MCSymbol *Sym) const {
242 return false;
243 }
244
245 bool isDarwinCanonicalPersonality(const MCSymbol *Sym) const;
246};
247
248} // end namespace llvm
249
250#endif // LLVM_MC_MCASMBACKEND_H
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define F(x, y, z)
Definition: MD5.cpp:55
PowerPC TLS Dynamic Call Fixup
raw_pwrite_stream & OS
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:43
virtual bool fixupNeedsRelaxationAdvanced(const MCFixup &Fixup, bool Resolved, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout, const bool WasForced) const
Target specific predicate for whether a given fixup requires the associated instruction to be relaxed...
std::unique_ptr< MCObjectWriter > createObjectWriter(raw_pwrite_stream &OS) const
Create a new MCObjectWriter instance for use by the assembler backend to emit the final object file.
std::unique_ptr< MCObjectWriter > createDwoObjectWriter(raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS) const
Create an MCObjectWriter that writes two object files: a .o file which is linked into the final progr...
virtual unsigned getMinimumNopSize() const
Returns the minimum size of a nop in bytes on this target.
Definition: MCAsmBackend.h:212
MCAsmBackend(const MCAsmBackend &)=delete
const llvm::endianness Endian
Definition: MCAsmBackend.h:52
virtual bool relaxDwarfLineAddr(MCDwarfLineAddrFragment &DF, MCAsmLayout &Layout, bool &WasRelaxed) const
Definition: MCAsmBackend.h:189
virtual bool handleAddSubRelocations(const MCAsmLayout &Layout, const MCFragment &F, const MCFixup &Fixup, const MCValue &Target, uint64_t &FixedValue) const
Definition: MCAsmBackend.h:134
virtual bool shouldInsertFixupForCodeAlign(MCAssembler &Asm, const MCAsmLayout &Layout, MCAlignFragment &AF)
Hook which indicates if the target requires a fixup to be generated when handling an align directive ...
Definition: MCAsmBackend.h:119
virtual bool allowEnhancedRelaxation() const
Return true if this target allows an unrelaxable instruction to be emitted into RelaxableFragment and...
Definition: MCAsmBackend.h:63
virtual unsigned getMaximumNopSize(const MCSubtargetInfo &STI) const
Returns the maximum size of a nop in bytes on this target.
Definition: MCAsmBackend.h:216
virtual void handleAssemblerFlag(MCAssemblerFlag Flag)
Handle any target-specific assembler flags. By default, do nothing.
Definition: MCAsmBackend.h:232
virtual bool writeNopData(raw_ostream &OS, uint64_t Count, const MCSubtargetInfo *STI) const =0
Write an (optimal) nop sequence of Count bytes to the given output.
virtual void relaxInstruction(MCInst &Inst, const MCSubtargetInfo &STI) const
Relax the instruction in the given fragment to the next wider instruction.
Definition: MCAsmBackend.h:186
virtual bool mayNeedRelaxation(const MCInst &Inst, const MCSubtargetInfo &STI) const
Check whether the given instruction may need relaxation.
Definition: MCAsmBackend.h:163
virtual bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout) const =0
Simple predicate for targets where !Resolved implies requiring relaxation.
virtual bool isMicroMips(const MCSymbol *Sym) const
Check whether a given symbol has been flagged with MICROMIPS flag.
Definition: MCAsmBackend.h:241
virtual void finishLayout(MCAssembler const &Asm, MCAsmLayout &Layout) const
Give backend an opportunity to finish layout after relaxation.
Definition: MCAsmBackend.h:228
virtual bool shouldInsertExtraNopBytesForCodeAlign(const MCAlignFragment &AF, unsigned &Size)
Hook to check if extra nop bytes must be inserted for alignment directive.
Definition: MCAsmBackend.h:112
virtual bool evaluateTargetFixup(const MCAssembler &Asm, const MCAsmLayout &Layout, const MCFixup &Fixup, const MCFragment *DF, const MCValue &Target, const MCSubtargetInfo *STI, uint64_t &Value, bool &WasForced)
Definition: MCAsmBackend.h:125
MCAsmBackend & operator=(const MCAsmBackend &)=delete
virtual bool relaxDwarfCFA(MCDwarfCallFrameFragment &DF, MCAsmLayout &Layout, bool &WasRelaxed) const
Definition: MCAsmBackend.h:194
bool isDarwinCanonicalPersonality(const MCSymbol *Sym) const
virtual void emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst)
Definition: MCAsmBackend.h:70
virtual std::unique_ptr< MCObjectTargetWriter > createObjectTargetWriter() const =0
virtual void emitInstructionBegin(MCObjectStreamer &OS, const MCInst &Inst, const MCSubtargetInfo &STI)
Give the target a chance to manipulate state related to instruction alignment (e.g.
Definition: MCAsmBackend.h:68
virtual void reset()
lifetime management
Definition: MCAsmBackend.h:73
virtual std::pair< bool, bool > relaxLEB128(MCLEBFragment &LF, MCAsmLayout &Layout, int64_t &Value) const
Definition: MCAsmBackend.h:202
virtual bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, const MCSubtargetInfo *STI)
Hook to check if a relocation is needed for some target specific reason.
Definition: MCAsmBackend.h:102
const unsigned RelaxFixupKind
Fixup kind used for linker relaxation. Currently only used by RISC-V.
Definition: MCAsmBackend.h:55
virtual unsigned getNumFixupKinds() const =0
Get the number of target specific fixup kinds.
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
virtual std::optional< MCFixupKind > getFixupKind(StringRef Name) const
Map a relocation name used in .reloc to a fixup kind.
virtual void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, MutableArrayRef< char > Data, uint64_t Value, bool IsResolved, const MCSubtargetInfo *STI) const =0
Apply the Value for given Fixup into the provided data fragment, at the offset specified by the fixup...
virtual bool allowAutoPadding() const
Return true if this target might automatically pad instructions and thus need to emit padding enable/...
Definition: MCAsmBackend.h:59
virtual ~MCAsmBackend()
virtual uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI, const MCContext *Ctxt) const
Generate the compact unwind encoding for the CFI instructions.
Definition: MCAsmBackend.h:235
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
Context object for machine code objects.
Definition: MCContext.h:76
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
Streaming object file generation interface.
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:274
Generic base class for all target subtargets.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
This represents an "assembler immediate".
Definition: MCValue.h:36
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Target - Wrapper for Target specific information.
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:444
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:21
@ MaxFixupKind
Set limit to accommodate the highest reloc type in use for all Targets, currently R_AARCH64_IRELATIVE...
Definition: MCFixup.h:54
MCAssemblerFlag
Definition: MCDirectives.h:53
endianness
Definition: bit.h:70
Target independent information on a fixup kind.