xref: /freebsd/contrib/llvm-project/llvm/lib/Target/Lanai/MCTargetDesc/LanaiAsmBackend.cpp (revision 86dc8398c9ca2283c5d6984992b7a585257b5adb)
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
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:
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
60   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 
68   unsigned getNumFixupKinds() const override {
69     return Lanai::NumTargetFixupKinds;
70   }
71 
72   bool writeNopData(raw_ostream &OS, uint64_t Count) const override;
73 };
74 
75 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 
85 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>
124 LanaiAsmBackend::createObjectTargetWriter() const {
125   return createLanaiELFObjectWriter(MCELFObjectTargetWriter::getOSABI(OSType));
126 }
127 
128 const MCFixupKindInfo &
129 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 
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