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