lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp

   1 //===-- HexagonMCCodeEmitter.cpp - Hexagon Target Descriptions ------------===//
   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 #include "Hexagon.h"
  11 #include "MCTargetDesc/HexagonBaseInfo.h"
  12 #include "MCTargetDesc/HexagonFixupKinds.h"
  13 #include "MCTargetDesc/HexagonMCCodeEmitter.h"
  14 #include "MCTargetDesc/HexagonMCInstrInfo.h"
  15 #include "MCTargetDesc/HexagonMCTargetDesc.h"
  16 #include "llvm/ADT/Statistic.h"
  17 #include "llvm/MC/MCCodeEmitter.h"
  18 #include "llvm/MC/MCContext.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCInstrInfo.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/raw_ostream.h"
  26
  27 #define DEBUG_TYPE "mccodeemitter"
  28
  29 using namespace llvm;
  30 using namespace Hexagon;
  31
  32 STATISTIC(MCNumEmitted, "Number of MC instructions emitted");
  33
  34 namespace {
  35 /// \brief 10.6 Instruction Packets
  36 /// Possible values for instruction packet parse field.
  37 enum class ParseField { duplex = 0x0, last0 = 0x1, last1 = 0x2, end = 0x3 };
  38 /// \brief Returns the packet bits based on instruction position.
  39 uint32_t getPacketBits(MCInst const &HMI) {
  40   unsigned const ParseFieldOffset = 14;
  41   ParseField Field = HexagonMCInstrInfo::isPacketEnd(HMI) ? ParseField::end
  42                                                           : ParseField::last0;
  43   return static_cast<uint32_t>(Field) << ParseFieldOffset;
  44 }
  45 void emitLittleEndian(uint64_t Binary, raw_ostream &OS) {
  46   OS << static_cast<uint8_t>((Binary >> 0x00) & 0xff);
  47   OS << static_cast<uint8_t>((Binary >> 0x08) & 0xff);
  48   OS << static_cast<uint8_t>((Binary >> 0x10) & 0xff);
  49   OS << static_cast<uint8_t>((Binary >> 0x18) & 0xff);
  50 }
  51 }
  52
  53 HexagonMCCodeEmitter::HexagonMCCodeEmitter(MCInstrInfo const &aMII,
  54                                            MCContext &aMCT)
  55     : MCT(aMCT), MCII(aMII), Addend(new unsigned(0)),
  56       Extended(new bool(false)) {}
  57
  58 void HexagonMCCodeEmitter::EncodeInstruction(MCInst const &MI, raw_ostream &OS,
  59                                              SmallVectorImpl<MCFixup> &Fixups,
  60                                              MCSubtargetInfo const &STI) const {
  61   uint64_t Binary = getBinaryCodeForInstr(MI, Fixups, STI) | getPacketBits(MI);
  62   assert(HexagonMCInstrInfo::getDesc(MCII, MI).getSize() == 4 &&
  63          "All instructions should be 32bit");
  64   (void)&MCII;
  65   emitLittleEndian(Binary, OS);
  66   ++MCNumEmitted;
  67 }
  68
  69 static Hexagon::Fixups getFixupNoBits(MCInstrInfo const &MCII, const MCInst &MI,
  70                                       const MCOperand &MO,
  71                                       const MCSymbolRefExpr::VariantKind kind) {
  72   const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI);
  73   unsigned insnType = llvm::HexagonMCInstrInfo::getType(MCII, MI);
  74
  75   if (insnType == HexagonII::TypePREFIX) {
  76     switch (kind) {
  77     case llvm::MCSymbolRefExpr::VK_GOTOFF:
  78       return Hexagon::fixup_Hexagon_GOTREL_32_6_X;
  79     case llvm::MCSymbolRefExpr::VK_GOT:
  80       return Hexagon::fixup_Hexagon_GOT_32_6_X;
  81     case llvm::MCSymbolRefExpr::VK_TPREL:
  82       return Hexagon::fixup_Hexagon_TPREL_32_6_X;
  83     case llvm::MCSymbolRefExpr::VK_DTPREL:
  84       return Hexagon::fixup_Hexagon_DTPREL_32_6_X;
  85     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
  86       return Hexagon::fixup_Hexagon_GD_GOT_32_6_X;
  87     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
  88       return Hexagon::fixup_Hexagon_LD_GOT_32_6_X;
  89     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
  90       return Hexagon::fixup_Hexagon_IE_32_6_X;
  91     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
  92       return Hexagon::fixup_Hexagon_IE_GOT_32_6_X;
  93     default:
  94       if (MCID.isBranch())
  95         return Hexagon::fixup_Hexagon_B32_PCREL_X;
  96       else
  97         return Hexagon::fixup_Hexagon_32_6_X;
  98     }
  99   } else if (MCID.isBranch())
 100     return (Hexagon::fixup_Hexagon_B13_PCREL);
 101
 102   switch (MCID.getOpcode()) {
 103   case Hexagon::HI:
 104   case Hexagon::A2_tfrih:
 105     switch (kind) {
 106     case llvm::MCSymbolRefExpr::VK_GOT:
 107       return Hexagon::fixup_Hexagon_GOT_HI16;
 108     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 109       return Hexagon::fixup_Hexagon_GOTREL_HI16;
 110     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 111       return Hexagon::fixup_Hexagon_GD_GOT_HI16;
 112     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 113       return Hexagon::fixup_Hexagon_LD_GOT_HI16;
 114     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 115       return Hexagon::fixup_Hexagon_IE_HI16;
 116     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 117       return Hexagon::fixup_Hexagon_IE_GOT_HI16;
 118     case llvm::MCSymbolRefExpr::VK_TPREL:
 119       return Hexagon::fixup_Hexagon_TPREL_HI16;
 120     case llvm::MCSymbolRefExpr::VK_DTPREL:
 121       return Hexagon::fixup_Hexagon_DTPREL_HI16;
 122     default:
 123       return Hexagon::fixup_Hexagon_HI16;
 124     }
 125
 126   case Hexagon::LO:
 127   case Hexagon::A2_tfril:
 128     switch (kind) {
 129     case llvm::MCSymbolRefExpr::VK_GOT:
 130       return Hexagon::fixup_Hexagon_GOT_LO16;
 131     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 132       return Hexagon::fixup_Hexagon_GOTREL_LO16;
 133     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 134       return Hexagon::fixup_Hexagon_GD_GOT_LO16;
 135     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 136       return Hexagon::fixup_Hexagon_LD_GOT_LO16;
 137     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 138       return Hexagon::fixup_Hexagon_IE_LO16;
 139     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 140       return Hexagon::fixup_Hexagon_IE_GOT_LO16;
 141     case llvm::MCSymbolRefExpr::VK_TPREL:
 142       return Hexagon::fixup_Hexagon_TPREL_LO16;
 143     case llvm::MCSymbolRefExpr::VK_DTPREL:
 144       return Hexagon::fixup_Hexagon_DTPREL_LO16;
 145     default:
 146       return Hexagon::fixup_Hexagon_LO16;
 147     }
 148
 149   // The only relocs left should be GP relative:
 150   default:
 151     if (MCID.mayStore() || MCID.mayLoad()) {
 152       for (const uint16_t *ImpUses = MCID.getImplicitUses(); *ImpUses;
 153            ++ImpUses) {
 154         if (*ImpUses == Hexagon::GP) {
 155           switch (HexagonMCInstrInfo::getAccessSize(MCII, MI)) {
 156           case HexagonII::MemAccessSize::ByteAccess:
 157             return fixup_Hexagon_GPREL16_0;
 158           case HexagonII::MemAccessSize::HalfWordAccess:
 159             return fixup_Hexagon_GPREL16_1;
 160           case HexagonII::MemAccessSize::WordAccess:
 161             return fixup_Hexagon_GPREL16_2;
 162           case HexagonII::MemAccessSize::DoubleWordAccess:
 163             return fixup_Hexagon_GPREL16_3;
 164           default:
 165             llvm_unreachable("unhandled fixup");
 166           }
 167         }
 168       }
 169     } else
 170       llvm_unreachable("unhandled fixup");
 171   }
 172
 173   return LastTargetFixupKind;
 174 }
 175
 176 unsigned HexagonMCCodeEmitter::getExprOpValue(const MCInst &MI,
 177                                               const MCOperand &MO,
 178                                               const MCExpr *ME,
 179                                               SmallVectorImpl<MCFixup> &Fixups,
 180                                               const MCSubtargetInfo &STI) const
 181
 182 {
 183   int64_t Res;
 184
 185   if (ME->EvaluateAsAbsolute(Res))
 186     return Res;
 187
 188   MCExpr::ExprKind MK = ME->getKind();
 189   if (MK == MCExpr::Constant) {
 190     return cast<MCConstantExpr>(ME)->getValue();
 191   }
 192   if (MK == MCExpr::Binary) {
 193     unsigned Res;
 194     Res = getExprOpValue(MI, MO, cast<MCBinaryExpr>(ME)->getLHS(), Fixups, STI);
 195     Res +=
 196         getExprOpValue(MI, MO, cast<MCBinaryExpr>(ME)->getRHS(), Fixups, STI);
 197     return Res;
 198   }
 199
 200   assert(MK == MCExpr::SymbolRef);
 201
 202   Hexagon::Fixups FixupKind =
 203       Hexagon::Fixups(Hexagon::fixup_Hexagon_TPREL_LO16);
 204   const MCSymbolRefExpr *MCSRE = static_cast<const MCSymbolRefExpr *>(ME);
 205   const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI);
 206   unsigned bits = HexagonMCInstrInfo::getExtentBits(MCII, MI) -
 207                   HexagonMCInstrInfo::getExtentAlignment(MCII, MI);
 208   const MCSymbolRefExpr::VariantKind kind = MCSRE->getKind();
 209
 210   DEBUG(dbgs() << "----------------------------------------\n");
 211   DEBUG(dbgs() << "Opcode Name: " << HexagonMCInstrInfo::getName(MCII, MI)
 212                << "\n");
 213   DEBUG(dbgs() << "Opcode: " << MCID.getOpcode() << "\n");
 214   DEBUG(dbgs() << "Relocation bits: " << bits << "\n");
 215   DEBUG(dbgs() << "Addend: " << *Addend << "\n");
 216   DEBUG(dbgs() << "----------------------------------------\n");
 217
 218   switch (bits) {
 219   default:
 220     DEBUG(dbgs() << "unrecognized bit count of " << bits << '\n');
 221     break;
 222
 223   case 32:
 224     switch (kind) {
 225     case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 226       FixupKind = Hexagon::fixup_Hexagon_32_PCREL;
 227       break;
 228     case llvm::MCSymbolRefExpr::VK_GOT:
 229       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOT_32_6_X
 230                             : Hexagon::fixup_Hexagon_GOT_32;
 231       break;
 232     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 233       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOTREL_32_6_X
 234                             : Hexagon::fixup_Hexagon_GOTREL_32;
 235       break;
 236     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 237       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GD_GOT_32_6_X
 238                             : Hexagon::fixup_Hexagon_GD_GOT_32;
 239       break;
 240     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 241       FixupKind = *Extended ? Hexagon::fixup_Hexagon_LD_GOT_32_6_X
 242                             : Hexagon::fixup_Hexagon_LD_GOT_32;
 243       break;
 244     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 245       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_32_6_X
 246                             : Hexagon::fixup_Hexagon_IE_32;
 247       break;
 248     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 249       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_GOT_32_6_X
 250                             : Hexagon::fixup_Hexagon_IE_GOT_32;
 251       break;
 252     case llvm::MCSymbolRefExpr::VK_TPREL:
 253       FixupKind = *Extended ? Hexagon::fixup_Hexagon_TPREL_32_6_X
 254                             : Hexagon::fixup_Hexagon_TPREL_32;
 255       break;
 256     case llvm::MCSymbolRefExpr::VK_DTPREL:
 257       FixupKind = *Extended ? Hexagon::fixup_Hexagon_DTPREL_32_6_X
 258                             : Hexagon::fixup_Hexagon_DTPREL_32;
 259       break;
 260     default:
 261       FixupKind =
 262           *Extended ? Hexagon::fixup_Hexagon_32_6_X : Hexagon::fixup_Hexagon_32;
 263       break;
 264     }
 265     break;
 266
 267   case 22:
 268     switch (kind) {
 269     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_PLT:
 270       FixupKind = Hexagon::fixup_Hexagon_GD_PLT_B22_PCREL;
 271       break;
 272     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_PLT:
 273       FixupKind = Hexagon::fixup_Hexagon_LD_PLT_B22_PCREL;
 274       break;
 275     default:
 276       if (MCID.isBranch() || MCID.isCall()) {
 277         FixupKind = *Extended ? Hexagon::fixup_Hexagon_B22_PCREL_X
 278                               : Hexagon::fixup_Hexagon_B22_PCREL;
 279       } else {
 280         errs() << "unrecognized relocation, bits: " << bits << "\n";
 281         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 282       }
 283       break;
 284     }
 285     break;
 286
 287   case 16:
 288     if (*Extended) {
 289       switch (kind) {
 290       default:
 291         FixupKind = Hexagon::fixup_Hexagon_16_X;
 292         break;
 293       case llvm::MCSymbolRefExpr::VK_GOT:
 294         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 295         break;
 296       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 297         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 298         break;
 299       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 300         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16_X;
 301         break;
 302       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 303         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16_X;
 304         break;
 305       case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 306         FixupKind = Hexagon::fixup_Hexagon_IE_16_X;
 307         break;
 308       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 309         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16_X;
 310         break;
 311       case llvm::MCSymbolRefExpr::VK_TPREL:
 312         FixupKind = Hexagon::fixup_Hexagon_TPREL_16_X;
 313         break;
 314       case llvm::MCSymbolRefExpr::VK_DTPREL:
 315         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16_X;
 316         break;
 317       }
 318     } else
 319       switch (kind) {
 320       default:
 321         errs() << "unrecognized relocation, bits " << bits << "\n";
 322         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 323         break;
 324       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 325         if ((MCID.getOpcode() == Hexagon::HI) ||
 326             (MCID.getOpcode() == Hexagon::LO_H))
 327           FixupKind = Hexagon::fixup_Hexagon_GOTREL_HI16;
 328         else
 329           FixupKind = Hexagon::fixup_Hexagon_GOTREL_LO16;
 330         break;
 331       case llvm::MCSymbolRefExpr::VK_Hexagon_GPREL:
 332         FixupKind = Hexagon::fixup_Hexagon_GPREL16_0;
 333         break;
 334       case llvm::MCSymbolRefExpr::VK_Hexagon_LO16:
 335         FixupKind = Hexagon::fixup_Hexagon_LO16;
 336         break;
 337       case llvm::MCSymbolRefExpr::VK_Hexagon_HI16:
 338         FixupKind = Hexagon::fixup_Hexagon_HI16;
 339         break;
 340       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 341         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16;
 342         break;
 343       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 344         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16;
 345         break;
 346       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 347         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16;
 348         break;
 349       case llvm::MCSymbolRefExpr::VK_TPREL:
 350         FixupKind = Hexagon::fixup_Hexagon_TPREL_16;
 351         break;
 352       case llvm::MCSymbolRefExpr::VK_DTPREL:
 353         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16;
 354         break;
 355       }
 356     break;
 357
 358   case 15:
 359     if (MCID.isBranch() || MCID.isCall())
 360       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B15_PCREL_X
 361                             : Hexagon::fixup_Hexagon_B15_PCREL;
 362     break;
 363
 364   case 13:
 365     if (MCID.isBranch())
 366       FixupKind = Hexagon::fixup_Hexagon_B13_PCREL;
 367     else {
 368       errs() << "unrecognized relocation, bits " << bits << "\n";
 369       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 370     }
 371     break;
 372
 373   case 12:
 374     if (*Extended)
 375       switch (kind) {
 376       default:
 377         FixupKind = Hexagon::fixup_Hexagon_12_X;
 378         break;
 379       // There isn't a GOT_12_X, both 11_X and 16_X resolve to 6/26
 380       case llvm::MCSymbolRefExpr::VK_GOT:
 381         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 382         break;
 383       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 384         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 385         break;
 386       }
 387     else {
 388       errs() << "unrecognized relocation, bits " << bits << "\n";
 389       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 390     }
 391     break;
 392
 393   case 11:
 394     if (*Extended)
 395       switch (kind) {
 396       default:
 397         FixupKind = Hexagon::fixup_Hexagon_11_X;
 398         break;
 399       case llvm::MCSymbolRefExpr::VK_GOT:
 400         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 401         break;
 402       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 403         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 404         break;
 405       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 406         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_11_X;
 407         break;
 408       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 409         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_11_X;
 410         break;
 411       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 412         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_11_X;
 413         break;
 414       case llvm::MCSymbolRefExpr::VK_TPREL:
 415         FixupKind = Hexagon::fixup_Hexagon_TPREL_11_X;
 416         break;
 417       case llvm::MCSymbolRefExpr::VK_DTPREL:
 418         FixupKind = Hexagon::fixup_Hexagon_DTPREL_11_X;
 419         break;
 420       }
 421     else {
 422       errs() << "unrecognized relocation, bits " << bits << "\n";
 423       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 424     }
 425     break;
 426
 427   case 10:
 428     if (*Extended)
 429       FixupKind = Hexagon::fixup_Hexagon_10_X;
 430     break;
 431
 432   case 9:
 433     if (MCID.isBranch() ||
 434         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 435       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B9_PCREL_X
 436                             : Hexagon::fixup_Hexagon_B9_PCREL;
 437     else if (*Extended)
 438       FixupKind = Hexagon::fixup_Hexagon_9_X;
 439     else {
 440       errs() << "unrecognized relocation, bits " << bits << "\n";
 441       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 442     }
 443     break;
 444
 445   case 8:
 446     if (*Extended)
 447       FixupKind = Hexagon::fixup_Hexagon_8_X;
 448     else {
 449       errs() << "unrecognized relocation, bits " << bits << "\n";
 450       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 451     }
 452     break;
 453
 454   case 7:
 455     if (MCID.isBranch() ||
 456         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 457       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B7_PCREL_X
 458                             : Hexagon::fixup_Hexagon_B7_PCREL;
 459     else if (*Extended)
 460       FixupKind = Hexagon::fixup_Hexagon_7_X;
 461     else {
 462       errs() << "unrecognized relocation, bits " << bits << "\n";
 463       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 464     }
 465     break;
 466
 467   case 6:
 468     if (*Extended) {
 469       switch (kind) {
 470       default:
 471         FixupKind = Hexagon::fixup_Hexagon_6_X;
 472         break;
 473       case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 474         FixupKind = Hexagon::fixup_Hexagon_6_PCREL_X;
 475         break;
 476       // This is part of an extender, GOT_11 is a
 477       // Word32_U6 unsigned/truncated reloc.
 478       case llvm::MCSymbolRefExpr::VK_GOT:
 479         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 480         break;
 481       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 482         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 483         break;
 484       }
 485     } else {
 486       errs() << "unrecognized relocation, bits " << bits << "\n";
 487       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 488     }
 489     break;
 490
 491   case 0:
 492     FixupKind = getFixupNoBits(MCII, MI, MO, kind);
 493     break;
 494   }
 495
 496   MCFixup fixup =
 497       MCFixup::Create(*Addend, MO.getExpr(), MCFixupKind(FixupKind));
 498   Fixups.push_back(fixup);
 499   // All of the information is in the fixup.
 500   return (0);
 501 }
 502
 503 unsigned
 504 HexagonMCCodeEmitter::getMachineOpValue(MCInst const &MI, MCOperand const &MO,
 505                                         SmallVectorImpl<MCFixup> &Fixups,
 506                                         MCSubtargetInfo const &STI) const {
 507   if (MO.isReg())
 508     return MCT.getRegisterInfo()->getEncodingValue(MO.getReg());
 509   if (MO.isImm())
 510     return static_cast<unsigned>(MO.getImm());
 511
 512   // MO must be an ME.
 513   assert(MO.isExpr());
 514   return getExprOpValue(MI, MO, MO.getExpr(), Fixups, STI);
 515 }
 516
 517 MCCodeEmitter *llvm::createHexagonMCCodeEmitter(MCInstrInfo const &MII,
 518                                                 MCRegisterInfo const &MRI,
 519                                                 MCContext &MCT) {
 520   return new HexagonMCCodeEmitter(MII, MCT);
 521 }
 522
 523 #include "HexagonGenMCCodeEmitter.inc"