LLVM  10.0.0svn
MCObjectStreamer.h
Go to the documentation of this file.
1 //===- MCObjectStreamer.h - MCStreamer Object File Interface ----*- 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_MCOBJECTSTREAMER_H
10 #define LLVM_MC_MCOBJECTSTREAMER_H
11 
12 #include "llvm/ADT/SmallVector.h"
13 #include "llvm/MC/MCAssembler.h"
14 #include "llvm/MC/MCSection.h"
15 #include "llvm/MC/MCStreamer.h"
16 
17 namespace llvm {
18 class MCAssembler;
19 class MCCodeEmitter;
20 class MCSubtargetInfo;
21 class MCExpr;
22 class MCFragment;
23 class MCDataFragment;
24 class MCAsmBackend;
25 class raw_ostream;
26 class raw_pwrite_stream;
27 
28 /// Streaming object file generation interface.
29 ///
30 /// This class provides an implementation of the MCStreamer interface which is
31 /// suitable for use with the assembler backend. Specific object file formats
32 /// are expected to subclass this interface to implement directives specific
33 /// to that file format or custom semantics expected by the object writer
34 /// implementation.
35 class MCObjectStreamer : public MCStreamer {
36  std::unique_ptr<MCAssembler> Assembler;
37  MCSection::iterator CurInsertionPoint;
38  bool EmitEHFrame;
39  bool EmitDebugFrame;
40  SmallVector<MCSymbol *, 2> PendingLabels;
41  struct PendingMCFixup {
42  const MCSymbol *Sym;
43  MCFixup Fixup;
44  MCDataFragment *DF;
45  PendingMCFixup(const MCSymbol *McSym, MCDataFragment *F, MCFixup McFixup)
46  : Sym(McSym), Fixup(McFixup), DF(F) {}
47  };
48  SmallVector<PendingMCFixup, 2> PendingFixups;
49 
50  virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
51  void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
52  void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
53  MCSymbol *EmitCFILabel() override;
54  void EmitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
55  void resolvePendingFixups();
56 
57 protected:
58  MCObjectStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
59  std::unique_ptr<MCObjectWriter> OW,
60  std::unique_ptr<MCCodeEmitter> Emitter);
62 
63 public:
64  /// state management
65  void reset() override;
66 
67  /// Object streamers require the integrated assembler.
68  bool isIntegratedAssemblerRequired() const override { return true; }
69 
70  void EmitFrames(MCAsmBackend *MAB);
71  void EmitCFISections(bool EH, bool Debug) override;
72 
74 
75  void insert(MCFragment *F) {
77  MCSection *CurSection = getCurrentSectionOnly();
78  CurSection->getFragmentList().insert(CurInsertionPoint, F);
79  F->setParent(CurSection);
80  }
81 
82  /// Get a data fragment to write into, creating a new one if the current
83  /// fragment is not a data fragment.
84  /// Optionally a \p STI can be passed in so that a new fragment is created
85  /// if the Subtarget differs from the current fragment.
88 
89 protected:
90  bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
91 
92  /// If any labels have been emitted but not assigned fragments, ensure that
93  /// they get assigned, either to F if possible or to a new data fragment.
94  /// Optionally, it is also possible to provide an offset \p FOffset, which
95  /// will be used as a symbol offset within the fragment.
96  void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
97 
98 public:
99  void visitUsedSymbol(const MCSymbol &Sym) override;
100 
101  /// Create a dummy fragment to assign any pending labels.
103 
104  MCAssembler &getAssembler() { return *Assembler; }
105  MCAssembler *getAssemblerPtr() override;
106  /// \name MCStreamer Interface
107  /// @{
108 
109  void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
110  virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
111  void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
112  void EmitValueImpl(const MCExpr *Value, unsigned Size,
113  SMLoc Loc = SMLoc()) override;
114  void EmitULEB128Value(const MCExpr *Value) override;
115  void EmitSLEB128Value(const MCExpr *Value) override;
116  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
117  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
118  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
119 
120  /// Emit an instruction to a special fragment, because this instruction
121  /// can change its size during relaxation.
122  virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
123 
124  void EmitBundleAlignMode(unsigned AlignPow2) override;
125  void EmitBundleLock(bool AlignToEnd) override;
126  void EmitBundleUnlock() override;
127  void EmitBytes(StringRef Data) override;
128  void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
129  unsigned ValueSize = 1,
130  unsigned MaxBytesToEmit = 0) override;
131  void EmitCodeAlignment(unsigned ByteAlignment,
132  unsigned MaxBytesToEmit = 0) override;
133  void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
134  SMLoc Loc) override;
135  void
136  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override;
137  void
138  EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;
139  void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
140  unsigned Column, unsigned Flags,
141  unsigned Isa, unsigned Discriminator,
142  StringRef FileName) override;
143  void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
144  const MCSymbol *Label,
145  unsigned PointerSize);
146  void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
147  const MCSymbol *Label);
148  void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
149  unsigned Column, bool PrologueEnd, bool IsStmt,
150  StringRef FileName, SMLoc Loc) override;
151  void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
152  const MCSymbol *End) override;
153  void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
154  unsigned SourceFileId,
155  unsigned SourceLineNum,
156  const MCSymbol *FnStartSym,
157  const MCSymbol *FnEndSym) override;
159  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
160  StringRef FixedSizePortion) override;
161  void EmitCVStringTableDirective() override;
162  void EmitCVFileChecksumsDirective() override;
163  void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
164  void EmitDTPRel32Value(const MCExpr *Value) override;
165  void EmitDTPRel64Value(const MCExpr *Value) override;
166  void EmitTPRel32Value(const MCExpr *Value) override;
167  void EmitTPRel64Value(const MCExpr *Value) override;
168  void EmitGPRel32Value(const MCExpr *Value) override;
169  void EmitGPRel64Value(const MCExpr *Value) override;
170  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
171  const MCExpr *Expr, SMLoc Loc,
172  const MCSubtargetInfo &STI) override;
173  using MCStreamer::emitFill;
174  void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
175  SMLoc Loc = SMLoc()) override;
176  void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
177  SMLoc Loc = SMLoc()) override;
178  void EmitFileDirective(StringRef Filename) override;
179 
180  void EmitAddrsig() override;
181  void EmitAddrsigSym(const MCSymbol *Sym) override;
182 
183  void FinishImpl() override;
184 
185  /// Emit the absolute difference between two symbols if possible.
186  ///
187  /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
188  /// compute it. Currently, that requires that both symbols are in the same
189  /// data fragment and that the target has not specified that diff expressions
190  /// require relocations to be emitted. Otherwise, do nothing and return
191  /// \c false.
192  ///
193  /// \pre Offset of \c Hi is greater than the offset \c Lo.
194  void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
195  unsigned Size) override;
196 
198  const MCSymbol *Lo) override;
199 
200  bool mayHaveInstructions(MCSection &Sec) const override;
201 };
202 
203 } // end namespace llvm
204 
205 #endif
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
Fragment for adding required padding.
Definition: MCFragment.h:342
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
void EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override
virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &)
Emit an instruction to a special fragment, because this instruction can change its size during relaxa...
F(f)
void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override
This implements the CodeView &#39;.cv_filechecksumoffset&#39; assembler directive.
void EmitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion) override
This implements the CodeView &#39;.cv_def_range&#39; assembler directive.
void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel, const MCSymbol *Label, unsigned PointerSize)
void EmitCVStringTableDirective() override
This implements the CodeView &#39;.cv_stringtable&#39; assembler directive.
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:77
void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override
Emit a .reloc directive.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool mayHaveInstructions(MCSection &Sec) const override
void flushPendingLabels()
Create a dummy fragment to assign any pending labels.
void EmitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
Context object for machine code objects.
Definition: MCContext.h:65
void EmitDTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc=SMLoc()) override
Emit Size bytes worth of the value specified by FillValue.
void EmitFileDirective(StringRef Filename) override
Switch to a new logical file.
Streaming object file generation interface.
MCAssembler * getAssemblerPtr() override
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void EmitDTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (32-bit DTP relative) value.
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) override
Emit the absolute difference between two symbols if possible.
void EmitULEB128Value(const MCExpr *Value) override
Streaming machine code generation interface.
Definition: MCStreamer.h:196
void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void visitUsedSymbol(const MCSymbol &Sym) override
void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc) override
This implements the CodeView &#39;.cv_loc&#39; assembler directive.
void EmitSLEB128Value(const MCExpr *Value) override
void insert(MCFragment *F)
void EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override
void EmitAddrsigSym(const MCSymbol *Sym) override
void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
MCAssembler & getAssembler()
void EmitFrames(MCAsmBackend *MAB)
void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc) override
Emit some number of copies of Value until the byte offset Offset is reached.
void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
PowerPC TLS Dynamic Call Fixup
MCPaddingFragment * getOrCreatePaddingFragment()
Iterator for intrusive lists based on ilist_node.
void EmitCFISections(bool EH, bool Debug) override
void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel, const MCSymbol *Label)
void ChangeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override
Emit the given Instruction into the current section.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin, const MCSymbol *End) override
This implements the CodeView &#39;.cv_linetable&#39; assembler directive.
void EmitBundleAlignMode(unsigned AlignPow2) override
Set the bundle alignment mode from now on in the section.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:351
void EmitTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment...
iterator insert(iterator where, pointer New)
Definition: ilist.h:226
void EmitBundleUnlock() override
Ends a bundle-locked group.
void FinishImpl() override
Streamer specific finalization.
void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override
Emit an assignment of Value to Symbol.
bool isIntegratedAssemblerRequired() const override
Object streamers require the integrated assembler.
void reset() override
state management
Generic base class for all target subtargets.
uint32_t Size
Definition: Profile.cpp:46
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 emitFill(uint64_t NumBytes, uint8_t FillValue)
Emit NumBytes bytes worth of the value specified by FillValue.
Definition: MCStreamer.cpp:203
void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName) override
This implements the DWARF2 &#39;.loc fileno lineno ...&#39; assembler directive.
void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) override
This implements the CodeView &#39;.cv_inline_linetable&#39; assembler directive.
MCFragment * getCurrentFragment() const
Fragment for data and encoded instructions.
Definition: MCFragment.h:243
MCObjectStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
LLVM Value Representation.
Definition: Value.h:74
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:41
static cl::opt< bool, true > Debug("debug", cl::desc("Enable debug output"), cl::Hidden, cl::location(DebugFlag))
void EmitGPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel32 (32-bit GP relative) value.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
void EmitCVFileChecksumsDirective() override
This implements the CodeView &#39;.cv_filechecksums&#39; assembler directive.
Represents a location in source code.
Definition: SMLoc.h:23
void setParent(MCSection *Value)
Definition: MCFragment.h:99
void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) override
Emit the absolute difference between two symbols encoded with ULEB128.
MCSection::FragmentListType & getFragmentList()
Definition: MCSection.h:150
void EmitGPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel64 (64-bit GP relative) value.
void EmitTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (64-bit TP relative) value.