[llvm] [AArch64][ISel] Recover ADDHN from OR comparison masks (PR #210943)

Hari Limaye via llvm-commits llvm-commits at lists.llvm.org
Tue Jul 28 03:39:29 PDT 2026


================
@@ -278,6 +278,101 @@ void applyFoldMergeToZext(MachineInstr &MI, MachineRegisterInfo &MRI,
   Observer.changedInstr(MI);
 }
 
+bool matchAddhnFromCmpMasks(MachineInstr &MI, MachineRegisterInfo &MRI,
+                            std::pair<Register, Register> &MatchInfo) {
+  assert(MI.getOpcode() == TargetOpcode::G_TRUNC && "Expected a G_TRUNC");
+
+  Register Dst = MI.getOperand(0).getReg();
+  Register Src = MI.getOperand(1).getReg();
+  LLT DstTy = MRI.getType(Dst);
+  LLT SrcTy = MRI.getType(Src);
+
+  if (!((DstTy == LLT::fixed_vector(8, 8) &&
+         SrcTy == LLT::fixed_vector(8, 16)) ||
+        (DstTy == LLT::fixed_vector(4, 16) &&
+         SrcTy == LLT::fixed_vector(4, 32)) ||
+        (DstTy == LLT::fixed_vector(2, 32) &&
+         SrcTy == LLT::fixed_vector(2, 64))))
+    return false;
+
+  // Do not form ADDHN when its narrow result is immediately widened for more
+  // vector operations. In that case retaining the wide OR is cheaper.
+  for (MachineInstr &Use : MRI.use_nodbg_instructions(Dst)) {
+    const unsigned Opc = Use.getOpcode();
+    if (Opc == TargetOpcode::G_ANYEXT) {
+      Register ExtDst = Use.getOperand(0).getReg();
+      if (!MRI.use_nodbg_empty(ExtDst) &&
+          llvm::all_of(
+              MRI.use_nodbg_instructions(ExtDst), [](MachineInstr &ExtUse) {
+                return ExtUse.getOpcode() == TargetOpcode::G_EXTRACT_VECTOR_ELT;
+              }))
+        continue;
+    }
+
+    if (Opc == TargetOpcode::G_ANYEXT || Opc == TargetOpcode::G_SEXT ||
+        Opc == TargetOpcode::G_ZEXT)
+      return false;
+  }
+
+  MachineInstr *Or = getOpcodeDef(TargetOpcode::G_OR, Src, MRI);
+  if (!Or || !MRI.hasOneNonDBGUse(Src))
+    return false;
+
+  auto IsComparisonMask = [&](Register Reg) {
+    MachineInstr *Def = getDefIgnoringCopies(Reg, MRI);
+    if (Def && Def->getOpcode() == TargetOpcode::G_FREEZE)
+      Def = getDefIgnoringCopies(Def->getOperand(1).getReg(), MRI);
+    return Def && (Def->getOpcode() == TargetOpcode::G_ICMP ||
+                   Def->getOpcode() == TargetOpcode::G_FCMP);
+  };
+
+  Register LHS = Or->getOperand(1).getReg();
+  Register RHS = Or->getOperand(2).getReg();
+  if (!IsComparisonMask(LHS) || !IsComparisonMask(RHS))
+    return false;
+
+  MatchInfo = {LHS, RHS};
+  return true;
+}
+
+void applyAddhnFromCmpMasks(MachineInstr &MI, MachineRegisterInfo &MRI,
+                            MachineIRBuilder &B, GISelChangeObserver &,
+                            const std::pair<Register, Register> &MatchInfo) {
+  Register Dst = MI.getOperand(0).getReg();
+
+  // Legalization promotes an extract from the narrow vector into an extract
+  // from an any-extended vector. Fold that promotion into a target extraction
+  // pseudo so instruction selection can use UMOV directly from the ADDHN
+  // result instead of requiring an additional USHLL.
+  SmallVector<MachineInstr *> Exts;
+  for (MachineInstr &Use : MRI.use_nodbg_instructions(Dst))
+    if (Use.getOpcode() == TargetOpcode::G_ANYEXT)
+      Exts.push_back(&Use);
+
+  for (MachineInstr *Ext : Exts) {
+    Register ExtDst = Ext->getOperand(0).getReg();
+    SmallVector<MachineInstr *> Extracts;
+    for (MachineInstr &ExtUse : MRI.use_nodbg_instructions(ExtDst))
+      Extracts.push_back(&ExtUse);
+
+    for (MachineInstr *Extract : Extracts) {
+      assert(Extract->getOpcode() == TargetOpcode::G_EXTRACT_VECTOR_ELT);
+      B.setInstrAndDebugLoc(*Extract);
+      B.buildInstr(AArch64::G_EXTRACT_VECTOR_ELT_ANYEXT,
+                   {Extract->getOperand(0).getReg()},
+                   {Dst, Extract->getOperand(2).getReg()});
+      Extract->eraseFromParent();
+    }
+
+    if (MRI.use_nodbg_empty(ExtDst))
+      Ext->eraseFromParent();
+  }
+
+  B.setInstrAndDebugLoc(MI);
+  B.buildInstr(AArch64::G_ADDHN, {Dst}, {MatchInfo.first, MatchInfo.second});
----------------
hazzlim wrote:

I think that the custom GISel Node for ADDHN is unnecessary? We should be able to just emit the add/shift/truncate pattern that the backend already matches

https://github.com/llvm/llvm-project/pull/210943


More information about the llvm-commits mailing list