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