SystemZMCAsmBackend.cpp Source File (original) (raw)

21using namespace llvm;

31 auto checkFixupInRange = [&](int64_t Min, int64_t Max) -> bool {

32 int64_t SVal = int64_t(Value);

33 if (SVal < Min || SVal > Max) {

35 " not between " + Twine(Min) +

36 " and " + Twine(Max) + ")");

37 return false;

38 }

39 return true;

40 };

42 auto handlePCRelFixupValue = [&](unsigned W) -> uint64_t {

43 if (Value % 2 != 0)

44 Ctx.reportError(Fixup.getLoc(), "Non-even PC relative offset.");

45 if (!checkFixupInRange(minIntN(W) * 2, maxIntN(W) * 2))

46 return 0;

47 return (int64_t)Value / 2;

48 };

50 auto handleImmValue = [&](bool IsSigned, unsigned W) -> uint64_t {

51 if (!(IsSigned ? checkFixupInRange(minIntN(W), maxIntN(W))

52 : checkFixupInRange(0, maxUIntN(W))))

53 return 0;

55 };

57 switch (unsigned(Kind)) {

59 return handlePCRelFixupValue(12);

61 return handlePCRelFixupValue(16);

63 return handlePCRelFixupValue(24);

65 return handlePCRelFixupValue(32);

68 return 0;

71 return handleImmValue(true, 8);

73 return handleImmValue(true, 16);

75 Value = handleImmValue(true, 20);

80 return (DLo << 8) | DHi;

81 }

83 return handleImmValue(true, 32);

85 return handleImmValue(false, 1);

87 return handleImmValue(false, 2);

89 return handleImmValue(false, 3);

91 return handleImmValue(false, 4);

93 return handleImmValue(false, 8);

95 return handleImmValue(false, 12);

97 return handleImmValue(false, 16);

99 return handleImmValue(false, 32);

101 return handleImmValue(false, 48);

102 }

103

105}

106

107namespace {

108class SystemZMCAsmBackend : public MCAsmBackend {

109public:

111

112

115 }

127};

128}

129

130std::optional

131SystemZMCAsmBackend::getFixupKind(StringRef Name) const {

133#define ELF_RELOC(X, Y) .Case(#X, Y)

134#include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"

135#undef ELF_RELOC

136 .Case("BFD_RELOC_NONE", ELF::R_390_NONE)

137 .Case("BFD_RELOC_8", ELF::R_390_8)

138 .Case("BFD_RELOC_16", ELF::R_390_16)

139 .Case("BFD_RELOC_32", ELF::R_390_32)

140 .Case("BFD_RELOC_64", ELF::R_390_64)

142 if (Type != -1u)

144 return std::nullopt;

145}

146

148SystemZMCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {

149

150

153

156

158 "Invalid kind!");

160}

161

162bool SystemZMCAsmBackend::shouldForceRelocation(const MCAssembler &,

167}

168

169void SystemZMCAsmBackend::applyFixup(const MCAssembler &Asm,

173 bool IsResolved,

177 return;

179 unsigned BitSize = getFixupKindInfo(Kind).TargetSize;

180 unsigned Size = (BitSize + 7) / 8;

181

182 assert(Offset + Size <= Data.size() && "Invalid fixup offset!");

183

184

186 if (BitSize < 64)

188 unsigned ShiftValue = (Size * 8) - 8;

189 for (unsigned I = 0; I != Size; ++I) {

191 ShiftValue -= 8;

192 }

193}

194

198 OS << '\x7';

199 return true;

200}

201

202namespace {

203class ELFSystemZAsmBackend : public SystemZMCAsmBackend {

205

206public:

207 ELFSystemZAsmBackend(uint8_t OsABI) : SystemZMCAsmBackend(), OSABI(OsABI){};

208

209 std::unique_ptr

210 createObjectTargetWriter() const override {

212 }

213};

214

215class GOFFSystemZAsmBackend : public SystemZMCAsmBackend {

216public:

217 GOFFSystemZAsmBackend() : SystemZMCAsmBackend(){};

218

219 std::unique_ptr

220 createObjectTargetWriter() const override {

222 }

223};

224}

225

231 return new GOFFSystemZAsmBackend();

232 }

233

236 return new ELFSystemZAsmBackend(OSABI);

237}

unsigned const MachineRegisterInfo * MRI

PowerPC TLS Dynamic Call Fixup

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...

static uint64_t extractBitsForFixup(MCFixupKind Kind, uint64_t Value, const MCFixup &Fixup, MCContext &Ctx)

Generic interface to target specific assembler backends.

virtual bool writeNopData(raw_ostream &OS, uint64_t Count, const MCSubtargetInfo *STI) const =0

Write an (optimal) nop sequence of Count bytes to the given output.

virtual bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, const uint64_t Value, const MCSubtargetInfo *STI)

Hook to check if a relocation is needed for some target specific reason.

virtual unsigned getNumFixupKinds() const =0

Get the number of target specific fixup kinds.

virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const

Get information on a fixup kind.

virtual std::optional< MCFixupKind > getFixupKind(StringRef Name) const

Map a relocation name used in .reloc to a fixup kind.

virtual void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, MutableArrayRef< char > Data, uint64_t Value, bool IsResolved, const MCSubtargetInfo *STI) const =0

Apply the Value for given Fixup into the provided data fragment, at the offset specified by the fixup...

Context object for machine code objects.

void reportError(SMLoc L, const Twine &Msg)

Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...

MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...

Generic base class for all target subtargets.

const Triple & getTargetTriple() const

This represents an "assembler immediate".

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

StringRef - Represent a constant reference to a string, i.e.

A switch()-like statement whose cases are string literals.

StringSwitch & Case(StringLiteral S, T Value)

Target - Wrapper for Target specific information.

OSType getOS() const

Get the parsed operating system type of this triple.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

The instances of the Type class are immutable: once they are created, they are never changed.

LLVM Value Representation.

This class implements an extremely fast bulk output stream that can only output to a stream.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

static const MCFixupKindInfo MCFixupKindInfos[SystemZ::NumTargetFixupKinds]

This is an optimization pass for GlobalISel generic memory operations.

int64_t maxIntN(int64_t N)

Gets the maximum value for a N-bit signed integer.

std::unique_ptr< MCObjectTargetWriter > createSystemZGOFFObjectWriter()

MCAsmBackend * createSystemZMCAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)

MCFixupKind

Extensible enumeration to represent the type of a fixup.

@ FirstLiteralRelocationKind

The range [FirstLiteralRelocationKind, MaxTargetFixupKind) is used for relocations coming from ....

int64_t minIntN(int64_t N)

Gets the minimum value for a N-bit signed integer.

std::unique_ptr< MCObjectTargetWriter > createSystemZELFObjectWriter(uint8_t OSABI)

uint64_t maxUIntN(uint64_t N)

Gets the maximum value for a N-bit unsigned integer.

Target independent information on a fixup kind.