LLVM  3.7.0
MCObjectStreamer.h
Go to the documentation of this file.
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 
18 namespace llvm {
19 class MCAssembler;
20 class MCCodeEmitter;
21 class MCSubtargetInfo;
22 class MCExpr;
23 class MCFragment;
24 class MCDataFragment;
25 class MCAsmBackend;
26 class raw_ostream;
27 class 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.
36 class 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 
47 protected:
49  MCCodeEmitter *Emitter);
50  ~MCObjectStreamer() override;
51 
52 public:
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 protected:
64 
65  void insert(MCFragment *F) {
67  MCSection *CurSection = getCurrentSectionOnly();
68  CurSection->getFragmentList().insert(CurInsertionPoint, F);
69  F->setParent(CurSection);
70  }
71 
72  /// Get a data fragment to write into, creating a new one if the current
73  /// fragment is not a data fragment.
75 
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 
84 public:
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  const 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  bool 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 EmitGPRel32Value(const MCExpr *Value) override;
126  void EmitGPRel64Value(const MCExpr *Value) override;
127  void EmitFill(uint64_t NumBytes, uint8_t FillValue) override;
128  void EmitZeros(uint64_t NumBytes) override;
129  void FinishImpl() override;
130 
131  /// Emit the absolute difference between two symbols if possible.
132  ///
133  /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
134  /// compute it. Currently, that requires that both symbols are in the same
135  /// data fragment. Otherwise, do nothing and return \c false.
136  ///
137  /// \pre Offset of \c Hi is greater than the offset \c Lo.
138  void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
139  unsigned Size) override;
140 
141  bool mayHaveInstructions(MCSection &Sec) const override;
142 };
143 
144 } // end namespace llvm
145 
146 #endif
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:48
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
void EmitLabel(MCSymbol *Symbol) override
Emit a label for Symbol into the current section.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
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 EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel, const MCSymbol *Label, unsigned PointerSize)
MCFragment * getCurrentFragment() const
void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:279
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:33
void EmitFill(uint64_t NumBytes, uint8_t FillValue) override
Emit NumBytes bytes worth of the value specified by FillValue.
bool mayHaveInstructions(MCSection &Sec) const override
void EmitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
Context object for machine code objects.
Definition: MCContext.h:48
Streaming object file generation interface.
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:150
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:157
void visitUsedSymbol(const MCSymbol &Sym) override
void EmitSLEB128Value(const MCExpr *Value) override
void insert(MCFragment *F)
void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
MCAssembler & getAssembler()
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:23
iterator insert(iterator where, NodeTy *New)
Definition: ilist.h:412
void EmitValueImpl(const MCExpr *Value, unsigned Size, const SMLoc &Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void EmitFrames(MCAsmBackend *MAB)
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.
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 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
void flushPendingLabels(MCFragment *F, uint64_t FOffset=0)
If any labels have been emitted but not assigned fragments, ensure that they get assigned, either to F if possible or to a new data fragment.
void EmitBundleAlignMode(unsigned AlignPow2) override
Set the bundle alignment mode from now on in the section.
void EmitZeros(uint64_t NumBytes) override
Emit NumBytes worth of zeros.
void EmitBundleUnlock() override
Ends a bundle-locked group.
bool EmitValueToOffset(const MCExpr *Offset, unsigned char Value) override
Emit some number of copies of Value until the byte offset Offset is reached.
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
MCSubtargetInfo - Generic base class for all target subtargets.
void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName) override
This implements the DWARF2 '.loc fileno lineno ...' assembler directive.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:321
Fragment for data and encoded instructions.
Definition: MCAssembler.h:228
LLVM Value Representation.
Definition: Value.h:69
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:34
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:40
Represents a location in source code.
Definition: SMLoc.h:23
void setParent(MCSection *Value)
Definition: MCAssembler.h:119
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.
MCDataFragment * getOrCreateDataFragment()
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment...
MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter)