1 //===- HexagonMCCodeEmitter.cpp - Hexagon Target Descriptions -------------===// 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/HexagonMCCodeEmitter.h" 10 #include "MCTargetDesc/HexagonBaseInfo.h" 11 #include "MCTargetDesc/HexagonFixupKinds.h" 12 #include "MCTargetDesc/HexagonMCExpr.h" 13 #include "MCTargetDesc/HexagonMCInstrInfo.h" 14 #include "MCTargetDesc/HexagonMCTargetDesc.h" 15 #include "llvm/ADT/Statistic.h" 16 #include "llvm/MC/MCContext.h" 17 #include "llvm/MC/MCExpr.h" 18 #include "llvm/MC/MCFixup.h" 19 #include "llvm/MC/MCInst.h" 20 #include "llvm/MC/MCInstrDesc.h" 21 #include "llvm/MC/MCInstrInfo.h" 22 #include "llvm/MC/MCRegisterInfo.h" 23 #include "llvm/MC/MCSubtargetInfo.h" 24 #include "llvm/Support/Casting.h" 25 #include "llvm/Support/Compiler.h" 26 #include "llvm/Support/Debug.h" 27 #include "llvm/Support/Endian.h" 28 #include "llvm/Support/EndianStream.h" 29 #include "llvm/Support/ErrorHandling.h" 30 #include "llvm/Support/raw_ostream.h" 31 #include <cassert> 32 #include <cstddef> 33 #include <cstdint> 34 #include <map> 35 #include <string> 36 #include <vector> 37 38 #define DEBUG_TYPE "mccodeemitter" 39 40 using namespace llvm; 41 using namespace Hexagon; 42 43 STATISTIC(MCNumEmitted, "Number of MC instructions emitted"); 44 45 static const unsigned fixup_Invalid = ~0u; 46 47 #define _ fixup_Invalid 48 #define P(x) Hexagon::fixup_Hexagon##x 49 static const std::map<unsigned, std::vector<unsigned>> ExtFixups = { 50 { MCSymbolRefExpr::VK_DTPREL, 51 { _, _, _, _, 52 _, _, P(_DTPREL_16_X), P(_DTPREL_11_X), 53 P(_DTPREL_11_X), P(_9_X), _, P(_DTPREL_11_X), 54 P(_DTPREL_16_X), _, _, _, 55 P(_DTPREL_16_X), _, _, _, 56 _, _, _, _, 57 _, _, _, _, 58 _, _, _, _, 59 P(_DTPREL_32_6_X) }}, 60 { MCSymbolRefExpr::VK_GOT, 61 { _, _, _, _, 62 _, _, P(_GOT_11_X), _ /* [1] */, 63 _ /* [1] */, P(_9_X), _, P(_GOT_11_X), 64 P(_GOT_16_X), _, _, _, 65 P(_GOT_16_X), _, _, _, 66 _, _, _, _, 67 _, _, _, _, 68 _, _, _, _, 69 P(_GOT_32_6_X) }}, 70 { MCSymbolRefExpr::VK_GOTREL, 71 { _, _, _, _, 72 _, _, P(_GOTREL_11_X), P(_GOTREL_11_X), 73 P(_GOTREL_11_X), P(_9_X), _, P(_GOTREL_11_X), 74 P(_GOTREL_16_X), _, _, _, 75 P(_GOTREL_16_X), _, _, _, 76 _, _, _, _, 77 _, _, _, _, 78 _, _, _, _, 79 P(_GOTREL_32_6_X) }}, 80 { MCSymbolRefExpr::VK_TPREL, 81 { _, _, _, _, 82 _, _, P(_TPREL_16_X), P(_TPREL_11_X), 83 P(_TPREL_11_X), P(_9_X), _, P(_TPREL_11_X), 84 P(_TPREL_16_X), _, _, _, 85 P(_TPREL_16_X), _, _, _, 86 _, _, _, _, 87 _, _, _, _, 88 _, _, _, _, 89 P(_TPREL_32_6_X) }}, 90 { MCSymbolRefExpr::VK_Hexagon_GD_GOT, 91 { _, _, _, _, 92 _, _, P(_GD_GOT_16_X), P(_GD_GOT_11_X), 93 P(_GD_GOT_11_X), P(_9_X), _, P(_GD_GOT_11_X), 94 P(_GD_GOT_16_X), _, _, _, 95 P(_GD_GOT_16_X), _, _, _, 96 _, _, _, _, 97 _, _, _, _, 98 _, _, _, _, 99 P(_GD_GOT_32_6_X) }}, 100 { MCSymbolRefExpr::VK_Hexagon_GD_PLT, 101 { _, _, _, _, 102 _, _, _, _, 103 _, P(_9_X), _, P(_GD_PLT_B22_PCREL_X), 104 _, _, _, _, 105 _, _, _, _, 106 _, _, P(_GD_PLT_B22_PCREL_X), _, 107 _, _, _, _, 108 _, _, _, _, 109 _ }}, 110 { MCSymbolRefExpr::VK_Hexagon_IE, 111 { _, _, _, _, 112 _, _, P(_IE_16_X), _, 113 _, P(_9_X), _, _, 114 P(_IE_16_X), _, _, _, 115 P(_IE_16_X), _, _, _, 116 _, _, _, _, 117 _, _, _, _, 118 _, _, _, _, 119 P(_IE_32_6_X) }}, 120 { MCSymbolRefExpr::VK_Hexagon_IE_GOT, 121 { _, _, _, _, 122 _, _, P(_IE_GOT_11_X), P(_IE_GOT_11_X), 123 P(_IE_GOT_11_X), P(_9_X), _, P(_IE_GOT_11_X), 124 P(_IE_GOT_16_X), _, _, _, 125 P(_IE_GOT_16_X), _, _, _, 126 _, _, _, _, 127 _, _, _, _, 128 _, _, _, _, 129 P(_IE_GOT_32_6_X) }}, 130 { MCSymbolRefExpr::VK_Hexagon_LD_GOT, 131 { _, _, _, _, 132 _, _, P(_LD_GOT_11_X), P(_LD_GOT_11_X), 133 P(_LD_GOT_11_X), P(_9_X), _, P(_LD_GOT_11_X), 134 P(_LD_GOT_16_X), _, _, _, 135 P(_LD_GOT_16_X), _, _, _, 136 _, _, _, _, 137 _, _, _, _, 138 _, _, _, _, 139 P(_LD_GOT_32_6_X) }}, 140 { MCSymbolRefExpr::VK_Hexagon_LD_PLT, 141 { _, _, _, _, 142 _, _, _, _, 143 _, P(_9_X), _, P(_LD_PLT_B22_PCREL_X), 144 _, _, _, _, 145 _, _, _, _, 146 _, _, P(_LD_PLT_B22_PCREL_X), _, 147 _, _, _, _, 148 _, _, _, _, 149 _ }}, 150 { MCSymbolRefExpr::VK_Hexagon_PCREL, 151 { _, _, _, _, 152 _, _, P(_6_PCREL_X), _, 153 _, P(_9_X), _, _, 154 _, _, _, _, 155 _, _, _, _, 156 _, _, _, _, 157 _, _, _, _, 158 _, _, _, _, 159 P(_32_PCREL) }}, 160 { MCSymbolRefExpr::VK_None, 161 { _, _, _, _, 162 _, _, P(_6_X), P(_8_X), 163 P(_8_X), P(_9_X), P(_10_X), P(_11_X), 164 P(_12_X), P(_B13_PCREL), _, P(_B15_PCREL_X), 165 P(_16_X), _, _, _, 166 _, _, P(_B22_PCREL_X), _, 167 _, _, _, _, 168 _, _, _, _, 169 P(_32_6_X) }}, 170 }; 171 // [1] The fixup is GOT_16_X for signed values and GOT_11_X for unsigned. 172 173 static const std::map<unsigned, std::vector<unsigned>> StdFixups = { 174 { MCSymbolRefExpr::VK_DTPREL, 175 { _, _, _, _, 176 _, _, _, _, 177 _, _, _, _, 178 _, _, _, _, 179 P(_DTPREL_16), _, _, _, 180 _, _, _, _, 181 _, _, _, _, 182 _, _, _, _, 183 P(_DTPREL_32) }}, 184 { MCSymbolRefExpr::VK_GOT, 185 { _, _, _, _, 186 _, _, _, _, 187 _, _, _, _, 188 _, _, _, _, 189 _, _, _, _, 190 _, _, _, _, 191 _, _, _, _, 192 _, _, _, _, 193 P(_GOT_32) }}, 194 { MCSymbolRefExpr::VK_GOTREL, 195 { _, _, _, _, 196 _, _, _, _, 197 _, _, _, _, 198 _, _, _, _, 199 _ /* [2] */, _, _, _, 200 _, _, _, _, 201 _, _, _, _, 202 _, _, _, _, 203 P(_GOTREL_32) }}, 204 { MCSymbolRefExpr::VK_PLT, 205 { _, _, _, _, 206 _, _, _, _, 207 _, _, _, _, 208 _, _, _, _, 209 _, _, _, _, 210 _, _, P(_PLT_B22_PCREL), _, 211 _, _, _, _, 212 _, _, _, _, 213 _ }}, 214 { MCSymbolRefExpr::VK_TPREL, 215 { _, _, _, _, 216 _, _, _, _, 217 _, _, _, P(_TPREL_11_X), 218 _, _, _, _, 219 P(_TPREL_16), _, _, _, 220 _, _, _, _, 221 _, _, _, _, 222 _, _, _, _, 223 P(_TPREL_32) }}, 224 { MCSymbolRefExpr::VK_Hexagon_GD_GOT, 225 { _, _, _, _, 226 _, _, _, _, 227 _, _, _, _, 228 _, _, _, _, 229 P(_GD_GOT_16), _, _, _, 230 _, _, _, _, 231 _, _, _, _, 232 _, _, _, _, 233 P(_GD_GOT_32) }}, 234 { MCSymbolRefExpr::VK_Hexagon_GD_PLT, 235 { _, _, _, _, 236 _, _, _, _, 237 _, _, _, _, 238 _, _, _, _, 239 _, _, _, _, 240 _, _, P(_GD_PLT_B22_PCREL), _, 241 _, _, _, _, 242 _, _, _, _, 243 _ }}, 244 { MCSymbolRefExpr::VK_Hexagon_GPREL, 245 { _, _, _, _, 246 _, _, _, _, 247 _, _, _, _, 248 _, _, _, _, 249 P(_GPREL16_0), _, _, _, 250 _, _, _, _, 251 _, _, _, _, 252 _, _, _, _, 253 _ }}, 254 { MCSymbolRefExpr::VK_Hexagon_HI16, 255 { _, _, _, _, 256 _, _, _, _, 257 _, _, _, _, 258 _, _, _, _, 259 P(_HI16), _, _, _, 260 _, _, _, _, 261 _, _, _, _, 262 _, _, _, _, 263 _ }}, 264 { MCSymbolRefExpr::VK_Hexagon_IE, 265 { _, _, _, _, 266 _, _, _, _, 267 _, _, _, _, 268 _, _, _, _, 269 _, _, _, _, 270 _, _, _, _, 271 _, _, _, _, 272 _, _, _, _, 273 P(_IE_32) }}, 274 { MCSymbolRefExpr::VK_Hexagon_IE_GOT, 275 { _, _, _, _, 276 _, _, _, _, 277 _, _, _, _, 278 _, _, _, _, 279 P(_IE_GOT_16), _, _, _, 280 _, _, _, _, 281 _, _, _, _, 282 _, _, _, _, 283 P(_IE_GOT_32) }}, 284 { MCSymbolRefExpr::VK_Hexagon_LD_GOT, 285 { _, _, _, _, 286 _, _, _, _, 287 _, _, _, _, 288 _, _, _, _, 289 P(_LD_GOT_16), _, _, _, 290 _, _, _, _, 291 _, _, _, _, 292 _, _, _, _, 293 P(_LD_GOT_32) }}, 294 { MCSymbolRefExpr::VK_Hexagon_LD_PLT, 295 { _, _, _, _, 296 _, _, _, _, 297 _, _, _, _, 298 _, _, _, _, 299 _, _, _, _, 300 _, _, P(_LD_PLT_B22_PCREL), _, 301 _, _, _, _, 302 _, _, _, _, 303 _ }}, 304 { MCSymbolRefExpr::VK_Hexagon_LO16, 305 { _, _, _, _, 306 _, _, _, _, 307 _, _, _, _, 308 _, _, _, _, 309 P(_LO16), _, _, _, 310 _, _, _, _, 311 _, _, _, _, 312 _, _, _, _, 313 _ }}, 314 { MCSymbolRefExpr::VK_Hexagon_PCREL, 315 { _, _, _, _, 316 _, _, _, _, 317 _, _, _, _, 318 _, _, _, _, 319 _, _, _, _, 320 _, _, _, _, 321 _, _, _, _, 322 _, _, _, _, 323 P(_32_PCREL) }}, 324 { MCSymbolRefExpr::VK_None, 325 { _, _, _, _, 326 _, _, _, _, 327 _, _, _, _, 328 _, P(_B13_PCREL), _, P(_B15_PCREL), 329 _, _, _, _, 330 _, _, P(_B22_PCREL), _, 331 _, _, _, _, 332 _, _, _, _, 333 P(_32) }}, 334 }; 335 // 336 // [2] The actual fixup is LO16 or HI16, depending on the instruction. 337 #undef P 338 #undef _ 339 340 uint32_t HexagonMCCodeEmitter::parseBits(size_t Last, MCInst const &MCB, 341 MCInst const &MCI) const { 342 bool Duplex = HexagonMCInstrInfo::isDuplex(MCII, MCI); 343 if (State.Index == 0) { 344 if (HexagonMCInstrInfo::isInnerLoop(MCB)) { 345 assert(!Duplex); 346 assert(State.Index != Last); 347 return HexagonII::INST_PARSE_LOOP_END; 348 } 349 } 350 if (State.Index == 1) { 351 if (HexagonMCInstrInfo::isOuterLoop(MCB)) { 352 assert(!Duplex); 353 assert(State.Index != Last); 354 return HexagonII::INST_PARSE_LOOP_END; 355 } 356 } 357 if (Duplex) { 358 assert(State.Index == Last); 359 return HexagonII::INST_PARSE_DUPLEX; 360 } 361 if (State.Index == Last) 362 return HexagonII::INST_PARSE_PACKET_END; 363 return HexagonII::INST_PARSE_NOT_END; 364 } 365 366 /// Emit the bundle. 367 void HexagonMCCodeEmitter::encodeInstruction(const MCInst &MI, raw_ostream &OS, 368 SmallVectorImpl<MCFixup> &Fixups, 369 const MCSubtargetInfo &STI) const { 370 MCInst &HMB = const_cast<MCInst &>(MI); 371 372 assert(HexagonMCInstrInfo::isBundle(HMB)); 373 LLVM_DEBUG(dbgs() << "Encoding bundle\n";); 374 State.Addend = 0; 375 State.Extended = false; 376 State.Bundle = &MI; 377 State.Index = 0; 378 size_t Last = HexagonMCInstrInfo::bundleSize(HMB) - 1; 379 FeatureBitset Features = computeAvailableFeatures(STI.getFeatureBits()); 380 381 for (auto &I : HexagonMCInstrInfo::bundleInstructions(HMB)) { 382 MCInst &HMI = const_cast<MCInst &>(*I.getInst()); 383 verifyInstructionPredicates(HMI, Features); 384 385 EncodeSingleInstruction(HMI, OS, Fixups, STI, parseBits(Last, HMB, HMI)); 386 State.Extended = HexagonMCInstrInfo::isImmext(HMI); 387 State.Addend += HEXAGON_INSTR_SIZE; 388 ++State.Index; 389 } 390 } 391 392 static bool RegisterMatches(unsigned Consumer, unsigned Producer, 393 unsigned Producer2) { 394 if (Consumer == Producer) 395 return true; 396 if (Consumer == Producer2) 397 return true; 398 // Calculate if we're a single vector consumer referencing a double producer 399 if (Producer >= Hexagon::W0 && Producer <= Hexagon::W15) 400 if (Consumer >= Hexagon::V0 && Consumer <= Hexagon::V31) 401 return ((Consumer - Hexagon::V0) >> 1) == (Producer - Hexagon::W0); 402 return false; 403 } 404 405 /// EncodeSingleInstruction - Emit a single 406 void HexagonMCCodeEmitter::EncodeSingleInstruction(const MCInst &MI, 407 raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups, 408 const MCSubtargetInfo &STI, uint32_t Parse) const { 409 assert(!HexagonMCInstrInfo::isBundle(MI)); 410 uint64_t Binary; 411 412 // Pseudo instructions don't get encoded and shouldn't be here 413 // in the first place! 414 assert(!HexagonMCInstrInfo::getDesc(MCII, MI).isPseudo() && 415 "pseudo-instruction found"); 416 LLVM_DEBUG(dbgs() << "Encoding insn `" 417 << HexagonMCInstrInfo::getName(MCII, MI) << "'\n"); 418 419 Binary = getBinaryCodeForInstr(MI, Fixups, STI); 420 unsigned Opc = MI.getOpcode(); 421 422 // Check for unimplemented instructions. Immediate extenders 423 // are encoded as zero, so they need to be accounted for. 424 if (!Binary && Opc != DuplexIClass0 && Opc != A4_ext) { 425 LLVM_DEBUG(dbgs() << "Unimplemented inst `" 426 << HexagonMCInstrInfo::getName(MCII, MI) << "'\n"); 427 llvm_unreachable("Unimplemented Instruction"); 428 } 429 Binary |= Parse; 430 431 // if we need to emit a duplexed instruction 432 if (Opc >= Hexagon::DuplexIClass0 && Opc <= Hexagon::DuplexIClassF) { 433 assert(Parse == HexagonII::INST_PARSE_DUPLEX && 434 "Emitting duplex without duplex parse bits"); 435 unsigned DupIClass = MI.getOpcode() - Hexagon::DuplexIClass0; 436 // 29 is the bit position. 437 // 0b1110 =0xE bits are masked off and down shifted by 1 bit. 438 // Last bit is moved to bit position 13 439 Binary = ((DupIClass & 0xE) << (29 - 1)) | ((DupIClass & 0x1) << 13); 440 441 const MCInst *Sub0 = MI.getOperand(0).getInst(); 442 const MCInst *Sub1 = MI.getOperand(1).getInst(); 443 444 // Get subinstruction slot 0. 445 unsigned SubBits0 = getBinaryCodeForInstr(*Sub0, Fixups, STI); 446 // Get subinstruction slot 1. 447 State.SubInst1 = true; 448 unsigned SubBits1 = getBinaryCodeForInstr(*Sub1, Fixups, STI); 449 State.SubInst1 = false; 450 451 Binary |= SubBits0 | (SubBits1 << 16); 452 } 453 support::endian::write<uint32_t>(OS, Binary, support::little); 454 ++MCNumEmitted; 455 } 456 457 LLVM_ATTRIBUTE_NORETURN 458 static void raise_relocation_error(unsigned Width, unsigned Kind) { 459 std::string Text; 460 raw_string_ostream Stream(Text); 461 Stream << "Unrecognized relocation combination: width=" << Width 462 << " kind=" << Kind; 463 report_fatal_error(Stream.str()); 464 } 465 466 /// Some insns are not extended and thus have no bits. These cases require 467 /// a more brute force method for determining the correct relocation. 468 Hexagon::Fixups HexagonMCCodeEmitter::getFixupNoBits( 469 MCInstrInfo const &MCII, const MCInst &MI, const MCOperand &MO, 470 const MCSymbolRefExpr::VariantKind VarKind) const { 471 const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI); 472 unsigned InsnType = HexagonMCInstrInfo::getType(MCII, MI); 473 using namespace Hexagon; 474 475 if (InsnType == HexagonII::TypeEXTENDER) { 476 if (VarKind == MCSymbolRefExpr::VK_None) { 477 auto Instrs = HexagonMCInstrInfo::bundleInstructions(*State.Bundle); 478 for (auto I = Instrs.begin(), N = Instrs.end(); I != N; ++I) { 479 if (I->getInst() != &MI) 480 continue; 481 assert(I+1 != N && "Extender cannot be last in packet"); 482 const MCInst &NextI = *(I+1)->getInst(); 483 const MCInstrDesc &NextD = HexagonMCInstrInfo::getDesc(MCII, NextI); 484 if (NextD.isBranch() || NextD.isCall() || 485 HexagonMCInstrInfo::getType(MCII, NextI) == HexagonII::TypeCR) 486 return fixup_Hexagon_B32_PCREL_X; 487 return fixup_Hexagon_32_6_X; 488 } 489 } 490 491 static const std::map<unsigned,unsigned> Relocs = { 492 { MCSymbolRefExpr::VK_GOTREL, fixup_Hexagon_GOTREL_32_6_X }, 493 { MCSymbolRefExpr::VK_GOT, fixup_Hexagon_GOT_32_6_X }, 494 { MCSymbolRefExpr::VK_TPREL, fixup_Hexagon_TPREL_32_6_X }, 495 { MCSymbolRefExpr::VK_DTPREL, fixup_Hexagon_DTPREL_32_6_X }, 496 { MCSymbolRefExpr::VK_Hexagon_GD_GOT, fixup_Hexagon_GD_GOT_32_6_X }, 497 { MCSymbolRefExpr::VK_Hexagon_LD_GOT, fixup_Hexagon_LD_GOT_32_6_X }, 498 { MCSymbolRefExpr::VK_Hexagon_IE, fixup_Hexagon_IE_32_6_X }, 499 { MCSymbolRefExpr::VK_Hexagon_IE_GOT, fixup_Hexagon_IE_GOT_32_6_X }, 500 { MCSymbolRefExpr::VK_Hexagon_PCREL, fixup_Hexagon_B32_PCREL_X }, 501 { MCSymbolRefExpr::VK_Hexagon_GD_PLT, fixup_Hexagon_GD_PLT_B32_PCREL_X }, 502 { MCSymbolRefExpr::VK_Hexagon_LD_PLT, fixup_Hexagon_LD_PLT_B32_PCREL_X }, 503 }; 504 505 auto F = Relocs.find(VarKind); 506 if (F != Relocs.end()) 507 return Hexagon::Fixups(F->second); 508 raise_relocation_error(0, VarKind); 509 } 510 511 if (MCID.isBranch()) 512 return fixup_Hexagon_B13_PCREL; 513 514 static const std::map<unsigned,unsigned> RelocsLo = { 515 { MCSymbolRefExpr::VK_GOT, fixup_Hexagon_GOT_LO16 }, 516 { MCSymbolRefExpr::VK_GOTREL, fixup_Hexagon_GOTREL_LO16 }, 517 { MCSymbolRefExpr::VK_Hexagon_GD_GOT, fixup_Hexagon_GD_GOT_LO16 }, 518 { MCSymbolRefExpr::VK_Hexagon_LD_GOT, fixup_Hexagon_LD_GOT_LO16 }, 519 { MCSymbolRefExpr::VK_Hexagon_IE, fixup_Hexagon_IE_LO16 }, 520 { MCSymbolRefExpr::VK_Hexagon_IE_GOT, fixup_Hexagon_IE_GOT_LO16 }, 521 { MCSymbolRefExpr::VK_TPREL, fixup_Hexagon_TPREL_LO16 }, 522 { MCSymbolRefExpr::VK_DTPREL, fixup_Hexagon_DTPREL_LO16 }, 523 { MCSymbolRefExpr::VK_None, fixup_Hexagon_LO16 }, 524 }; 525 526 static const std::map<unsigned,unsigned> RelocsHi = { 527 { MCSymbolRefExpr::VK_GOT, fixup_Hexagon_GOT_HI16 }, 528 { MCSymbolRefExpr::VK_GOTREL, fixup_Hexagon_GOTREL_HI16 }, 529 { MCSymbolRefExpr::VK_Hexagon_GD_GOT, fixup_Hexagon_GD_GOT_HI16 }, 530 { MCSymbolRefExpr::VK_Hexagon_LD_GOT, fixup_Hexagon_LD_GOT_HI16 }, 531 { MCSymbolRefExpr::VK_Hexagon_IE, fixup_Hexagon_IE_HI16 }, 532 { MCSymbolRefExpr::VK_Hexagon_IE_GOT, fixup_Hexagon_IE_GOT_HI16 }, 533 { MCSymbolRefExpr::VK_TPREL, fixup_Hexagon_TPREL_HI16 }, 534 { MCSymbolRefExpr::VK_DTPREL, fixup_Hexagon_DTPREL_HI16 }, 535 { MCSymbolRefExpr::VK_None, fixup_Hexagon_HI16 }, 536 }; 537 538 switch (MCID.getOpcode()) { 539 case Hexagon::LO: 540 case Hexagon::A2_tfril: { 541 auto F = RelocsLo.find(VarKind); 542 if (F != RelocsLo.end()) 543 return Hexagon::Fixups(F->second); 544 break; 545 } 546 case Hexagon::HI: 547 case Hexagon::A2_tfrih: { 548 auto F = RelocsHi.find(VarKind); 549 if (F != RelocsHi.end()) 550 return Hexagon::Fixups(F->second); 551 break; 552 } 553 } 554 555 raise_relocation_error(0, VarKind); 556 } 557 558 static bool isPCRel(unsigned Kind) { 559 switch (Kind){ 560 case fixup_Hexagon_B22_PCREL: 561 case fixup_Hexagon_B15_PCREL: 562 case fixup_Hexagon_B7_PCREL: 563 case fixup_Hexagon_B13_PCREL: 564 case fixup_Hexagon_B9_PCREL: 565 case fixup_Hexagon_B32_PCREL_X: 566 case fixup_Hexagon_B22_PCREL_X: 567 case fixup_Hexagon_B15_PCREL_X: 568 case fixup_Hexagon_B13_PCREL_X: 569 case fixup_Hexagon_B9_PCREL_X: 570 case fixup_Hexagon_B7_PCREL_X: 571 case fixup_Hexagon_32_PCREL: 572 case fixup_Hexagon_PLT_B22_PCREL: 573 case fixup_Hexagon_GD_PLT_B22_PCREL: 574 case fixup_Hexagon_LD_PLT_B22_PCREL: 575 case fixup_Hexagon_GD_PLT_B22_PCREL_X: 576 case fixup_Hexagon_LD_PLT_B22_PCREL_X: 577 case fixup_Hexagon_6_PCREL_X: 578 return true; 579 default: 580 return false; 581 } 582 } 583 584 unsigned HexagonMCCodeEmitter::getExprOpValue(const MCInst &MI, 585 const MCOperand &MO, const MCExpr *ME, SmallVectorImpl<MCFixup> &Fixups, 586 const MCSubtargetInfo &STI) const { 587 if (isa<HexagonMCExpr>(ME)) 588 ME = &HexagonMCInstrInfo::getExpr(*ME); 589 int64_t Value; 590 if (ME->evaluateAsAbsolute(Value)) { 591 bool InstExtendable = HexagonMCInstrInfo::isExtendable(MCII, MI) || 592 HexagonMCInstrInfo::isExtended(MCII, MI); 593 // Only sub-instruction #1 can be extended in a duplex. If MI is a 594 // sub-instruction #0, it is not extended even if Extended is true 595 // (it can be true for the duplex as a whole). 596 bool IsSub0 = HexagonMCInstrInfo::isSubInstruction(MI) && !State.SubInst1; 597 if (State.Extended && InstExtendable && !IsSub0) { 598 unsigned OpIdx = ~0u; 599 for (unsigned I = 0, E = MI.getNumOperands(); I != E; ++I) { 600 if (&MO != &MI.getOperand(I)) 601 continue; 602 OpIdx = I; 603 break; 604 } 605 assert(OpIdx != ~0u); 606 if (OpIdx == HexagonMCInstrInfo::getExtendableOp(MCII, MI)) { 607 unsigned Shift = HexagonMCInstrInfo::getExtentAlignment(MCII, MI); 608 Value = (Value & 0x3f) << Shift; 609 } 610 } 611 return Value; 612 } 613 assert(ME->getKind() == MCExpr::SymbolRef || 614 ME->getKind() == MCExpr::Binary); 615 if (ME->getKind() == MCExpr::Binary) { 616 MCBinaryExpr const *Binary = cast<MCBinaryExpr>(ME); 617 getExprOpValue(MI, MO, Binary->getLHS(), Fixups, STI); 618 getExprOpValue(MI, MO, Binary->getRHS(), Fixups, STI); 619 return 0; 620 } 621 622 unsigned FixupKind = fixup_Invalid; 623 const MCSymbolRefExpr *MCSRE = static_cast<const MCSymbolRefExpr *>(ME); 624 const MCInstrDesc &MCID = HexagonMCInstrInfo::getDesc(MCII, MI); 625 unsigned FixupWidth = HexagonMCInstrInfo::getExtentBits(MCII, MI) - 626 HexagonMCInstrInfo::getExtentAlignment(MCII, MI); 627 MCSymbolRefExpr::VariantKind VarKind = MCSRE->getKind(); 628 unsigned Opc = MCID.getOpcode(); 629 unsigned IType = HexagonMCInstrInfo::getType(MCII, MI); 630 631 LLVM_DEBUG(dbgs() << "----------------------------------------\n" 632 << "Opcode Name: " << HexagonMCInstrInfo::getName(MCII, MI) 633 << "\nOpcode: " << Opc << "\nRelocation bits: " 634 << FixupWidth << "\nAddend: " << State.Addend 635 << "\nVariant: " << unsigned(VarKind) 636 << "\n----------------------------------------\n"); 637 638 // Pick the applicable fixup kind for the symbol. 639 // Handle special cases first, the rest will be looked up in the tables. 640 641 if (FixupWidth == 16 && !State.Extended) { 642 if (VarKind == MCSymbolRefExpr::VK_None) { 643 if (HexagonMCInstrInfo::s27_2_reloc(*MO.getExpr())) { 644 // A2_iconst. 645 FixupKind = Hexagon::fixup_Hexagon_27_REG; 646 } else { 647 // Look for GP-relative fixups. 648 unsigned Shift = HexagonMCInstrInfo::getExtentAlignment(MCII, MI); 649 static const Hexagon::Fixups GPRelFixups[] = { 650 Hexagon::fixup_Hexagon_GPREL16_0, Hexagon::fixup_Hexagon_GPREL16_1, 651 Hexagon::fixup_Hexagon_GPREL16_2, Hexagon::fixup_Hexagon_GPREL16_3 652 }; 653 assert(Shift < array_lengthof(GPRelFixups)); 654 auto UsesGP = [] (const MCInstrDesc &D) { 655 for (const MCPhysReg *U = D.getImplicitUses(); U && *U; ++U) 656 if (*U == Hexagon::GP) 657 return true; 658 return false; 659 }; 660 if (UsesGP(MCID)) 661 FixupKind = GPRelFixups[Shift]; 662 } 663 } else if (VarKind == MCSymbolRefExpr::VK_GOTREL) { 664 // Select between LO/HI. 665 if (Opc == Hexagon::LO) 666 FixupKind = Hexagon::fixup_Hexagon_GOTREL_LO16; 667 else if (Opc == Hexagon::HI) 668 FixupKind = Hexagon::fixup_Hexagon_GOTREL_HI16; 669 } 670 } else { 671 bool BranchOrCR = MCID.isBranch() || IType == HexagonII::TypeCR; 672 switch (FixupWidth) { 673 case 9: 674 if (BranchOrCR) 675 FixupKind = State.Extended ? Hexagon::fixup_Hexagon_B9_PCREL_X 676 : Hexagon::fixup_Hexagon_B9_PCREL; 677 break; 678 case 8: 679 case 7: 680 if (State.Extended && VarKind == MCSymbolRefExpr::VK_GOT) 681 FixupKind = HexagonMCInstrInfo::isExtentSigned(MCII, MI) 682 ? Hexagon::fixup_Hexagon_GOT_16_X 683 : Hexagon::fixup_Hexagon_GOT_11_X; 684 else if (FixupWidth == 7 && BranchOrCR) 685 FixupKind = State.Extended ? Hexagon::fixup_Hexagon_B7_PCREL_X 686 : Hexagon::fixup_Hexagon_B7_PCREL; 687 break; 688 case 0: 689 FixupKind = getFixupNoBits(MCII, MI, MO, VarKind); 690 break; 691 } 692 } 693 694 if (FixupKind == fixup_Invalid) { 695 const auto &FixupTable = State.Extended ? ExtFixups : StdFixups; 696 697 auto FindVK = FixupTable.find(VarKind); 698 if (FindVK != FixupTable.end()) 699 FixupKind = FindVK->second[FixupWidth]; 700 } 701 702 if (FixupKind == fixup_Invalid) 703 raise_relocation_error(FixupWidth, VarKind); 704 705 const MCExpr *FixupExpr = MO.getExpr(); 706 if (State.Addend != 0 && isPCRel(FixupKind)) { 707 const MCExpr *C = MCConstantExpr::create(State.Addend, MCT); 708 FixupExpr = MCBinaryExpr::createAdd(FixupExpr, C, MCT); 709 } 710 711 MCFixup Fixup = MCFixup::create(State.Addend, FixupExpr, 712 MCFixupKind(FixupKind), MI.getLoc()); 713 Fixups.push_back(Fixup); 714 // All of the information is in the fixup. 715 return 0; 716 } 717 718 unsigned 719 HexagonMCCodeEmitter::getMachineOpValue(MCInst const &MI, MCOperand const &MO, 720 SmallVectorImpl<MCFixup> &Fixups, 721 MCSubtargetInfo const &STI) const { 722 #ifndef NDEBUG 723 size_t OperandNumber = ~0U; 724 for (unsigned i = 0, n = MI.getNumOperands(); i < n; ++i) 725 if (&MI.getOperand(i) == &MO) { 726 OperandNumber = i; 727 break; 728 } 729 assert((OperandNumber != ~0U) && "Operand not found"); 730 #endif 731 732 if (HexagonMCInstrInfo::isNewValue(MCII, MI) && 733 &MO == &HexagonMCInstrInfo::getNewValueOperand(MCII, MI)) { 734 // Calculate the new value distance to the associated producer 735 unsigned SOffset = 0; 736 unsigned VOffset = 0; 737 unsigned UseReg = MO.getReg(); 738 unsigned DefReg1, DefReg2; 739 740 auto Instrs = HexagonMCInstrInfo::bundleInstructions(*State.Bundle); 741 const MCOperand *I = Instrs.begin() + State.Index - 1; 742 743 for (;; --I) { 744 assert(I != Instrs.begin() - 1 && "Couldn't find producer"); 745 MCInst const &Inst = *I->getInst(); 746 if (HexagonMCInstrInfo::isImmext(Inst)) 747 continue; 748 749 DefReg1 = DefReg2 = 0; 750 ++SOffset; 751 if (HexagonMCInstrInfo::isVector(MCII, Inst)) { 752 // Vector instructions don't count scalars. 753 ++VOffset; 754 } 755 if (HexagonMCInstrInfo::hasNewValue(MCII, Inst)) 756 DefReg1 = HexagonMCInstrInfo::getNewValueOperand(MCII, Inst).getReg(); 757 if (HexagonMCInstrInfo::hasNewValue2(MCII, Inst)) 758 DefReg2 = HexagonMCInstrInfo::getNewValueOperand2(MCII, Inst).getReg(); 759 if (!RegisterMatches(UseReg, DefReg1, DefReg2)) { 760 // This isn't the register we're looking for 761 continue; 762 } 763 if (!HexagonMCInstrInfo::isPredicated(MCII, Inst)) { 764 // Producer is unpredicated 765 break; 766 } 767 assert(HexagonMCInstrInfo::isPredicated(MCII, MI) && 768 "Unpredicated consumer depending on predicated producer"); 769 if (HexagonMCInstrInfo::isPredicatedTrue(MCII, Inst) == 770 HexagonMCInstrInfo::isPredicatedTrue(MCII, MI)) 771 // Producer predicate sense matched ours. 772 break; 773 } 774 // Hexagon PRM 10.11 Construct Nt from distance 775 unsigned Offset = HexagonMCInstrInfo::isVector(MCII, MI) ? VOffset 776 : SOffset; 777 Offset <<= 1; 778 Offset |= HexagonMCInstrInfo::SubregisterBit(UseReg, DefReg1, DefReg2); 779 return Offset; 780 } 781 782 assert(!MO.isImm()); 783 if (MO.isReg()) { 784 unsigned Reg = MO.getReg(); 785 if (HexagonMCInstrInfo::isSubInstruction(MI) || 786 HexagonMCInstrInfo::getType(MCII, MI) == HexagonII::TypeCJ) 787 return HexagonMCInstrInfo::getDuplexRegisterNumbering(Reg); 788 return MCT.getRegisterInfo()->getEncodingValue(Reg); 789 } 790 791 return getExprOpValue(MI, MO, MO.getExpr(), Fixups, STI); 792 } 793 794 MCCodeEmitter *llvm::createHexagonMCCodeEmitter(MCInstrInfo const &MII, 795 MCRegisterInfo const &MRI, 796 MCContext &MCT) { 797 return new HexagonMCCodeEmitter(MII, MCT); 798 } 799 800 #define ENABLE_INSTR_PREDICATE_VERIFIER 801 #include "HexagonGenMCCodeEmitter.inc" 802