LLVM  6.0.0svn
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  std::unique_ptr<MCObjectWriter> ObjectWriter;
38  std::unique_ptr<MCAsmBackend> TAB;
39  std::unique_ptr<MCCodeEmitter> Emitter;
40  std::unique_ptr<MCAssembler> Assembler;
41  MCSection::iterator CurInsertionPoint;
42  bool EmitEHFrame;
43  bool EmitDebugFrame;
44  SmallVector<MCSymbol *, 2> PendingLabels;
45 
46  virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
47  void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
48  void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
49  MCSymbol *EmitCFILabel() override;
50  void EmitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
51 
52 protected:
53  MCObjectStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
55  std::unique_ptr<MCCodeEmitter> Emitter);
57 
58 public:
59  /// state management
60  void reset() override;
61 
62  /// Object streamers require the integrated assembler.
63  bool isIntegratedAssemblerRequired() const override { return true; }
64 
65  void EmitFrames(MCAsmBackend *MAB);
66  void EmitCFISections(bool EH, bool Debug) override;
67 
69 
70  void insert(MCFragment *F) {
72  MCSection *CurSection = getCurrentSectionOnly();
73  CurSection->getFragmentList().insert(CurInsertionPoint, F);
74  F->setParent(CurSection);
75  }
76 
77  /// Get a data fragment to write into, creating a new one if the current
78  /// fragment is not a data fragment.
81 
82 protected:
83  bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
84 
85  /// If any labels have been emitted but not assigned fragments, ensure that
86  /// they get assigned, either to F if possible or to a new data fragment.
87  /// Optionally, it is also possible to provide an offset \p FOffset, which
88  /// will be used as a symbol offset within the fragment.
89  void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
90 
91 public:
92  void visitUsedSymbol(const MCSymbol &Sym) override;
93 
94  MCAssembler &getAssembler() { return *Assembler; }
95 
96  /// \name MCStreamer Interface
97  /// @{
98 
99  void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
100  virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
101  void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
102  void EmitValueImpl(const MCExpr *Value, unsigned Size,
103  SMLoc Loc = SMLoc()) override;
104  void EmitULEB128Value(const MCExpr *Value) override;
105  void EmitSLEB128Value(const MCExpr *Value) override;
106  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
107  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
108  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
109  bool = false) override;
110 
111  /// \brief Emit an instruction to a special fragment, because this instruction
112  /// can change its size during relaxation.
113  virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
114 
115  void EmitBundleAlignMode(unsigned AlignPow2) override;
116  void EmitBundleLock(bool AlignToEnd) override;
117  void EmitBundleUnlock() override;
118  void EmitBytes(StringRef Data) override;
119  void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
120  unsigned ValueSize = 1,
121  unsigned MaxBytesToEmit = 0) override;
122  void EmitCodeAlignment(unsigned ByteAlignment,
123  unsigned MaxBytesToEmit = 0) override;
124  void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
125  SMLoc Loc) override;
126  void
127  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override;
128  void
129  EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;
130  void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
131  unsigned Column, unsigned Flags,
132  unsigned Isa, unsigned Discriminator,
133  StringRef FileName) override;
134  void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
135  const MCSymbol *Label,
136  unsigned PointerSize);
137  void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
138  const MCSymbol *Label);
139  void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
140  unsigned Column, bool PrologueEnd, bool IsStmt,
141  StringRef FileName, SMLoc Loc) override;
142  void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
143  const MCSymbol *End) override;
144  void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
145  unsigned SourceFileId,
146  unsigned SourceLineNum,
147  const MCSymbol *FnStartSym,
148  const MCSymbol *FnEndSym) override;
150  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
151  StringRef FixedSizePortion) override;
152  void EmitCVStringTableDirective() override;
153  void EmitCVFileChecksumsDirective() override;
154  void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
155  void EmitDTPRel32Value(const MCExpr *Value) override;
156  void EmitDTPRel64Value(const MCExpr *Value) override;
157  void EmitTPRel32Value(const MCExpr *Value) override;
158  void EmitTPRel64Value(const MCExpr *Value) override;
159  void EmitGPRel32Value(const MCExpr *Value) override;
160  void EmitGPRel64Value(const MCExpr *Value) override;
161  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
162  const MCExpr *Expr, SMLoc Loc) override;
163  using MCStreamer::emitFill;
164  void emitFill(uint64_t NumBytes, uint8_t FillValue) override;
165  void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
166  SMLoc Loc = SMLoc()) override;
167  void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
168  SMLoc Loc = SMLoc()) override;
169  void EmitFileDirective(StringRef Filename) override;
170 
171  void FinishImpl() override;
172 
173  /// Emit the absolute difference between two symbols if possible.
174  ///
175  /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
176  /// compute it. Currently, that requires that both symbols are in the same
177  /// data fragment. Otherwise, do nothing and return \c false.
178  ///
179  /// \pre Offset of \c Hi is greater than the offset \c Lo.
180  void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
181  unsigned Size) override;
182 
183  bool mayHaveInstructions(MCSection &Sec) const override;
184 };
185 
186 } // end namespace llvm
187 
188 #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:333
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
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...
MCObjectStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, raw_pwrite_stream &OS, std::unique_ptr< MCCodeEmitter > Emitter)
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.
void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc) override
Emit a .reloc directive.
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:59
void EmitDTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
void EmitFileDirective(StringRef Filename) override
Switch to a new logical file.
Streaming object file generation interface.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
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:159
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:169
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 EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
MCAssembler & getAssembler()
static const unsigned End
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 emitFill(uint64_t NumBytes, uint8_t FillValue) override
Emit NumBytes bytes worth of the value specified by FillValue.
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.
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.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin, const MCSymbol *End) override
This implements the CodeView &#39;.cv_linetable&#39; assembler directive.
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.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:316
void EmitTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
iterator insert(iterator where, pointer New)
Definition: ilist.h:241
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
MCSubtargetInfo - Generic base class for all target subtargets.
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.
virtual void emitFill(uint64_t NumBytes, uint8_t FillValue)
Emit NumBytes bytes worth of the value specified by FillValue.
Definition: MCStreamer.cpp:164
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
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:337
Fragment for data and encoded instructions.
Definition: MCFragment.h:226
LLVM Value Representation.
Definition: Value.h:73
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:40
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
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:49
void EmitCVFileChecksumsDirective() override
This implements the CodeView &#39;.cv_filechecksums&#39; assembler directive.
Represents a location in source code.
Definition: SMLoc.h:24
void setParent(MCSection *Value)
Definition: MCFragment.h:105
MCSection::FragmentListType & getFragmentList()
Definition: MCSection.h:143
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...
void EmitTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (64-bit TP relative) value.
void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool=false) override
Emit the given Instruction into the current section.