contrib/llvm/lib/Target/AVR/MCTargetDesc/AVRAsmBackend.cpp

   1 //===-- AVRAsmBackend.cpp - AVR Asm Backend  ------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the AVRAsmBackend class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MCTargetDesc/AVRAsmBackend.h"
  15 #include "MCTargetDesc/AVRFixupKinds.h"
  16 #include "MCTargetDesc/AVRMCTargetDesc.h"
  17
  18 #include "llvm/MC/MCAsmBackend.h"
  19 #include "llvm/MC/MCAssembler.h"
  20 #include "llvm/MC/MCContext.h"
  21 #include "llvm/MC/MCDirectives.h"
  22 #include "llvm/MC/MCELFObjectWriter.h"
  23 #include "llvm/MC/MCFixupKindInfo.h"
  24 #include "llvm/MC/MCObjectWriter.h"
  25 #include "llvm/MC/MCSubtargetInfo.h"
  26 #include "llvm/MC/MCValue.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/MathExtras.h"
  29 #include "llvm/Support/raw_ostream.h"
  30
  31 // FIXME: we should be doing checks to make sure asm operands
  32 // are not out of bounds.
  33
  34 namespace adjust {
  35
  36 using namespace llvm;
  37
  38 void signed_width(unsigned Width, uint64_t Value, std::string Description,
  39                   const MCFixup &Fixup, MCContext *Ctx = nullptr) {
  40   if (!isIntN(Width, Value)) {
  41     std::string Diagnostic = "out of range " + Description;
  42
  43     int64_t Min = minIntN(Width);
  44     int64_t Max = maxIntN(Width);
  45
  46     Diagnostic += " (expected an integer in the range " + std::to_string(Min) +
  47       " to " + std::to_string(Max) + ")";
  48
  49     if (Ctx) {
  50       Ctx->reportFatalError(Fixup.getLoc(), Diagnostic);
  51     } else {
  52       llvm_unreachable(Diagnostic.c_str());
  53     }
  54   }
  55 }
  56
  57 void unsigned_width(unsigned Width, uint64_t Value, std::string Description,
  58                     const MCFixup &Fixup, MCContext *Ctx = nullptr) {
  59   if (!isUIntN(Width, Value)) {
  60     std::string Diagnostic = "out of range " + Description;
  61
  62     int64_t Max = maxUIntN(Width);
  63
  64     Diagnostic += " (expected an integer in the range 0 to " +
  65       std::to_string(Max) + ")";
  66
  67     if (Ctx) {
  68       Ctx->reportFatalError(Fixup.getLoc(), Diagnostic);
  69     } else {
  70       llvm_unreachable(Diagnostic.c_str());
  71     }
  72   }
  73 }
  74
  75 /// Adjusts the value of a branch target before fixup application.
  76 void adjustBranch(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
  77                   MCContext *Ctx = nullptr) {
  78   // We have one extra bit of precision because the value is rightshifted by
  79   // one.
  80   unsigned_width(Size + 1, Value, std::string("branch target"), Fixup, Ctx);
  81
  82   // Rightshifts the value by one.
  83   AVR::fixups::adjustBranchTarget(Value);
  84 }
  85
  86 /// Adjusts the value of a relative branch target before fixup application.
  87 void adjustRelativeBranch(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
  88                           MCContext *Ctx = nullptr) {
  89   // We have one extra bit of precision because the value is rightshifted by
  90   // one.
  91   signed_width(Size + 1, Value, std::string("branch target"), Fixup, Ctx);
  92
  93   Value -= 2;
  94
  95   // Rightshifts the value by one.
  96   AVR::fixups::adjustBranchTarget(Value);
  97 }
  98
  99 /// 22-bit absolute fixup.
 100 ///
 101 /// Resolves to:
 102 /// 1001 kkkk 010k kkkk kkkk kkkk 111k kkkk
 103 ///
 104 /// Offset of 0 (so the result is left shifted by 3 bits before application).
 105 void fixup_call(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 106                 MCContext *Ctx = nullptr) {
 107   adjustBranch(Size, Fixup, Value, Ctx);
 108
 109   auto top = Value & (0xf00000 << 6);   // the top four bits
 110   auto middle = Value & (0x1ffff << 5); // the middle 13 bits
 111   auto bottom = Value & 0x1f;           // end bottom 5 bits
 112
 113   Value = (top << 6) | (middle << 3) | (bottom << 0);
 114 }
 115
 116 /// 7-bit PC-relative fixup.
 117 ///
 118 /// Resolves to:
 119 /// 0000 00kk kkkk k000
 120 /// Offset of 0 (so the result is left shifted by 3 bits before application).
 121 void fixup_7_pcrel(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 122                    MCContext *Ctx = nullptr) {
 123   adjustRelativeBranch(Size, Fixup, Value, Ctx);
 124
 125   // Because the value may be negative, we must mask out the sign bits
 126   Value &= 0x7f;
 127 }
 128
 129 /// 12-bit PC-relative fixup.
 130 /// Yes, the fixup is 12 bits even though the name says otherwise.
 131 ///
 132 /// Resolves to:
 133 /// 0000 kkkk kkkk kkkk
 134 /// Offset of 0 (so the result isn't left-shifted before application).
 135 void fixup_13_pcrel(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 136                     MCContext *Ctx = nullptr) {
 137   adjustRelativeBranch(Size, Fixup, Value, Ctx);
 138
 139   // Because the value may be negative, we must mask out the sign bits
 140   Value &= 0xfff;
 141 }
 142
 143 /// 6-bit fixup for the immediate operand of the ADIW family of
 144 /// instructions.
 145 ///
 146 /// Resolves to:
 147 /// 0000 0000 kk00 kkkk
 148 void fixup_6_adiw(const MCFixup &Fixup, uint64_t &Value,
 149                   MCContext *Ctx = nullptr) {
 150   unsigned_width(6, Value, std::string("immediate"), Fixup, Ctx);
 151
 152   Value = ((Value & 0x30) << 2) | (Value & 0x0f);
 153 }
 154
 155 /// 5-bit port number fixup on the SBIC family of instructions.
 156 ///
 157 /// Resolves to:
 158 /// 0000 0000 AAAA A000
 159 void fixup_port5(const MCFixup &Fixup, uint64_t &Value,
 160                  MCContext *Ctx = nullptr) {
 161   unsigned_width(5, Value, std::string("port number"), Fixup, Ctx);
 162
 163   Value &= 0x1f;
 164
 165   Value <<= 3;
 166 }
 167
 168 /// 6-bit port number fixup on the `IN` family of instructions.
 169 ///
 170 /// Resolves to:
 171 /// 1011 0AAd dddd AAAA
 172 void fixup_port6(const MCFixup &Fixup, uint64_t &Value,
 173                  MCContext *Ctx = nullptr) {
 174   unsigned_width(6, Value, std::string("port number"), Fixup, Ctx);
 175
 176   Value = ((Value & 0x30) << 5) | (Value & 0x0f);
 177 }
 178
 179 /// Adjusts a program memory address.
 180 /// This is a simple right-shift.
 181 void pm(uint64_t &Value) {
 182   Value >>= 1;
 183 }
 184
 185 /// Fixups relating to the LDI instruction.
 186 namespace ldi {
 187
 188 /// Adjusts a value to fix up the immediate of an `LDI Rd, K` instruction.
 189 ///
 190 /// Resolves to:
 191 /// 0000 KKKK 0000 KKKK
 192 /// Offset of 0 (so the result isn't left-shifted before application).
 193 void fixup(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 194            MCContext *Ctx = nullptr) {
 195   uint64_t upper = Value & 0xf0;
 196   uint64_t lower = Value & 0x0f;
 197
 198   Value = (upper << 4) | lower;
 199 }
 200
 201 void neg(uint64_t &Value) { Value *= -1; }
 202
 203 void lo8(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 204          MCContext *Ctx = nullptr) {
 205   Value &= 0xff;
 206   ldi::fixup(Size, Fixup, Value, Ctx);
 207 }
 208
 209 void hi8(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 210          MCContext *Ctx = nullptr) {
 211   Value = (Value & 0xff00) >> 8;
 212   ldi::fixup(Size, Fixup, Value, Ctx);
 213 }
 214
 215 void hh8(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 216          MCContext *Ctx = nullptr) {
 217   Value = (Value & 0xff0000) >> 16;
 218   ldi::fixup(Size, Fixup, Value, Ctx);
 219 }
 220
 221 void ms8(unsigned Size, const MCFixup &Fixup, uint64_t &Value,
 222          MCContext *Ctx = nullptr) {
 223   Value = (Value & 0xff000000) >> 24;
 224   ldi::fixup(Size, Fixup, Value, Ctx);
 225 }
 226
 227 } // end of ldi namespace
 228 } // end of adjust namespace
 229
 230 namespace llvm {
 231
 232 // Prepare value for the target space for it
 233 void AVRAsmBackend::adjustFixupValue(const MCFixup &Fixup,
 234                                      const MCValue &Target,
 235                                      uint64_t &Value,
 236                                      MCContext *Ctx) const {
 237   // The size of the fixup in bits.
 238   uint64_t Size = AVRAsmBackend::getFixupKindInfo(Fixup.getKind()).TargetSize;
 239
 240   unsigned Kind = Fixup.getKind();
 241
 242   // Parsed LLVM-generated temporary labels are already
 243   // adjusted for instruction size, but normal labels aren't.
 244   //
 245   // To handle both cases, we simply un-adjust the temporary label
 246   // case so it acts like all other labels.
 247   if (const MCSymbolRefExpr *A = Target.getSymA()) {
 248     if (A->getSymbol().isTemporary())
 249       Value += 2;
 250   }
 251
 252   switch (Kind) {
 253   default:
 254     llvm_unreachable("unhandled fixup");
 255   case AVR::fixup_7_pcrel:
 256     adjust::fixup_7_pcrel(Size, Fixup, Value, Ctx);
 257     break;
 258   case AVR::fixup_13_pcrel:
 259     adjust::fixup_13_pcrel(Size, Fixup, Value, Ctx);
 260     break;
 261   case AVR::fixup_call:
 262     adjust::fixup_call(Size, Fixup, Value, Ctx);
 263     break;
 264   case AVR::fixup_ldi:
 265     adjust::ldi::fixup(Size, Fixup, Value, Ctx);
 266     break;
 267   case AVR::fixup_lo8_ldi:
 268   case AVR::fixup_lo8_ldi_pm:
 269     if (Kind == AVR::fixup_lo8_ldi_pm) adjust::pm(Value);
 270
 271     adjust::ldi::lo8(Size, Fixup, Value, Ctx);
 272     break;
 273   case AVR::fixup_hi8_ldi:
 274   case AVR::fixup_hi8_ldi_pm:
 275     if (Kind == AVR::fixup_hi8_ldi_pm) adjust::pm(Value);
 276
 277     adjust::ldi::hi8(Size, Fixup, Value, Ctx);
 278     break;
 279   case AVR::fixup_hh8_ldi:
 280   case AVR::fixup_hh8_ldi_pm:
 281     if (Kind == AVR::fixup_hh8_ldi_pm) adjust::pm(Value);
 282
 283     adjust::ldi::hh8(Size, Fixup, Value, Ctx);
 284     break;
 285   case AVR::fixup_ms8_ldi:
 286     adjust::ldi::ms8(Size, Fixup, Value, Ctx);
 287     break;
 288
 289   case AVR::fixup_lo8_ldi_neg:
 290   case AVR::fixup_lo8_ldi_pm_neg:
 291     if (Kind == AVR::fixup_lo8_ldi_pm_neg) adjust::pm(Value);
 292
 293     adjust::ldi::neg(Value);
 294     adjust::ldi::lo8(Size, Fixup, Value, Ctx);
 295     break;
 296   case AVR::fixup_hi8_ldi_neg:
 297   case AVR::fixup_hi8_ldi_pm_neg:
 298     if (Kind == AVR::fixup_hi8_ldi_pm_neg) adjust::pm(Value);
 299
 300     adjust::ldi::neg(Value);
 301     adjust::ldi::hi8(Size, Fixup, Value, Ctx);
 302     break;
 303   case AVR::fixup_hh8_ldi_neg:
 304   case AVR::fixup_hh8_ldi_pm_neg:
 305     if (Kind == AVR::fixup_hh8_ldi_pm_neg) adjust::pm(Value);
 306
 307     adjust::ldi::neg(Value);
 308     adjust::ldi::hh8(Size, Fixup, Value, Ctx);
 309     break;
 310   case AVR::fixup_ms8_ldi_neg:
 311     adjust::ldi::neg(Value);
 312     adjust::ldi::ms8(Size, Fixup, Value, Ctx);
 313     break;
 314   case AVR::fixup_16:
 315     adjust::unsigned_width(16, Value, std::string("port number"), Fixup, Ctx);
 316
 317     Value &= 0xffff;
 318     break;
 319   case AVR::fixup_6_adiw:
 320     adjust::fixup_6_adiw(Fixup, Value, Ctx);
 321     break;
 322
 323   case AVR::fixup_port5:
 324     adjust::fixup_port5(Fixup, Value, Ctx);
 325     break;
 326
 327   case AVR::fixup_port6:
 328     adjust::fixup_port6(Fixup, Value, Ctx);
 329     break;
 330
 331   // Fixups which do not require adjustments.
 332   case FK_Data_2:
 333   case FK_Data_4:
 334   case FK_Data_8:
 335     break;
 336
 337   case FK_GPRel_4:
 338     llvm_unreachable("don't know how to adjust this fixup");
 339     break;
 340   }
 341 }
 342
 343 MCObjectWriter *AVRAsmBackend::createObjectWriter(raw_pwrite_stream &OS) const {
 344   return createAVRELFObjectWriter(OS,
 345                                   MCELFObjectTargetWriter::getOSABI(OSType));
 346 }
 347
 348 void AVRAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
 349                                const MCValue &Target, MutableArrayRef<char> Data,
 350                                uint64_t Value, bool IsPCRel) const {
 351   adjustFixupValue(Fixup, Target, Value, &Asm.getContext());
 352   if (Value == 0)
 353     return; // Doesn't change encoding.
 354
 355   MCFixupKindInfo Info = getFixupKindInfo(Fixup.getKind());
 356
 357   // The number of bits in the fixup mask
 358   auto NumBits = Info.TargetSize + Info.TargetOffset;
 359   auto NumBytes = (NumBits / 8) + ((NumBits % 8) == 0 ? 0 : 1);
 360
 361   // Shift the value into position.
 362   Value <<= Info.TargetOffset;
 363
 364   unsigned Offset = Fixup.getOffset();
 365   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
 366
 367   // For each byte of the fragment that the fixup touches, mask in the
 368   // bits from the fixup value.
 369   for (unsigned i = 0; i < NumBytes; ++i) {
 370     uint8_t mask = (((Value >> (i * 8)) & 0xff));
 371     Data[Offset + i] |= mask;
 372   }
 373 }
 374
 375 MCFixupKindInfo const &AVRAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
 376   // NOTE: Many AVR fixups work on sets of non-contignous bits. We work around
 377   // this by saying that the fixup is the size of the entire instruction.
 378   const static MCFixupKindInfo Infos[AVR::NumTargetFixupKinds] = {
 379       // This table *must* be in same the order of fixup_* kinds in
 380       // AVRFixupKinds.h.
 381       //
 382       // name                    offset  bits  flags
 383       {"fixup_32", 0, 32, 0},
 384
 385       {"fixup_7_pcrel", 3, 7, MCFixupKindInfo::FKF_IsPCRel},
 386       {"fixup_13_pcrel", 0, 12, MCFixupKindInfo::FKF_IsPCRel},
 387
 388       {"fixup_16", 0, 16, 0},
 389       {"fixup_16_pm", 0, 16, 0},
 390
 391       {"fixup_ldi", 0, 8, 0},
 392
 393       {"fixup_lo8_ldi", 0, 8, 0},
 394       {"fixup_hi8_ldi", 0, 8, 0},
 395       {"fixup_hh8_ldi", 0, 8, 0},
 396       {"fixup_ms8_ldi", 0, 8, 0},
 397
 398       {"fixup_lo8_ldi_neg", 0, 8, 0},
 399       {"fixup_hi8_ldi_neg", 0, 8, 0},
 400       {"fixup_hh8_ldi_neg", 0, 8, 0},
 401       {"fixup_ms8_ldi_neg", 0, 8, 0},
 402
 403       {"fixup_lo8_ldi_pm", 0, 8, 0},
 404       {"fixup_hi8_ldi_pm", 0, 8, 0},
 405       {"fixup_hh8_ldi_pm", 0, 8, 0},
 406
 407       {"fixup_lo8_ldi_pm_neg", 0, 8, 0},
 408       {"fixup_hi8_ldi_pm_neg", 0, 8, 0},
 409       {"fixup_hh8_ldi_pm_neg", 0, 8, 0},
 410
 411       {"fixup_call", 0, 22, 0},
 412
 413       {"fixup_6", 0, 16, 0}, // non-contiguous
 414       {"fixup_6_adiw", 0, 6, 0},
 415
 416       {"fixup_lo8_ldi_gs", 0, 8, 0},
 417       {"fixup_hi8_ldi_gs", 0, 8, 0},
 418
 419       {"fixup_8", 0, 8, 0},
 420       {"fixup_8_lo8", 0, 8, 0},
 421       {"fixup_8_hi8", 0, 8, 0},
 422       {"fixup_8_hlo8", 0, 8, 0},
 423
 424       {"fixup_sym_diff", 0, 32, 0},
 425       {"fixup_16_ldst", 0, 16, 0},
 426
 427       {"fixup_lds_sts_16", 0, 16, 0},
 428
 429       {"fixup_port6", 0, 16, 0}, // non-contiguous
 430       {"fixup_port5", 3, 5, 0},
 431   };
 432
 433   if (Kind < FirstTargetFixupKind)
 434     return MCAsmBackend::getFixupKindInfo(Kind);
 435
 436   assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
 437          "Invalid kind!");
 438
 439   return Infos[Kind - FirstTargetFixupKind];
 440 }
 441
 442 bool AVRAsmBackend::writeNopData(uint64_t Count, MCObjectWriter *OW) const {
 443   // If the count is not 2-byte aligned, we must be writing data into the text
 444   // section (otherwise we have unaligned instructions, and thus have far
 445   // bigger problems), so just write zeros instead.
 446   assert((Count % 2) == 0 && "NOP instructions must be 2 bytes");
 447
 448   OW->WriteZeros(Count);
 449   return true;
 450 }
 451
 452 bool AVRAsmBackend::shouldForceRelocation(const MCAssembler &Asm,
 453                                           const MCFixup &Fixup,
 454                                           const MCValue &Target) {
 455   switch ((unsigned) Fixup.getKind()) {
 456   default: return false;
 457   // Fixups which should always be recorded as relocations.
 458   case AVR::fixup_7_pcrel:
 459   case AVR::fixup_13_pcrel:
 460   case AVR::fixup_call:
 461     return true;
 462   }
 463 }
 464
 465 MCAsmBackend *createAVRAsmBackend(const Target &T, const MCRegisterInfo &MRI,
 466                                   const Triple &TT, StringRef CPU,
 467                                   const llvm::MCTargetOptions &TO) {
 468   return new AVRAsmBackend(TT.getOS());
 469 }
 470
 471 } // end of namespace llvm
 472