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 mayNeedRelaxation(const MCInst & /*Inst*/, 73 const MCSubtargetInfo &STI) const override { 74 return false; 75 } 76 77 void relaxInstruction(const MCInst & /*Inst*/, 78 const MCSubtargetInfo & /*STI*/, 79 MCInst & /*Res*/) const override {} 80 81 bool writeNopData(raw_ostream &OS, uint64_t Count) const override; 82 }; 83 84 bool LanaiAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count) const { 85 if ((Count % 4) != 0) 86 return false; 87 88 for (uint64_t i = 0; i < Count; i += 4) 89 OS.write("\x15\0\0\0", 4); 90 91 return true; 92 } 93 94 void LanaiAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup, 95 const MCValue &Target, 96 MutableArrayRef<char> Data, uint64_t Value, 97 bool /*IsResolved*/, 98 const MCSubtargetInfo * /*STI*/) const { 99 MCFixupKind Kind = Fixup.getKind(); 100 Value = adjustFixupValue(static_cast<unsigned>(Kind), Value); 101 102 if (!Value) 103 return; // This value doesn't change the encoding 104 105 // Where in the object and where the number of bytes that need 106 // fixing up 107 unsigned Offset = Fixup.getOffset(); 108 unsigned NumBytes = (getFixupKindInfo(Kind).TargetSize + 7) / 8; 109 unsigned FullSize = 4; 110 111 // Grab current value, if any, from bits. 112 uint64_t CurVal = 0; 113 114 // Load instruction and apply value 115 for (unsigned i = 0; i != NumBytes; ++i) { 116 unsigned Idx = (FullSize - 1 - i); 117 CurVal |= static_cast<uint64_t>(static_cast<uint8_t>(Data[Offset + Idx])) 118 << (i * 8); 119 } 120 121 uint64_t Mask = 122 (static_cast<uint64_t>(-1) >> (64 - getFixupKindInfo(Kind).TargetSize)); 123 CurVal |= Value & Mask; 124 125 // Write out the fixed up bytes back to the code/data bits. 126 for (unsigned i = 0; i != NumBytes; ++i) { 127 unsigned Idx = (FullSize - 1 - i); 128 Data[Offset + Idx] = static_cast<uint8_t>((CurVal >> (i * 8)) & 0xff); 129 } 130 } 131 132 std::unique_ptr<MCObjectTargetWriter> 133 LanaiAsmBackend::createObjectTargetWriter() const { 134 return createLanaiELFObjectWriter(MCELFObjectTargetWriter::getOSABI(OSType)); 135 } 136 137 const MCFixupKindInfo & 138 LanaiAsmBackend::getFixupKindInfo(MCFixupKind Kind) const { 139 static const MCFixupKindInfo Infos[Lanai::NumTargetFixupKinds] = { 140 // This table *must* be in same the order of fixup_* kinds in 141 // LanaiFixupKinds.h. 142 // Note: The number of bits indicated here are assumed to be contiguous. 143 // This does not hold true for LANAI_21 and LANAI_21_F which are applied 144 // to bits 0x7cffff and 0x7cfffc, respectively. Since the 'bits' counts 145 // here are used only for cosmetic purposes, we set the size to 16 bits 146 // for these 21-bit relocation as llvm/lib/MC/MCAsmStreamer.cpp checks 147 // no bits are set in the fixup range. 148 // 149 // name offset bits flags 150 {"FIXUP_LANAI_NONE", 0, 32, 0}, 151 {"FIXUP_LANAI_21", 16, 16 /*21*/, 0}, 152 {"FIXUP_LANAI_21_F", 16, 16 /*21*/, 0}, 153 {"FIXUP_LANAI_25", 7, 25, 0}, 154 {"FIXUP_LANAI_32", 0, 32, 0}, 155 {"FIXUP_LANAI_HI16", 16, 16, 0}, 156 {"FIXUP_LANAI_LO16", 16, 16, 0}}; 157 158 if (Kind < FirstTargetFixupKind) 159 return MCAsmBackend::getFixupKindInfo(Kind); 160 161 assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() && 162 "Invalid kind!"); 163 return Infos[Kind - FirstTargetFixupKind]; 164 } 165 166 } // namespace 167 168 MCAsmBackend *llvm::createLanaiAsmBackend(const Target &T, 169 const MCSubtargetInfo &STI, 170 const MCRegisterInfo & /*MRI*/, 171 const MCTargetOptions & /*Options*/) { 172 const Triple &TT = STI.getTargetTriple(); 173 if (!TT.isOSBinFormatELF()) 174 llvm_unreachable("OS not supported"); 175 176 return new LanaiAsmBackend(T, TT.getOS()); 177 } 178