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 void emitLittleEndian(uint64_t Binary, raw_ostream &OS) {
  36   OS << static_cast<uint8_t>((Binary >> 0x00) & 0xff);
  37   OS << static_cast<uint8_t>((Binary >> 0x08) & 0xff);
  38   OS << static_cast<uint8_t>((Binary >> 0x10) & 0xff);
  39   OS << static_cast<uint8_t>((Binary >> 0x18) & 0xff);
  40 }
  41 }
  42
  43 HexagonMCCodeEmitter::HexagonMCCodeEmitter(MCInstrInfo const &aMII,
  44                                            MCContext &aMCT)
  45     : MCT(aMCT), MCII(aMII), Addend(new unsigned(0)),
  46       Extended(new bool(false)), CurrentBundle(new MCInst const *) {}
  47
  48 uint32_t HexagonMCCodeEmitter::parseBits(size_t Instruction, size_t Last,
  49                                          MCInst const &MCB,
  50                                          MCInst const &MCI) const {
  51   if (Instruction == 0) {
  52     if (HexagonMCInstrInfo::isInnerLoop(MCB)) {
  53       assert(Instruction != Last);
  54       return HexagonII::INST_PARSE_LOOP_END;
  55     }
  56   }
  57   if (Instruction == 1) {
  58     if (HexagonMCInstrInfo::isOuterLoop(MCB)) {
  59       assert(Instruction != Last);
  60       return HexagonII::INST_PARSE_LOOP_END;
  61     }
  62   }
  63   if(Instruction == Last)
  64     return HexagonII::INST_PARSE_PACKET_END;
  65   return HexagonII::INST_PARSE_NOT_END;
  66 }
  67
  68 void HexagonMCCodeEmitter::encodeInstruction(MCInst const &MI, raw_ostream &OS,
  69                                              SmallVectorImpl<MCFixup> &Fixups,
  70                                              MCSubtargetInfo const &STI) const {
  71   MCInst &HMB = const_cast<MCInst &>(MI);
  72
  73   assert(HexagonMCInstrInfo::isBundle(HMB));
  74   DEBUG(dbgs() << "Encoding bundle\n";);
  75   *Addend = 0;
  76   *Extended = false;
  77   *CurrentBundle = &MI;
  78   size_t Instruction = 0;
  79   size_t Last = HexagonMCInstrInfo::bundleSize(HMB) - 1;
  80   for (auto &I : HexagonMCInstrInfo::bundleInstructions(HMB)) {
  81     MCInst &HMI = const_cast<MCInst &>(*I.getInst());
  82     EncodeSingleInstruction(HMI, OS, Fixups, STI,
  83                             parseBits(Instruction, Last, HMB, HMI),
  84                             Instruction);
  85     *Extended = HexagonMCInstrInfo::isImmext(HMI);
  86     *Addend += HEXAGON_INSTR_SIZE;
  87     ++Instruction;
  88   }
  89   return;
  90 }
  91
  92 /// EncodeSingleInstruction - Emit a single
  93 void HexagonMCCodeEmitter::EncodeSingleInstruction(
  94     const MCInst &MI, raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups,
  95     const MCSubtargetInfo &STI, uint32_t Parse, size_t Index) const {
  96   MCInst HMB = MI;
  97   assert(!HexagonMCInstrInfo::isBundle(HMB));
  98   uint64_t Binary;
  99
 100   // Pseudo instructions don't get encoded and shouldn't be here
 101   // in the first place!
 102   assert(!HexagonMCInstrInfo::getDesc(MCII, HMB).isPseudo() &&
 103          "pseudo-instruction found");
 104   DEBUG(dbgs() << "Encoding insn"
 105                   " `" << HexagonMCInstrInfo::getName(MCII, HMB) << "'"
 106                                                                     "\n");
 107
 108   if (HexagonMCInstrInfo::isNewValue(MCII, HMB)) {
 109     // Calculate the new value distance to the associated producer
 110     MCOperand &MCO =
 111         HMB.getOperand(HexagonMCInstrInfo::getNewValueOp(MCII, HMB));
 112     unsigned SOffset = 0;
 113     unsigned Register = MCO.getReg();
 114     unsigned Register1;
 115     auto Instructions = HexagonMCInstrInfo::bundleInstructions(**CurrentBundle);
 116     auto i = Instructions.begin() + Index - 1;
 117     for (;; --i) {
 118       assert(i != Instructions.begin() - 1 && "Couldn't find producer");
 119       MCInst const &Inst = *i->getInst();
 120       if (HexagonMCInstrInfo::isImmext(Inst))
 121         continue;
 122       ++SOffset;
 123       Register1 =
 124           HexagonMCInstrInfo::hasNewValue(MCII, Inst)
 125               ? HexagonMCInstrInfo::getNewValueOperand(MCII, Inst).getReg()
 126               : static_cast<unsigned>(Hexagon::NoRegister);
 127       if (Register != Register1)
 128         // This isn't the register we're looking for
 129         continue;
 130       if (!HexagonMCInstrInfo::isPredicated(MCII, Inst))
 131         // Producer is unpredicated
 132         break;
 133       assert(HexagonMCInstrInfo::isPredicated(MCII, HMB) &&
 134              "Unpredicated consumer depending on predicated producer");
 135       if (HexagonMCInstrInfo::isPredicatedTrue(MCII, Inst) ==
 136           HexagonMCInstrInfo::isPredicatedTrue(MCII, HMB))
 137         // Producer predicate sense matched ours
 138         break;
 139     }
 140     // Hexagon PRM 10.11 Construct Nt from distance
 141     unsigned Offset = SOffset;
 142     Offset <<= 1;
 143     MCO.setReg(Offset + Hexagon::R0);
 144   }
 145
 146   Binary = getBinaryCodeForInstr(HMB, Fixups, STI);
 147   // Check for unimplemented instructions. Immediate extenders
 148   // are encoded as zero, so they need to be accounted for.
 149   if ((!Binary) &&
 150       ((HMB.getOpcode() != DuplexIClass0) && (HMB.getOpcode() != A4_ext) &&
 151        (HMB.getOpcode() != A4_ext_b) && (HMB.getOpcode() != A4_ext_c) &&
 152        (HMB.getOpcode() != A4_ext_g))) {
 153     // Use a A2_nop for unimplemented instructions.
 154     DEBUG(dbgs() << "Unimplemented inst: "
 155                     " `" << HexagonMCInstrInfo::getName(MCII, HMB) << "'"
 156                                                                       "\n");
 157     llvm_unreachable("Unimplemented Instruction");
 158   }
 159   Binary |= Parse;
 160   emitLittleEndian(Binary, OS);
 161   ++MCNumEmitted;
 162 }
 163
 164 static Hexagon::Fixups getFixupNoBits(MCInstrInfo const &MCII, const MCInst &MI,
 165                                       const MCOperand &MO,
 166                                       const MCSymbolRefExpr::VariantKind kind) {
 167   const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI);
 168   unsigned insnType = llvm::HexagonMCInstrInfo::getType(MCII, MI);
 169
 170   if (insnType == HexagonII::TypePREFIX) {
 171     switch (kind) {
 172     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 173       return Hexagon::fixup_Hexagon_GOTREL_32_6_X;
 174     case llvm::MCSymbolRefExpr::VK_GOT:
 175       return Hexagon::fixup_Hexagon_GOT_32_6_X;
 176     case llvm::MCSymbolRefExpr::VK_TPREL:
 177       return Hexagon::fixup_Hexagon_TPREL_32_6_X;
 178     case llvm::MCSymbolRefExpr::VK_DTPREL:
 179       return Hexagon::fixup_Hexagon_DTPREL_32_6_X;
 180     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 181       return Hexagon::fixup_Hexagon_GD_GOT_32_6_X;
 182     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 183       return Hexagon::fixup_Hexagon_LD_GOT_32_6_X;
 184     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 185       return Hexagon::fixup_Hexagon_IE_32_6_X;
 186     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 187       return Hexagon::fixup_Hexagon_IE_GOT_32_6_X;
 188     default:
 189       if (MCID.isBranch())
 190         return Hexagon::fixup_Hexagon_B32_PCREL_X;
 191       else
 192         return Hexagon::fixup_Hexagon_32_6_X;
 193     }
 194   } else if (MCID.isBranch())
 195     return (Hexagon::fixup_Hexagon_B13_PCREL);
 196
 197   switch (MCID.getOpcode()) {
 198   case Hexagon::HI:
 199   case Hexagon::A2_tfrih:
 200     switch (kind) {
 201     case llvm::MCSymbolRefExpr::VK_GOT:
 202       return Hexagon::fixup_Hexagon_GOT_HI16;
 203     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 204       return Hexagon::fixup_Hexagon_GOTREL_HI16;
 205     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 206       return Hexagon::fixup_Hexagon_GD_GOT_HI16;
 207     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 208       return Hexagon::fixup_Hexagon_LD_GOT_HI16;
 209     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 210       return Hexagon::fixup_Hexagon_IE_HI16;
 211     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 212       return Hexagon::fixup_Hexagon_IE_GOT_HI16;
 213     case llvm::MCSymbolRefExpr::VK_TPREL:
 214       return Hexagon::fixup_Hexagon_TPREL_HI16;
 215     case llvm::MCSymbolRefExpr::VK_DTPREL:
 216       return Hexagon::fixup_Hexagon_DTPREL_HI16;
 217     default:
 218       return Hexagon::fixup_Hexagon_HI16;
 219     }
 220
 221   case Hexagon::LO:
 222   case Hexagon::A2_tfril:
 223     switch (kind) {
 224     case llvm::MCSymbolRefExpr::VK_GOT:
 225       return Hexagon::fixup_Hexagon_GOT_LO16;
 226     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 227       return Hexagon::fixup_Hexagon_GOTREL_LO16;
 228     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 229       return Hexagon::fixup_Hexagon_GD_GOT_LO16;
 230     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 231       return Hexagon::fixup_Hexagon_LD_GOT_LO16;
 232     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 233       return Hexagon::fixup_Hexagon_IE_LO16;
 234     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 235       return Hexagon::fixup_Hexagon_IE_GOT_LO16;
 236     case llvm::MCSymbolRefExpr::VK_TPREL:
 237       return Hexagon::fixup_Hexagon_TPREL_LO16;
 238     case llvm::MCSymbolRefExpr::VK_DTPREL:
 239       return Hexagon::fixup_Hexagon_DTPREL_LO16;
 240     default:
 241       return Hexagon::fixup_Hexagon_LO16;
 242     }
 243
 244   // The only relocs left should be GP relative:
 245   default:
 246     if (MCID.mayStore() || MCID.mayLoad()) {
 247       for (const uint16_t *ImpUses = MCID.getImplicitUses(); *ImpUses;
 248            ++ImpUses) {
 249         if (*ImpUses == Hexagon::GP) {
 250           switch (HexagonMCInstrInfo::getAccessSize(MCII, MI)) {
 251           case HexagonII::MemAccessSize::ByteAccess:
 252             return fixup_Hexagon_GPREL16_0;
 253           case HexagonII::MemAccessSize::HalfWordAccess:
 254             return fixup_Hexagon_GPREL16_1;
 255           case HexagonII::MemAccessSize::WordAccess:
 256             return fixup_Hexagon_GPREL16_2;
 257           case HexagonII::MemAccessSize::DoubleWordAccess:
 258             return fixup_Hexagon_GPREL16_3;
 259           default:
 260             llvm_unreachable("unhandled fixup");
 261           }
 262         }
 263       }
 264     } else
 265       llvm_unreachable("unhandled fixup");
 266   }
 267
 268   return LastTargetFixupKind;
 269 }
 270
 271 unsigned HexagonMCCodeEmitter::getExprOpValue(const MCInst &MI,
 272                                               const MCOperand &MO,
 273                                               const MCExpr *ME,
 274                                               SmallVectorImpl<MCFixup> &Fixups,
 275                                               const MCSubtargetInfo &STI) const
 276
 277 {
 278   int64_t Res;
 279
 280   if (ME->evaluateAsAbsolute(Res))
 281     return Res;
 282
 283   MCExpr::ExprKind MK = ME->getKind();
 284   if (MK == MCExpr::Constant) {
 285     return cast<MCConstantExpr>(ME)->getValue();
 286   }
 287   if (MK == MCExpr::Binary) {
 288     unsigned Res;
 289     Res = getExprOpValue(MI, MO, cast<MCBinaryExpr>(ME)->getLHS(), Fixups, STI);
 290     Res +=
 291         getExprOpValue(MI, MO, cast<MCBinaryExpr>(ME)->getRHS(), Fixups, STI);
 292     return Res;
 293   }
 294
 295   assert(MK == MCExpr::SymbolRef);
 296
 297   Hexagon::Fixups FixupKind =
 298       Hexagon::Fixups(Hexagon::fixup_Hexagon_TPREL_LO16);
 299   const MCSymbolRefExpr *MCSRE = static_cast<const MCSymbolRefExpr *>(ME);
 300   const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI);
 301   unsigned bits = HexagonMCInstrInfo::getExtentBits(MCII, MI) -
 302                   HexagonMCInstrInfo::getExtentAlignment(MCII, MI);
 303   const MCSymbolRefExpr::VariantKind kind = MCSRE->getKind();
 304
 305   DEBUG(dbgs() << "----------------------------------------\n");
 306   DEBUG(dbgs() << "Opcode Name: " << HexagonMCInstrInfo::getName(MCII, MI)
 307                << "\n");
 308   DEBUG(dbgs() << "Opcode: " << MCID.getOpcode() << "\n");
 309   DEBUG(dbgs() << "Relocation bits: " << bits << "\n");
 310   DEBUG(dbgs() << "Addend: " << *Addend << "\n");
 311   DEBUG(dbgs() << "----------------------------------------\n");
 312
 313   switch (bits) {
 314   default:
 315     DEBUG(dbgs() << "unrecognized bit count of " << bits << '\n');
 316     break;
 317
 318   case 32:
 319     switch (kind) {
 320     case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 321       FixupKind = Hexagon::fixup_Hexagon_32_PCREL;
 322       break;
 323     case llvm::MCSymbolRefExpr::VK_GOT:
 324       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOT_32_6_X
 325                             : Hexagon::fixup_Hexagon_GOT_32;
 326       break;
 327     case llvm::MCSymbolRefExpr::VK_GOTOFF:
 328       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GOTREL_32_6_X
 329                             : Hexagon::fixup_Hexagon_GOTREL_32;
 330       break;
 331     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 332       FixupKind = *Extended ? Hexagon::fixup_Hexagon_GD_GOT_32_6_X
 333                             : Hexagon::fixup_Hexagon_GD_GOT_32;
 334       break;
 335     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 336       FixupKind = *Extended ? Hexagon::fixup_Hexagon_LD_GOT_32_6_X
 337                             : Hexagon::fixup_Hexagon_LD_GOT_32;
 338       break;
 339     case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 340       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_32_6_X
 341                             : Hexagon::fixup_Hexagon_IE_32;
 342       break;
 343     case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 344       FixupKind = *Extended ? Hexagon::fixup_Hexagon_IE_GOT_32_6_X
 345                             : Hexagon::fixup_Hexagon_IE_GOT_32;
 346       break;
 347     case llvm::MCSymbolRefExpr::VK_TPREL:
 348       FixupKind = *Extended ? Hexagon::fixup_Hexagon_TPREL_32_6_X
 349                             : Hexagon::fixup_Hexagon_TPREL_32;
 350       break;
 351     case llvm::MCSymbolRefExpr::VK_DTPREL:
 352       FixupKind = *Extended ? Hexagon::fixup_Hexagon_DTPREL_32_6_X
 353                             : Hexagon::fixup_Hexagon_DTPREL_32;
 354       break;
 355     default:
 356       FixupKind =
 357           *Extended ? Hexagon::fixup_Hexagon_32_6_X : Hexagon::fixup_Hexagon_32;
 358       break;
 359     }
 360     break;
 361
 362   case 22:
 363     switch (kind) {
 364     case llvm::MCSymbolRefExpr::VK_Hexagon_GD_PLT:
 365       FixupKind = Hexagon::fixup_Hexagon_GD_PLT_B22_PCREL;
 366       break;
 367     case llvm::MCSymbolRefExpr::VK_Hexagon_LD_PLT:
 368       FixupKind = Hexagon::fixup_Hexagon_LD_PLT_B22_PCREL;
 369       break;
 370     default:
 371       if (MCID.isBranch() || MCID.isCall()) {
 372         FixupKind = *Extended ? Hexagon::fixup_Hexagon_B22_PCREL_X
 373                               : Hexagon::fixup_Hexagon_B22_PCREL;
 374       } else {
 375         errs() << "unrecognized relocation, bits: " << bits << "\n";
 376         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 377       }
 378       break;
 379     }
 380     break;
 381
 382   case 16:
 383     if (*Extended) {
 384       switch (kind) {
 385       default:
 386         FixupKind = Hexagon::fixup_Hexagon_16_X;
 387         break;
 388       case llvm::MCSymbolRefExpr::VK_GOT:
 389         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 390         break;
 391       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 392         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 393         break;
 394       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 395         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16_X;
 396         break;
 397       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 398         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16_X;
 399         break;
 400       case llvm::MCSymbolRefExpr::VK_Hexagon_IE:
 401         FixupKind = Hexagon::fixup_Hexagon_IE_16_X;
 402         break;
 403       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 404         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16_X;
 405         break;
 406       case llvm::MCSymbolRefExpr::VK_TPREL:
 407         FixupKind = Hexagon::fixup_Hexagon_TPREL_16_X;
 408         break;
 409       case llvm::MCSymbolRefExpr::VK_DTPREL:
 410         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16_X;
 411         break;
 412       }
 413     } else
 414       switch (kind) {
 415       default:
 416         errs() << "unrecognized relocation, bits " << bits << "\n";
 417         errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 418         break;
 419       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 420         if ((MCID.getOpcode() == Hexagon::HI) ||
 421             (MCID.getOpcode() == Hexagon::LO_H))
 422           FixupKind = Hexagon::fixup_Hexagon_GOTREL_HI16;
 423         else
 424           FixupKind = Hexagon::fixup_Hexagon_GOTREL_LO16;
 425         break;
 426       case llvm::MCSymbolRefExpr::VK_Hexagon_GPREL:
 427         FixupKind = Hexagon::fixup_Hexagon_GPREL16_0;
 428         break;
 429       case llvm::MCSymbolRefExpr::VK_Hexagon_LO16:
 430         FixupKind = Hexagon::fixup_Hexagon_LO16;
 431         break;
 432       case llvm::MCSymbolRefExpr::VK_Hexagon_HI16:
 433         FixupKind = Hexagon::fixup_Hexagon_HI16;
 434         break;
 435       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 436         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_16;
 437         break;
 438       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 439         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_16;
 440         break;
 441       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 442         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_16;
 443         break;
 444       case llvm::MCSymbolRefExpr::VK_TPREL:
 445         FixupKind = Hexagon::fixup_Hexagon_TPREL_16;
 446         break;
 447       case llvm::MCSymbolRefExpr::VK_DTPREL:
 448         FixupKind = Hexagon::fixup_Hexagon_DTPREL_16;
 449         break;
 450       }
 451     break;
 452
 453   case 15:
 454     if (MCID.isBranch() || MCID.isCall())
 455       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B15_PCREL_X
 456                             : Hexagon::fixup_Hexagon_B15_PCREL;
 457     break;
 458
 459   case 13:
 460     if (MCID.isBranch())
 461       FixupKind = Hexagon::fixup_Hexagon_B13_PCREL;
 462     else {
 463       errs() << "unrecognized relocation, bits " << bits << "\n";
 464       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 465     }
 466     break;
 467
 468   case 12:
 469     if (*Extended)
 470       switch (kind) {
 471       default:
 472         FixupKind = Hexagon::fixup_Hexagon_12_X;
 473         break;
 474       // There isn't a GOT_12_X, both 11_X and 16_X resolve to 6/26
 475       case llvm::MCSymbolRefExpr::VK_GOT:
 476         FixupKind = Hexagon::fixup_Hexagon_GOT_16_X;
 477         break;
 478       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 479         FixupKind = Hexagon::fixup_Hexagon_GOTREL_16_X;
 480         break;
 481       }
 482     else {
 483       errs() << "unrecognized relocation, bits " << bits << "\n";
 484       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 485     }
 486     break;
 487
 488   case 11:
 489     if (*Extended)
 490       switch (kind) {
 491       default:
 492         FixupKind = Hexagon::fixup_Hexagon_11_X;
 493         break;
 494       case llvm::MCSymbolRefExpr::VK_GOT:
 495         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 496         break;
 497       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 498         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 499         break;
 500       case llvm::MCSymbolRefExpr::VK_Hexagon_GD_GOT:
 501         FixupKind = Hexagon::fixup_Hexagon_GD_GOT_11_X;
 502         break;
 503       case llvm::MCSymbolRefExpr::VK_Hexagon_LD_GOT:
 504         FixupKind = Hexagon::fixup_Hexagon_LD_GOT_11_X;
 505         break;
 506       case llvm::MCSymbolRefExpr::VK_Hexagon_IE_GOT:
 507         FixupKind = Hexagon::fixup_Hexagon_IE_GOT_11_X;
 508         break;
 509       case llvm::MCSymbolRefExpr::VK_TPREL:
 510         FixupKind = Hexagon::fixup_Hexagon_TPREL_11_X;
 511         break;
 512       case llvm::MCSymbolRefExpr::VK_DTPREL:
 513         FixupKind = Hexagon::fixup_Hexagon_DTPREL_11_X;
 514         break;
 515       }
 516     else {
 517       errs() << "unrecognized relocation, bits " << bits << "\n";
 518       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 519     }
 520     break;
 521
 522   case 10:
 523     if (*Extended)
 524       FixupKind = Hexagon::fixup_Hexagon_10_X;
 525     break;
 526
 527   case 9:
 528     if (MCID.isBranch() ||
 529         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 530       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B9_PCREL_X
 531                             : Hexagon::fixup_Hexagon_B9_PCREL;
 532     else if (*Extended)
 533       FixupKind = Hexagon::fixup_Hexagon_9_X;
 534     else {
 535       errs() << "unrecognized relocation, bits " << bits << "\n";
 536       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 537     }
 538     break;
 539
 540   case 8:
 541     if (*Extended)
 542       FixupKind = Hexagon::fixup_Hexagon_8_X;
 543     else {
 544       errs() << "unrecognized relocation, bits " << bits << "\n";
 545       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 546     }
 547     break;
 548
 549   case 7:
 550     if (MCID.isBranch() ||
 551         (llvm::HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCR))
 552       FixupKind = *Extended ? Hexagon::fixup_Hexagon_B7_PCREL_X
 553                             : Hexagon::fixup_Hexagon_B7_PCREL;
 554     else if (*Extended)
 555       FixupKind = Hexagon::fixup_Hexagon_7_X;
 556     else {
 557       errs() << "unrecognized relocation, bits " << bits << "\n";
 558       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 559     }
 560     break;
 561
 562   case 6:
 563     if (*Extended) {
 564       switch (kind) {
 565       default:
 566         FixupKind = Hexagon::fixup_Hexagon_6_X;
 567         break;
 568       case llvm::MCSymbolRefExpr::VK_Hexagon_PCREL:
 569         FixupKind = Hexagon::fixup_Hexagon_6_PCREL_X;
 570         break;
 571       // This is part of an extender, GOT_11 is a
 572       // Word32_U6 unsigned/truncated reloc.
 573       case llvm::MCSymbolRefExpr::VK_GOT:
 574         FixupKind = Hexagon::fixup_Hexagon_GOT_11_X;
 575         break;
 576       case llvm::MCSymbolRefExpr::VK_GOTOFF:
 577         FixupKind = Hexagon::fixup_Hexagon_GOTREL_11_X;
 578         break;
 579       }
 580     } else {
 581       errs() << "unrecognized relocation, bits " << bits << "\n";
 582       errs() << "name = " << HexagonMCInstrInfo::getName(MCII, MI) << "\n";
 583     }
 584     break;
 585
 586   case 0:
 587     FixupKind = getFixupNoBits(MCII, MI, MO, kind);
 588     break;
 589   }
 590
 591   MCFixup fixup =
 592       MCFixup::create(*Addend, MO.getExpr(), MCFixupKind(FixupKind));
 593   Fixups.push_back(fixup);
 594   // All of the information is in the fixup.
 595   return (0);
 596 }
 597
 598 unsigned
 599 HexagonMCCodeEmitter::getMachineOpValue(MCInst const &MI, MCOperand const &MO,
 600                                         SmallVectorImpl<MCFixup> &Fixups,
 601                                         MCSubtargetInfo const &STI) const {
 602   if (MO.isReg())
 603     return MCT.getRegisterInfo()->getEncodingValue(MO.getReg());
 604   if (MO.isImm())
 605     return static_cast<unsigned>(MO.getImm());
 606
 607   // MO must be an ME.
 608   assert(MO.isExpr());
 609   return getExprOpValue(MI, MO, MO.getExpr(), Fixups, STI);
 610 }
 611
 612 MCCodeEmitter *llvm::createHexagonMCCodeEmitter(MCInstrInfo const &MII,
 613                                                 MCRegisterInfo const &MRI,
 614                                                 MCContext &MCT) {
 615   return new HexagonMCCodeEmitter(MII, MCT);
 616 }
 617
 618 #include "HexagonGenMCCodeEmitter.inc"