[RISCV] Set isAsCheapAsAMove for ADDI, ORI, XORI, LUI

[apazos]

Summary

Affected instructions:
PseudoLI simplest form (ADDI with X0)
ALU operations with immediate (they do not set status flag - ADDI, ORI, XORI)

[asb]

Adding myself as reviewer.

[asb]

I think it would be best to have a separate patch to fix isReMaterializable for LUI affecting the neighbouring instructions, and leave this patch for the isAsCheapAsAMove changes.

I'd be very happy for you to directly commit the change to isReMaterializable for LUI, and we can focus on discussing isAsCheapAsAMove here.

lib/Target/RISCV/RISCVInstrInfo.td

311 ↗

(On Diff #181360)

Should LUI have isAsCheapAsAMove = 1?

[apazos]

Sure, will update this patch and I have pushed the other changes to separate patches:
R351895 - Fixed isReMaterializable setting for LUI instruction.
https://reviews.llvm.org/D57069 [RISCV] Fixed isReMaterializable setting for ORI, XORI

[asb]

LGTM, thanks. Might be best titled as something like "[RISCV] Set isAsCheapAsAMove for ADDI, ORI, XORI, LUI"

[asb]

Hi Ana. I reviewed the test changes caused by this commit, and they all seem fine to me.

lib/Target/RISCV/RISCVInstrInfo.h

public:
 
   bool
   reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const override;
 
   MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
 
   bool isBranchOffsetInRange(unsigned BranchOpc,
                              int64_t BrOffset) const override;
+
+  bool isAsCheapAsAMove(const MachineInstr &MI) const override;
+
+  bool isReallyTriviallyReMaterializable(const MachineInstr &MI,
+                                         AliasAnalysis *AA) const override;
 };
 }
 #endif

lib/Target/RISCV/RISCVInstrInfo.cpp

unsigned RISCVInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
   case TargetOpcode::INLINEASM: {
     const MachineFunction &MF = *MI.getParent()->getParent();
     const auto &TM = static_cast<const RISCVTargetMachine &>(MF.getTarget());
     return getInlineAsmLength(MI.getOperand(0).getSymbolName(),
                               *TM.getMCAsmInfo());
   }
   }
 }
+
+bool RISCVInstrInfo::isAsCheapAsAMove(const MachineInstr &MI) const {
+  const unsigned Opcode = MI.getOpcode();
+  switch(Opcode) {
+    default:
+      break;
+    case RISCV::ADDI:
+      //  Catching LI reg, %lo(sym) or LI reg, %pcrel_lo(sym) or something similar.
+      if ((MI.getOperand(1).isReg() && MI.getOperand(1).getReg() == RISCV::X0))
+        return true;
+      return false;
+  }
+  return MI.isAsCheapAsAMove();
+}
+
+bool
+RISCVInstrInfo::isReallyTriviallyReMaterializable(const MachineInstr &MI,
+                                                  AliasAnalysis *AA) const {
+  switch (MI.getOpcode()) {
+  default:
+    // This function should only be called for opcodes with the ReMaterializable
+    // flag set.
+    llvm_unreachable("Unknown rematerializable operation!");
+    break;
+  case RISCV::ADDI:
+    return false;
+  case RISCV::AUIPC:
+  case RISCV::LUI:
+    return true;
+  }
+  return false;
+}