| 1 | //=- LoongArchInstrInfo.cpp - LoongArch Instruction Information -*- C++ -*-===// |
| 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 | // This file contains the LoongArch implementation of the TargetInstrInfo class. |
| 10 | // |
| 11 | //===----------------------------------------------------------------------===// |
| 12 | |
| 13 | #include "LoongArchInstrInfo.h" |
| 14 | #include "LoongArch.h" |
| 15 | #include "LoongArchMachineFunctionInfo.h" |
| 16 | #include "LoongArchRegisterInfo.h" |
| 17 | #include "MCTargetDesc/LoongArchMCTargetDesc.h" |
| 18 | #include "MCTargetDesc/LoongArchMatInt.h" |
| 19 | #include "llvm/CodeGen/RegisterScavenging.h" |
| 20 | #include "llvm/CodeGen/StackMaps.h" |
| 21 | #include "llvm/MC/MCContext.h" |
| 22 | #include "llvm/MC/MCInstBuilder.h" |
| 23 | #include "llvm/Support/CommandLine.h" |
| 24 | |
| 25 | using namespace llvm; |
| 26 | |
| 27 | static cl::opt<bool> DisableRelocSched( |
| 28 | "loongarch-disable-reloc-sched" , |
| 29 | cl::desc("Disable scheduling of instructions with target flags" ), |
| 30 | cl::init(Val: false), cl::Hidden); |
| 31 | |
| 32 | #define GET_INSTRINFO_CTOR_DTOR |
| 33 | #include "LoongArchGenInstrInfo.inc" |
| 34 | |
| 35 | LoongArchInstrInfo::LoongArchInstrInfo(const LoongArchSubtarget &STI) |
| 36 | : LoongArchGenInstrInfo(STI, RegInfo, LoongArch::ADJCALLSTACKDOWN, |
| 37 | LoongArch::ADJCALLSTACKUP), |
| 38 | RegInfo(STI.getHwMode()), STI(STI) {} |
| 39 | |
| 40 | MCInst LoongArchInstrInfo::getNop() const { |
| 41 | return MCInstBuilder(LoongArch::ANDI) |
| 42 | .addReg(Reg: LoongArch::R0) |
| 43 | .addReg(Reg: LoongArch::R0) |
| 44 | .addImm(Val: 0); |
| 45 | } |
| 46 | |
| 47 | void LoongArchInstrInfo::copyPhysReg(MachineBasicBlock &MBB, |
| 48 | MachineBasicBlock::iterator MBBI, |
| 49 | const DebugLoc &DL, Register DstReg, |
| 50 | Register SrcReg, bool KillSrc, |
| 51 | bool RenamableDest, |
| 52 | bool RenamableSrc) const { |
| 53 | if (LoongArch::GPRRegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 54 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::OR), DestReg: DstReg) |
| 55 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)) |
| 56 | .addReg(RegNo: LoongArch::R0); |
| 57 | return; |
| 58 | } |
| 59 | |
| 60 | // VR->VR copies. |
| 61 | if (LoongArch::LSX128RegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 62 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::VORI_B), DestReg: DstReg) |
| 63 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)) |
| 64 | .addImm(Val: 0); |
| 65 | return; |
| 66 | } |
| 67 | |
| 68 | // XR->XR copies. |
| 69 | if (LoongArch::LASX256RegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 70 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::XVORI_B), DestReg: DstReg) |
| 71 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)) |
| 72 | .addImm(Val: 0); |
| 73 | return; |
| 74 | } |
| 75 | |
| 76 | // GPR->CFR copy. |
| 77 | if (LoongArch::CFRRegClass.contains(Reg: DstReg) && |
| 78 | LoongArch::GPRRegClass.contains(Reg: SrcReg)) { |
| 79 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::MOVGR2CF), DestReg: DstReg) |
| 80 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)); |
| 81 | return; |
| 82 | } |
| 83 | // CFR->GPR copy. |
| 84 | if (LoongArch::GPRRegClass.contains(Reg: DstReg) && |
| 85 | LoongArch::CFRRegClass.contains(Reg: SrcReg)) { |
| 86 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::MOVCF2GR), DestReg: DstReg) |
| 87 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)); |
| 88 | return; |
| 89 | } |
| 90 | // CFR->CFR copy. |
| 91 | if (LoongArch::CFRRegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 92 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: LoongArch::PseudoCopyCFR), DestReg: DstReg) |
| 93 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)); |
| 94 | return; |
| 95 | } |
| 96 | |
| 97 | // FPR->FPR copies. |
| 98 | unsigned Opc; |
| 99 | if (LoongArch::FPR32RegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 100 | Opc = LoongArch::FMOV_S; |
| 101 | } else if (LoongArch::FPR64RegClass.contains(Reg1: DstReg, Reg2: SrcReg)) { |
| 102 | Opc = LoongArch::FMOV_D; |
| 103 | } else if (LoongArch::GPRRegClass.contains(Reg: DstReg) && |
| 104 | LoongArch::FPR32RegClass.contains(Reg: SrcReg)) { |
| 105 | // FPR32 -> GPR copies |
| 106 | Opc = LoongArch::MOVFR2GR_S; |
| 107 | } else if (LoongArch::GPRRegClass.contains(Reg: DstReg) && |
| 108 | LoongArch::FPR64RegClass.contains(Reg: SrcReg)) { |
| 109 | // FPR64 -> GPR copies |
| 110 | Opc = LoongArch::MOVFR2GR_D; |
| 111 | } else { |
| 112 | // TODO: support other copies. |
| 113 | llvm_unreachable("Impossible reg-to-reg copy" ); |
| 114 | } |
| 115 | |
| 116 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: Opc), DestReg: DstReg) |
| 117 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: KillSrc)); |
| 118 | } |
| 119 | |
| 120 | void LoongArchInstrInfo::storeRegToStackSlot( |
| 121 | MachineBasicBlock &MBB, MachineBasicBlock::iterator I, Register SrcReg, |
| 122 | bool IsKill, int FI, const TargetRegisterClass *RC, |
| 123 | |
| 124 | Register VReg, MachineInstr::MIFlag Flags) const { |
| 125 | MachineFunction *MF = MBB.getParent(); |
| 126 | MachineFrameInfo &MFI = MF->getFrameInfo(); |
| 127 | |
| 128 | unsigned Opcode; |
| 129 | if (LoongArch::GPRRegClass.hasSubClassEq(RC)) |
| 130 | Opcode = TRI.getRegSizeInBits(RC: LoongArch::GPRRegClass) == 32 |
| 131 | ? LoongArch::ST_W |
| 132 | : LoongArch::ST_D; |
| 133 | else if (LoongArch::FPR32RegClass.hasSubClassEq(RC)) |
| 134 | Opcode = LoongArch::FST_S; |
| 135 | else if (LoongArch::FPR64RegClass.hasSubClassEq(RC)) |
| 136 | Opcode = LoongArch::FST_D; |
| 137 | else if (LoongArch::LSX128RegClass.hasSubClassEq(RC)) |
| 138 | Opcode = LoongArch::VST; |
| 139 | else if (LoongArch::LASX256RegClass.hasSubClassEq(RC)) |
| 140 | Opcode = LoongArch::XVST; |
| 141 | else if (LoongArch::CFRRegClass.hasSubClassEq(RC)) |
| 142 | Opcode = LoongArch::PseudoST_CFR; |
| 143 | else |
| 144 | llvm_unreachable("Can't store this register to stack slot" ); |
| 145 | |
| 146 | MachineMemOperand *MMO = MF->getMachineMemOperand( |
| 147 | PtrInfo: MachinePointerInfo::getFixedStack(MF&: *MF, FI), F: MachineMemOperand::MOStore, |
| 148 | Size: MFI.getObjectSize(ObjectIdx: FI), BaseAlignment: MFI.getObjectAlign(ObjectIdx: FI)); |
| 149 | |
| 150 | BuildMI(BB&: MBB, I, MIMD: DebugLoc(), MCID: get(Opcode)) |
| 151 | .addReg(RegNo: SrcReg, Flags: getKillRegState(B: IsKill)) |
| 152 | .addFrameIndex(Idx: FI) |
| 153 | .addImm(Val: 0) |
| 154 | .addMemOperand(MMO); |
| 155 | } |
| 156 | |
| 157 | void LoongArchInstrInfo::loadRegFromStackSlot( |
| 158 | MachineBasicBlock &MBB, MachineBasicBlock::iterator I, Register DstReg, |
| 159 | int FI, const TargetRegisterClass *RC, Register VReg, unsigned SubReg, |
| 160 | MachineInstr::MIFlag Flags) const { |
| 161 | MachineFunction *MF = MBB.getParent(); |
| 162 | MachineFrameInfo &MFI = MF->getFrameInfo(); |
| 163 | DebugLoc DL; |
| 164 | if (I != MBB.end()) |
| 165 | DL = I->getDebugLoc(); |
| 166 | |
| 167 | unsigned Opcode; |
| 168 | if (LoongArch::GPRRegClass.hasSubClassEq(RC)) |
| 169 | Opcode = RegInfo.getRegSizeInBits(RC: LoongArch::GPRRegClass) == 32 |
| 170 | ? LoongArch::LD_W |
| 171 | : LoongArch::LD_D; |
| 172 | else if (LoongArch::FPR32RegClass.hasSubClassEq(RC)) |
| 173 | Opcode = LoongArch::FLD_S; |
| 174 | else if (LoongArch::FPR64RegClass.hasSubClassEq(RC)) |
| 175 | Opcode = LoongArch::FLD_D; |
| 176 | else if (LoongArch::LSX128RegClass.hasSubClassEq(RC)) |
| 177 | Opcode = LoongArch::VLD; |
| 178 | else if (LoongArch::LASX256RegClass.hasSubClassEq(RC)) |
| 179 | Opcode = LoongArch::XVLD; |
| 180 | else if (LoongArch::CFRRegClass.hasSubClassEq(RC)) |
| 181 | Opcode = LoongArch::PseudoLD_CFR; |
| 182 | else |
| 183 | llvm_unreachable("Can't load this register from stack slot" ); |
| 184 | |
| 185 | MachineMemOperand *MMO = MF->getMachineMemOperand( |
| 186 | PtrInfo: MachinePointerInfo::getFixedStack(MF&: *MF, FI), F: MachineMemOperand::MOLoad, |
| 187 | Size: MFI.getObjectSize(ObjectIdx: FI), BaseAlignment: MFI.getObjectAlign(ObjectIdx: FI)); |
| 188 | |
| 189 | BuildMI(BB&: MBB, I, MIMD: DL, MCID: get(Opcode), DestReg: DstReg) |
| 190 | .addFrameIndex(Idx: FI) |
| 191 | .addImm(Val: 0) |
| 192 | .addMemOperand(MMO); |
| 193 | } |
| 194 | |
| 195 | Register LoongArchInstrInfo::isLoadFromStackSlot(const MachineInstr &MI, |
| 196 | int &FrameIndex) const { |
| 197 | TypeSize Dummy = TypeSize::getZero(); |
| 198 | return isLoadFromStackSlot(MI, FrameIndex, MemBytes&: Dummy); |
| 199 | } |
| 200 | |
| 201 | Register LoongArchInstrInfo::isLoadFromStackSlot(const MachineInstr &MI, |
| 202 | int &FrameIndex, |
| 203 | TypeSize &MemBytes) const { |
| 204 | switch (MI.getOpcode()) { |
| 205 | default: |
| 206 | return Register(); |
| 207 | case LoongArch::LD_W: |
| 208 | case LoongArch::FLD_S: |
| 209 | MemBytes = TypeSize::getFixed(ExactSize: 4); |
| 210 | break; |
| 211 | case LoongArch::LD_D: |
| 212 | case LoongArch::FLD_D: |
| 213 | MemBytes = TypeSize::getFixed(ExactSize: 8); |
| 214 | break; |
| 215 | case LoongArch::VLD: |
| 216 | MemBytes = TypeSize::getFixed(ExactSize: 16); |
| 217 | break; |
| 218 | case LoongArch::XVLD: |
| 219 | MemBytes = TypeSize::getFixed(ExactSize: 32); |
| 220 | break; |
| 221 | } |
| 222 | |
| 223 | if ((MI.getOperand(i: 1).isFI()) && // is a stack slot |
| 224 | (MI.getOperand(i: 2).isImm()) && // the imm is zero |
| 225 | (MI.getOperand(i: 2).getImm() == 0)) { |
| 226 | FrameIndex = MI.getOperand(i: 1).getIndex(); |
| 227 | return MI.getOperand(i: 0).getReg(); |
| 228 | } |
| 229 | |
| 230 | return Register(); |
| 231 | } |
| 232 | |
| 233 | Register LoongArchInstrInfo::isStoreToStackSlot(const MachineInstr &MI, |
| 234 | int &FrameIndex) const { |
| 235 | TypeSize Dummy = TypeSize::getZero(); |
| 236 | return isStoreToStackSlot(MI, FrameIndex, MemBytes&: Dummy); |
| 237 | } |
| 238 | |
| 239 | Register LoongArchInstrInfo::isStoreToStackSlot(const MachineInstr &MI, |
| 240 | int &FrameIndex, |
| 241 | TypeSize &MemBytes) const { |
| 242 | switch (MI.getOpcode()) { |
| 243 | default: |
| 244 | return Register(); |
| 245 | case LoongArch::ST_W: |
| 246 | case LoongArch::FST_S: |
| 247 | MemBytes = TypeSize::getFixed(ExactSize: 4); |
| 248 | break; |
| 249 | case LoongArch::ST_D: |
| 250 | case LoongArch::FST_D: |
| 251 | MemBytes = TypeSize::getFixed(ExactSize: 8); |
| 252 | break; |
| 253 | case LoongArch::VST: |
| 254 | MemBytes = TypeSize::getFixed(ExactSize: 16); |
| 255 | break; |
| 256 | case LoongArch::XVST: |
| 257 | MemBytes = TypeSize::getFixed(ExactSize: 32); |
| 258 | break; |
| 259 | } |
| 260 | |
| 261 | if ((MI.getOperand(i: 1).isFI()) && // is a stack slot |
| 262 | (MI.getOperand(i: 2).isImm()) && // the imm is zero |
| 263 | (MI.getOperand(i: 2).getImm() == 0)) { |
| 264 | FrameIndex = MI.getOperand(i: 1).getIndex(); |
| 265 | return MI.getOperand(i: 0).getReg(); |
| 266 | } |
| 267 | |
| 268 | return Register(); |
| 269 | } |
| 270 | |
| 271 | void LoongArchInstrInfo::movImm(MachineBasicBlock &MBB, |
| 272 | MachineBasicBlock::iterator MBBI, |
| 273 | const DebugLoc &DL, Register DstReg, |
| 274 | uint64_t Val, MachineInstr::MIFlag Flag) const { |
| 275 | Register SrcReg = LoongArch::R0; |
| 276 | |
| 277 | if (!STI.is64Bit() && !isInt<32>(x: Val)) |
| 278 | report_fatal_error(reason: "Should only materialize 32-bit constants for LA32" ); |
| 279 | |
| 280 | auto Seq = LoongArchMatInt::generateInstSeq(Val); |
| 281 | assert(!Seq.empty()); |
| 282 | |
| 283 | for (auto &Inst : Seq) { |
| 284 | switch (Inst.Opc) { |
| 285 | case LoongArch::LU12I_W: |
| 286 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: Inst.Opc), DestReg: DstReg) |
| 287 | .addImm(Val: Inst.Imm) |
| 288 | .setMIFlag(Flag); |
| 289 | break; |
| 290 | case LoongArch::ADDI_W: |
| 291 | case LoongArch::ORI: |
| 292 | case LoongArch::LU32I_D: // "rj" is needed due to InstrInfo pattern |
| 293 | case LoongArch::LU52I_D: |
| 294 | case LoongArch::SLLI_D: |
| 295 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: Inst.Opc), DestReg: DstReg) |
| 296 | .addReg(RegNo: SrcReg, Flags: RegState::Kill) |
| 297 | .addImm(Val: Inst.Imm) |
| 298 | .setMIFlag(Flag); |
| 299 | break; |
| 300 | case LoongArch::BSTRINS_D: |
| 301 | BuildMI(BB&: MBB, I: MBBI, MIMD: DL, MCID: get(Opcode: Inst.Opc), DestReg: DstReg) |
| 302 | .addReg(RegNo: SrcReg, Flags: RegState::Kill) |
| 303 | .addReg(RegNo: SrcReg, Flags: RegState::Kill) |
| 304 | .addImm(Val: Inst.Imm >> 32) |
| 305 | .addImm(Val: Inst.Imm & 0xFF) |
| 306 | .setMIFlag(Flag); |
| 307 | break; |
| 308 | default: |
| 309 | assert(false && "Unknown insn emitted by LoongArchMatInt" ); |
| 310 | } |
| 311 | |
| 312 | // Only the first instruction has $zero as its source. |
| 313 | SrcReg = DstReg; |
| 314 | } |
| 315 | } |
| 316 | |
| 317 | unsigned LoongArchInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const { |
| 318 | unsigned Opcode = MI.getOpcode(); |
| 319 | |
| 320 | if (Opcode == TargetOpcode::INLINEASM || |
| 321 | Opcode == TargetOpcode::INLINEASM_BR) { |
| 322 | const MachineFunction *MF = MI.getParent()->getParent(); |
| 323 | const MCAsmInfo &MAI = MF->getTarget().getMCAsmInfo(); |
| 324 | return getInlineAsmLength(Str: MI.getOperand(i: 0).getSymbolName(), MAI); |
| 325 | } |
| 326 | |
| 327 | unsigned NumBytes = 0; |
| 328 | const MCInstrDesc &Desc = MI.getDesc(); |
| 329 | |
| 330 | // Size should be preferably set in |
| 331 | // llvm/lib/Target/LoongArch/LoongArch*InstrInfo.td (default case). |
| 332 | // Specific cases handle instructions of variable sizes. |
| 333 | switch (Desc.getOpcode()) { |
| 334 | default: |
| 335 | return Desc.getSize(); |
| 336 | case TargetOpcode::STATEPOINT: |
| 337 | NumBytes = StatepointOpers(&MI).getNumPatchBytes(); |
| 338 | assert(NumBytes % 4 == 0 && "Invalid number of NOP bytes requested!" ); |
| 339 | // No patch bytes means a normal call inst (i.e. `bl`) is emitted. |
| 340 | if (NumBytes == 0) |
| 341 | NumBytes = 4; |
| 342 | break; |
| 343 | case TargetOpcode::PATCHABLE_FUNCTION_ENTER: { |
| 344 | const MachineFunction *MF = MI.getParent()->getParent(); |
| 345 | const Function &F = MF->getFunction(); |
| 346 | if (F.hasFnAttribute(Kind: "patchable-function-entry" )) { |
| 347 | unsigned Num = |
| 348 | F.getFnAttributeAsParsedInteger(Kind: "patchable-function-entry" ); |
| 349 | return Num * 4; |
| 350 | } |
| 351 | [[fallthrough]]; |
| 352 | } |
| 353 | case TargetOpcode::PATCHABLE_FUNCTION_EXIT: |
| 354 | case TargetOpcode::PATCHABLE_TAIL_CALL: |
| 355 | // Size of xray sled (branch + 11 nops). |
| 356 | return 12 * 4; |
| 357 | case TargetOpcode::BUNDLE: |
| 358 | return getInstBundleSize(MI); |
| 359 | } |
| 360 | return NumBytes; |
| 361 | } |
| 362 | |
| 363 | bool LoongArchInstrInfo::isAsCheapAsAMove(const MachineInstr &MI) const { |
| 364 | const unsigned Opcode = MI.getOpcode(); |
| 365 | switch (Opcode) { |
| 366 | default: |
| 367 | break; |
| 368 | case LoongArch::ADDI_D: |
| 369 | case LoongArch::ORI: |
| 370 | case LoongArch::XORI: |
| 371 | return (MI.getOperand(i: 1).isReg() && |
| 372 | MI.getOperand(i: 1).getReg() == LoongArch::R0) || |
| 373 | (MI.getOperand(i: 2).isImm() && MI.getOperand(i: 2).getImm() == 0); |
| 374 | } |
| 375 | return MI.isAsCheapAsAMove(); |
| 376 | } |
| 377 | |
| 378 | static bool isJumpTableLoad(const MachineInstr &MI) { |
| 379 | return any_of(Range: MI.memoperands(), P: [](const MachineMemOperand *MMO) { |
| 380 | const PseudoSourceValue *PSV = MMO->getPseudoValue(); |
| 381 | return PSV && PSV->isJumpTable(); |
| 382 | }); |
| 383 | } |
| 384 | |
| 385 | // Return the index of the jump table whose address |
| 386 | // (or an entry loaded from it) is held in Reg, or -1. |
| 387 | static int getJumpTableIndexFromReg(const MachineRegisterInfo &MRI, |
| 388 | Register Reg) { |
| 389 | if (!Reg.isVirtual()) |
| 390 | return -1; |
| 391 | const MachineInstr *MI = MRI.getUniqueVRegDef(Reg); |
| 392 | if (!MI) |
| 393 | return -1; |
| 394 | |
| 395 | int JTI; |
| 396 | switch (MI->getOpcode()) { |
| 397 | case LoongArch::ADDI_D: |
| 398 | case LoongArch::ADDI_W: |
| 399 | case LoongArch::PseudoLA_PCREL: |
| 400 | for (const MachineOperand &MO : MI->operands()) |
| 401 | if (MO.isJTI()) |
| 402 | return MO.getIndex(); |
| 403 | return -1; |
| 404 | case LoongArch::LDX_D: |
| 405 | case LoongArch::LDX_W: |
| 406 | // Normally, NonFIBaseAddr is corresponding to register $rj. |
| 407 | JTI = getJumpTableIndexFromReg(MRI, Reg: MI->getOperand(i: 1).getReg()); |
| 408 | if (JTI >= 0) |
| 409 | return JTI; |
| 410 | JTI = getJumpTableIndexFromReg(MRI, Reg: MI->getOperand(i: 2).getReg()); |
| 411 | if (JTI >= 0) |
| 412 | return JTI; |
| 413 | break; |
| 414 | default: |
| 415 | return -1; |
| 416 | } |
| 417 | |
| 418 | return -1; |
| 419 | } |
| 420 | |
| 421 | // LA32 do not support register offset load instrunctions (LDX), |
| 422 | // so add another layer to get jump table address. |
| 423 | static int getJumpTableIndexFromLoadAddr(const MachineRegisterInfo &MRI, |
| 424 | Register Reg) { |
| 425 | if (!Reg.isVirtual()) |
| 426 | return -1; |
| 427 | const MachineInstr *MI = MRI.getUniqueVRegDef(Reg); |
| 428 | if (!MI) |
| 429 | return -1; |
| 430 | |
| 431 | int JTI; |
| 432 | switch (MI->getOpcode()) { |
| 433 | case LoongArch::ADD_W: |
| 434 | JTI = getJumpTableIndexFromReg(MRI, Reg: MI->getOperand(i: 1).getReg()); |
| 435 | if (JTI >= 0) |
| 436 | return JTI; |
| 437 | JTI = getJumpTableIndexFromReg(MRI, Reg: MI->getOperand(i: 2).getReg()); |
| 438 | if (JTI >= 0) |
| 439 | return JTI; |
| 440 | break; |
| 441 | case LoongArch::ALSL_W: |
| 442 | // For la32s, address could only stores in register $rk. |
| 443 | return getJumpTableIndexFromReg(MRI, Reg: MI->getOperand(i: 2).getReg()); |
| 444 | } |
| 445 | |
| 446 | return -1; |
| 447 | } |
| 448 | |
| 449 | // Recursively search for %jump-table.N starting from PseudoBRIND, |
| 450 | // and return the index of &jump-table.N |
| 451 | // |
| 452 | // One common jump table: |
| 453 | // |
| 454 | // %base = PseudoLA_PCREL %jump-table.N |
| 455 | // %off = LDX_W %base, %index |
| 456 | // %tgt = ADD_D %base, %off |
| 457 | // %PseudoBRIND %tgt, 0 |
| 458 | // |
| 459 | int LoongArchInstrInfo::getJumpTableIndex(const MachineInstr &MI) const { |
| 460 | if (MI.getOpcode() != LoongArch::PseudoBRIND) |
| 461 | return -1; |
| 462 | |
| 463 | Register Reg = MI.getOperand(i: 0).getReg(); |
| 464 | if (!Reg.isVirtual()) |
| 465 | return -1; |
| 466 | |
| 467 | const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo(); |
| 468 | MachineInstr *Def = MRI.getUniqueVRegDef(Reg); |
| 469 | if (!Def) |
| 470 | return -1; |
| 471 | |
| 472 | int JTI; |
| 473 | switch (Def->getOpcode()) { |
| 474 | case LoongArch::LD_W: |
| 475 | if (!isJumpTableLoad(MI: *Def)) |
| 476 | return -1; |
| 477 | |
| 478 | JTI = getJumpTableIndexFromLoadAddr(MRI, Reg: Def->getOperand(i: 1).getReg()); |
| 479 | if (JTI >= 0) |
| 480 | return JTI; |
| 481 | break; |
| 482 | case LoongArch::ADD_D: |
| 483 | case LoongArch::ADD_W: |
| 484 | JTI = getJumpTableIndexFromReg(MRI, Reg: Def->getOperand(i: 1).getReg()); |
| 485 | if (JTI >= 0) |
| 486 | return JTI; |
| 487 | return getJumpTableIndexFromReg(MRI, Reg: Def->getOperand(i: 2).getReg()); |
| 488 | } |
| 489 | |
| 490 | return getJumpTableIndexFromReg(MRI, Reg); |
| 491 | } |
| 492 | |
| 493 | bool LoongArchInstrInfo::isAssociativeAndCommutative(const MachineInstr &Inst, |
| 494 | bool Invert) const { |
| 495 | unsigned Opc = Inst.getOpcode(); |
| 496 | if (Invert) { |
| 497 | auto InverseOpcode = getInverseOpcode(Opcode: Opc); |
| 498 | if (!InverseOpcode) |
| 499 | return false; |
| 500 | Opc = *InverseOpcode; |
| 501 | } |
| 502 | |
| 503 | switch (Opc) { |
| 504 | default: |
| 505 | return false; |
| 506 | case LoongArch::FADD_S: |
| 507 | case LoongArch::FADD_D: |
| 508 | case LoongArch::FMUL_S: |
| 509 | case LoongArch::FMUL_D: |
| 510 | case LoongArch::VFADD_S: |
| 511 | case LoongArch::VFADD_D: |
| 512 | case LoongArch::VFMUL_S: |
| 513 | case LoongArch::VFMUL_D: |
| 514 | case LoongArch::XVFADD_S: |
| 515 | case LoongArch::XVFADD_D: |
| 516 | case LoongArch::XVFMUL_S: |
| 517 | case LoongArch::XVFMUL_D: |
| 518 | return Inst.getFlag(Flag: MachineInstr::MIFlag::FmReassoc) && |
| 519 | Inst.getFlag(Flag: MachineInstr::MIFlag::FmNsz); |
| 520 | // IEEE 754-2008 minNum/maxNum: an sNaN operand yields qNaN, which breaks |
| 521 | // associativity (min(min(3,sNaN),1) = 1 but min(3,min(sNaN,1)) = 3). |
| 522 | // Signed zeros are ordered (-0 < +0) and the result is exact, so no |
| 523 | // reassoc/nsz requirement. |
| 524 | case LoongArch::FMIN_S: |
| 525 | case LoongArch::FMIN_D: |
| 526 | case LoongArch::FMAX_S: |
| 527 | case LoongArch::FMAX_D: |
| 528 | case LoongArch::VFMIN_S: |
| 529 | case LoongArch::VFMIN_D: |
| 530 | case LoongArch::VFMAX_S: |
| 531 | case LoongArch::VFMAX_D: |
| 532 | case LoongArch::XVFMIN_S: |
| 533 | case LoongArch::XVFMIN_D: |
| 534 | case LoongArch::XVFMAX_S: |
| 535 | case LoongArch::XVFMAX_D: |
| 536 | return Inst.getFlag(Flag: MachineInstr::MIFlag::FmNoNans); |
| 537 | case LoongArch::ADD_D: |
| 538 | case LoongArch::ADD_W: |
| 539 | case LoongArch::AND: |
| 540 | case LoongArch::OR: |
| 541 | case LoongArch::XOR: |
| 542 | case LoongArch::MUL_D: |
| 543 | case LoongArch::MUL_W: |
| 544 | case LoongArch::VADD_B: |
| 545 | case LoongArch::VADD_H: |
| 546 | case LoongArch::VADD_W: |
| 547 | case LoongArch::VADD_D: |
| 548 | case LoongArch::VMUL_B: |
| 549 | case LoongArch::VMUL_H: |
| 550 | case LoongArch::VMUL_W: |
| 551 | case LoongArch::VMUL_D: |
| 552 | case LoongArch::VAND_V: |
| 553 | case LoongArch::VOR_V: |
| 554 | case LoongArch::VXOR_V: |
| 555 | case LoongArch::VMIN_B: |
| 556 | case LoongArch::VMIN_H: |
| 557 | case LoongArch::VMIN_W: |
| 558 | case LoongArch::VMIN_D: |
| 559 | case LoongArch::VMIN_BU: |
| 560 | case LoongArch::VMIN_HU: |
| 561 | case LoongArch::VMIN_WU: |
| 562 | case LoongArch::VMIN_DU: |
| 563 | case LoongArch::VMAX_B: |
| 564 | case LoongArch::VMAX_H: |
| 565 | case LoongArch::VMAX_W: |
| 566 | case LoongArch::VMAX_D: |
| 567 | case LoongArch::VMAX_BU: |
| 568 | case LoongArch::VMAX_HU: |
| 569 | case LoongArch::VMAX_WU: |
| 570 | case LoongArch::VMAX_DU: |
| 571 | case LoongArch::XVADD_B: |
| 572 | case LoongArch::XVADD_H: |
| 573 | case LoongArch::XVADD_W: |
| 574 | case LoongArch::XVADD_D: |
| 575 | case LoongArch::XVMUL_B: |
| 576 | case LoongArch::XVMUL_H: |
| 577 | case LoongArch::XVMUL_W: |
| 578 | case LoongArch::XVMUL_D: |
| 579 | case LoongArch::XVAND_V: |
| 580 | case LoongArch::XVOR_V: |
| 581 | case LoongArch::XVXOR_V: |
| 582 | case LoongArch::XVMIN_B: |
| 583 | case LoongArch::XVMIN_H: |
| 584 | case LoongArch::XVMIN_W: |
| 585 | case LoongArch::XVMIN_D: |
| 586 | case LoongArch::XVMIN_BU: |
| 587 | case LoongArch::XVMIN_HU: |
| 588 | case LoongArch::XVMIN_WU: |
| 589 | case LoongArch::XVMIN_DU: |
| 590 | case LoongArch::XVMAX_B: |
| 591 | case LoongArch::XVMAX_H: |
| 592 | case LoongArch::XVMAX_W: |
| 593 | case LoongArch::XVMAX_D: |
| 594 | case LoongArch::XVMAX_BU: |
| 595 | case LoongArch::XVMAX_HU: |
| 596 | case LoongArch::XVMAX_WU: |
| 597 | case LoongArch::XVMAX_DU: |
| 598 | return true; |
| 599 | } |
| 600 | |
| 601 | return false; |
| 602 | } |
| 603 | |
| 604 | std::optional<unsigned> |
| 605 | LoongArchInstrInfo::getInverseOpcode(unsigned Opcode) const { |
| 606 | switch (Opcode) { |
| 607 | default: |
| 608 | return std::nullopt; |
| 609 | case LoongArch::ADD_W: |
| 610 | return LoongArch::SUB_W; |
| 611 | case LoongArch::ADD_D: |
| 612 | return LoongArch::SUB_D; |
| 613 | case LoongArch::SUB_W: |
| 614 | return LoongArch::ADD_W; |
| 615 | case LoongArch::SUB_D: |
| 616 | return LoongArch::ADD_D; |
| 617 | case LoongArch::FADD_S: |
| 618 | return LoongArch::FSUB_S; |
| 619 | case LoongArch::FADD_D: |
| 620 | return LoongArch::FSUB_D; |
| 621 | case LoongArch::FSUB_S: |
| 622 | return LoongArch::FADD_S; |
| 623 | case LoongArch::FSUB_D: |
| 624 | return LoongArch::FADD_D; |
| 625 | case LoongArch::VADD_B: |
| 626 | return LoongArch::VSUB_B; |
| 627 | case LoongArch::VADD_H: |
| 628 | return LoongArch::VSUB_H; |
| 629 | case LoongArch::VADD_W: |
| 630 | return LoongArch::VSUB_W; |
| 631 | case LoongArch::VADD_D: |
| 632 | return LoongArch::VSUB_D; |
| 633 | case LoongArch::VSUB_B: |
| 634 | return LoongArch::VADD_B; |
| 635 | case LoongArch::VSUB_H: |
| 636 | return LoongArch::VADD_H; |
| 637 | case LoongArch::VSUB_W: |
| 638 | return LoongArch::VADD_W; |
| 639 | case LoongArch::VSUB_D: |
| 640 | return LoongArch::VADD_D; |
| 641 | case LoongArch::VFADD_S: |
| 642 | return LoongArch::VFSUB_S; |
| 643 | case LoongArch::VFADD_D: |
| 644 | return LoongArch::VFSUB_D; |
| 645 | case LoongArch::VFSUB_S: |
| 646 | return LoongArch::VFADD_S; |
| 647 | case LoongArch::VFSUB_D: |
| 648 | return LoongArch::VFADD_D; |
| 649 | case LoongArch::XVADD_B: |
| 650 | return LoongArch::XVSUB_B; |
| 651 | case LoongArch::XVADD_H: |
| 652 | return LoongArch::XVSUB_H; |
| 653 | case LoongArch::XVADD_W: |
| 654 | return LoongArch::XVSUB_W; |
| 655 | case LoongArch::XVADD_D: |
| 656 | return LoongArch::XVSUB_D; |
| 657 | case LoongArch::XVSUB_B: |
| 658 | return LoongArch::XVADD_B; |
| 659 | case LoongArch::XVSUB_H: |
| 660 | return LoongArch::XVADD_H; |
| 661 | case LoongArch::XVSUB_W: |
| 662 | return LoongArch::XVADD_W; |
| 663 | case LoongArch::XVSUB_D: |
| 664 | return LoongArch::XVADD_D; |
| 665 | case LoongArch::XVFADD_S: |
| 666 | return LoongArch::XVFSUB_S; |
| 667 | case LoongArch::XVFADD_D: |
| 668 | return LoongArch::XVFSUB_D; |
| 669 | case LoongArch::XVFSUB_S: |
| 670 | return LoongArch::XVFADD_S; |
| 671 | case LoongArch::XVFSUB_D: |
| 672 | return LoongArch::XVFADD_D; |
| 673 | } |
| 674 | } |
| 675 | |
| 676 | MachineBasicBlock * |
| 677 | LoongArchInstrInfo::getBranchDestBlock(const MachineInstr &MI) const { |
| 678 | assert(MI.getDesc().isBranch() && "Unexpected opcode!" ); |
| 679 | // The branch target is always the last operand. |
| 680 | return MI.getOperand(i: MI.getNumExplicitOperands() - 1).getMBB(); |
| 681 | } |
| 682 | |
| 683 | static void parseCondBranch(MachineInstr &LastInst, MachineBasicBlock *&Target, |
| 684 | SmallVectorImpl<MachineOperand> &Cond) { |
| 685 | // Block ends with fall-through condbranch. |
| 686 | assert(LastInst.getDesc().isConditionalBranch() && |
| 687 | "Unknown conditional branch" ); |
| 688 | int NumOp = LastInst.getNumExplicitOperands(); |
| 689 | Target = LastInst.getOperand(i: NumOp - 1).getMBB(); |
| 690 | |
| 691 | Cond.push_back(Elt: MachineOperand::CreateImm(Val: LastInst.getOpcode())); |
| 692 | for (int i = 0; i < NumOp - 1; i++) |
| 693 | Cond.push_back(Elt: LastInst.getOperand(i)); |
| 694 | } |
| 695 | |
| 696 | bool LoongArchInstrInfo::analyzeBranch(MachineBasicBlock &MBB, |
| 697 | MachineBasicBlock *&TBB, |
| 698 | MachineBasicBlock *&FBB, |
| 699 | SmallVectorImpl<MachineOperand> &Cond, |
| 700 | bool AllowModify) const { |
| 701 | TBB = FBB = nullptr; |
| 702 | Cond.clear(); |
| 703 | |
| 704 | // If the block has no terminators, it just falls into the block after it. |
| 705 | MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr(); |
| 706 | if (I == MBB.end() || !isUnpredicatedTerminator(MI: *I)) |
| 707 | return false; |
| 708 | |
| 709 | // Count the number of terminators and find the first unconditional or |
| 710 | // indirect branch. |
| 711 | MachineBasicBlock::iterator FirstUncondOrIndirectBr = MBB.end(); |
| 712 | int NumTerminators = 0; |
| 713 | for (auto J = I.getReverse(); J != MBB.rend() && isUnpredicatedTerminator(MI: *J); |
| 714 | J++) { |
| 715 | NumTerminators++; |
| 716 | if (J->getDesc().isUnconditionalBranch() || |
| 717 | J->getDesc().isIndirectBranch()) { |
| 718 | FirstUncondOrIndirectBr = J.getReverse(); |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | // If AllowModify is true, we can erase any terminators after |
| 723 | // FirstUncondOrIndirectBR. |
| 724 | if (AllowModify && FirstUncondOrIndirectBr != MBB.end()) { |
| 725 | while (std::next(x: FirstUncondOrIndirectBr) != MBB.end()) { |
| 726 | std::next(x: FirstUncondOrIndirectBr)->eraseFromParent(); |
| 727 | NumTerminators--; |
| 728 | } |
| 729 | I = FirstUncondOrIndirectBr; |
| 730 | } |
| 731 | |
| 732 | // Handle a single unconditional branch. |
| 733 | if (NumTerminators == 1 && I->getDesc().isUnconditionalBranch()) { |
| 734 | TBB = getBranchDestBlock(MI: *I); |
| 735 | return false; |
| 736 | } |
| 737 | |
| 738 | // Handle a single conditional branch. |
| 739 | if (NumTerminators == 1 && I->getDesc().isConditionalBranch()) { |
| 740 | parseCondBranch(LastInst&: *I, Target&: TBB, Cond); |
| 741 | return false; |
| 742 | } |
| 743 | |
| 744 | // Handle a conditional branch followed by an unconditional branch. |
| 745 | if (NumTerminators == 2 && std::prev(x: I)->getDesc().isConditionalBranch() && |
| 746 | I->getDesc().isUnconditionalBranch()) { |
| 747 | parseCondBranch(LastInst&: *std::prev(x: I), Target&: TBB, Cond); |
| 748 | FBB = getBranchDestBlock(MI: *I); |
| 749 | return false; |
| 750 | } |
| 751 | |
| 752 | // Otherwise, we can't handle this. |
| 753 | return true; |
| 754 | } |
| 755 | |
| 756 | bool LoongArchInstrInfo::isBranchOffsetInRange(unsigned BranchOp, |
| 757 | int64_t BrOffset) const { |
| 758 | switch (BranchOp) { |
| 759 | default: |
| 760 | llvm_unreachable("Unknown branch instruction!" ); |
| 761 | case LoongArch::BEQ: |
| 762 | case LoongArch::BNE: |
| 763 | case LoongArch::BLT: |
| 764 | case LoongArch::BGE: |
| 765 | case LoongArch::BLTU: |
| 766 | case LoongArch::BGEU: |
| 767 | return isInt<18>(x: BrOffset); |
| 768 | case LoongArch::BEQZ: |
| 769 | case LoongArch::BNEZ: |
| 770 | case LoongArch::BCEQZ: |
| 771 | case LoongArch::BCNEZ: |
| 772 | return isInt<23>(x: BrOffset); |
| 773 | case LoongArch::B: |
| 774 | case LoongArch::PseudoBR: |
| 775 | return isInt<28>(x: BrOffset); |
| 776 | } |
| 777 | } |
| 778 | |
| 779 | bool LoongArchInstrInfo::isSafeToMove(const MachineInstr &MI, |
| 780 | const MachineBasicBlock *MBB, |
| 781 | const MachineFunction &MF) const { |
| 782 | if (DisableRelocSched) { |
| 783 | for (const MachineOperand &MO : MI.operands()) |
| 784 | if (MO.getTargetFlags()) |
| 785 | return false; |
| 786 | } |
| 787 | |
| 788 | auto MII = MI.getIterator(); |
| 789 | auto MIE = MBB->end(); |
| 790 | |
| 791 | // According to psABI v2.30: |
| 792 | // |
| 793 | // https://github.com/loongson/la-abi-specs/releases/tag/v2.30 |
| 794 | // |
| 795 | // The following instruction patterns are prohibited from being reordered: |
| 796 | // |
| 797 | // * pcalau12i $a0, %pc_hi20(s) |
| 798 | // addi.d $a1, $zero, %pc_lo12(s) |
| 799 | // lu32i.d $a1, %pc64_lo20(s) |
| 800 | // lu52i.d $a1, $a1, %pc64_hi12(s) |
| 801 | // |
| 802 | // * pcalau12i $a0, %got_pc_hi20(s) | %ld_pc_hi20(s) | %gd_pc_hi20(s) |
| 803 | // addi.d $a1, $zero, %got_pc_lo12(s) |
| 804 | // lu32i.d $a1, %got64_pc_lo20(s) |
| 805 | // lu52i.d $a1, $a1, %got64_pc_hi12(s) |
| 806 | // |
| 807 | // * pcalau12i $a0, %ie_pc_hi20(s) |
| 808 | // addi.d $a1, $zero, %ie_pc_lo12(s) |
| 809 | // lu32i.d $a1, %ie64_pc_lo20(s) |
| 810 | // lu52i.d $a1, $a1, %ie64_pc_hi12(s) |
| 811 | // |
| 812 | // * pcalau12i $a0, %desc_pc_hi20(s) |
| 813 | // addi.d $a1, $zero, %desc_pc_lo12(s) |
| 814 | // lu32i.d $a1, %desc64_pc_lo20(s) |
| 815 | // lu52i.d $a1, $a1, %desc64_pc_hi12(s) |
| 816 | // |
| 817 | // For simplicity, only pcalau12i and lu52i.d are marked as scheduling |
| 818 | // boundaries, and the instructions between them are guaranteed to be |
| 819 | // ordered according to data dependencies. |
| 820 | switch (MI.getOpcode()) { |
| 821 | case LoongArch::PCALAU12I: { |
| 822 | auto AddI = std::next(x: MII); |
| 823 | if (AddI == MIE || AddI->getOpcode() != LoongArch::ADDI_D) |
| 824 | break; |
| 825 | auto Lu32I = std::next(x: AddI); |
| 826 | if (Lu32I == MIE || Lu32I->getOpcode() != LoongArch::LU32I_D) |
| 827 | break; |
| 828 | auto MO0 = MI.getOperand(i: 1).getTargetFlags(); |
| 829 | auto MO1 = AddI->getOperand(i: 2).getTargetFlags(); |
| 830 | auto MO2 = Lu32I->getOperand(i: 2).getTargetFlags(); |
| 831 | if (MO0 == LoongArchII::MO_PCREL_HI && MO1 == LoongArchII::MO_PCREL_LO && |
| 832 | MO2 == LoongArchII::MO_PCREL64_LO) |
| 833 | return false; |
| 834 | if ((MO0 == LoongArchII::MO_GOT_PC_HI || MO0 == LoongArchII::MO_LD_PC_HI || |
| 835 | MO0 == LoongArchII::MO_GD_PC_HI) && |
| 836 | MO1 == LoongArchII::MO_GOT_PC_LO && MO2 == LoongArchII::MO_GOT_PC64_LO) |
| 837 | return false; |
| 838 | if (MO0 == LoongArchII::MO_IE_PC_HI && MO1 == LoongArchII::MO_IE_PC_LO && |
| 839 | MO2 == LoongArchII::MO_IE_PC64_LO) |
| 840 | return false; |
| 841 | if (MO0 == LoongArchII::MO_DESC_PC_HI && |
| 842 | MO1 == LoongArchII::MO_DESC_PC_LO && |
| 843 | MO2 == LoongArchII::MO_DESC64_PC_LO) |
| 844 | return false; |
| 845 | break; |
| 846 | } |
| 847 | case LoongArch::LU52I_D: { |
| 848 | auto MO = MI.getOperand(i: 2).getTargetFlags(); |
| 849 | if (MO == LoongArchII::MO_PCREL64_HI || MO == LoongArchII::MO_GOT_PC64_HI || |
| 850 | MO == LoongArchII::MO_IE_PC64_HI || MO == LoongArchII::MO_DESC64_PC_HI) |
| 851 | return false; |
| 852 | break; |
| 853 | } |
| 854 | default: |
| 855 | break; |
| 856 | } |
| 857 | |
| 858 | const auto &STI = MF.getSubtarget<LoongArchSubtarget>(); |
| 859 | if (STI.hasFeature(Feature: LoongArch::FeatureRelax)) { |
| 860 | // When linker relaxation enabled, the following instruction patterns are |
| 861 | // prohibited from being reordered: |
| 862 | // |
| 863 | // * pcalau12i $a0, %pc_hi20(s) |
| 864 | // addi.w/d $a0, $a0, %pc_lo12(s) |
| 865 | // |
| 866 | // * pcalau12i $a0, %got_pc_hi20(s) |
| 867 | // ld.w/d $a0, $a0, %got_pc_lo12(s) |
| 868 | // |
| 869 | // * pcalau12i $a0, %ld_pc_hi20(s) | %gd_pc_hi20(s) |
| 870 | // addi.w/d $a0, $a0, %got_pc_lo12(s) |
| 871 | // |
| 872 | // * pcalau12i $a0, %desc_pc_hi20(s) |
| 873 | // addi.w/d $a0, $a0, %desc_pc_lo12(s) |
| 874 | // ld.w/d $ra, $a0, %desc_ld(s) |
| 875 | // jirl $ra, $ra, %desc_call(s) |
| 876 | unsigned AddiOp = STI.is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W; |
| 877 | unsigned LdOp = STI.is64Bit() ? LoongArch::LD_D : LoongArch::LD_W; |
| 878 | switch (MI.getOpcode()) { |
| 879 | case LoongArch::PCALAU12I: { |
| 880 | auto MO0 = LoongArchII::getDirectFlags(MO: MI.getOperand(i: 1)); |
| 881 | auto SecondOp = std::next(x: MII); |
| 882 | if (MO0 == LoongArchII::MO_DESC_PC_HI) { |
| 883 | if (SecondOp == MIE || SecondOp->getOpcode() != AddiOp) |
| 884 | break; |
| 885 | auto Ld = std::next(x: SecondOp); |
| 886 | if (Ld == MIE || Ld->getOpcode() != LdOp) |
| 887 | break; |
| 888 | auto MO1 = LoongArchII::getDirectFlags(MO: SecondOp->getOperand(i: 2)); |
| 889 | auto MO2 = LoongArchII::getDirectFlags(MO: Ld->getOperand(i: 2)); |
| 890 | if (MO1 == LoongArchII::MO_DESC_PC_LO && MO2 == LoongArchII::MO_DESC_LD) |
| 891 | return false; |
| 892 | break; |
| 893 | } |
| 894 | if (SecondOp == MIE || |
| 895 | (SecondOp->getOpcode() != AddiOp && SecondOp->getOpcode() != LdOp)) |
| 896 | break; |
| 897 | auto MO1 = LoongArchII::getDirectFlags(MO: SecondOp->getOperand(i: 2)); |
| 898 | if (MO0 == LoongArchII::MO_PCREL_HI && SecondOp->getOpcode() == AddiOp && |
| 899 | MO1 == LoongArchII::MO_PCREL_LO) |
| 900 | return false; |
| 901 | if (MO0 == LoongArchII::MO_GOT_PC_HI && SecondOp->getOpcode() == LdOp && |
| 902 | MO1 == LoongArchII::MO_GOT_PC_LO) |
| 903 | return false; |
| 904 | if ((MO0 == LoongArchII::MO_LD_PC_HI || |
| 905 | MO0 == LoongArchII::MO_GD_PC_HI) && |
| 906 | SecondOp->getOpcode() == AddiOp && MO1 == LoongArchII::MO_GOT_PC_LO) |
| 907 | return false; |
| 908 | break; |
| 909 | } |
| 910 | case LoongArch::ADDI_W: |
| 911 | case LoongArch::ADDI_D: { |
| 912 | auto MO = LoongArchII::getDirectFlags(MO: MI.getOperand(i: 2)); |
| 913 | if (MO == LoongArchII::MO_PCREL_LO || MO == LoongArchII::MO_GOT_PC_LO) |
| 914 | return false; |
| 915 | break; |
| 916 | } |
| 917 | case LoongArch::LD_W: |
| 918 | case LoongArch::LD_D: { |
| 919 | auto MO = LoongArchII::getDirectFlags(MO: MI.getOperand(i: 2)); |
| 920 | if (MO == LoongArchII::MO_GOT_PC_LO) |
| 921 | return false; |
| 922 | break; |
| 923 | } |
| 924 | case LoongArch::PseudoDESC_CALL: { |
| 925 | auto MO = LoongArchII::getDirectFlags(MO: MI.getOperand(i: 2)); |
| 926 | if (MO == LoongArchII::MO_DESC_CALL) |
| 927 | return false; |
| 928 | break; |
| 929 | } |
| 930 | default: |
| 931 | break; |
| 932 | } |
| 933 | } |
| 934 | |
| 935 | return true; |
| 936 | } |
| 937 | |
| 938 | bool LoongArchInstrInfo::isSchedulingBoundary(const MachineInstr &MI, |
| 939 | const MachineBasicBlock *MBB, |
| 940 | const MachineFunction &MF) const { |
| 941 | if (TargetInstrInfo::isSchedulingBoundary(MI, MBB, MF)) |
| 942 | return true; |
| 943 | |
| 944 | if (!isSafeToMove(MI, MBB, MF)) |
| 945 | return true; |
| 946 | |
| 947 | return false; |
| 948 | } |
| 949 | |
| 950 | unsigned LoongArchInstrInfo::removeBranch(MachineBasicBlock &MBB, |
| 951 | int *BytesRemoved) const { |
| 952 | if (BytesRemoved) |
| 953 | *BytesRemoved = 0; |
| 954 | MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr(); |
| 955 | if (I == MBB.end()) |
| 956 | return 0; |
| 957 | |
| 958 | if (!I->getDesc().isBranch()) |
| 959 | return 0; |
| 960 | |
| 961 | // Remove the branch. |
| 962 | if (BytesRemoved) |
| 963 | *BytesRemoved += getInstSizeInBytes(MI: *I); |
| 964 | I->eraseFromParent(); |
| 965 | |
| 966 | I = MBB.end(); |
| 967 | |
| 968 | if (I == MBB.begin()) |
| 969 | return 1; |
| 970 | --I; |
| 971 | if (!I->getDesc().isConditionalBranch()) |
| 972 | return 1; |
| 973 | |
| 974 | // Remove the branch. |
| 975 | if (BytesRemoved) |
| 976 | *BytesRemoved += getInstSizeInBytes(MI: *I); |
| 977 | I->eraseFromParent(); |
| 978 | return 2; |
| 979 | } |
| 980 | |
| 981 | // Inserts a branch into the end of the specific MachineBasicBlock, returning |
| 982 | // the number of instructions inserted. |
| 983 | unsigned LoongArchInstrInfo::insertBranch( |
| 984 | MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB, |
| 985 | ArrayRef<MachineOperand> Cond, const DebugLoc &DL, int *BytesAdded) const { |
| 986 | if (BytesAdded) |
| 987 | *BytesAdded = 0; |
| 988 | |
| 989 | // Shouldn't be a fall through. |
| 990 | assert(TBB && "insertBranch must not be told to insert a fallthrough" ); |
| 991 | assert(Cond.size() <= 3 && Cond.size() != 1 && |
| 992 | "LoongArch branch conditions have at most two components!" ); |
| 993 | |
| 994 | // Unconditional branch. |
| 995 | if (Cond.empty()) { |
| 996 | MachineInstr &MI = *BuildMI(BB: &MBB, MIMD: DL, MCID: get(Opcode: LoongArch::PseudoBR)).addMBB(MBB: TBB); |
| 997 | if (BytesAdded) |
| 998 | *BytesAdded += getInstSizeInBytes(MI); |
| 999 | return 1; |
| 1000 | } |
| 1001 | |
| 1002 | // Either a one or two-way conditional branch. |
| 1003 | MachineInstrBuilder MIB = BuildMI(BB: &MBB, MIMD: DL, MCID: get(Opcode: Cond[0].getImm())); |
| 1004 | for (unsigned i = 1; i < Cond.size(); ++i) |
| 1005 | MIB.add(MO: Cond[i]); |
| 1006 | MIB.addMBB(MBB: TBB); |
| 1007 | if (BytesAdded) |
| 1008 | *BytesAdded += getInstSizeInBytes(MI: *MIB); |
| 1009 | |
| 1010 | // One-way conditional branch. |
| 1011 | if (!FBB) |
| 1012 | return 1; |
| 1013 | |
| 1014 | // Two-way conditional branch. |
| 1015 | MachineInstr &MI = *BuildMI(BB: &MBB, MIMD: DL, MCID: get(Opcode: LoongArch::PseudoBR)).addMBB(MBB: FBB); |
| 1016 | if (BytesAdded) |
| 1017 | *BytesAdded += getInstSizeInBytes(MI); |
| 1018 | return 2; |
| 1019 | } |
| 1020 | |
| 1021 | void LoongArchInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB, |
| 1022 | MachineBasicBlock &DestBB, |
| 1023 | MachineBasicBlock &RestoreBB, |
| 1024 | const DebugLoc &DL, |
| 1025 | int64_t BrOffset, |
| 1026 | RegScavenger *RS) const { |
| 1027 | assert(RS && "RegScavenger required for long branching" ); |
| 1028 | assert(MBB.empty() && |
| 1029 | "new block should be inserted for expanding unconditional branch" ); |
| 1030 | assert(MBB.pred_size() == 1); |
| 1031 | |
| 1032 | MachineFunction *MF = MBB.getParent(); |
| 1033 | MachineRegisterInfo &MRI = MF->getRegInfo(); |
| 1034 | const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); |
| 1035 | LoongArchMachineFunctionInfo *LAFI = |
| 1036 | MF->getInfo<LoongArchMachineFunctionInfo>(); |
| 1037 | bool Has32S = STI.hasFeature(Feature: LoongArch::Feature32S); |
| 1038 | |
| 1039 | if (!isInt<32>(x: BrOffset)) |
| 1040 | report_fatal_error( |
| 1041 | reason: "Branch offsets outside of the signed 32-bit range not supported" ); |
| 1042 | |
| 1043 | Register ScratchReg = MRI.createVirtualRegister(RegClass: &LoongArch::GPRRegClass); |
| 1044 | MachineInstr *PCAI = nullptr; |
| 1045 | MachineInstr *ADDI = nullptr; |
| 1046 | auto II = MBB.end(); |
| 1047 | unsigned ADDIOp = STI.is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W; |
| 1048 | |
| 1049 | if (Has32S) { |
| 1050 | PCAI = BuildMI(BB&: MBB, I: II, MIMD: DL, MCID: get(Opcode: LoongArch::PCALAU12I), DestReg: ScratchReg) |
| 1051 | .addMBB(MBB: &DestBB, TargetFlags: LoongArchII::MO_PCREL_HI); |
| 1052 | ADDI = BuildMI(BB&: MBB, I: II, MIMD: DL, MCID: get(Opcode: ADDIOp), DestReg: ScratchReg) |
| 1053 | .addReg(RegNo: ScratchReg) |
| 1054 | .addMBB(MBB: &DestBB, TargetFlags: LoongArchII::MO_PCREL_LO); |
| 1055 | } else { |
| 1056 | MCSymbol *PCAddSymbol = MF->getContext().createNamedTempSymbol(Name: "pcadd_hi" ); |
| 1057 | PCAI = BuildMI(BB&: MBB, I: II, MIMD: DL, MCID: get(Opcode: LoongArch::PCADDU12I), DestReg: ScratchReg) |
| 1058 | .addMBB(MBB: &DestBB, TargetFlags: LoongArchII::MO_PCADD_HI); |
| 1059 | PCAI->setPreInstrSymbol(MF&: *MF, Symbol: PCAddSymbol); |
| 1060 | ADDI = BuildMI(BB&: MBB, I: II, MIMD: DL, MCID: get(Opcode: ADDIOp), DestReg: ScratchReg) |
| 1061 | .addReg(RegNo: ScratchReg) |
| 1062 | .addSym(Sym: PCAddSymbol, TargetFlags: LoongArchII::MO_PCADD_LO); |
| 1063 | } |
| 1064 | BuildMI(BB&: MBB, I: II, MIMD: DL, MCID: get(Opcode: LoongArch::PseudoBRIND)) |
| 1065 | .addReg(RegNo: ScratchReg, Flags: RegState::Kill) |
| 1066 | .addImm(Val: 0); |
| 1067 | |
| 1068 | RS->enterBasicBlockEnd(MBB); |
| 1069 | Register Scav = RS->scavengeRegisterBackwards( |
| 1070 | RC: LoongArch::GPRRegClass, To: PCAI->getIterator(), /*RestoreAfter=*/false, |
| 1071 | /*SPAdj=*/0, /*AllowSpill=*/false); |
| 1072 | if (Scav != LoongArch::NoRegister) |
| 1073 | RS->setRegUsed(Reg: Scav); |
| 1074 | else { |
| 1075 | // When there is no scavenged register, it needs to specify a register. |
| 1076 | // Specify t8 register because it won't be used too often. |
| 1077 | Scav = LoongArch::R20; |
| 1078 | int FrameIndex = LAFI->getBranchRelaxationSpillFrameIndex(); |
| 1079 | if (FrameIndex == -1) |
| 1080 | report_fatal_error(reason: "The function size is incorrectly estimated." ); |
| 1081 | storeRegToStackSlot(MBB, I: PCAI, SrcReg: Scav, /*IsKill=*/true, FI: FrameIndex, |
| 1082 | RC: &LoongArch::GPRRegClass, VReg: Register()); |
| 1083 | TRI->eliminateFrameIndex(MI: std::prev(x: PCAI->getIterator()), |
| 1084 | /*SpAdj=*/SPAdj: 0, /*FIOperandNum=*/1); |
| 1085 | PCAI->getOperand(i: 1).setMBB(&RestoreBB); |
| 1086 | if (Has32S) |
| 1087 | ADDI->getOperand(i: 2).setMBB(&RestoreBB); |
| 1088 | loadRegFromStackSlot(MBB&: RestoreBB, I: RestoreBB.end(), DstReg: Scav, FI: FrameIndex, |
| 1089 | RC: &LoongArch::GPRRegClass, VReg: Register()); |
| 1090 | TRI->eliminateFrameIndex(MI: RestoreBB.back(), |
| 1091 | /*SpAdj=*/SPAdj: 0, /*FIOperandNum=*/1); |
| 1092 | } |
| 1093 | MRI.replaceRegWith(FromReg: ScratchReg, ToReg: Scav); |
| 1094 | MRI.clearVirtRegs(); |
| 1095 | } |
| 1096 | |
| 1097 | static unsigned getOppositeBranchOpc(unsigned Opc) { |
| 1098 | switch (Opc) { |
| 1099 | default: |
| 1100 | llvm_unreachable("Unrecognized conditional branch" ); |
| 1101 | case LoongArch::BEQ: |
| 1102 | return LoongArch::BNE; |
| 1103 | case LoongArch::BNE: |
| 1104 | return LoongArch::BEQ; |
| 1105 | case LoongArch::BEQZ: |
| 1106 | return LoongArch::BNEZ; |
| 1107 | case LoongArch::BNEZ: |
| 1108 | return LoongArch::BEQZ; |
| 1109 | case LoongArch::BCEQZ: |
| 1110 | return LoongArch::BCNEZ; |
| 1111 | case LoongArch::BCNEZ: |
| 1112 | return LoongArch::BCEQZ; |
| 1113 | case LoongArch::BLT: |
| 1114 | return LoongArch::BGE; |
| 1115 | case LoongArch::BGE: |
| 1116 | return LoongArch::BLT; |
| 1117 | case LoongArch::BLTU: |
| 1118 | return LoongArch::BGEU; |
| 1119 | case LoongArch::BGEU: |
| 1120 | return LoongArch::BLTU; |
| 1121 | } |
| 1122 | } |
| 1123 | |
| 1124 | bool LoongArchInstrInfo::reverseBranchCondition( |
| 1125 | SmallVectorImpl<MachineOperand> &Cond) const { |
| 1126 | assert((Cond.size() && Cond.size() <= 3) && "Invalid branch condition!" ); |
| 1127 | Cond[0].setImm(getOppositeBranchOpc(Opc: Cond[0].getImm())); |
| 1128 | return false; |
| 1129 | } |
| 1130 | |
| 1131 | std::pair<unsigned, unsigned> |
| 1132 | LoongArchInstrInfo::decomposeMachineOperandsTargetFlags(unsigned TF) const { |
| 1133 | const unsigned Mask = LoongArchII::MO_DIRECT_FLAG_MASK; |
| 1134 | return std::make_pair(x: TF & Mask, y: TF & ~Mask); |
| 1135 | } |
| 1136 | |
| 1137 | ArrayRef<std::pair<unsigned, const char *>> |
| 1138 | LoongArchInstrInfo::getSerializableDirectMachineOperandTargetFlags() const { |
| 1139 | using namespace LoongArchII; |
| 1140 | // TODO: Add more target flags. |
| 1141 | static const std::pair<unsigned, const char *> TargetFlags[] = { |
| 1142 | {MO_CALL, "loongarch-call" }, |
| 1143 | {MO_CALL_PLT, "loongarch-call-plt" }, |
| 1144 | {MO_PCREL_HI, "loongarch-pcrel-hi" }, |
| 1145 | {MO_PCREL_LO, "loongarch-pcrel-lo" }, |
| 1146 | {MO_PCREL64_LO, "loongarch-pcrel64-lo" }, |
| 1147 | {MO_PCREL64_HI, "loongarch-pcrel64-hi" }, |
| 1148 | {MO_GOT_PC_HI, "loongarch-got-pc-hi" }, |
| 1149 | {MO_GOT_PC_LO, "loongarch-got-pc-lo" }, |
| 1150 | {MO_GOT_PC64_LO, "loongarch-got-pc64-lo" }, |
| 1151 | {MO_GOT_PC64_HI, "loongarch-got-pc64-hi" }, |
| 1152 | {MO_LE_HI, "loongarch-le-hi" }, |
| 1153 | {MO_LE_LO, "loongarch-le-lo" }, |
| 1154 | {MO_LE64_LO, "loongarch-le64-lo" }, |
| 1155 | {MO_LE64_HI, "loongarch-le64-hi" }, |
| 1156 | {MO_IE_PC_HI, "loongarch-ie-pc-hi" }, |
| 1157 | {MO_IE_PC_LO, "loongarch-ie-pc-lo" }, |
| 1158 | {MO_IE_PC64_LO, "loongarch-ie-pc64-lo" }, |
| 1159 | {MO_IE_PC64_HI, "loongarch-ie-pc64-hi" }, |
| 1160 | {MO_LD_PC_HI, "loongarch-ld-pc-hi" }, |
| 1161 | {MO_GD_PC_HI, "loongarch-gd-pc-hi" }, |
| 1162 | {MO_CALL30, "loongarch-call30" }, |
| 1163 | {MO_CALL36, "loongarch-call36" }, |
| 1164 | {MO_DESC_PC_HI, "loongarch-desc-pc-hi" }, |
| 1165 | {MO_DESC_PC_LO, "loongarch-desc-pc-lo" }, |
| 1166 | {MO_DESC64_PC_LO, "loongarch-desc64-pc-lo" }, |
| 1167 | {MO_DESC64_PC_HI, "loongarch-desc64-pc-hi" }, |
| 1168 | {MO_DESC_LD, "loongarch-desc-ld" }, |
| 1169 | {MO_DESC_CALL, "loongarch-desc-call" }, |
| 1170 | {MO_LE_HI_R, "loongarch-le-hi-r" }, |
| 1171 | {MO_LE_ADD_R, "loongarch-le-add-r" }, |
| 1172 | {MO_LE_LO_R, "loongarch-le-lo-r" }, |
| 1173 | {MO_PCADD_HI, "loongarch-pcadd-hi" }, |
| 1174 | {MO_PCADD_LO, "loongarch-pcadd-lo" }, |
| 1175 | {MO_GOT_PCADD_HI, "loongarch-got-pcadd-hi" }, |
| 1176 | {MO_GOT_PCADD_LO, "loongarch-got-pcadd-lo" }, |
| 1177 | {MO_IE_PCADD_HI, "loongarch-ie-pcadd-hi" }, |
| 1178 | {MO_IE_PCADD_LO, "loongarch-ie-pcadd-lo" }, |
| 1179 | {MO_LD_PCADD_HI, "loongarch-ld-pcadd-hi" }, |
| 1180 | {MO_LD_PCADD_LO, "loongarch-ld-pcadd-lo" }, |
| 1181 | {MO_GD_PCADD_HI, "loongarch-gd-pcadd-hi" }, |
| 1182 | {MO_GD_PCADD_LO, "loongarch-gd-pcadd-lo" }, |
| 1183 | {MO_DESC_PCADD_HI, "loongarch-pcadd-desc-hi" }, |
| 1184 | {MO_DESC_PCADD_LO, "loongarch-pcadd-desc-lo" }}; |
| 1185 | return ArrayRef(TargetFlags); |
| 1186 | } |
| 1187 | |
| 1188 | ArrayRef<std::pair<unsigned, const char *>> |
| 1189 | LoongArchInstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const { |
| 1190 | using namespace LoongArchII; |
| 1191 | static const std::pair<unsigned, const char *> TargetFlags[] = { |
| 1192 | {MO_RELAX, "loongarch-relax" }}; |
| 1193 | return ArrayRef(TargetFlags); |
| 1194 | } |
| 1195 | |
| 1196 | bool LoongArchInstrInfo::canFoldIntoAddrMode(const MachineInstr &MemI, |
| 1197 | Register Reg, |
| 1198 | const MachineInstr &AddrI, |
| 1199 | ExtAddrMode &AM) const { |
| 1200 | enum MemIOffsetType { |
| 1201 | Imm14Shift2, |
| 1202 | Imm12, |
| 1203 | Imm11Shift1, |
| 1204 | Imm10Shift2, |
| 1205 | Imm9Shift3, |
| 1206 | Imm8, |
| 1207 | Imm8Shift1, |
| 1208 | Imm8Shift2, |
| 1209 | Imm8Shift3 |
| 1210 | }; |
| 1211 | |
| 1212 | MemIOffsetType OT; |
| 1213 | switch (MemI.getOpcode()) { |
| 1214 | default: |
| 1215 | return false; |
| 1216 | case LoongArch::LDPTR_W: |
| 1217 | case LoongArch::LDPTR_D: |
| 1218 | case LoongArch::STPTR_W: |
| 1219 | case LoongArch::STPTR_D: |
| 1220 | OT = Imm14Shift2; |
| 1221 | break; |
| 1222 | case LoongArch::LD_B: |
| 1223 | case LoongArch::LD_H: |
| 1224 | case LoongArch::LD_W: |
| 1225 | case LoongArch::LD_D: |
| 1226 | case LoongArch::LD_BU: |
| 1227 | case LoongArch::LD_HU: |
| 1228 | case LoongArch::LD_WU: |
| 1229 | case LoongArch::ST_B: |
| 1230 | case LoongArch::ST_H: |
| 1231 | case LoongArch::ST_W: |
| 1232 | case LoongArch::ST_D: |
| 1233 | case LoongArch::FLD_S: |
| 1234 | case LoongArch::FLD_D: |
| 1235 | case LoongArch::FST_S: |
| 1236 | case LoongArch::FST_D: |
| 1237 | case LoongArch::VLD: |
| 1238 | case LoongArch::VST: |
| 1239 | case LoongArch::XVLD: |
| 1240 | case LoongArch::XVST: |
| 1241 | case LoongArch::VLDREPL_B: |
| 1242 | case LoongArch::XVLDREPL_B: |
| 1243 | OT = Imm12; |
| 1244 | break; |
| 1245 | case LoongArch::VLDREPL_H: |
| 1246 | case LoongArch::XVLDREPL_H: |
| 1247 | OT = Imm11Shift1; |
| 1248 | break; |
| 1249 | case LoongArch::VLDREPL_W: |
| 1250 | case LoongArch::XVLDREPL_W: |
| 1251 | OT = Imm10Shift2; |
| 1252 | break; |
| 1253 | case LoongArch::VLDREPL_D: |
| 1254 | case LoongArch::XVLDREPL_D: |
| 1255 | OT = Imm9Shift3; |
| 1256 | break; |
| 1257 | case LoongArch::VSTELM_B: |
| 1258 | case LoongArch::XVSTELM_B: |
| 1259 | OT = Imm8; |
| 1260 | break; |
| 1261 | case LoongArch::VSTELM_H: |
| 1262 | case LoongArch::XVSTELM_H: |
| 1263 | OT = Imm8Shift1; |
| 1264 | break; |
| 1265 | case LoongArch::VSTELM_W: |
| 1266 | case LoongArch::XVSTELM_W: |
| 1267 | OT = Imm8Shift2; |
| 1268 | break; |
| 1269 | case LoongArch::VSTELM_D: |
| 1270 | case LoongArch::XVSTELM_D: |
| 1271 | OT = Imm8Shift3; |
| 1272 | break; |
| 1273 | } |
| 1274 | |
| 1275 | if (MemI.getOperand(i: 0).getReg() == Reg) |
| 1276 | return false; |
| 1277 | |
| 1278 | if ((AddrI.getOpcode() != LoongArch::ADDI_W && |
| 1279 | AddrI.getOpcode() != LoongArch::ADDI_D) || |
| 1280 | !AddrI.getOperand(i: 1).isReg() || !AddrI.getOperand(i: 2).isImm()) |
| 1281 | return false; |
| 1282 | |
| 1283 | int64_t OldOffset = MemI.getOperand(i: 2).getImm(); |
| 1284 | int64_t Disp = AddrI.getOperand(i: 2).getImm(); |
| 1285 | int64_t NewOffset = OldOffset + Disp; |
| 1286 | if (!STI.is64Bit()) |
| 1287 | NewOffset = SignExtend64<32>(x: NewOffset); |
| 1288 | |
| 1289 | if (!(OT == Imm14Shift2 && isShiftedInt<14, 2>(x: NewOffset) && STI.hasUAL()) && |
| 1290 | !(OT == Imm12 && isInt<12>(x: NewOffset)) && |
| 1291 | !(OT == Imm11Shift1 && isShiftedInt<11, 1>(x: NewOffset)) && |
| 1292 | !(OT == Imm10Shift2 && isShiftedInt<10, 2>(x: NewOffset)) && |
| 1293 | !(OT == Imm9Shift3 && isShiftedInt<9, 3>(x: NewOffset)) && |
| 1294 | !(OT == Imm8 && isInt<8>(x: NewOffset)) && |
| 1295 | !(OT == Imm8Shift1 && isShiftedInt<8, 1>(x: NewOffset)) && |
| 1296 | !(OT == Imm8Shift2 && isShiftedInt<8, 2>(x: NewOffset)) && |
| 1297 | !(OT == Imm8Shift3 && isShiftedInt<8, 3>(x: NewOffset))) |
| 1298 | return false; |
| 1299 | |
| 1300 | AM.BaseReg = AddrI.getOperand(i: 1).getReg(); |
| 1301 | AM.ScaledReg = 0; |
| 1302 | AM.Scale = 0; |
| 1303 | AM.Displacement = NewOffset; |
| 1304 | AM.Form = ExtAddrMode::Formula::Basic; |
| 1305 | return true; |
| 1306 | } |
| 1307 | |
| 1308 | MachineInstr * |
| 1309 | LoongArchInstrInfo::emitLdStWithAddr(MachineInstr &MemI, |
| 1310 | const ExtAddrMode &AM) const { |
| 1311 | const DebugLoc &DL = MemI.getDebugLoc(); |
| 1312 | MachineBasicBlock &MBB = *MemI.getParent(); |
| 1313 | |
| 1314 | assert(AM.ScaledReg == 0 && AM.Scale == 0 && |
| 1315 | "Addressing mode not supported for folding" ); |
| 1316 | |
| 1317 | unsigned MemIOp = MemI.getOpcode(); |
| 1318 | switch (MemIOp) { |
| 1319 | default: |
| 1320 | return BuildMI(BB&: MBB, I&: MemI, MIMD: DL, MCID: get(Opcode: MemIOp)) |
| 1321 | .addReg(RegNo: MemI.getOperand(i: 0).getReg(), Flags: getDefRegState(B: MemI.mayLoad())) |
| 1322 | .addReg(RegNo: AM.BaseReg) |
| 1323 | .addImm(Val: AM.Displacement) |
| 1324 | .setMemRefs(MemI.memoperands()) |
| 1325 | .setMIFlags(MemI.getFlags()); |
| 1326 | case LoongArch::VSTELM_B: |
| 1327 | case LoongArch::VSTELM_H: |
| 1328 | case LoongArch::VSTELM_W: |
| 1329 | case LoongArch::VSTELM_D: |
| 1330 | case LoongArch::XVSTELM_B: |
| 1331 | case LoongArch::XVSTELM_H: |
| 1332 | case LoongArch::XVSTELM_W: |
| 1333 | case LoongArch::XVSTELM_D: |
| 1334 | return BuildMI(BB&: MBB, I&: MemI, MIMD: DL, MCID: get(Opcode: MemIOp)) |
| 1335 | .addReg(RegNo: MemI.getOperand(i: 0).getReg()) |
| 1336 | .addReg(RegNo: AM.BaseReg) |
| 1337 | .addImm(Val: AM.Displacement) |
| 1338 | .addImm(Val: MemI.getOperand(i: 3).getImm()) |
| 1339 | .setMemRefs(MemI.memoperands()) |
| 1340 | .setMIFlags(MemI.getFlags()); |
| 1341 | } |
| 1342 | } |
| 1343 | |
| 1344 | // Returns true if this is the sext.w pattern, addi.w rd, rs, 0. |
| 1345 | bool LoongArch::isSEXT_W(const MachineInstr &MI) { |
| 1346 | return MI.getOpcode() == LoongArch::ADDI_W && MI.getOperand(i: 1).isReg() && |
| 1347 | MI.getOperand(i: 2).isImm() && MI.getOperand(i: 2).getImm() == 0; |
| 1348 | } |
| 1349 | |