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/ADT/SmallVector.h"
14#include "llvm/Support/Compiler.h"
15#include "llvm/Support/DataTypes.h"
16#include "llvm/Support/EndianStream.h"
17#include "llvm/Support/raw_ostream.h"
18#include <cassert>
19
20namespace llvm {
21class MCAsmLayout;
22class MCAssembler;
23class MCFixup;
24class MCFragment;
25class MCSymbol;
26class MCSymbolRefExpr;
27class MCValue;
28
29/// Defines the object file and target independent interfaces used by the
30/// assembler backend to write native file format object files.
31///
32/// The object writer contains a few callbacks used by the assembler to allow
33/// the object writer to modify the assembler data structures at appropriate
34/// points. Once assembly is complete, the object writer is given the
35/// MCAssembler instance, which contains all the symbol and section data which
36/// should be emitted as part of writeObject().
37///
38/// The object writer also contains a number of helper methods for writing
39/// binary data to the output stream.
40class MCObjectWriter {
41  MCObjectWriter(const MCObjectWriter &) = delete;
42  void operator=(const MCObjectWriter &) = delete;
43
44  raw_pwrite_stream *OS;
45
46protected:
47  unsigned IsLittleEndian : 1;
48
49protected: // Can only create subclasses.
50  MCObjectWriter(raw_pwrite_stream &OS, bool IsLittleEndian)
51      : OS(&OS), IsLittleEndian(IsLittleEndian) {}
52
53  unsigned getInitialOffset() {
54    return OS->tell();
55  }
56
57public:
58  virtual ~MCObjectWriter();
59
60  /// lifetime management
61  virtual void reset() {}
62
63  bool isLittleEndian() const { return IsLittleEndian; }
64
65  raw_pwrite_stream &getStream() { return *OS; }
66  void setStream(raw_pwrite_stream &NewOS) { OS = &NewOS; }
67
68  /// \name High-Level API
69  /// @{
70
71  /// Perform any late binding of symbols (for example, to assign symbol
72  /// indices for use when generating relocations).
73  ///
74  /// This routine is called by the assembler after layout and relaxation is
75  /// complete.
76  virtual void executePostLayoutBinding(MCAssembler &Asm,
77                                        const MCAsmLayout &Layout) = 0;
78
79  /// Record a relocation entry.
80  ///
81  /// This routine is called by the assembler after layout and relaxation, and
82  /// post layout binding. The implementation is responsible for storing
83  /// information about the relocation so that it can be emitted during
84  /// writeObject().
85  virtual void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
86                                const MCFragment *Fragment,
87                                const MCFixup &Fixup, MCValue Target,
88                                bool &IsPCRel, uint64_t &FixedValue) = 0;
89
90  /// Check whether the difference (A - B) between two symbol references is
91  /// fully resolved.
92  ///
93  /// Clients are not required to answer precisely and may conservatively return
94  /// false, even when a difference is fully resolved.
95  bool isSymbolRefDifferenceFullyResolved(const MCAssembler &Asm,
96                                          const MCSymbolRefExpr *A,
97                                          const MCSymbolRefExpr *B,
98                                          bool InSet) const;
99
100  virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
101                                                      const MCSymbol &A,
102                                                      const MCSymbol &B,
103                                                      bool InSet) const;
104
105  virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
106                                                      const MCSymbol &SymA,
107                                                      const MCFragment &FB,
108                                                      bool InSet,
109                                                      bool IsPCRel) const;
110
111  /// True if this symbol (which is a variable) is weak. This is not
112  /// just STB_WEAK, but more generally whether or not we can evaluate
113  /// past it.
114  virtual bool isWeak(const MCSymbol &Sym) const;
115
116  /// Write the object file.
117  ///
118  /// This routine is called by the assembler after layout and relaxation is
119  /// complete, fixups have been evaluated and applied, and relocations
120  /// generated.
121  virtual void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
122
123  /// @}
124  /// \name Binary Output
125  /// @{
126
127  void write8(uint8_t Value) { *OS << char(Value); }
128
129  void writeLE16(uint16_t Value) {
130    support::endian::Writer<support::little>(*OS).write(Value);
131  }
132
133  void writeLE32(uint32_t Value) {
134    support::endian::Writer<support::little>(*OS).write(Value);
135  }
136
137  void writeLE64(uint64_t Value) {
138    support::endian::Writer<support::little>(*OS).write(Value);
139  }
140
141  void writeBE16(uint16_t Value) {
142    support::endian::Writer<support::big>(*OS).write(Value);
143  }
144
145  void writeBE32(uint32_t Value) {
146    support::endian::Writer<support::big>(*OS).write(Value);
147  }
148
149  void writeBE64(uint64_t Value) {
150    support::endian::Writer<support::big>(*OS).write(Value);
151  }
152
153  void write16(uint16_t Value) {
154    if (IsLittleEndian)
155      writeLE16(Value);
156    else
157      writeBE16(Value);
158  }
159
160  void write32(uint32_t Value) {
161    if (IsLittleEndian)
162      writeLE32(Value);
163    else
164      writeBE32(Value);
165  }
166
167  void write64(uint64_t Value) {
168    if (IsLittleEndian)
169      writeLE64(Value);
170    else
171      writeBE64(Value);
172  }
173
174  void WriteZeros(unsigned N) {
175    const char Zeros[16] = {0};
176
177    for (unsigned i = 0, e = N / 16; i != e; ++i)
178      *OS << StringRef(Zeros, 16);
179
180    *OS << StringRef(Zeros, N % 16);
181  }
182
183  void writeBytes(const SmallVectorImpl<char> &ByteVec,
184                  unsigned ZeroFillSize = 0) {
185    writeBytes(StringRef(ByteVec.data(), ByteVec.size()), ZeroFillSize);
186  }
187
188  void writeBytes(StringRef Str, unsigned ZeroFillSize = 0) {
189    // TODO: this version may need to go away once all fragment contents are
190    // converted to SmallVector<char, N>
191    assert(
192        (ZeroFillSize == 0 || Str.size() <= ZeroFillSize) &&
193        "data size greater than fill size, unexpected large write will occur");
194    *OS << Str;
195    if (ZeroFillSize)
196      WriteZeros(ZeroFillSize - Str.size());
197  }
198
199  /// @}
200};
201
202} // End llvm namespace
203
204#endif
205