1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
|
//===-- LanaiAsmBackend.cpp - Lanai Assembler Backend ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "LanaiFixupKinds.h"
#include "MCTargetDesc/LanaiMCTargetDesc.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCELFObjectWriter.h"
#include "llvm/MC/MCFixupKindInfo.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
// Prepare value for the target space
static unsigned adjustFixupValue(unsigned Kind, uint64_t Value) {
switch (Kind) {
case FK_Data_1:
case FK_Data_2:
case FK_Data_4:
case FK_Data_8:
return Value;
case Lanai::FIXUP_LANAI_21:
case Lanai::FIXUP_LANAI_21_F:
case Lanai::FIXUP_LANAI_25:
case Lanai::FIXUP_LANAI_32:
case Lanai::FIXUP_LANAI_HI16:
case Lanai::FIXUP_LANAI_LO16:
return Value;
default:
llvm_unreachable("Unknown fixup kind!");
}
}
namespace {
class LanaiAsmBackend : public MCAsmBackend {
Triple::OSType OSType;
public:
LanaiAsmBackend(const Target &T, Triple::OSType OST)
: MCAsmBackend(support::big), OSType(OST) {}
void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
const MCValue &Target, MutableArrayRef<char> Data,
uint64_t Value, bool IsResolved,
const MCSubtargetInfo *STI) const override;
std::unique_ptr<MCObjectTargetWriter>
createObjectTargetWriter() const override;
// No instruction requires relaxation
bool fixupNeedsRelaxation(const MCFixup & /*Fixup*/, uint64_t /*Value*/,
const MCRelaxableFragment * /*DF*/,
const MCAsmLayout & /*Layout*/) const override {
return false;
}
const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
unsigned getNumFixupKinds() const override {
return Lanai::NumTargetFixupKinds;
}
bool writeNopData(raw_ostream &OS, uint64_t Count,
const MCSubtargetInfo *STI) const override;
};
bool LanaiAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count,
const MCSubtargetInfo *STI) const {
if ((Count % 4) != 0)
return false;
for (uint64_t i = 0; i < Count; i += 4)
OS.write("\x15\0\0\0", 4);
return true;
}
void LanaiAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
const MCValue &Target,
MutableArrayRef<char> Data, uint64_t Value,
bool /*IsResolved*/,
const MCSubtargetInfo * /*STI*/) const {
MCFixupKind Kind = Fixup.getKind();
Value = adjustFixupValue(static_cast<unsigned>(Kind), Value);
if (!Value)
return; // This value doesn't change the encoding
// Where in the object and where the number of bytes that need
// fixing up
unsigned Offset = Fixup.getOffset();
unsigned NumBytes = (getFixupKindInfo(Kind).TargetSize + 7) / 8;
unsigned FullSize = 4;
// Grab current value, if any, from bits.
uint64_t CurVal = 0;
// Load instruction and apply value
for (unsigned i = 0; i != NumBytes; ++i) {
unsigned Idx = (FullSize - 1 - i);
CurVal |= static_cast<uint64_t>(static_cast<uint8_t>(Data[Offset + Idx]))
<< (i * 8);
}
uint64_t Mask =
(static_cast<uint64_t>(-1) >> (64 - getFixupKindInfo(Kind).TargetSize));
CurVal |= Value & Mask;
// Write out the fixed up bytes back to the code/data bits.
for (unsigned i = 0; i != NumBytes; ++i) {
unsigned Idx = (FullSize - 1 - i);
Data[Offset + Idx] = static_cast<uint8_t>((CurVal >> (i * 8)) & 0xff);
}
}
std::unique_ptr<MCObjectTargetWriter>
LanaiAsmBackend::createObjectTargetWriter() const {
return createLanaiELFObjectWriter(MCELFObjectTargetWriter::getOSABI(OSType));
}
const MCFixupKindInfo &
LanaiAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
static const MCFixupKindInfo Infos[Lanai::NumTargetFixupKinds] = {
// This table *must* be in same the order of fixup_* kinds in
// LanaiFixupKinds.h.
// Note: The number of bits indicated here are assumed to be contiguous.
// This does not hold true for LANAI_21 and LANAI_21_F which are applied
// to bits 0x7cffff and 0x7cfffc, respectively. Since the 'bits' counts
// here are used only for cosmetic purposes, we set the size to 16 bits
// for these 21-bit relocation as llvm/lib/MC/MCAsmStreamer.cpp checks
// no bits are set in the fixup range.
//
// name offset bits flags
{"FIXUP_LANAI_NONE", 0, 32, 0},
{"FIXUP_LANAI_21", 16, 16 /*21*/, 0},
{"FIXUP_LANAI_21_F", 16, 16 /*21*/, 0},
{"FIXUP_LANAI_25", 7, 25, 0},
{"FIXUP_LANAI_32", 0, 32, 0},
{"FIXUP_LANAI_HI16", 16, 16, 0},
{"FIXUP_LANAI_LO16", 16, 16, 0}};
if (Kind < FirstTargetFixupKind)
return MCAsmBackend::getFixupKindInfo(Kind);
assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
"Invalid kind!");
return Infos[Kind - FirstTargetFixupKind];
}
} // namespace
MCAsmBackend *llvm::createLanaiAsmBackend(const Target &T,
const MCSubtargetInfo &STI,
const MCRegisterInfo & /*MRI*/,
const MCTargetOptions & /*Options*/) {
const Triple &TT = STI.getTargetTriple();
if (!TT.isOSBinFormatELF())
llvm_unreachable("OS not supported");
return new LanaiAsmBackend(T, TT.getOS());
}
|