1//===- MCObjectStreamer.h - MCStreamer Object File Interface ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef LLVM_MC_MCOBJECTSTREAMER_H
11#define LLVM_MC_MCOBJECTSTREAMER_H
12
13#include "llvm/ADT/SmallVector.h"
14#include "llvm/MC/MCAssembler.h"
15#include "llvm/MC/MCSection.h"
16#include "llvm/MC/MCStreamer.h"
17
18namespace llvm {
19class MCAssembler;
20class MCCodeEmitter;
21class MCSubtargetInfo;
22class MCExpr;
23class MCFragment;
24class MCDataFragment;
25class MCAsmBackend;
26class raw_ostream;
27class raw_pwrite_stream;
28
29/// \brief Streaming object file generation interface.
30///
31/// This class provides an implementation of the MCStreamer interface which is
32/// suitable for use with the assembler backend. Specific object file formats
33/// are expected to subclass this interface to implement directives specific
34/// to that file format or custom semantics expected by the object writer
35/// implementation.
36class MCObjectStreamer : public MCStreamer {
37  MCAssembler *Assembler;
38  MCSection::iterator CurInsertionPoint;
39  bool EmitEHFrame;
40  bool EmitDebugFrame;
41  SmallVector<MCSymbol *, 2> PendingLabels;
42
43  virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
44  void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
45  void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
46
47protected:
48  MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
49                   MCCodeEmitter *Emitter);
50  ~MCObjectStreamer() override;
51
52public:
53  /// state management
54  void reset() override;
55
56  /// Object streamers require the integrated assembler.
57  bool isIntegratedAssemblerRequired() const override { return true; }
58
59  void EmitFrames(MCAsmBackend *MAB);
60  void EmitCFISections(bool EH, bool Debug) override;
61
62  MCFragment *getCurrentFragment() const;
63
64  void insert(MCFragment *F) {
65    flushPendingLabels(F);
66    MCSection *CurSection = getCurrentSectionOnly();
67    CurSection->getFragmentList().insert(CurInsertionPoint, F);
68    F->setParent(CurSection);
69  }
70
71  /// Get a data fragment to write into, creating a new one if the current
72  /// fragment is not a data fragment.
73  MCDataFragment *getOrCreateDataFragment();
74
75protected:
76  bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
77
78  /// If any labels have been emitted but not assigned fragments, ensure that
79  /// they get assigned, either to F if possible or to a new data fragment.
80  /// Optionally, it is also possible to provide an offset \p FOffset, which
81  /// will be used as a symbol offset within the fragment.
82  void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
83
84public:
85  void visitUsedSymbol(const MCSymbol &Sym) override;
86
87  MCAssembler &getAssembler() { return *Assembler; }
88
89  /// \name MCStreamer Interface
90  /// @{
91
92  void EmitLabel(MCSymbol *Symbol) override;
93  void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
94  void EmitValueImpl(const MCExpr *Value, unsigned Size,
95                     SMLoc Loc = SMLoc()) override;
96  void EmitULEB128Value(const MCExpr *Value) override;
97  void EmitSLEB128Value(const MCExpr *Value) override;
98  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
99  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
100  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo& STI) override;
101
102  /// \brief Emit an instruction to a special fragment, because this instruction
103  /// can change its size during relaxation.
104  virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
105
106  void EmitBundleAlignMode(unsigned AlignPow2) override;
107  void EmitBundleLock(bool AlignToEnd) override;
108  void EmitBundleUnlock() override;
109  void EmitBytes(StringRef Data) override;
110  void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
111                            unsigned ValueSize = 1,
112                            unsigned MaxBytesToEmit = 0) override;
113  void EmitCodeAlignment(unsigned ByteAlignment,
114                         unsigned MaxBytesToEmit = 0) override;
115  void emitValueToOffset(const MCExpr *Offset, unsigned char Value) override;
116  void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
117                             unsigned Column, unsigned Flags,
118                             unsigned Isa, unsigned Discriminator,
119                             StringRef FileName) override;
120  void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
121                                const MCSymbol *Label,
122                                unsigned PointerSize);
123  void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
124                                 const MCSymbol *Label);
125  void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
126                          unsigned Column, bool PrologueEnd, bool IsStmt,
127                          StringRef FileName) override;
128  void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
129                                const MCSymbol *End) override;
130  void EmitCVInlineLinetableDirective(
131      unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
132      const MCSymbol *FnStartSym, const MCSymbol *FnEndSym,
133      ArrayRef<unsigned> SecondaryFunctionIds) override;
134  void EmitCVDefRangeDirective(
135      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
136      StringRef FixedSizePortion) override;
137  void EmitCVStringTableDirective() override;
138  void EmitCVFileChecksumsDirective() override;
139  void EmitGPRel32Value(const MCExpr *Value) override;
140  void EmitGPRel64Value(const MCExpr *Value) override;
141  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
142                          const MCExpr *Expr, SMLoc Loc) override;
143  using MCStreamer::emitFill;
144  void emitFill(uint64_t NumBytes, uint8_t FillValue) override;
145  void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
146                SMLoc Loc = SMLoc()) override;
147  void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
148                SMLoc Loc = SMLoc()) override;
149
150  void FinishImpl() override;
151
152  /// Emit the absolute difference between two symbols if possible.
153  ///
154  /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
155  /// compute it.  Currently, that requires that both symbols are in the same
156  /// data fragment.  Otherwise, do nothing and return \c false.
157  ///
158  /// \pre Offset of \c Hi is greater than the offset \c Lo.
159  void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
160                              unsigned Size) override;
161
162  bool mayHaveInstructions(MCSection &Sec) const override;
163};
164
165} // end namespace llvm
166
167#endif
168