[RISCV] Reduce duplicated code in RISCVMergeBaseOffsetOpt::detectFoldable. NFC

[craig.topper]

Summary

The LUI and AUIPC share quite a few similarities. This refactors the code
to share what we can.

[asb]

LGTM.

llvm/lib/Target/RISCV/RISCVMergeBaseOffset.cpp

 //===----- RISCVMergeBaseOffset.cpp - Optimise address calculations  ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 //
 // The pattern is only accepted if:
 //    1) The first instruction has only one use, which is the ADDI.
 //    2) The address operands have the appropriate type, reflecting the
 //       lowering of a global address or constant pool using medlow or medany.
 //    3) The offset value in the Global Address or Constant Pool is 0.
 bool RISCVMergeBaseOffsetOpt::detectFoldable(MachineInstr &Hi,
                                              MachineInstr *&Lo) {
-  if (Hi.getOpcode() == RISCV::LUI) {
-    Register HiDestReg = Hi.getOperand(0).getReg();
-    const MachineOperand &HiOp1 = Hi.getOperand(1);
-    if (HiOp1.getTargetFlags() != RISCVII::MO_HI ||
-        !(HiOp1.isGlobal() || HiOp1.isCPI()) || HiOp1.getOffset() != 0 ||
-        !MRI->hasOneUse(HiDestReg))
-      return false;
-    Lo = &*MRI->use_instr_begin(HiDestReg);
-    if (Lo->getOpcode() != RISCV::ADDI)
-      return false;
-    const MachineOperand &LoOp2 = Lo->getOperand(2);
-    if (LoOp2.getTargetFlags() != RISCVII::MO_LO ||
-        !(LoOp2.isGlobal() || LoOp2.isCPI()) || LoOp2.getOffset() != 0)
-      return false;
-    return true;
-  }
+  if (Hi.getOpcode() != RISCV::LUI && Hi.getOpcode() != RISCV::AUIPC)
+
+  const MachineOperand &HiOp1 = Hi.getOperand(1);
+  unsigned ExpectedFlags =
+      Hi.getOpcode() == RISCV::AUIPC ? RISCVII::MO_PCREL_HI : RISCVII::MO_HI;
+  if (HiOp1.getTargetFlags() != ExpectedFlags)
+
+  if (!(HiOp1.isGlobal() || HiOp1.isCPI()) || HiOp1.getOffset() != 0)
 
-  if (Hi.getOpcode() == RISCV::AUIPC) {
-    Register HiDestReg = Hi.getOperand(0).getReg();
-    const MachineOperand &HiOp1 = Hi.getOperand(1);
-    if (HiOp1.getTargetFlags() != RISCVII::MO_PCREL_HI ||
-        !(HiOp1.isGlobal() || HiOp1.isCPI()) || HiOp1.getOffset() != 0 ||
-        !MRI->hasOneUse(HiDestReg))
-      return false;
-    Lo = &*MRI->use_instr_begin(HiDestReg);
-    if (Lo->getOpcode() != RISCV::ADDI)
-      return false;
-    const MachineOperand &LoOp2 = Lo->getOperand(2);
+  if (!MRI->hasOneUse(HiDestReg))
+
+
+  if (Hi.getOpcode() == RISCV::LUI) {
+    if (LoOp2.getTargetFlags() != RISCVII::MO_LO ||
+        !(LoOp2.isGlobal() || LoOp2.isCPI()) || LoOp2.getOffset() != 0)
+      return false;
+  } else {
+    assert(Hi.getOpcode() == RISCV::AUIPC);
     if (LoOp2.getTargetFlags() != RISCVII::MO_PCREL_LO ||
         LoOp2.getType() != MachineOperand::MO_MCSymbol)
       return false;
-    return true;
   }
 
-  return false;
+  if (HiOp1.isGlobal()) {
+    LLVM_DEBUG(dbgs() << "  Found lowered global address: "
+                      << *HiOp1.getGlobal() << "\n");
+  } else {
+    assert(HiOp1.isCPI());
+    LLVM_DEBUG(dbgs() << "  Found lowered constant pool: " << HiOp1.getIndex()
+                      << "\n");
+  }
+
+  return true;
 }
 
 // Update the offset in Hi and Lo instructions.
 // Delete the tail instruction and update all the uses to use the
 // output from Lo.
 void RISCVMergeBaseOffsetOpt::foldOffset(MachineInstr &Hi, MachineInstr &Lo,
                                          MachineInstr &Tail, int64_t Offset) {
   assert(isInt<32>(Offset) && "Unexpected offset");
bool RISCVMergeBaseOffsetOpt::runOnMachineFunction(MachineFunction &Fn) {
   bool MadeChange = false;
   MRI = &Fn.getRegInfo();
   for (MachineBasicBlock &MBB : Fn) {
     LLVM_DEBUG(dbgs() << "MBB: " << MBB.getName() << "\n");
     for (MachineInstr &Hi : MBB) {
       MachineInstr *Lo = nullptr;
       if (!detectFoldable(Hi, Lo))
         continue;
-      if (Hi.getOperand(1).isGlobal()) {
-        LLVM_DEBUG(dbgs() << "  Found lowered global address: "
-                          << *Hi.getOperand(1).getGlobal() << "\n");
-      } else {
-        assert(Hi.getOperand(1).isCPI());
-        LLVM_DEBUG(dbgs() << "  Found lowered constant pool: "
-                          << Hi.getOperand(1).getIndex() << "\n");
-      }
       MadeChange |= detectAndFoldOffset(Hi, *Lo);
       MadeChange |= foldIntoMemoryOps(Hi, *Lo);
     }
   }
 
   return MadeChange;
 }
 
 /// Returns an instance of the Merge Base Offset Optimization pass.
 FunctionPass *llvm::createRISCVMergeBaseOffsetOptPass() {
   return new RISCVMergeBaseOffsetOpt();
 }