llvm/lib/Target/MSP430/MCTargetDesc/MSP430AsmBackend.cpp

   1 //===-- MSP430AsmBackend.cpp - MSP430 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 "MCTargetDesc/MSP430FixupKinds.h"
  10 #include "MCTargetDesc/MSP430MCTargetDesc.h"
  11 #include "llvm/ADT/APInt.h"
  12 #include "llvm/MC/MCAsmBackend.h"
  13 #include "llvm/MC/MCAssembler.h"
  14 #include "llvm/MC/MCContext.h"
  15 #include "llvm/MC/MCELFObjectWriter.h"
  16 #include "llvm/MC/MCExpr.h"
  17 #include "llvm/MC/MCFixupKindInfo.h"
  18 #include "llvm/MC/MCObjectWriter.h"
  19 #include "llvm/MC/MCSubtargetInfo.h"
  20 #include "llvm/MC/MCSymbol.h"
  21 #include "llvm/MC/MCTargetOptions.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/raw_ostream.h"
  24
  25 using namespace llvm;
  26
  27 namespace {
  28 class MSP430AsmBackend : public MCAsmBackend {
  29   uint8_t OSABI;
  30
  31   uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value,
  32                             MCContext &Ctx) const;
  33
  34 public:
  35   MSP430AsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI)
  36       : MCAsmBackend(llvm::endianness::little), OSABI(OSABI) {}
  37   ~MSP430AsmBackend() override = default;
  38
  39   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
  40                   const MCValue &Target, MutableArrayRef<char> Data,
  41                   uint64_t Value, bool IsResolved,
  42                   const MCSubtargetInfo *STI) const override;
  43
  44   std::unique_ptr<MCObjectTargetWriter>
  45   createObjectTargetWriter() const override {
  46     return createMSP430ELFObjectWriter(OSABI);
  47   }
  48
  49   bool fixupNeedsRelaxationAdvanced(const MCAssembler &Asm,
  50                                     const MCFixup &Fixup, bool Resolved,
  51                                     uint64_t Value,
  52                                     const MCRelaxableFragment *DF,
  53                                     const bool WasForced) const override {
  54     return false;
  55   }
  56
  57   unsigned getNumFixupKinds() const override {
  58     return MSP430::NumTargetFixupKinds;
  59   }
  60
  61   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override {
  62     const static MCFixupKindInfo Infos[MSP430::NumTargetFixupKinds] = {
  63       // This table must be in the same order of enum in MSP430FixupKinds.h.
  64       //
  65       // name            offset bits flags
  66       {"fixup_32",            0, 32, 0},
  67       {"fixup_10_pcrel",      0, 10, MCFixupKindInfo::FKF_IsPCRel},
  68       {"fixup_16",            0, 16, 0},
  69       {"fixup_16_pcrel",      0, 16, MCFixupKindInfo::FKF_IsPCRel},
  70       {"fixup_16_byte",       0, 16, 0},
  71       {"fixup_16_pcrel_byte", 0, 16, MCFixupKindInfo::FKF_IsPCRel},
  72       {"fixup_2x_pcrel",      0, 10, MCFixupKindInfo::FKF_IsPCRel},
  73       {"fixup_rl_pcrel",      0, 16, MCFixupKindInfo::FKF_IsPCRel},
  74       {"fixup_8",             0,  8, 0},
  75       {"fixup_sym_diff",      0, 32, 0},
  76     };
  77     static_assert((std::size(Infos)) == MSP430::NumTargetFixupKinds,
  78                   "Not all fixup kinds added to Infos array");
  79
  80     if (Kind < FirstTargetFixupKind)
  81       return MCAsmBackend::getFixupKindInfo(Kind);
  82
  83     return Infos[Kind - FirstTargetFixupKind];
  84   }
  85
  86   bool writeNopData(raw_ostream &OS, uint64_t Count,
  87                     const MCSubtargetInfo *STI) const override;
  88 };
  89
  90 uint64_t MSP430AsmBackend::adjustFixupValue(const MCFixup &Fixup,
  91                                             uint64_t Value,
  92                                             MCContext &Ctx) const {
  93   unsigned Kind = Fixup.getKind();
  94   switch (Kind) {
  95   case MSP430::fixup_10_pcrel: {
  96     if (Value & 0x1)
  97       Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned");
  98
  99     // Offset is signed
 100     int16_t Offset = Value;
 101     // Jumps are in words
 102     Offset >>= 1;
 103     // PC points to the next instruction so decrement by one
 104     --Offset;
 105
 106     if (Offset < -512 || Offset > 511)
 107       Ctx.reportError(Fixup.getLoc(), "fixup value out of range");
 108
 109     // Mask 10 bits
 110     Offset &= 0x3ff;
 111
 112     return Offset;
 113   }
 114   default:
 115     return Value;
 116   }
 117 }
 118
 119 void MSP430AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
 120                                   const MCValue &Target,
 121                                   MutableArrayRef<char> Data,
 122                                   uint64_t Value, bool IsResolved,
 123                                   const MCSubtargetInfo *STI) const {
 124   Value = adjustFixupValue(Fixup, Value, Asm.getContext());
 125   MCFixupKindInfo Info = getFixupKindInfo(Fixup.getKind());
 126   if (!Value)
 127     return; // Doesn't change encoding.
 128
 129   // Shift the value into position.
 130   Value <<= Info.TargetOffset;
 131
 132   unsigned Offset = Fixup.getOffset();
 133   unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
 134
 135   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
 136
 137   // For each byte of the fragment that the fixup touches, mask in the
 138   // bits from the fixup value.
 139   for (unsigned i = 0; i != NumBytes; ++i) {
 140     Data[Offset + i] |= uint8_t((Value >> (i * 8)) & 0xff);
 141   }
 142 }
 143
 144 bool MSP430AsmBackend::writeNopData(raw_ostream &OS, uint64_t Count,
 145                                     const MCSubtargetInfo *STI) const {
 146   if ((Count % 2) != 0)
 147     return false;
 148
 149   // The canonical nop on MSP430 is mov #0, r3
 150   uint64_t NopCount = Count / 2;
 151   while (NopCount--)
 152     OS.write("\x03\x43", 2);
 153
 154   return true;
 155 }
 156
 157 } // end anonymous namespace
 158
 159 MCAsmBackend *llvm::createMSP430MCAsmBackend(const Target &T,
 160                                              const MCSubtargetInfo &STI,
 161                                              const MCRegisterInfo &MRI,
 162                                              const MCTargetOptions &Options) {
 163   return new MSP430AsmBackend(STI, ELF::ELFOSABI_STANDALONE);
 164 }