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 opcode = MCID.getOpcode();
 207   unsigned bits = HexagonMCInstrInfo::getExtentBits(MCII, MI) -
 208                   HexagonMCInstrInfo::getExtentAlignment(MCII, MI);
 209   const MCSymbolRefExpr::VariantKind kind = MCSRE->getKind();
 210
 211   DEBUG(dbgs() << "----------------------------------------\n");
 212   DEBUG(dbgs() << "Opcode Name: " << HexagonMCInstrInfo::getName(MCII, MI)
 213                << "\n");
 214   DEBUG(dbgs() << "Opcode: " << opcode << "\n");
 215   DEBUG(dbgs() << "Relocation bits: " << bits << "\n");
 216   DEBUG(dbgs() << "Addend: " << *Addend << "\n");
 217   DEBUG(dbgs() << "----------------------------------------\n");
 218
 219   switch (bits) {
 220   default:
 221     DEBUG(dbgs() << "unrecognized bit count of " << bits << '\n');
 222     break;
 223
 224   case 32:
 225     switch (kind) {
 226     case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 227       FixupKind = Hexagon::fixup_Hexagon_32_PCREL;
 228       break;
 229     case llvm::MCSymbolRefExpr::VK_GOT:
 230       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOT_32_6_X
 231                             : Hexagon::fixup_Hexagon_GOT_32;
 232       break;
 233     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 234       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOTREL_32_6_X
 235                             : Hexagon::fixup_Hexagon_GOTREL_32;
 236       break;
 237     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 238       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GD_GOT_32_6_X
 239                             : Hexagon::fixup_Hexagon_GD_GOT_32;
 240       break;
 241     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 242       FixupKind = *Extended ? Hexagon::fixup_Hexagon_LD_GOT_32_6_X
 243                             : Hexagon::fixup_Hexagon_LD_GOT_32;
 244       break;
 245     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 246       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_32_6_X
 247                             : Hexagon::fixup_Hexagon_IE_32;
 248       break;
 249     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 250       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_GOT_32_6_X
 251                             : Hexagon::fixup_Hexagon_IE_GOT_32;
 252       break;
 253     case llvm::MCSymbolRefExpr::VK_TPREL:
 254       FixupKind = *Extended ? Hexagon::fixup_Hexagon_TPREL_32_6_X
 255                             : Hexagon::fixup_Hexagon_TPREL_32;
 256       break;
 257     case llvm::MCSymbolRefExpr::VK_DTPREL:
 258       FixupKind = *Extended ? Hexagon::fixup_Hexagon_DTPREL_32_6_X
 259                             : Hexagon::fixup_Hexagon_DTPREL_32;
 260       break;
 261     default:
 262       FixupKind =
 263           *Extended ? Hexagon::fixup_Hexagon_32_6_X : Hexagon::fixup_Hexagon_32;
 264       break;
 265     }
 266     break;
 267
 268   case 22:
 269     switch (kind) {
 270     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_PLT:
 271       FixupKind = Hexagon::fixup_Hexagon_GD_PLT_B22_PCREL;
 272       break;
 273     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_PLT:
 274       FixupKind = Hexagon::fixup_Hexagon_LD_PLT_B22_PCREL;
 275       break;
 276     default:
 277       if (MCID.isBranch() || MCID.isCall()) {
 278         FixupKind = *Extended ? Hexagon::fixup_Hexagon_B22_PCREL_X
 279                               : Hexagon::fixup_Hexagon_B22_PCREL;
 280       } else {
 281         errs() << "unrecognized relocation, bits: " << bits << "\n";
 282         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 283       }
 284       break;
 285     }
 286     break;
 287
 288   case 16:
 289     if (*Extended) {
 290       switch (kind) {
 291       default:
 292         FixupKind = Hexagon::fixup_Hexagon_16_X;
 293         break;
 294       case llvm::MCSymbolRefExpr::VK_GOT:
 295         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 296         break;
 297       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 298         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 299         break;
 300       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 301         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16_X;
 302         break;
 303       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 304         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16_X;
 305         break;
 306       case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 307         FixupKind = Hexagon::fixup_Hexagon_IE_16_X;
 308         break;
 309       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 310         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16_X;
 311         break;
 312       case llvm::MCSymbolRefExpr::VK_TPREL:
 313         FixupKind = Hexagon::fixup_Hexagon_TPREL_16_X;
 314         break;
 315       case llvm::MCSymbolRefExpr::VK_DTPREL:
 316         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16_X;
 317         break;
 318       }
 319     } else
 320       switch (kind) {
 321       default:
 322         errs() << "unrecognized relocation, bits " << bits << "\n";
 323         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 324         break;
 325       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 326         if ((MCID.getOpcode() == Hexagon::HI) ||
 327             (MCID.getOpcode() == Hexagon::LO_H))
 328           FixupKind = Hexagon::fixup_Hexagon_GOTREL_HI16;
 329         else
 330           FixupKind = Hexagon::fixup_Hexagon_GOTREL_LO16;
 331         break;
 332       case llvm::MCSymbolRefExpr::VK_Hexagon_GPREL:
 333         FixupKind = Hexagon::fixup_Hexagon_GPREL16_0;
 334         break;
 335       case llvm::MCSymbolRefExpr::VK_Hexagon_LO16:
 336         FixupKind = Hexagon::fixup_Hexagon_LO16;
 337         break;
 338       case llvm::MCSymbolRefExpr::VK_Hexagon_HI16:
 339         FixupKind = Hexagon::fixup_Hexagon_HI16;
 340         break;
 341       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 342         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16;
 343         break;
 344       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 345         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16;
 346         break;
 347       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 348         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16;
 349         break;
 350       case llvm::MCSymbolRefExpr::VK_TPREL:
 351         FixupKind = Hexagon::fixup_Hexagon_TPREL_16;
 352         break;
 353       case llvm::MCSymbolRefExpr::VK_DTPREL:
 354         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16;
 355         break;
 356       }
 357     break;
 358
 359   case 15:
 360     if (MCID.isBranch() || MCID.isCall())
 361       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B15_PCREL_X
 362                             : Hexagon::fixup_Hexagon_B15_PCREL;
 363     break;
 364
 365   case 13:
 366     if (MCID.isBranch())
 367       FixupKind = Hexagon::fixup_Hexagon_B13_PCREL;
 368     else {
 369       errs() << "unrecognized relocation, bits " << bits << "\n";
 370       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 371     }
 372     break;
 373
 374   case 12:
 375     if (*Extended)
 376       switch (kind) {
 377       default:
 378         FixupKind = Hexagon::fixup_Hexagon_12_X;
 379         break;
 380       // There isn't a GOT_12_X, both 11_X and 16_X resolve to 6/26
 381       case llvm::MCSymbolRefExpr::VK_GOT:
 382         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 383         break;
 384       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 385         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 386         break;
 387       }
 388     else {
 389       errs() << "unrecognized relocation, bits " << bits << "\n";
 390       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 391     }
 392     break;
 393
 394   case 11:
 395     if (*Extended)
 396       switch (kind) {
 397       default:
 398         FixupKind = Hexagon::fixup_Hexagon_11_X;
 399         break;
 400       case llvm::MCSymbolRefExpr::VK_GOT:
 401         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 402         break;
 403       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 404         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 405         break;
 406       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 407         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_11_X;
 408         break;
 409       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 410         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_11_X;
 411         break;
 412       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 413         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_11_X;
 414         break;
 415       case llvm::MCSymbolRefExpr::VK_TPREL:
 416         FixupKind = Hexagon::fixup_Hexagon_TPREL_11_X;
 417         break;
 418       case llvm::MCSymbolRefExpr::VK_DTPREL:
 419         FixupKind = Hexagon::fixup_Hexagon_DTPREL_11_X;
 420         break;
 421       }
 422     else {
 423       errs() << "unrecognized relocation, bits " << bits << "\n";
 424       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 425     }
 426     break;
 427
 428   case 10:
 429     if (*Extended)
 430       FixupKind = Hexagon::fixup_Hexagon_10_X;
 431     break;
 432
 433   case 9:
 434     if (MCID.isBranch() ||
 435         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 436       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B9_PCREL_X
 437                             : Hexagon::fixup_Hexagon_B9_PCREL;
 438     else if (*Extended)
 439       FixupKind = Hexagon::fixup_Hexagon_9_X;
 440     else {
 441       errs() << "unrecognized relocation, bits " << bits << "\n";
 442       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 443     }
 444     break;
 445
 446   case 8:
 447     if (*Extended)
 448       FixupKind = Hexagon::fixup_Hexagon_8_X;
 449     else {
 450       errs() << "unrecognized relocation, bits " << bits << "\n";
 451       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 452     }
 453     break;
 454
 455   case 7:
 456     if (MCID.isBranch() ||
 457         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 458       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B7_PCREL_X
 459                             : Hexagon::fixup_Hexagon_B7_PCREL;
 460     else if (*Extended)
 461       FixupKind = Hexagon::fixup_Hexagon_7_X;
 462     else {
 463       errs() << "unrecognized relocation, bits " << bits << "\n";
 464       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 465     }
 466     break;
 467
 468   case 6:
 469     if (*Extended) {
 470       switch (kind) {
 471       default:
 472         FixupKind = Hexagon::fixup_Hexagon_6_X;
 473         break;
 474       case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 475         FixupKind = Hexagon::fixup_Hexagon_6_PCREL_X;
 476         break;
 477       // This is part of an extender, GOT_11 is a
 478       // Word32_U6 unsigned/truncated reloc.
 479       case llvm::MCSymbolRefExpr::VK_GOT:
 480         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 481         break;
 482       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 483         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 484         break;
 485       }
 486     } else {
 487       errs() << "unrecognized relocation, bits " << bits << "\n";
 488       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 489     }
 490     break;
 491
 492   case 0:
 493     FixupKind = getFixupNoBits(MCII, MI, MO, kind);
 494     break;
 495   }
 496
 497   MCFixup fixup =
 498       MCFixup::Create(*Addend, MO.getExpr(), MCFixupKind(FixupKind));
 499   Fixups.push_back(fixup);
 500   // All of the information is in the fixup.
 501   return (0);
 502 }
 503
 504 unsigned
 505 HexagonMCCodeEmitter::getMachineOpValue(MCInst const &MI, MCOperand const &MO,
 506                                         SmallVectorImpl<MCFixup> &Fixups,
 507                                         MCSubtargetInfo const &STI) const {
 508   if (MO.isReg())
 509     return MCT.getRegisterInfo()->getEncodingValue(MO.getReg());
 510   if (MO.isImm())
 511     return static_cast<unsigned>(MO.getImm());
 512
 513   // MO must be an ME.
 514   assert(MO.isExpr());
 515   return getExprOpValue(MI, MO, MO.getExpr(), Fixups, STI);
 516 }
 517
 518 MCCodeEmitter *llvm::createHexagonMCCodeEmitter(MCInstrInfo const &MII,
 519                                                 MCRegisterInfo const &MRI,
 520                                                 MCContext &MCT) {
 521   return new HexagonMCCodeEmitter(MII, MCT);
 522 }
 523
 524 #include "HexagonGenMCCodeEmitter.inc"