include/llvm/MC/MCObjectWriter.h

   1 //===-- llvm/MC/MCObjectWriter.h - Object File Writer 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_MCOBJECTWRITER_H
  11 #define LLVM_MC_MCOBJECTWRITER_H
  12
  13 #include "llvm/Support/raw_ostream.h"
  14 #include "llvm/System/DataTypes.h"
  15 #include <cassert>
  16
  17 namespace llvm {
  18 class MCAsmLayout;
  19 class MCAssembler;
  20 class MCFixup;
  21 class MCFragment;
  22 class MCValue;
  23 class raw_ostream;
  24
  25 /// MCObjectWriter - Defines the object file and target independent interfaces
  26 /// used by the assembler backend to write native file format object files.
  27 ///
  28 /// The object writer contains a few callbacks used by the assembler to allow
  29 /// the object writer to modify the assembler data structures at appropriate
  30 /// points. Once assembly is complete, the object writer is given the
  31 /// MCAssembler instance, which contains all the symbol and section data which
  32 /// should be emitted as part of WriteObject().
  33 ///
  34 /// The object writer also contains a number of helper methods for writing
  35 /// binary data to the output stream.
  36 class MCObjectWriter {
  37   MCObjectWriter(const MCObjectWriter &); // DO NOT IMPLEMENT
  38   void operator=(const MCObjectWriter &); // DO NOT IMPLEMENT
  39
  40 protected:
  41   raw_ostream &OS;
  42
  43   unsigned IsLittleEndian : 1;
  44
  45 protected: // Can only create subclasses.
  46   MCObjectWriter(raw_ostream &_OS, bool _IsLittleEndian)
  47     : OS(_OS), IsLittleEndian(_IsLittleEndian) {}
  48
  49 public:
  50   virtual ~MCObjectWriter();
  51
  52   bool isLittleEndian() const { return IsLittleEndian; }
  53
  54   raw_ostream &getStream() { return OS; }
  55
  56   /// @name High-Level API
  57   /// @{
  58
  59   /// Perform any late binding of symbols (for example, to assign symbol indices
  60   /// for use when generating relocations).
  61   ///
  62   /// This routine is called by the assembler after layout and relaxation is
  63   /// complete.
  64   virtual void ExecutePostLayoutBinding(MCAssembler &Asm) = 0;
  65
  66   /// Record a relocation entry.
  67   ///
  68   /// This routine is called by the assembler after layout and relaxation, and
  69   /// post layout binding. The implementation is responsible for storing
  70   /// information about the relocation so that it can be emitted during
  71   /// WriteObject().
  72   virtual void RecordRelocation(const MCAssembler &Asm,
  73                                 const MCAsmLayout &Layout,
  74                                 const MCFragment *Fragment,
  75                                 const MCFixup &Fixup, MCValue Target,
  76                                 uint64_t &FixedValue) = 0;
  77
  78   /// Check if a fixup is fully resolved.
  79   ///
  80   /// This routine is used by the assembler to let the file format decide
  81   /// if a fixup is not fully resolved. For example, one that crosses
  82   /// two sections on ELF.
  83   virtual bool IsFixupFullyResolved(const MCAssembler &Asm,
  84                                     const MCValue Target,
  85                                     bool IsPCRel,
  86                                     const MCFragment *DF) const = 0;
  87
  88   /// Write the object file.
  89   ///
  90   /// This routine is called by the assembler after layout and relaxation is
  91   /// complete, fixups have been evaluated and applied, and relocations
  92   /// generated.
  93   virtual void WriteObject(const MCAssembler &Asm,
  94                            const MCAsmLayout &Layout) = 0;
  95
  96   /// @}
  97   /// @name Binary Output
  98   /// @{
  99
 100   void Write8(uint8_t Value) {
 101     OS << char(Value);
 102   }
 103
 104   void WriteLE16(uint16_t Value) {
 105     Write8(uint8_t(Value >> 0));
 106     Write8(uint8_t(Value >> 8));
 107   }
 108
 109   void WriteLE32(uint32_t Value) {
 110     WriteLE16(uint16_t(Value >> 0));
 111     WriteLE16(uint16_t(Value >> 16));
 112   }
 113
 114   void WriteLE64(uint64_t Value) {
 115     WriteLE32(uint32_t(Value >> 0));
 116     WriteLE32(uint32_t(Value >> 32));
 117   }
 118
 119   void WriteBE16(uint16_t Value) {
 120     Write8(uint8_t(Value >> 8));
 121     Write8(uint8_t(Value >> 0));
 122   }
 123
 124   void WriteBE32(uint32_t Value) {
 125     WriteBE16(uint16_t(Value >> 16));
 126     WriteBE16(uint16_t(Value >> 0));
 127   }
 128
 129   void WriteBE64(uint64_t Value) {
 130     WriteBE32(uint32_t(Value >> 32));
 131     WriteBE32(uint32_t(Value >> 0));
 132   }
 133
 134   void Write16(uint16_t Value) {
 135     if (IsLittleEndian)
 136       WriteLE16(Value);
 137     else
 138       WriteBE16(Value);
 139   }
 140
 141   void Write32(uint32_t Value) {
 142     if (IsLittleEndian)
 143       WriteLE32(Value);
 144     else
 145       WriteBE32(Value);
 146   }
 147
 148   void Write64(uint64_t Value) {
 149     if (IsLittleEndian)
 150       WriteLE64(Value);
 151     else
 152       WriteBE64(Value);
 153   }
 154
 155   void WriteZeros(unsigned N) {
 156     const char Zeros[16] = { 0 };
 157
 158     for (unsigned i = 0, e = N / 16; i != e; ++i)
 159       OS << StringRef(Zeros, 16);
 160
 161     OS << StringRef(Zeros, N % 16);
 162   }
 163
 164   void WriteBytes(StringRef Str, unsigned ZeroFillSize = 0) {
 165     assert((ZeroFillSize == 0 || Str.size () <= ZeroFillSize) &&
 166       "data size greater than fill size, unexpected large write will occur");
 167     OS << Str;
 168     if (ZeroFillSize)
 169       WriteZeros(ZeroFillSize - Str.size());
 170   }
 171
 172   /// @}
 173
 174   /// Utility function to encode a SLEB128 value.
 175   static void EncodeSLEB128(int64_t Value, raw_ostream &OS);
 176   /// Utility function to encode a ULEB128 value.
 177   static void EncodeULEB128(uint64_t Value, raw_ostream &OS);
 178 };
 179
 180 MCObjectWriter *createWinCOFFObjectWriter(raw_ostream &OS, bool is64Bit);
 181
 182 } // End llvm namespace
 183
 184 #endif