lib/Target/Lanai/MCTargetDesc/LanaiAsmBackend.cpp

   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 }