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: 48 MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS, 49 MCCodeEmitter *Emitter); 50 ~MCObjectStreamer() override; 51 52 public: 53 /// state management 54 void reset() override; 55 56 /// Object streamers require the integrated assembler. isIntegratedAssemblerRequired()57 bool isIntegratedAssemblerRequired() const override { return true; } 58 59 void EmitFrames(MCAsmBackend *MAB); 60 void EmitCFISections(bool EH, bool Debug) override; 61 62 protected: 63 MCFragment *getCurrentFragment() const; 64 insert(MCFragment * F)65 void insert(MCFragment *F) { 66 flushPendingLabels(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. 74 MCDataFragment *getOrCreateDataFragment(); 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 getAssembler()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 EmitGPRel32Value(const MCExpr *Value) override; 126 void EmitGPRel64Value(const MCExpr *Value) override; 127 bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, 128 const MCExpr *Expr, SMLoc Loc) override; 129 void EmitFill(uint64_t NumBytes, uint8_t FillValue) override; 130 void FinishImpl() override; 131 132 /// Emit the absolute difference between two symbols if possible. 133 /// 134 /// Emit the absolute difference between \c Hi and \c Lo, as long as we can 135 /// compute it. Currently, that requires that both symbols are in the same 136 /// data fragment. Otherwise, do nothing and return \c false. 137 /// 138 /// \pre Offset of \c Hi is greater than the offset \c Lo. 139 void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, 140 unsigned Size) override; 141 142 bool mayHaveInstructions(MCSection &Sec) const override; 143 }; 144 145 } // end namespace llvm 146 147 #endif 148