#ifndef LLVM_MC_MCOBJECTWRITER_H
#define LLVM_MC_MCOBJECTWRITER_H
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
namespace llvm {
class MCAsmLayout;
class MCAssembler;
class MCFixup;
class MCFragment;
class MCSymbol;
class MCSymbolRefExpr;
class MCValue;
class MCObjectWriter {
MCObjectWriter(const MCObjectWriter &) = delete;
void operator=(const MCObjectWriter &) = delete;
raw_pwrite_stream *OS;
protected:
unsigned IsLittleEndian : 1;
protected: MCObjectWriter(raw_pwrite_stream &OS, bool IsLittleEndian)
: OS(&OS), IsLittleEndian(IsLittleEndian) {}
unsigned getInitialOffset() {
return OS->tell();
}
public:
virtual ~MCObjectWriter();
virtual void reset() {}
bool isLittleEndian() const { return IsLittleEndian; }
raw_pwrite_stream &getStream() { return *OS; }
void setStream(raw_pwrite_stream &NewOS) { OS = &NewOS; }
virtual void executePostLayoutBinding(MCAssembler &Asm,
const MCAsmLayout &Layout) = 0;
virtual void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target,
bool &IsPCRel, uint64_t &FixedValue) = 0;
bool isSymbolRefDifferenceFullyResolved(const MCAssembler &Asm,
const MCSymbolRefExpr *A,
const MCSymbolRefExpr *B,
bool InSet) const;
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
const MCSymbol &A,
const MCSymbol &B,
bool InSet) const;
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
const MCSymbol &SymA,
const MCFragment &FB,
bool InSet,
bool IsPCRel) const;
virtual bool isWeak(const MCSymbol &Sym) const;
virtual void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
void write8(uint8_t Value) { *OS << char(Value); }
void writeLE16(uint16_t Value) {
support::endian::Writer<support::little>(*OS).write(Value);
}
void writeLE32(uint32_t Value) {
support::endian::Writer<support::little>(*OS).write(Value);
}
void writeLE64(uint64_t Value) {
support::endian::Writer<support::little>(*OS).write(Value);
}
void writeBE16(uint16_t Value) {
support::endian::Writer<support::big>(*OS).write(Value);
}
void writeBE32(uint32_t Value) {
support::endian::Writer<support::big>(*OS).write(Value);
}
void writeBE64(uint64_t Value) {
support::endian::Writer<support::big>(*OS).write(Value);
}
void write16(uint16_t Value) {
if (IsLittleEndian)
writeLE16(Value);
else
writeBE16(Value);
}
void write32(uint32_t Value) {
if (IsLittleEndian)
writeLE32(Value);
else
writeBE32(Value);
}
void write64(uint64_t Value) {
if (IsLittleEndian)
writeLE64(Value);
else
writeBE64(Value);
}
void WriteZeros(unsigned N) {
const char Zeros[16] = {0};
for (unsigned i = 0, e = N / 16; i != e; ++i)
*OS << StringRef(Zeros, 16);
*OS << StringRef(Zeros, N % 16);
}
void writeBytes(const SmallVectorImpl<char> &ByteVec,
unsigned ZeroFillSize = 0) {
writeBytes(StringRef(ByteVec.data(), ByteVec.size()), ZeroFillSize);
}
void writeBytes(StringRef Str, unsigned ZeroFillSize = 0) {
assert(
(ZeroFillSize == 0 || Str.size() <= ZeroFillSize) &&
"data size greater than fill size, unexpected large write will occur");
*OS << Str;
if (ZeroFillSize)
WriteZeros(ZeroFillSize - Str.size());
}
};
}
#endif