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