[llvm] [LoongArch] Add initial MachineCombiner support (PR #230830)

via llvm-commits llvm-commits at lists.llvm.org
Sat Oct 10 11:49:45 PDT 2026


https://github.com/lrzlin updated https://github.com/llvm/llvm-project/pull/230830

>From 04ba2f062a913a15363ab9b16ea45c2aed892edd Mon Sep 17 00:00:00 2001
From: Lin Runze <lrzlin at 163.com>
Date: Wed, 30 Sep 2026 18:04:04 +0800
Subject: [PATCH] [LoongArch] Add initial MachineCombiner support

---
 .../Target/LoongArch/LoongArchInstrInfo.cpp   |  184 +++
 .../lib/Target/LoongArch/LoongArchInstrInfo.h |    7 +
 .../LoongArch/LoongArchTargetMachine.cpp      |   13 +
 llvm/test/CodeGen/LoongArch/alsl.ll           |   50 +-
 llvm/test/CodeGen/LoongArch/bittest.ll        |    6 +-
 .../CodeGen/LoongArch/calling-conv-common.ll  |    6 +-
 .../LoongArch/lasx/machine-combiner.ll        |  565 +++++++++
 .../CodeGen/LoongArch/lsx/machine-combiner.ll |  565 +++++++++
 .../CodeGen/LoongArch/machine-combiner.ll     | 1062 +++++++++++++++++
 llvm/test/CodeGen/LoongArch/opt-pipeline.ll   |    5 +-
 llvm/test/CodeGen/LoongArch/rotl-rotr.ll      |   26 +-
 .../CodeGen/LoongArch/select-binop-combine.ll |    4 +-
 .../CodeGen/LoongArch/smul-with-overflow.ll   |   28 +-
 13 files changed, 2460 insertions(+), 61 deletions(-)
 create mode 100644 llvm/test/CodeGen/LoongArch/lasx/machine-combiner.ll
 create mode 100644 llvm/test/CodeGen/LoongArch/lsx/machine-combiner.ll
 create mode 100644 llvm/test/CodeGen/LoongArch/machine-combiner.ll

diff --git a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp
index 1d99139e2e0a5..653e0ced81bea 100644
--- a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp
@@ -21,6 +21,7 @@
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/CommandLine.h"
+#include <optional>
 
 using namespace llvm;
 
@@ -489,6 +490,189 @@ int LoongArchInstrInfo::getJumpTableIndex(const MachineInstr &MI) const {
   return getJumpTableIndexFromReg(MRI, Reg);
 }
 
+bool LoongArchInstrInfo::isAssociativeAndCommutative(const MachineInstr &Inst,
+                                                     bool Invert) const {
+  unsigned Opc = Inst.getOpcode();
+  if (Invert) {
+    auto InverseOpcode = getInverseOpcode(Opc);
+    if (!InverseOpcode)
+      return false;
+    Opc = *InverseOpcode;
+  }
+
+  switch (Opc) {
+  default:
+    return false;
+  case LoongArch::FADD_S:
+  case LoongArch::FADD_D:
+  case LoongArch::FMUL_S:
+  case LoongArch::FMUL_D:
+  case LoongArch::VFADD_S:
+  case LoongArch::VFADD_D:
+  case LoongArch::VFMUL_S:
+  case LoongArch::VFMUL_D:
+  case LoongArch::XVFADD_S:
+  case LoongArch::XVFADD_D:
+  case LoongArch::XVFMUL_S:
+  case LoongArch::XVFMUL_D:
+    return Inst.getFlag(MachineInstr::MIFlag::FmReassoc) &&
+           Inst.getFlag(MachineInstr::MIFlag::FmNsz);
+  // IEEE 754-2008 minNum/maxNum: an sNaN operand yields qNaN, which breaks
+  // associativity (min(min(3,sNaN),1) = 1 but min(3,min(sNaN,1)) = 3).
+  // Signed zeros are ordered (-0 < +0) and the result is exact, so no
+  // reassoc/nsz requirement.
+  case LoongArch::FMIN_S:
+  case LoongArch::FMIN_D:
+  case LoongArch::FMAX_S:
+  case LoongArch::FMAX_D:
+  case LoongArch::VFMIN_S:
+  case LoongArch::VFMIN_D:
+  case LoongArch::VFMAX_S:
+  case LoongArch::VFMAX_D:
+  case LoongArch::XVFMIN_S:
+  case LoongArch::XVFMIN_D:
+  case LoongArch::XVFMAX_S:
+  case LoongArch::XVFMAX_D:
+    return Inst.getFlag(MachineInstr::MIFlag::FmNoNans);
+  case LoongArch::ADD_D:
+  case LoongArch::ADD_W:
+  case LoongArch::AND:
+  case LoongArch::OR:
+  case LoongArch::XOR:
+  case LoongArch::MUL_D:
+  case LoongArch::MUL_W:
+  case LoongArch::VADD_B:
+  case LoongArch::VADD_H:
+  case LoongArch::VADD_W:
+  case LoongArch::VADD_D:
+  case LoongArch::VMUL_B:
+  case LoongArch::VMUL_H:
+  case LoongArch::VMUL_W:
+  case LoongArch::VMUL_D:
+  case LoongArch::VAND_V:
+  case LoongArch::VOR_V:
+  case LoongArch::VXOR_V:
+  case LoongArch::VMIN_B:
+  case LoongArch::VMIN_H:
+  case LoongArch::VMIN_W:
+  case LoongArch::VMIN_D:
+  case LoongArch::VMIN_BU:
+  case LoongArch::VMIN_HU:
+  case LoongArch::VMIN_WU:
+  case LoongArch::VMIN_DU:
+  case LoongArch::VMAX_B:
+  case LoongArch::VMAX_H:
+  case LoongArch::VMAX_W:
+  case LoongArch::VMAX_D:
+  case LoongArch::VMAX_BU:
+  case LoongArch::VMAX_HU:
+  case LoongArch::VMAX_WU:
+  case LoongArch::VMAX_DU:
+  case LoongArch::XVADD_B:
+  case LoongArch::XVADD_H:
+  case LoongArch::XVADD_W:
+  case LoongArch::XVADD_D:
+  case LoongArch::XVMUL_B:
+  case LoongArch::XVMUL_H:
+  case LoongArch::XVMUL_W:
+  case LoongArch::XVMUL_D:
+  case LoongArch::XVAND_V:
+  case LoongArch::XVOR_V:
+  case LoongArch::XVXOR_V:
+  case LoongArch::XVMIN_B:
+  case LoongArch::XVMIN_H:
+  case LoongArch::XVMIN_W:
+  case LoongArch::XVMIN_D:
+  case LoongArch::XVMIN_BU:
+  case LoongArch::XVMIN_HU:
+  case LoongArch::XVMIN_WU:
+  case LoongArch::XVMIN_DU:
+  case LoongArch::XVMAX_B:
+  case LoongArch::XVMAX_H:
+  case LoongArch::XVMAX_W:
+  case LoongArch::XVMAX_D:
+  case LoongArch::XVMAX_BU:
+  case LoongArch::XVMAX_HU:
+  case LoongArch::XVMAX_WU:
+  case LoongArch::XVMAX_DU:
+    return true;
+  }
+
+  return false;
+}
+
+std::optional<unsigned>
+LoongArchInstrInfo::getInverseOpcode(unsigned Opcode) const {
+  switch (Opcode) {
+  default:
+    return std::nullopt;
+  case LoongArch::ADD_W:
+    return LoongArch::SUB_W;
+  case LoongArch::ADD_D:
+    return LoongArch::SUB_D;
+  case LoongArch::SUB_W:
+    return LoongArch::ADD_W;
+  case LoongArch::SUB_D:
+    return LoongArch::ADD_D;
+  case LoongArch::FADD_S:
+    return LoongArch::FSUB_S;
+  case LoongArch::FADD_D:
+    return LoongArch::FSUB_D;
+  case LoongArch::FSUB_S:
+    return LoongArch::FADD_S;
+  case LoongArch::FSUB_D:
+    return LoongArch::FADD_D;
+  case LoongArch::VADD_B:
+    return LoongArch::VSUB_B;
+  case LoongArch::VADD_H:
+    return LoongArch::VSUB_H;
+  case LoongArch::VADD_W:
+    return LoongArch::VSUB_W;
+  case LoongArch::VADD_D:
+    return LoongArch::VSUB_D;
+  case LoongArch::VSUB_B:
+    return LoongArch::VADD_B;
+  case LoongArch::VSUB_H:
+    return LoongArch::VADD_H;
+  case LoongArch::VSUB_W:
+    return LoongArch::VADD_W;
+  case LoongArch::VSUB_D:
+    return LoongArch::VADD_D;
+  case LoongArch::VFADD_S:
+    return LoongArch::VFSUB_S;
+  case LoongArch::VFADD_D:
+    return LoongArch::VFSUB_D;
+  case LoongArch::VFSUB_S:
+    return LoongArch::VFADD_S;
+  case LoongArch::VFSUB_D:
+    return LoongArch::VFADD_D;
+  case LoongArch::XVADD_B:
+    return LoongArch::XVSUB_B;
+  case LoongArch::XVADD_H:
+    return LoongArch::XVSUB_H;
+  case LoongArch::XVADD_W:
+    return LoongArch::XVSUB_W;
+  case LoongArch::XVADD_D:
+    return LoongArch::XVSUB_D;
+  case LoongArch::XVSUB_B:
+    return LoongArch::XVADD_B;
+  case LoongArch::XVSUB_H:
+    return LoongArch::XVADD_H;
+  case LoongArch::XVSUB_W:
+    return LoongArch::XVADD_W;
+  case LoongArch::XVSUB_D:
+    return LoongArch::XVADD_D;
+  case LoongArch::XVFADD_S:
+    return LoongArch::XVFSUB_S;
+  case LoongArch::XVFADD_D:
+    return LoongArch::XVFSUB_D;
+  case LoongArch::XVFSUB_S:
+    return LoongArch::XVFADD_S;
+  case LoongArch::XVFSUB_D:
+    return LoongArch::XVFADD_D;
+  }
+}
+
 MachineBasicBlock *
 LoongArchInstrInfo::getBranchDestBlock(const MachineInstr &MI) const {
   assert(MI.getDesc().isBranch() && "Unexpected opcode!");
diff --git a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.h b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.h
index 64217220fa2ff..1852c98667db1 100644
--- a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.h
+++ b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.h
@@ -121,6 +121,13 @@ class LoongArchInstrInfo : public LoongArchGenInstrInfo {
   MachineInstr *emitLdStWithAddr(MachineInstr &MemI,
                                  const ExtAddrMode &AM) const override;
 
+  bool useMachineCombiner() const override { return true; }
+
+  bool isAssociativeAndCommutative(const MachineInstr &Inst,
+                                   bool Invert) const override;
+
+  std::optional<unsigned> getInverseOpcode(unsigned Opcode) const override;
+
 protected:
   const LoongArchSubtarget &STI;
 };
diff --git a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
index bb3825392a1b7..10457c7636807 100644
--- a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
@@ -69,6 +69,11 @@ static cl::opt<bool>
                    cl::desc("Enable sinking and folding of instruction copies"),
                    cl::init(true), cl::Hidden);
 
+static cl::opt<bool>
+    EnableMachineCombiner("loongarch-enable-machine-combiner",
+                          cl::desc("Enable the machine combiner pass"),
+                          cl::init(true), cl::Hidden);
+
 static Reloc::Model getEffectiveRelocModel(std::optional<Reloc::Model> RM) {
   return RM.value_or(Reloc::Static);
 }
@@ -155,6 +160,7 @@ class LoongArchPassConfig : public TargetPassConfig {
   void addPreEmitPass2() override;
   void addMachineSSAOptimization() override;
   void addPreRegAlloc() override;
+  bool addILPOpts() override;
   bool addRegAssignAndRewriteFast() override;
   bool addRegAssignAndRewriteOptimized() override;
   void addMachineLateOptimization() override;
@@ -221,6 +227,13 @@ void LoongArchPassConfig::addPreRegAlloc() {
     addPass(createLoongArchMergeBaseOffsetOptPass());
 }
 
+bool LoongArchPassConfig::addILPOpts() {
+  if (EnableMachineCombiner)
+    addPass(&MachineCombinerID);
+
+  return true;
+}
+
 bool LoongArchPassConfig::addRegAssignAndRewriteFast() {
   if (TM->getOptLevel() != CodeGenOptLevel::None &&
       EnableLoongArchDeadRegisterElimination)
diff --git a/llvm/test/CodeGen/LoongArch/alsl.ll b/llvm/test/CodeGen/LoongArch/alsl.ll
index da3460953c5c9..b8e82018f9886 100644
--- a/llvm/test/CodeGen/LoongArch/alsl.ll
+++ b/llvm/test/CodeGen/LoongArch/alsl.ll
@@ -186,8 +186,8 @@ define i8 @mul_add_i8(i8 signext %a, i8 signext %b) nounwind {
 ; LA32R-LABEL: mul_add_i8:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 1
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    add.w $a0, $a1, $a0
+; LA32R-NEXT:    add.w $a0, $a0, $a2
 ; LA32R-NEXT:    ret
 ;
 ; LA32S-LABEL: mul_add_i8:
@@ -272,9 +272,9 @@ define i64 @mul_add_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA32R-NEXT:    sub.w $a1, $a5, $a1
 ; LA32R-NEXT:    add.w $a1, $a4, $a1
 ; LA32R-NEXT:    slli.w $a4, $a0, 4
-; LA32R-NEXT:    sub.w $a0, $a4, $a0
 ; LA32R-NEXT:    add.w $a1, $a3, $a1
-; LA32R-NEXT:    add.w $a0, $a2, $a0
+; LA32R-NEXT:    sub.w $a0, $a2, $a0
+; LA32R-NEXT:    add.w $a0, $a0, $a4
 ; LA32R-NEXT:    sltu $a2, $a0, $a2
 ; LA32R-NEXT:    add.w $a1, $a1, $a2
 ; LA32R-NEXT:    ret
@@ -287,9 +287,9 @@ define i64 @mul_add_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA32S-NEXT:    sub.w $a1, $a5, $a1
 ; LA32S-NEXT:    add.w $a1, $a4, $a1
 ; LA32S-NEXT:    slli.w $a4, $a0, 4
-; LA32S-NEXT:    sub.w $a0, $a4, $a0
 ; LA32S-NEXT:    add.w $a1, $a3, $a1
-; LA32S-NEXT:    add.w $a0, $a2, $a0
+; LA32S-NEXT:    sub.w $a0, $a2, $a0
+; LA32S-NEXT:    add.w $a0, $a0, $a4
 ; LA32S-NEXT:    sltu $a2, $a0, $a2
 ; LA32S-NEXT:    add.w $a1, $a1, $a2
 ; LA32S-NEXT:    ret
@@ -297,8 +297,8 @@ define i64 @mul_add_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA64-LABEL: mul_add_i64:
 ; LA64:       # %bb.0: # %entry
 ; LA64-NEXT:    slli.d $a2, $a0, 4
-; LA64-NEXT:    sub.d $a0, $a2, $a0
-; LA64-NEXT:    add.d $a0, $a1, $a0
+; LA64-NEXT:    sub.d $a0, $a1, $a0
+; LA64-NEXT:    add.d $a0, $a0, $a2
 ; LA64-NEXT:    ret
 entry:
   %mul = mul nsw i64 %a, 15
@@ -310,8 +310,8 @@ define i32 @mul_add_zext_i8(i8 signext %a, i8 signext %b) nounwind {
 ; LA32R-LABEL: mul_add_zext_i8:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 2
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    add.w $a0, $a1, $a0
+; LA32R-NEXT:    add.w $a0, $a0, $a2
 ; LA32R-NEXT:    andi $a0, $a0, 255
 ; LA32R-NEXT:    ret
 ;
@@ -339,8 +339,8 @@ define i32 @mul_add_zext_i16(i16 signext %a, i16 signext %b) nounwind {
 ; LA32R-LABEL: mul_add_zext_i16:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 4
-; LA32R-NEXT:    sub.w $a0, $a2, $a0
-; LA32R-NEXT:    add.w $a0, $a1, $a0
+; LA32R-NEXT:    sub.w $a0, $a1, $a0
+; LA32R-NEXT:    add.w $a0, $a0, $a2
 ; LA32R-NEXT:    lu12i.w $a1, 15
 ; LA32R-NEXT:    ori $a1, $a1, 4095
 ; LA32R-NEXT:    and $a0, $a0, $a1
@@ -349,16 +349,16 @@ define i32 @mul_add_zext_i16(i16 signext %a, i16 signext %b) nounwind {
 ; LA32S-LABEL: mul_add_zext_i16:
 ; LA32S:       # %bb.0: # %entry
 ; LA32S-NEXT:    slli.w $a2, $a0, 4
-; LA32S-NEXT:    sub.w $a0, $a2, $a0
-; LA32S-NEXT:    add.w $a0, $a1, $a0
+; LA32S-NEXT:    sub.w $a0, $a1, $a0
+; LA32S-NEXT:    add.w $a0, $a0, $a2
 ; LA32S-NEXT:    bstrpick.w $a0, $a0, 15, 0
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: mul_add_zext_i16:
 ; LA64:       # %bb.0: # %entry
 ; LA64-NEXT:    slli.d $a2, $a0, 4
-; LA64-NEXT:    sub.d $a0, $a2, $a0
-; LA64-NEXT:    add.d $a0, $a1, $a0
+; LA64-NEXT:    sub.d $a0, $a1, $a0
+; LA64-NEXT:    add.d $a0, $a0, $a2
 ; LA64-NEXT:    bstrpick.d $a0, $a0, 15, 0
 ; LA64-NEXT:    ret
 entry:
@@ -372,8 +372,8 @@ define i64 @mul_add_zext_i32(i32 signext %a, i32 signext %b) nounwind {
 ; LA32R-LABEL: mul_add_zext_i32:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 2
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    add.w $a0, $a1, $a0
+; LA32R-NEXT:    add.w $a0, $a0, $a2
 ; LA32R-NEXT:    move $a1, $zero
 ; LA32R-NEXT:    ret
 ;
@@ -401,8 +401,8 @@ define i8 @alsl_neg_i8(i8 signext %a, i8 signext %b) nounwind {
 ; LA32R-LABEL: alsl_neg_i8:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 1
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    sub.w $a0, $a1, $a0
+; LA32R-NEXT:    sub.w $a0, $a0, $a2
 ; LA32R-NEXT:    ret
 ;
 ; LA32S-LABEL: alsl_neg_i8:
@@ -426,8 +426,8 @@ define i16 @alsl_neg_i16(i16 signext %a, i16 signext %b) nounwind {
 ; LA32R-LABEL: alsl_neg_i16:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 2
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    sub.w $a0, $a1, $a0
+; LA32R-NEXT:    sub.w $a0, $a0, $a2
 ; LA32R-NEXT:    ret
 ;
 ; LA32S-LABEL: alsl_neg_i16:
@@ -451,8 +451,8 @@ define i32 @alsl_neg_i32(i32 signext %a, i32 signext %b) nounwind {
 ; LA32R-LABEL: alsl_neg_i32:
 ; LA32R:       # %bb.0: # %entry
 ; LA32R-NEXT:    slli.w $a2, $a0, 3
-; LA32R-NEXT:    add.w $a0, $a2, $a0
 ; LA32R-NEXT:    sub.w $a0, $a1, $a0
+; LA32R-NEXT:    sub.w $a0, $a0, $a2
 ; LA32R-NEXT:    ret
 ;
 ; LA32S-LABEL: alsl_neg_i32:
@@ -480,11 +480,11 @@ define i64 @mul_add_neg_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA32R-NEXT:    addi.w $a4, $zero, -15
 ; LA32R-NEXT:    mulh.wu $a4, $a0, $a4
 ; LA32R-NEXT:    sub.w $a4, $a4, $a0
-; LA32R-NEXT:    add.w $a1, $a4, $a1
-; LA32R-NEXT:    slli.w $a4, $a0, 4
-; LA32R-NEXT:    sub.w $a0, $a0, $a4
+; LA32R-NEXT:    slli.w $a5, $a0, 4
 ; LA32R-NEXT:    add.w $a1, $a3, $a1
+; LA32R-NEXT:    add.w $a1, $a1, $a4
 ; LA32R-NEXT:    add.w $a0, $a2, $a0
+; LA32R-NEXT:    sub.w $a0, $a0, $a5
 ; LA32R-NEXT:    sltu $a2, $a0, $a2
 ; LA32R-NEXT:    add.w $a1, $a1, $a2
 ; LA32R-NEXT:    ret
@@ -496,11 +496,11 @@ define i64 @mul_add_neg_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA32S-NEXT:    addi.w $a4, $zero, -15
 ; LA32S-NEXT:    mulh.wu $a4, $a0, $a4
 ; LA32S-NEXT:    sub.w $a4, $a4, $a0
-; LA32S-NEXT:    add.w $a1, $a4, $a1
-; LA32S-NEXT:    slli.w $a4, $a0, 4
-; LA32S-NEXT:    sub.w $a0, $a0, $a4
+; LA32S-NEXT:    slli.w $a5, $a0, 4
 ; LA32S-NEXT:    add.w $a1, $a3, $a1
+; LA32S-NEXT:    add.w $a1, $a1, $a4
 ; LA32S-NEXT:    add.w $a0, $a2, $a0
+; LA32S-NEXT:    sub.w $a0, $a0, $a5
 ; LA32S-NEXT:    sltu $a2, $a0, $a2
 ; LA32S-NEXT:    add.w $a1, $a1, $a2
 ; LA32S-NEXT:    ret
@@ -508,8 +508,8 @@ define i64 @mul_add_neg_i64(i64 signext %a, i64 signext %b) nounwind {
 ; LA64-LABEL: mul_add_neg_i64:
 ; LA64:       # %bb.0: # %entry
 ; LA64-NEXT:    slli.d $a2, $a0, 4
-; LA64-NEXT:    sub.d $a0, $a0, $a2
 ; LA64-NEXT:    add.d $a0, $a1, $a0
+; LA64-NEXT:    sub.d $a0, $a0, $a2
 ; LA64-NEXT:    ret
 entry:
   %mul = mul nsw i64 %a, -15
diff --git a/llvm/test/CodeGen/LoongArch/bittest.ll b/llvm/test/CodeGen/LoongArch/bittest.ll
index 9cf24dc5f65cc..b229c2740d4ea 100644
--- a/llvm/test/CodeGen/LoongArch/bittest.ll
+++ b/llvm/test/CodeGen/LoongArch/bittest.ll
@@ -256,10 +256,10 @@ define i1 @bittest_constant_by_var_shl_i64(i64 %b) nounwind {
 ; LA32-NEXT:    sub.w $a1, $zero, $a1
 ; LA32-NEXT:    ori $a2, $zero, 1
 ; LA32-NEXT:    sll.w $a0, $a2, $a0
+; LA32-NEXT:    lu12i.w $a2, 301408
+; LA32-NEXT:    ori $a2, $a2, 722
+; LA32-NEXT:    and $a0, $a0, $a2
 ; LA32-NEXT:    and $a0, $a1, $a0
-; LA32-NEXT:    lu12i.w $a1, 301408
-; LA32-NEXT:    ori $a1, $a1, 722
-; LA32-NEXT:    and $a0, $a0, $a1
 ; LA32-NEXT:    sltu $a0, $zero, $a0
 ; LA32-NEXT:    ret
 ;
diff --git a/llvm/test/CodeGen/LoongArch/calling-conv-common.ll b/llvm/test/CodeGen/LoongArch/calling-conv-common.ll
index f7653af1fa9ba..f148236a14f65 100644
--- a/llvm/test/CodeGen/LoongArch/calling-conv-common.ll
+++ b/llvm/test/CodeGen/LoongArch/calling-conv-common.ll
@@ -43,15 +43,15 @@ define i64 @callee_many_scalars(i8 %a, i16 %b, i32 %c, i64 %d, i128 %e, i64 %f,
 ; CHECK-NEXT:    bstrpick.d $a1, $a1, 15, 0
 ; CHECK-NEXT:    bstrpick.d $a2, $a2, 31, 0
 ; CHECK-NEXT:    add.d $a0, $a0, $a1
-; CHECK-NEXT:    add.d $a0, $a0, $a2
-; CHECK-NEXT:    add.d $a0, $a0, $a3
+; CHECK-NEXT:    add.d $a1, $a2, $a3
+; CHECK-NEXT:    add.d $a0, $a0, $a1
 ; CHECK-NEXT:    xor $a1, $a5, $t1
 ; CHECK-NEXT:    xor $a2, $a4, $a7
 ; CHECK-NEXT:    or $a1, $a2, $a1
 ; CHECK-NEXT:    sltui $a1, $a1, 1
-; CHECK-NEXT:    add.d $a0, $a1, $a0
 ; CHECK-NEXT:    add.d $a0, $a0, $a6
 ; CHECK-NEXT:    add.d $a0, $a0, $t0
+; CHECK-NEXT:    add.d $a0, $a1, $a0
 ; CHECK-NEXT:    ret
   %a_ext = zext i8 %a to i64
   %b_ext = zext i16 %b to i64
diff --git a/llvm/test/CodeGen/LoongArch/lasx/machine-combiner.ll b/llvm/test/CodeGen/LoongArch/lasx/machine-combiner.ll
new file mode 100644
index 0000000000000..ba6bb9d90b1d4
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/lasx/machine-combiner.ll
@@ -0,0 +1,565 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc --mtriple=loongarch64 --mattr=+lasx -verify-machineinstrs -O1 \
+; RUN:   -loongarch-enable-machine-combiner=true < %s | FileCheck %s
+
+define <32 x i8> @test_add_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_add_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.b $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvadd.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <32 x i8> %a0, %a1
+  %t1 = add <32 x i8> %t0, %a2
+  %t2 = add <32 x i8> %t1, %a3
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_add_sub_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_add_sub_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.b $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvsub.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <32 x i8> %a0, %a1
+  %t1 = sub <32 x i8> %t0, %a2
+  %t2 = sub <32 x i8> %t1, %a3
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_mul_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_mul_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmul.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmul.b $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmul.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = mul <32 x i8> %a0, %a1
+  %t1 = mul <32 x i8> %t0, %a2
+  %t2 = mul <32 x i8> %t1, %a3
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_smin_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_smin_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.b $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <32 x i8> @llvm.smin.v32i8(<32 x i8> %a0, <32 x i8> %a1)
+  %t1 = call <32 x i8> @llvm.smin.v32i8(<32 x i8> %t0, <32 x i8> %a2)
+  %t2 = call <32 x i8> @llvm.smin.v32i8(<32 x i8> %t1, <32 x i8> %a3)
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_smax_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_smax_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.b $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.b $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <32 x i8> @llvm.smax.v32i8(<32 x i8> %a0, <32 x i8> %a1)
+  %t1 = call <32 x i8> @llvm.smax.v32i8(<32 x i8> %t0, <32 x i8> %a2)
+  %t2 = call <32 x i8> @llvm.smax.v32i8(<32 x i8> %t1, <32 x i8> %a3)
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_umin_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_umin_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.bu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.bu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.bu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <32 x i8> @llvm.umin.v32i8(<32 x i8> %a0, <32 x i8> %a1)
+  %t1 = call <32 x i8> @llvm.umin.v32i8(<32 x i8> %t0, <32 x i8> %a2)
+  %t2 = call <32 x i8> @llvm.umin.v32i8(<32 x i8> %t1, <32 x i8> %a3)
+  ret <32 x i8> %t2
+}
+
+define <32 x i8> @test_umax_v32i8(<32 x i8> %a0, <32 x i8> %a1, <32 x i8> %a2, <32 x i8> %a3) {
+; CHECK-LABEL: test_umax_v32i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.bu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.bu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.bu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <32 x i8> @llvm.umax.v32i8(<32 x i8> %a0, <32 x i8> %a1)
+  %t1 = call <32 x i8> @llvm.umax.v32i8(<32 x i8> %t0, <32 x i8> %a2)
+  %t2 = call <32 x i8> @llvm.umax.v32i8(<32 x i8> %t1, <32 x i8> %a3)
+  ret <32 x i8> %t2
+}
+
+define <16 x i16> @test_add_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_add_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.h $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvadd.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <16 x i16> %a0, %a1
+  %t1 = add <16 x i16> %t0, %a2
+  %t2 = add <16 x i16> %t1, %a3
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_add_sub_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_add_sub_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.h $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvsub.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <16 x i16> %a0, %a1
+  %t1 = sub <16 x i16> %t0, %a2
+  %t2 = sub <16 x i16> %t1, %a3
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_mul_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_mul_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmul.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmul.h $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmul.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = mul <16 x i16> %a0, %a1
+  %t1 = mul <16 x i16> %t0, %a2
+  %t2 = mul <16 x i16> %t1, %a3
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_smin_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_smin_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.h $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i16> @llvm.smin.v16i16(<16 x i16> %a0, <16 x i16> %a1)
+  %t1 = call <16 x i16> @llvm.smin.v16i16(<16 x i16> %t0, <16 x i16> %a2)
+  %t2 = call <16 x i16> @llvm.smin.v16i16(<16 x i16> %t1, <16 x i16> %a3)
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_smax_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_smax_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.h $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.h $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i16> @llvm.smax.v16i16(<16 x i16> %a0, <16 x i16> %a1)
+  %t1 = call <16 x i16> @llvm.smax.v16i16(<16 x i16> %t0, <16 x i16> %a2)
+  %t2 = call <16 x i16> @llvm.smax.v16i16(<16 x i16> %t1, <16 x i16> %a3)
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_umin_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_umin_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.hu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.hu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.hu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i16> @llvm.umin.v16i16(<16 x i16> %a0, <16 x i16> %a1)
+  %t1 = call <16 x i16> @llvm.umin.v16i16(<16 x i16> %t0, <16 x i16> %a2)
+  %t2 = call <16 x i16> @llvm.umin.v16i16(<16 x i16> %t1, <16 x i16> %a3)
+  ret <16 x i16> %t2
+}
+
+define <16 x i16> @test_umax_v16i16(<16 x i16> %a0, <16 x i16> %a1, <16 x i16> %a2, <16 x i16> %a3) {
+; CHECK-LABEL: test_umax_v16i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.hu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.hu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.hu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i16> @llvm.umax.v16i16(<16 x i16> %a0, <16 x i16> %a1)
+  %t1 = call <16 x i16> @llvm.umax.v16i16(<16 x i16> %t0, <16 x i16> %a2)
+  %t2 = call <16 x i16> @llvm.umax.v16i16(<16 x i16> %t1, <16 x i16> %a3)
+  ret <16 x i16> %t2
+}
+
+define <8 x i32> @test_add_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_add_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.w $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvadd.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <8 x i32> %a0, %a1
+  %t1 = add <8 x i32> %t0, %a2
+  %t2 = add <8 x i32> %t1, %a3
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_add_sub_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_add_sub_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.w $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvsub.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <8 x i32> %a0, %a1
+  %t1 = sub <8 x i32> %t0, %a2
+  %t2 = sub <8 x i32> %t1, %a3
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_mul_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_mul_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmul.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmul.w $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmul.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = mul <8 x i32> %a0, %a1
+  %t1 = mul <8 x i32> %t0, %a2
+  %t2 = mul <8 x i32> %t1, %a3
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_smin_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_smin_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.w $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i32> @llvm.smin.v8i32(<8 x i32> %a0, <8 x i32> %a1)
+  %t1 = call <8 x i32> @llvm.smin.v8i32(<8 x i32> %t0, <8 x i32> %a2)
+  %t2 = call <8 x i32> @llvm.smin.v8i32(<8 x i32> %t1, <8 x i32> %a3)
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_smax_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_smax_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.w $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.w $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i32> @llvm.smax.v8i32(<8 x i32> %a0, <8 x i32> %a1)
+  %t1 = call <8 x i32> @llvm.smax.v8i32(<8 x i32> %t0, <8 x i32> %a2)
+  %t2 = call <8 x i32> @llvm.smax.v8i32(<8 x i32> %t1, <8 x i32> %a3)
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_umin_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_umin_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.wu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.wu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.wu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i32> @llvm.umin.v8i32(<8 x i32> %a0, <8 x i32> %a1)
+  %t1 = call <8 x i32> @llvm.umin.v8i32(<8 x i32> %t0, <8 x i32> %a2)
+  %t2 = call <8 x i32> @llvm.umin.v8i32(<8 x i32> %t1, <8 x i32> %a3)
+  ret <8 x i32> %t2
+}
+
+define <8 x i32> @test_umax_v8i32(<8 x i32> %a0, <8 x i32> %a1, <8 x i32> %a2, <8 x i32> %a3) {
+; CHECK-LABEL: test_umax_v8i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.wu $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.wu $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.wu $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i32> @llvm.umax.v8i32(<8 x i32> %a0, <8 x i32> %a1)
+  %t1 = call <8 x i32> @llvm.umax.v8i32(<8 x i32> %t0, <8 x i32> %a2)
+  %t2 = call <8 x i32> @llvm.umax.v8i32(<8 x i32> %t1, <8 x i32> %a3)
+  ret <8 x i32> %t2
+}
+
+define <4 x i64> @test_add_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_add_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <4 x i64> %a0, %a1
+  %t1 = add <4 x i64> %t0, %a2
+  %t2 = add <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_add_sub_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_add_sub_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvadd.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvsub.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = add <4 x i64> %a0, %a1
+  %t1 = sub <4 x i64> %t0, %a2
+  %t2 = sub <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_mul_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_mul_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmul.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmul.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmul.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = mul <4 x i64> %a0, %a1
+  %t1 = mul <4 x i64> %t0, %a2
+  %t2 = mul <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_smin_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_smin_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i64> @llvm.smin.v4i64(<4 x i64> %a0, <4 x i64> %a1)
+  %t1 = call <4 x i64> @llvm.smin.v4i64(<4 x i64> %t0, <4 x i64> %a2)
+  %t2 = call <4 x i64> @llvm.smin.v4i64(<4 x i64> %t1, <4 x i64> %a3)
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_smax_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_smax_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i64> @llvm.smax.v4i64(<4 x i64> %a0, <4 x i64> %a1)
+  %t1 = call <4 x i64> @llvm.smax.v4i64(<4 x i64> %t0, <4 x i64> %a2)
+  %t2 = call <4 x i64> @llvm.smax.v4i64(<4 x i64> %t1, <4 x i64> %a3)
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_umin_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_umin_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmin.du $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmin.du $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmin.du $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i64> @llvm.umin.v4i64(<4 x i64> %a0, <4 x i64> %a1)
+  %t1 = call <4 x i64> @llvm.umin.v4i64(<4 x i64> %t0, <4 x i64> %a2)
+  %t2 = call <4 x i64> @llvm.umin.v4i64(<4 x i64> %t1, <4 x i64> %a3)
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_umax_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_umax_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvmax.du $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvmax.du $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvmax.du $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i64> @llvm.umax.v4i64(<4 x i64> %a0, <4 x i64> %a1)
+  %t1 = call <4 x i64> @llvm.umax.v4i64(<4 x i64> %t0, <4 x i64> %a2)
+  %t2 = call <4 x i64> @llvm.umax.v4i64(<4 x i64> %t1, <4 x i64> %a3)
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_and_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_and_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvand.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvand.v $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvand.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = and <4 x i64> %a0, %a1
+  %t1 = and <4 x i64> %t0, %a2
+  %t2 = and <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_or_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_or_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvor.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvor.v $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvor.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = or <4 x i64> %a0, %a1
+  %t1 = or <4 x i64> %t0, %a2
+  %t2 = or <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <4 x i64> @test_xor_v4i64(<4 x i64> %a0, <4 x i64> %a1, <4 x i64> %a2, <4 x i64> %a3) {
+; CHECK-LABEL: test_xor_v4i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvxor.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvxor.v $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvxor.v $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = xor <4 x i64> %a0, %a1
+  %t1 = xor <4 x i64> %t0, %a2
+  %t2 = xor <4 x i64> %t1, %a3
+  ret <4 x i64> %t2
+}
+
+define <8 x float> @test_fadd_v8f32(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, <8 x float> %a3) {
+; CHECK-LABEL: test_fadd_v8f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfadd.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfadd.s $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfadd.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <8 x float> %a0, %a1
+  %t1 = fadd nsz reassoc <8 x float> %t0, %a2
+  %t2 = fadd nsz reassoc <8 x float> %t1, %a3
+  ret <8 x float> %t2
+}
+
+define <8 x float> @test_fadd_fsub_v8f32(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, <8 x float> %a3) {
+; CHECK-LABEL: test_fadd_fsub_v8f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfadd.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfadd.s $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfsub.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <8 x float> %a0, %a1
+  %t1 = fsub nsz reassoc <8 x float> %t0, %a2
+  %t2 = fsub nsz reassoc <8 x float> %t1, %a3
+  ret <8 x float> %t2
+}
+
+define <8 x float> @test_fmul_v8f32(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, <8 x float> %a3) {
+; CHECK-LABEL: test_fmul_v8f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmul.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmul.s $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmul.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc <8 x float> %a0, %a1
+  %t1 = fmul nsz reassoc <8 x float> %t0, %a2
+  %t2 = fmul nsz reassoc <8 x float> %t1, %a3
+  ret <8 x float> %t2
+}
+
+define <8 x float> @test_fmin_nnan_v8f32(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, <8 x float> %a3) {
+; CHECK-LABEL: test_fmin_nnan_v8f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmin.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmin.s $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmin.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <8 x float> @llvm.minnum.v8f32(<8 x float> %a0, <8 x float> %a1)
+  %t1 = call nnan <8 x float> @llvm.minnum.v8f32(<8 x float> %t0, <8 x float> %a2)
+  %t2 = call nnan <8 x float> @llvm.minnum.v8f32(<8 x float> %t1, <8 x float> %a3)
+  ret <8 x float> %t2
+}
+
+define <8 x float> @test_fmax_nnan_v8f32(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, <8 x float> %a3) {
+; CHECK-LABEL: test_fmax_nnan_v8f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmax.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmax.s $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmax.s $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <8 x float> @llvm.maxnum.v8f32(<8 x float> %a0, <8 x float> %a1)
+  %t1 = call nnan <8 x float> @llvm.maxnum.v8f32(<8 x float> %t0, <8 x float> %a2)
+  %t2 = call nnan <8 x float> @llvm.maxnum.v8f32(<8 x float> %t1, <8 x float> %a3)
+  ret <8 x float> %t2
+}
+
+define <4 x double> @test_fadd_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fadd_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfadd.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <4 x double> %a0, %a1
+  %t1 = fadd nsz reassoc <4 x double> %t0, %a2
+  %t2 = fadd nsz reassoc <4 x double> %t1, %a3
+  ret <4 x double> %t2
+}
+
+define <4 x double> @test_fadd_fsub_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fadd_fsub_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfadd.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfsub.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <4 x double> %a0, %a1
+  %t1 = fsub nsz reassoc <4 x double> %t0, %a2
+  %t2 = fsub nsz reassoc <4 x double> %t1, %a3
+  ret <4 x double> %t2
+}
+
+define <4 x double> @test_fmul_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fmul_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmul.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmul.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmul.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc <4 x double> %a0, %a1
+  %t1 = fmul nsz reassoc <4 x double> %t0, %a2
+  %t2 = fmul nsz reassoc <4 x double> %t1, %a3
+  ret <4 x double> %t2
+}
+
+define <4 x double> @test_fmin_nnan_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fmin_nnan_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmin.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmin.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmin.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <4 x double> @llvm.minnum.v4f64(<4 x double> %a0, <4 x double> %a1)
+  %t1 = call nnan <4 x double> @llvm.minnum.v4f64(<4 x double> %t0, <4 x double> %a2)
+  %t2 = call nnan <4 x double> @llvm.minnum.v4f64(<4 x double> %t1, <4 x double> %a3)
+  ret <4 x double> %t2
+}
+
+define <4 x double> @test_fmax_nnan_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fmax_nnan_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmax.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmax.d $xr1, $xr2, $xr3
+; CHECK-NEXT:    xvfmax.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <4 x double> @llvm.maxnum.v4f64(<4 x double> %a0, <4 x double> %a1)
+  %t1 = call nnan <4 x double> @llvm.maxnum.v4f64(<4 x double> %t0, <4 x double> %a2)
+  %t2 = call nnan <4 x double> @llvm.maxnum.v4f64(<4 x double> %t1, <4 x double> %a3)
+  ret <4 x double> %t2
+}
+
+; Negative test
+define <4 x double> @test_fadd_noflags_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fadd_noflags_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr2
+; CHECK-NEXT:    xvfadd.d $xr0, $xr0, $xr3
+; CHECK-NEXT:    ret
+  %t0 = fadd <4 x double> %a0, %a1
+  %t1 = fadd <4 x double> %t0, %a2
+  %t2 = fadd <4 x double> %t1, %a3
+  ret <4 x double> %t2
+}
+
+; Negative test
+define <4 x double> @test_fmin_no_nnan_v4f64(<4 x double> %a0, <4 x double> %a1, <4 x double> %a2, <4 x double> %a3) {
+; CHECK-LABEL: test_fmin_no_nnan_v4f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xvfmin.d $xr0, $xr0, $xr1
+; CHECK-NEXT:    xvfmin.d $xr0, $xr0, $xr2
+; CHECK-NEXT:    xvfmin.d $xr0, $xr0, $xr3
+; CHECK-NEXT:    ret
+  %t0 = call <4 x double> @llvm.minnum.v4f64(<4 x double> %a0, <4 x double> %a1)
+  %t1 = call <4 x double> @llvm.minnum.v4f64(<4 x double> %t0, <4 x double> %a2)
+  %t2 = call <4 x double> @llvm.minnum.v4f64(<4 x double> %t1, <4 x double> %a3)
+  ret <4 x double> %t2
+}
+
diff --git a/llvm/test/CodeGen/LoongArch/lsx/machine-combiner.ll b/llvm/test/CodeGen/LoongArch/lsx/machine-combiner.ll
new file mode 100644
index 0000000000000..00960057872b2
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/lsx/machine-combiner.ll
@@ -0,0 +1,565 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc --mtriple=loongarch64 --mattr=+lsx -verify-machineinstrs -O1 \
+; RUN:   -loongarch-enable-machine-combiner=true < %s | FileCheck %s
+
+define <16 x i8> @test_add_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_add_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.b $vr1, $vr2, $vr3
+; CHECK-NEXT:    vadd.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <16 x i8> %a0, %a1
+  %t1 = add <16 x i8> %t0, %a2
+  %t2 = add <16 x i8> %t1, %a3
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_add_sub_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_add_sub_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.b $vr1, $vr2, $vr3
+; CHECK-NEXT:    vsub.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <16 x i8> %a0, %a1
+  %t1 = sub <16 x i8> %t0, %a2
+  %t2 = sub <16 x i8> %t1, %a3
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_mul_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_mul_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmul.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmul.b $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmul.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = mul <16 x i8> %a0, %a1
+  %t1 = mul <16 x i8> %t0, %a2
+  %t2 = mul <16 x i8> %t1, %a3
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_smin_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_smin_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.b $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i8> @llvm.smin.v16i8(<16 x i8> %a0, <16 x i8> %a1)
+  %t1 = call <16 x i8> @llvm.smin.v16i8(<16 x i8> %t0, <16 x i8> %a2)
+  %t2 = call <16 x i8> @llvm.smin.v16i8(<16 x i8> %t1, <16 x i8> %a3)
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_smax_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_smax_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.b $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.b $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i8> @llvm.smax.v16i8(<16 x i8> %a0, <16 x i8> %a1)
+  %t1 = call <16 x i8> @llvm.smax.v16i8(<16 x i8> %t0, <16 x i8> %a2)
+  %t2 = call <16 x i8> @llvm.smax.v16i8(<16 x i8> %t1, <16 x i8> %a3)
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_umin_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_umin_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.bu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.bu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.bu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i8> @llvm.umin.v16i8(<16 x i8> %a0, <16 x i8> %a1)
+  %t1 = call <16 x i8> @llvm.umin.v16i8(<16 x i8> %t0, <16 x i8> %a2)
+  %t2 = call <16 x i8> @llvm.umin.v16i8(<16 x i8> %t1, <16 x i8> %a3)
+  ret <16 x i8> %t2
+}
+
+define <16 x i8> @test_umax_v16i8(<16 x i8> %a0, <16 x i8> %a1, <16 x i8> %a2, <16 x i8> %a3) {
+; CHECK-LABEL: test_umax_v16i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.bu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.bu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.bu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <16 x i8> @llvm.umax.v16i8(<16 x i8> %a0, <16 x i8> %a1)
+  %t1 = call <16 x i8> @llvm.umax.v16i8(<16 x i8> %t0, <16 x i8> %a2)
+  %t2 = call <16 x i8> @llvm.umax.v16i8(<16 x i8> %t1, <16 x i8> %a3)
+  ret <16 x i8> %t2
+}
+
+define <8 x i16> @test_add_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_add_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.h $vr1, $vr2, $vr3
+; CHECK-NEXT:    vadd.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <8 x i16> %a0, %a1
+  %t1 = add <8 x i16> %t0, %a2
+  %t2 = add <8 x i16> %t1, %a3
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_add_sub_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_add_sub_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.h $vr1, $vr2, $vr3
+; CHECK-NEXT:    vsub.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <8 x i16> %a0, %a1
+  %t1 = sub <8 x i16> %t0, %a2
+  %t2 = sub <8 x i16> %t1, %a3
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_mul_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_mul_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmul.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmul.h $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmul.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = mul <8 x i16> %a0, %a1
+  %t1 = mul <8 x i16> %t0, %a2
+  %t2 = mul <8 x i16> %t1, %a3
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_smin_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_smin_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.h $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i16> @llvm.smin.v8i16(<8 x i16> %a0, <8 x i16> %a1)
+  %t1 = call <8 x i16> @llvm.smin.v8i16(<8 x i16> %t0, <8 x i16> %a2)
+  %t2 = call <8 x i16> @llvm.smin.v8i16(<8 x i16> %t1, <8 x i16> %a3)
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_smax_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_smax_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.h $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.h $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i16> @llvm.smax.v8i16(<8 x i16> %a0, <8 x i16> %a1)
+  %t1 = call <8 x i16> @llvm.smax.v8i16(<8 x i16> %t0, <8 x i16> %a2)
+  %t2 = call <8 x i16> @llvm.smax.v8i16(<8 x i16> %t1, <8 x i16> %a3)
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_umin_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_umin_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.hu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.hu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.hu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i16> @llvm.umin.v8i16(<8 x i16> %a0, <8 x i16> %a1)
+  %t1 = call <8 x i16> @llvm.umin.v8i16(<8 x i16> %t0, <8 x i16> %a2)
+  %t2 = call <8 x i16> @llvm.umin.v8i16(<8 x i16> %t1, <8 x i16> %a3)
+  ret <8 x i16> %t2
+}
+
+define <8 x i16> @test_umax_v8i16(<8 x i16> %a0, <8 x i16> %a1, <8 x i16> %a2, <8 x i16> %a3) {
+; CHECK-LABEL: test_umax_v8i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.hu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.hu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.hu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <8 x i16> @llvm.umax.v8i16(<8 x i16> %a0, <8 x i16> %a1)
+  %t1 = call <8 x i16> @llvm.umax.v8i16(<8 x i16> %t0, <8 x i16> %a2)
+  %t2 = call <8 x i16> @llvm.umax.v8i16(<8 x i16> %t1, <8 x i16> %a3)
+  ret <8 x i16> %t2
+}
+
+define <4 x i32> @test_add_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_add_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.w $vr1, $vr2, $vr3
+; CHECK-NEXT:    vadd.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <4 x i32> %a0, %a1
+  %t1 = add <4 x i32> %t0, %a2
+  %t2 = add <4 x i32> %t1, %a3
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_add_sub_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_add_sub_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.w $vr1, $vr2, $vr3
+; CHECK-NEXT:    vsub.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <4 x i32> %a0, %a1
+  %t1 = sub <4 x i32> %t0, %a2
+  %t2 = sub <4 x i32> %t1, %a3
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_mul_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_mul_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmul.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmul.w $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmul.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = mul <4 x i32> %a0, %a1
+  %t1 = mul <4 x i32> %t0, %a2
+  %t2 = mul <4 x i32> %t1, %a3
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_smin_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_smin_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.w $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i32> @llvm.smin.v4i32(<4 x i32> %a0, <4 x i32> %a1)
+  %t1 = call <4 x i32> @llvm.smin.v4i32(<4 x i32> %t0, <4 x i32> %a2)
+  %t2 = call <4 x i32> @llvm.smin.v4i32(<4 x i32> %t1, <4 x i32> %a3)
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_smax_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_smax_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.w $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.w $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i32> @llvm.smax.v4i32(<4 x i32> %a0, <4 x i32> %a1)
+  %t1 = call <4 x i32> @llvm.smax.v4i32(<4 x i32> %t0, <4 x i32> %a2)
+  %t2 = call <4 x i32> @llvm.smax.v4i32(<4 x i32> %t1, <4 x i32> %a3)
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_umin_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_umin_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.wu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.wu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.wu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i32> @llvm.umin.v4i32(<4 x i32> %a0, <4 x i32> %a1)
+  %t1 = call <4 x i32> @llvm.umin.v4i32(<4 x i32> %t0, <4 x i32> %a2)
+  %t2 = call <4 x i32> @llvm.umin.v4i32(<4 x i32> %t1, <4 x i32> %a3)
+  ret <4 x i32> %t2
+}
+
+define <4 x i32> @test_umax_v4i32(<4 x i32> %a0, <4 x i32> %a1, <4 x i32> %a2, <4 x i32> %a3) {
+; CHECK-LABEL: test_umax_v4i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.wu $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.wu $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.wu $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <4 x i32> @llvm.umax.v4i32(<4 x i32> %a0, <4 x i32> %a1)
+  %t1 = call <4 x i32> @llvm.umax.v4i32(<4 x i32> %t0, <4 x i32> %a2)
+  %t2 = call <4 x i32> @llvm.umax.v4i32(<4 x i32> %t1, <4 x i32> %a3)
+  ret <4 x i32> %t2
+}
+
+define <2 x i64> @test_add_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_add_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <2 x i64> %a0, %a1
+  %t1 = add <2 x i64> %t0, %a2
+  %t2 = add <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_add_sub_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_add_sub_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vadd.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vsub.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = add <2 x i64> %a0, %a1
+  %t1 = sub <2 x i64> %t0, %a2
+  %t2 = sub <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_mul_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_mul_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmul.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmul.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmul.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = mul <2 x i64> %a0, %a1
+  %t1 = mul <2 x i64> %t0, %a2
+  %t2 = mul <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_smin_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_smin_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <2 x i64> @llvm.smin.v2i64(<2 x i64> %a0, <2 x i64> %a1)
+  %t1 = call <2 x i64> @llvm.smin.v2i64(<2 x i64> %t0, <2 x i64> %a2)
+  %t2 = call <2 x i64> @llvm.smin.v2i64(<2 x i64> %t1, <2 x i64> %a3)
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_smax_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_smax_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <2 x i64> @llvm.smax.v2i64(<2 x i64> %a0, <2 x i64> %a1)
+  %t1 = call <2 x i64> @llvm.smax.v2i64(<2 x i64> %t0, <2 x i64> %a2)
+  %t2 = call <2 x i64> @llvm.smax.v2i64(<2 x i64> %t1, <2 x i64> %a3)
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_umin_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_umin_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmin.du $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmin.du $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmin.du $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <2 x i64> @llvm.umin.v2i64(<2 x i64> %a0, <2 x i64> %a1)
+  %t1 = call <2 x i64> @llvm.umin.v2i64(<2 x i64> %t0, <2 x i64> %a2)
+  %t2 = call <2 x i64> @llvm.umin.v2i64(<2 x i64> %t1, <2 x i64> %a3)
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_umax_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_umax_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vmax.du $vr0, $vr0, $vr1
+; CHECK-NEXT:    vmax.du $vr1, $vr2, $vr3
+; CHECK-NEXT:    vmax.du $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call <2 x i64> @llvm.umax.v2i64(<2 x i64> %a0, <2 x i64> %a1)
+  %t1 = call <2 x i64> @llvm.umax.v2i64(<2 x i64> %t0, <2 x i64> %a2)
+  %t2 = call <2 x i64> @llvm.umax.v2i64(<2 x i64> %t1, <2 x i64> %a3)
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_and_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_and_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vand.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    vand.v $vr1, $vr2, $vr3
+; CHECK-NEXT:    vand.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = and <2 x i64> %a0, %a1
+  %t1 = and <2 x i64> %t0, %a2
+  %t2 = and <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_or_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_or_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vor.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    vor.v $vr1, $vr2, $vr3
+; CHECK-NEXT:    vor.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = or <2 x i64> %a0, %a1
+  %t1 = or <2 x i64> %t0, %a2
+  %t2 = or <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <2 x i64> @test_xor_v2i64(<2 x i64> %a0, <2 x i64> %a1, <2 x i64> %a2, <2 x i64> %a3) {
+; CHECK-LABEL: test_xor_v2i64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vxor.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    vxor.v $vr1, $vr2, $vr3
+; CHECK-NEXT:    vxor.v $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = xor <2 x i64> %a0, %a1
+  %t1 = xor <2 x i64> %t0, %a2
+  %t2 = xor <2 x i64> %t1, %a3
+  ret <2 x i64> %t2
+}
+
+define <4 x float> @test_fadd_v4f32(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, <4 x float> %a3) {
+; CHECK-LABEL: test_fadd_v4f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfadd.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfadd.s $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfadd.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <4 x float> %a0, %a1
+  %t1 = fadd nsz reassoc <4 x float> %t0, %a2
+  %t2 = fadd nsz reassoc <4 x float> %t1, %a3
+  ret <4 x float> %t2
+}
+
+define <4 x float> @test_fadd_fsub_v4f32(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, <4 x float> %a3) {
+; CHECK-LABEL: test_fadd_fsub_v4f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfadd.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfadd.s $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfsub.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <4 x float> %a0, %a1
+  %t1 = fsub nsz reassoc <4 x float> %t0, %a2
+  %t2 = fsub nsz reassoc <4 x float> %t1, %a3
+  ret <4 x float> %t2
+}
+
+define <4 x float> @test_fmul_v4f32(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, <4 x float> %a3) {
+; CHECK-LABEL: test_fmul_v4f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmul.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmul.s $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmul.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc <4 x float> %a0, %a1
+  %t1 = fmul nsz reassoc <4 x float> %t0, %a2
+  %t2 = fmul nsz reassoc <4 x float> %t1, %a3
+  ret <4 x float> %t2
+}
+
+define <4 x float> @test_fmin_nnan_v4f32(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, <4 x float> %a3) {
+; CHECK-LABEL: test_fmin_nnan_v4f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmin.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmin.s $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmin.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <4 x float> @llvm.minnum.v4f32(<4 x float> %a0, <4 x float> %a1)
+  %t1 = call nnan <4 x float> @llvm.minnum.v4f32(<4 x float> %t0, <4 x float> %a2)
+  %t2 = call nnan <4 x float> @llvm.minnum.v4f32(<4 x float> %t1, <4 x float> %a3)
+  ret <4 x float> %t2
+}
+
+define <4 x float> @test_fmax_nnan_v4f32(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, <4 x float> %a3) {
+; CHECK-LABEL: test_fmax_nnan_v4f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmax.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmax.s $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmax.s $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <4 x float> @llvm.maxnum.v4f32(<4 x float> %a0, <4 x float> %a1)
+  %t1 = call nnan <4 x float> @llvm.maxnum.v4f32(<4 x float> %t0, <4 x float> %a2)
+  %t2 = call nnan <4 x float> @llvm.maxnum.v4f32(<4 x float> %t1, <4 x float> %a3)
+  ret <4 x float> %t2
+}
+
+define <2 x double> @test_fadd_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fadd_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfadd.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <2 x double> %a0, %a1
+  %t1 = fadd nsz reassoc <2 x double> %t0, %a2
+  %t2 = fadd nsz reassoc <2 x double> %t1, %a3
+  ret <2 x double> %t2
+}
+
+define <2 x double> @test_fadd_fsub_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fadd_fsub_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfadd.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfsub.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc <2 x double> %a0, %a1
+  %t1 = fsub nsz reassoc <2 x double> %t0, %a2
+  %t2 = fsub nsz reassoc <2 x double> %t1, %a3
+  ret <2 x double> %t2
+}
+
+define <2 x double> @test_fmul_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fmul_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmul.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmul.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmul.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc <2 x double> %a0, %a1
+  %t1 = fmul nsz reassoc <2 x double> %t0, %a2
+  %t2 = fmul nsz reassoc <2 x double> %t1, %a3
+  ret <2 x double> %t2
+}
+
+define <2 x double> @test_fmin_nnan_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fmin_nnan_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmin.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmin.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmin.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <2 x double> @llvm.minnum.v2f64(<2 x double> %a0, <2 x double> %a1)
+  %t1 = call nnan <2 x double> @llvm.minnum.v2f64(<2 x double> %t0, <2 x double> %a2)
+  %t2 = call nnan <2 x double> @llvm.minnum.v2f64(<2 x double> %t1, <2 x double> %a3)
+  ret <2 x double> %t2
+}
+
+define <2 x double> @test_fmax_nnan_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fmax_nnan_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmax.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmax.d $vr1, $vr2, $vr3
+; CHECK-NEXT:    vfmax.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    ret
+  %t0 = call nnan <2 x double> @llvm.maxnum.v2f64(<2 x double> %a0, <2 x double> %a1)
+  %t1 = call nnan <2 x double> @llvm.maxnum.v2f64(<2 x double> %t0, <2 x double> %a2)
+  %t2 = call nnan <2 x double> @llvm.maxnum.v2f64(<2 x double> %t1, <2 x double> %a3)
+  ret <2 x double> %t2
+}
+
+; Negative test
+define <2 x double> @test_fadd_noflags_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fadd_noflags_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr2
+; CHECK-NEXT:    vfadd.d $vr0, $vr0, $vr3
+; CHECK-NEXT:    ret
+  %t0 = fadd <2 x double> %a0, %a1
+  %t1 = fadd <2 x double> %t0, %a2
+  %t2 = fadd <2 x double> %t1, %a3
+  ret <2 x double> %t2
+}
+
+; Negative test
+define <2 x double> @test_fmin_no_nnan_v2f64(<2 x double> %a0, <2 x double> %a1, <2 x double> %a2, <2 x double> %a3) {
+; CHECK-LABEL: test_fmin_no_nnan_v2f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vfmin.d $vr0, $vr0, $vr1
+; CHECK-NEXT:    vfmin.d $vr0, $vr0, $vr2
+; CHECK-NEXT:    vfmin.d $vr0, $vr0, $vr3
+; CHECK-NEXT:    ret
+  %t0 = call <2 x double> @llvm.minnum.v2f64(<2 x double> %a0, <2 x double> %a1)
+  %t1 = call <2 x double> @llvm.minnum.v2f64(<2 x double> %t0, <2 x double> %a2)
+  %t2 = call <2 x double> @llvm.minnum.v2f64(<2 x double> %t1, <2 x double> %a3)
+  ret <2 x double> %t2
+}
+
diff --git a/llvm/test/CodeGen/LoongArch/machine-combiner.ll b/llvm/test/CodeGen/LoongArch/machine-combiner.ll
new file mode 100644
index 0000000000000..b09b598ca538a
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/machine-combiner.ll
@@ -0,0 +1,1062 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc --mtriple=loongarch32 --mattr=+32s,+d -verify-machineinstrs -O1 \
+; RUN:   -loongarch-enable-machine-combiner=true < %s | FileCheck %s --check-prefixes=CHECK,LA32
+; RUN: llc --mtriple=loongarch64 --mattr=+d -verify-machineinstrs -O1 \
+; RUN:   -loongarch-enable-machine-combiner=true < %s | FileCheck %s --check-prefixes=CHECK,LA64
+
+define double @test_reassoc_fadd1(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fadd nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fadd2(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %a2, %t0
+  %t2 = fadd nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fadd3(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd3:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fadd nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fadd4(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd4:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %a2, %t0
+  %t2 = fadd nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fmul1(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fmul1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc double %a0, %a1
+  %t1 = fmul nsz reassoc double %t0, %a2
+  %t2 = fmul nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fmul2(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fmul2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmul.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc double %a0, %a1
+  %t1 = fmul nsz reassoc double %a2, %t0
+  %t2 = fmul nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fmul3(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fmul3:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fmul.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc double %a0, %a1
+  %t1 = fmul nsz reassoc double %t0, %a2
+  %t2 = fmul nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fmul4(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fmul4:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fmul.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc double %a0, %a1
+  %t1 = fmul nsz reassoc double %a2, %t0
+  %t2 = fmul nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_big1(double %a0, double %a1, double %a2, double %a3, double %a4, double %a5, double %a6) {
+; CHECK-LABEL: test_reassoc_big1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa4, $fa5
+; CHECK-NEXT:    fadd.d $fa1, $fa1, $fa6
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fadd nsz reassoc double %t1, %a3
+  %t3 = fadd nsz reassoc double %t2, %a4
+  %t4 = fadd nsz reassoc double %t3, %a5
+  %t5 = fadd nsz reassoc double %t4, %a6
+  ret double %t5
+}
+
+define double @test_reassoc_big2(double %a0, double %a1, i32 %a2, double %a3, i32 %a4, double %a5) {
+; CHECK-LABEL: test_reassoc_big2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    movgr2fr.w $fa4, $a0
+; CHECK-NEXT:    ffint.d.w $fa4, $fa4
+; CHECK-NEXT:    movgr2fr.w $fa5, $a1
+; CHECK-NEXT:    ffint.d.w $fa5, $fa5
+; CHECK-NEXT:    fmul.d $fa4, $fa2, $fa4
+; CHECK-NEXT:    fmul.d $fa5, $fa5, $fa1
+; CHECK-NEXT:    fmul.d $fa4, $fa5, $fa4
+; CHECK-NEXT:    fadd.d $fa5, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa1
+; CHECK-NEXT:    fsub.d $fa2, $fa3, $fa2
+; CHECK-NEXT:    fsub.d $fa2, $fa2, $fa5
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa0, $fa2, $fa0
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa4
+; CHECK-NEXT:    ret
+  %cvt1 = sitofp i32 %a2 to double
+  %cvt2 = sitofp i32 %a4 to double
+  %t5 = fmul nsz reassoc double %a3, %cvt1
+  %t9 = fmul nsz reassoc double %cvt2, %t5
+  %t4 = fmul nsz reassoc double %t9, %a1
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %a3, %t0
+  %t3 = fadd nsz reassoc double %a3, %a1
+  %t6 = fmul nsz reassoc double %t4, %a0
+  %t2 = fsub nsz reassoc double %a5, %t1
+  %t7 = fmul nsz reassoc double %t6, %t3
+  %t8 = fmul nsz reassoc double %t2, %t7
+  ret double %t8
+}
+
+; Negative test
+define double @test_reassoc_fadd_flags_1(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd_flags_1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd double %t0, %a2
+  %t2 = fadd nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+; Negative test
+define double @test_reassoc_fadd_flags_2(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd_flags_2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fadd double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub1(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fsub nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub2(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fsub.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %t0, %a2
+  %t2 = fadd nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub3(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub3:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fsub.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %t0, %a2
+  %t2 = fsub nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub4(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub4:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %a2, %t0
+  %t2 = fsub nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub5(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub5:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %a2, %t0
+  %t2 = fadd nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub6(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub6:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %a2, %t0
+  %t2 = fsub nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+define double @test_reassoc_fsub7(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub7:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %t0, %a2
+  %t2 = fsub nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fsub8(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %t0, %a2
+  %t2 = fadd nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fsub9(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub9:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %t0, %a2
+  %t2 = fsub nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fsub10(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub10:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fadd nsz reassoc double %a2, %t0
+  %t2 = fsub nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fsub11(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub11:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fsub.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %a2, %t0
+  %t2 = fadd nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define double @test_reassoc_fsub12(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fsub12:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fsub.d $fa1, $fa3, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa1, $fa0
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc double %a0, %a1
+  %t1 = fsub nsz reassoc double %a2, %t0
+  %t2 = fsub nsz reassoc double %a3, %t1
+  ret double %t2
+}
+
+define i8 @test_reassoc_add_i8(i8 %a0, i8 %a1, i8 %a2, i8 %a3) {
+; LA32-LABEL: test_reassoc_add_i8:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    add.w $a1, $a2, $a3
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_i8:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i8 %a0, %a1
+  %t1 = add i8 %t0, %a2
+  %t2 = add i8 %t1, %a3
+  ret i8 %t2
+}
+
+define i16 @test_reassoc_add_i16(i16 %a0, i16 %a1, i16 %a2, i16 %a3) {
+; LA32-LABEL: test_reassoc_add_i16:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    add.w $a1, $a2, $a3
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_i16:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i16 %a0, %a1
+  %t1 = add i16 %t0, %a2
+  %t2 = add i16 %t1, %a3
+  ret i16 %t2
+}
+
+define i32 @test_reassoc_add_i32(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; LA32-LABEL: test_reassoc_add_i32:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    add.w $a1, $a2, $a3
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_i32:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    add.w $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i32 %a0, %a1
+  %t1 = add i32 %t0, %a2
+  %t2 = add i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_add_i64(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_add_i64:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a1, $a1, $a3
+; LA32-NEXT:    add.w $a2, $a0, $a2
+; LA32-NEXT:    sltu $a0, $a2, $a0
+; LA32-NEXT:    add.w $a3, $a2, $a4
+; LA32-NEXT:    sltu $a2, $a3, $a2
+; LA32-NEXT:    add.w $a1, $a1, $a5
+; LA32-NEXT:    add.w $a0, $a1, $a0
+; LA32-NEXT:    add.w $a0, $a0, $a2
+; LA32-NEXT:    add.w $a1, $a0, $a7
+; LA32-NEXT:    add.w $a0, $a3, $a6
+; LA32-NEXT:    sltu $a2, $a0, $a3
+; LA32-NEXT:    add.w $a1, $a1, $a2
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_i64:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i64 %a0, %a1
+  %t1 = add i64 %t0, %a2
+  %t2 = add i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i32 @test_reassoc_add_sub_i32_1(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i32_1:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    sub.w $a1, $a2, $a3
+; LA32-NEXT:    sub.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i32_1:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    sub.d $a1, $a2, $a3
+; LA64-NEXT:    sub.w $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i32 %a0, %a1
+  %t1 = sub i32 %t0, %a2
+  %t2 = add i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i32 @test_reassoc_add_sub_i32_2(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i32_2:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    sub.w $a1, $a2, $a3
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i32_2:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    sub.d $a1, $a2, $a3
+; LA64-NEXT:    add.w $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i32 %a0, %a1
+  %t1 = add i32 %t0, %a2
+  %t2 = sub i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i32 @test_reassoc_add_sub_i32_3(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i32_3:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    add.w $a1, $a2, $a3
+; LA32-NEXT:    sub.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i32_3:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    sub.w $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i32 %a0, %a1
+  %t1 = sub i32 %t0, %a2
+  %t2 = sub i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_add_sub_i64_1(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i64_1:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a1, $a1, $a3
+; LA32-NEXT:    add.w $a2, $a0, $a2
+; LA32-NEXT:    sltu $a0, $a2, $a0
+; LA32-NEXT:    sub.w $a1, $a1, $a5
+; LA32-NEXT:    add.w $a1, $a1, $a0
+; LA32-NEXT:    sltu $a3, $a2, $a4
+; LA32-NEXT:    sub.w $a2, $a2, $a4
+; LA32-NEXT:    add.w $a0, $a2, $a6
+; LA32-NEXT:    sltu $a2, $a0, $a2
+; LA32-NEXT:    sub.w $a3, $a3, $a7
+; LA32-NEXT:    sub.w $a1, $a1, $a3
+; LA32-NEXT:    add.w $a1, $a1, $a2
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i64_1:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    sub.d $a1, $a2, $a3
+; LA64-NEXT:    sub.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i64 %a0, %a1
+  %t1 = sub i64 %t0, %a2
+  %t2 = add i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i64 @test_reassoc_add_sub_i64_2(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i64_2:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a1, $a1, $a3
+; LA32-NEXT:    add.w $a2, $a0, $a2
+; LA32-NEXT:    sltu $a0, $a2, $a0
+; LA32-NEXT:    add.w $a3, $a2, $a4
+; LA32-NEXT:    sltu $a2, $a3, $a2
+; LA32-NEXT:    add.w $a1, $a1, $a5
+; LA32-NEXT:    add.w $a0, $a1, $a0
+; LA32-NEXT:    add.w $a0, $a0, $a2
+; LA32-NEXT:    sltu $a1, $a3, $a6
+; LA32-NEXT:    add.w $a1, $a7, $a1
+; LA32-NEXT:    sub.w $a1, $a0, $a1
+; LA32-NEXT:    sub.w $a0, $a3, $a6
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i64_2:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    sub.d $a1, $a2, $a3
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i64 %a0, %a1
+  %t1 = add i64 %t0, %a2
+  %t2 = sub i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i64 @test_reassoc_add_sub_i64_3(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_add_sub_i64_3:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a1, $a1, $a3
+; LA32-NEXT:    add.w $a2, $a0, $a2
+; LA32-NEXT:    sltu $a0, $a2, $a0
+; LA32-NEXT:    sub.w $a1, $a1, $a5
+; LA32-NEXT:    add.w $a0, $a1, $a0
+; LA32-NEXT:    sltu $a1, $a2, $a4
+; LA32-NEXT:    sub.w $a2, $a2, $a4
+; LA32-NEXT:    add.w $a1, $a1, $a7
+; LA32-NEXT:    sub.w $a0, $a0, $a1
+; LA32-NEXT:    sltu $a1, $a2, $a6
+; LA32-NEXT:    sub.w $a1, $a0, $a1
+; LA32-NEXT:    sub.w $a0, $a2, $a6
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_sub_i64_3:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a2, $a3
+; LA64-NEXT:    sub.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = add i64 %a0, %a1
+  %t1 = sub i64 %t0, %a2
+  %t2 = sub i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i8 @test_reassoc_and_i8(i8 %a0, i8 %a1, i8 %a2, i8 %a3) {
+; CHECK-LABEL: test_reassoc_and_i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    and $a1, $a2, $a3
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = and i8 %a0, %a1
+  %t1 = and i8 %t0, %a2
+  %t2 = and i8 %t1, %a3
+  ret i8 %t2
+}
+
+define i16 @test_reassoc_and_i16(i16 %a0, i16 %a1, i16 %a2, i16 %a3) {
+; CHECK-LABEL: test_reassoc_and_i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    and $a1, $a2, $a3
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = and i16 %a0, %a1
+  %t1 = and i16 %t0, %a2
+  %t2 = and i16 %t1, %a3
+  ret i16 %t2
+}
+
+define i32 @test_reassoc_and_i32(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; CHECK-LABEL: test_reassoc_and_i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    and $a1, $a2, $a3
+; CHECK-NEXT:    and $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = and i32 %a0, %a1
+  %t1 = and i32 %t0, %a2
+  %t2 = and i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_and_i64(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_and_i64:
+; LA32:       # %bb.0:
+; LA32-NEXT:    and $a0, $a0, $a2
+; LA32-NEXT:    and $a1, $a1, $a3
+; LA32-NEXT:    and $a2, $a4, $a6
+; LA32-NEXT:    and $a0, $a0, $a2
+; LA32-NEXT:    and $a2, $a5, $a7
+; LA32-NEXT:    and $a1, $a1, $a2
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_and_i64:
+; LA64:       # %bb.0:
+; LA64-NEXT:    and $a0, $a0, $a1
+; LA64-NEXT:    and $a1, $a2, $a3
+; LA64-NEXT:    and $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = and i64 %a0, %a1
+  %t1 = and i64 %t0, %a2
+  %t2 = and i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i8 @test_reassoc_or_i8(i8 %a0, i8 %a1, i8 %a2, i8 %a3) {
+; CHECK-LABEL: test_reassoc_or_i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    or $a1, $a2, $a3
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = or i8 %a0, %a1
+  %t1 = or i8 %t0, %a2
+  %t2 = or i8 %t1, %a3
+  ret i8 %t2
+}
+
+define i16 @test_reassoc_or_i16(i16 %a0, i16 %a1, i16 %a2, i16 %a3) {
+; CHECK-LABEL: test_reassoc_or_i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    or $a1, $a2, $a3
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = or i16 %a0, %a1
+  %t1 = or i16 %t0, %a2
+  %t2 = or i16 %t1, %a3
+  ret i16 %t2
+}
+
+define i32 @test_reassoc_or_i32(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; CHECK-LABEL: test_reassoc_or_i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    or $a1, $a2, $a3
+; CHECK-NEXT:    or $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = or i32 %a0, %a1
+  %t1 = or i32 %t0, %a2
+  %t2 = or i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_or_i64(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_or_i64:
+; LA32:       # %bb.0:
+; LA32-NEXT:    or $a0, $a0, $a2
+; LA32-NEXT:    or $a1, $a1, $a3
+; LA32-NEXT:    or $a2, $a4, $a6
+; LA32-NEXT:    or $a0, $a0, $a2
+; LA32-NEXT:    or $a2, $a5, $a7
+; LA32-NEXT:    or $a1, $a1, $a2
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_or_i64:
+; LA64:       # %bb.0:
+; LA64-NEXT:    or $a0, $a0, $a1
+; LA64-NEXT:    or $a1, $a2, $a3
+; LA64-NEXT:    or $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = or i64 %a0, %a1
+  %t1 = or i64 %t0, %a2
+  %t2 = or i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i8 @test_reassoc_xor_i8(i8 %a0, i8 %a1, i8 %a2, i8 %a3) {
+; CHECK-LABEL: test_reassoc_xor_i8:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    xor $a1, $a2, $a3
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = xor i8 %a0, %a1
+  %t1 = xor i8 %t0, %a2
+  %t2 = xor i8 %t1, %a3
+  ret i8 %t2
+}
+
+define i16 @test_reassoc_xor_i16(i16 %a0, i16 %a1, i16 %a2, i16 %a3) {
+; CHECK-LABEL: test_reassoc_xor_i16:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    xor $a1, $a2, $a3
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = xor i16 %a0, %a1
+  %t1 = xor i16 %t0, %a2
+  %t2 = xor i16 %t1, %a3
+  ret i16 %t2
+}
+
+define i32 @test_reassoc_xor_i32(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; CHECK-LABEL: test_reassoc_xor_i32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    xor $a1, $a2, $a3
+; CHECK-NEXT:    xor $a0, $a0, $a1
+; CHECK-NEXT:    ret
+  %t0 = xor i32 %a0, %a1
+  %t1 = xor i32 %t0, %a2
+  %t2 = xor i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_xor_i64(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_xor_i64:
+; LA32:       # %bb.0:
+; LA32-NEXT:    xor $a0, $a0, $a2
+; LA32-NEXT:    xor $a1, $a1, $a3
+; LA32-NEXT:    xor $a2, $a4, $a6
+; LA32-NEXT:    xor $a0, $a0, $a2
+; LA32-NEXT:    xor $a2, $a5, $a7
+; LA32-NEXT:    xor $a1, $a1, $a2
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_xor_i64:
+; LA64:       # %bb.0:
+; LA64-NEXT:    xor $a0, $a0, $a1
+; LA64-NEXT:    xor $a1, $a2, $a3
+; LA64-NEXT:    xor $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = xor i64 %a0, %a1
+  %t1 = xor i64 %t0, %a2
+  %t2 = xor i64 %t1, %a3
+  ret i64 %t2
+}
+
+define i32 @test_reassoc_mul_i32(i32 %a0, i32 %a1, i32 %a2, i32 %a3) {
+; LA32-LABEL: test_reassoc_mul_i32:
+; LA32:       # %bb.0:
+; LA32-NEXT:    mul.w $a0, $a0, $a1
+; LA32-NEXT:    mul.w $a1, $a2, $a3
+; LA32-NEXT:    mul.w $a0, $a0, $a1
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_mul_i32:
+; LA64:       # %bb.0:
+; LA64-NEXT:    mul.d $a0, $a0, $a1
+; LA64-NEXT:    mul.d $a1, $a2, $a3
+; LA64-NEXT:    mul.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = mul i32 %a0, %a1
+  %t1 = mul i32 %t0, %a2
+  %t2 = mul i32 %t1, %a3
+  ret i32 %t2
+}
+
+define i64 @test_reassoc_mul_i64(i64 %a0, i64 %a1, i64 %a2, i64 %a3) {
+; LA32-LABEL: test_reassoc_mul_i64:
+; LA32:       # %bb.0:
+; LA32-NEXT:    mul.w $a3, $a0, $a3
+; LA32-NEXT:    mulh.wu $t0, $a0, $a2
+; LA32-NEXT:    add.w $a3, $t0, $a3
+; LA32-NEXT:    mul.w $a1, $a1, $a2
+; LA32-NEXT:    add.w $a1, $a3, $a1
+; LA32-NEXT:    mul.w $a0, $a0, $a2
+; LA32-NEXT:    mul.w $a2, $a0, $a5
+; LA32-NEXT:    mulh.wu $a3, $a0, $a4
+; LA32-NEXT:    add.w $a2, $a3, $a2
+; LA32-NEXT:    mul.w $a1, $a1, $a4
+; LA32-NEXT:    add.w $a1, $a2, $a1
+; LA32-NEXT:    mul.w $a0, $a0, $a4
+; LA32-NEXT:    mul.w $a1, $a1, $a6
+; LA32-NEXT:    mul.w $a2, $a0, $a7
+; LA32-NEXT:    mulh.wu $a3, $a0, $a6
+; LA32-NEXT:    add.w $a2, $a3, $a2
+; LA32-NEXT:    add.w $a1, $a2, $a1
+; LA32-NEXT:    mul.w $a0, $a0, $a6
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_mul_i64:
+; LA64:       # %bb.0:
+; LA64-NEXT:    mul.d $a0, $a0, $a1
+; LA64-NEXT:    mul.d $a1, $a2, $a3
+; LA64-NEXT:    mul.d $a0, $a0, $a1
+; LA64-NEXT:    ret
+  %t0 = mul i64 %a0, %a1
+  %t1 = mul i64 %t0, %a2
+  %t2 = mul i64 %t1, %a3
+  ret i64 %t2
+}
+
+; Negative tests: fmin/fmax without nnan must not be reassociated.
+define float @test_fmin_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_fmin_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.s $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmin.s $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call float @llvm.minnum.f32(float %a0, float %a1)
+  %t1 = call float @llvm.minnum.f32(float %t0, float %a2)
+  %t2 = call float @llvm.minnum.f32(float %t1, float %a3)
+  ret float %t2
+}
+
+define double @test_fmin_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmin_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call double @llvm.minnum.f64(double %a0, double %a1)
+  %t1 = call double @llvm.minnum.f64(double %t0, double %a2)
+  %t2 = call double @llvm.minnum.f64(double %t1, double %a3)
+  ret double %t2
+}
+
+define float @test_fmax_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_fmax_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmax.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmax.s $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmax.s $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call float @llvm.maxnum.f32(float %a0, float %a1)
+  %t1 = call float @llvm.maxnum.f32(float %t0, float %a2)
+  %t2 = call float @llvm.maxnum.f32(float %t1, float %a3)
+  ret float %t2
+}
+
+define double @test_fmax_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmax_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmax.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmax.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmax.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call double @llvm.maxnum.f64(double %a0, double %a1)
+  %t1 = call double @llvm.maxnum.f64(double %t0, double %a2)
+  %t2 = call double @llvm.maxnum.f64(double %t1, double %a3)
+  ret double %t2
+}
+
+define float @test_reassoc_fadd_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_reassoc_fadd_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.s $fa1, $fa2, $fa3
+; CHECK-NEXT:    fadd.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc float %a0, %a1
+  %t1 = fadd nsz reassoc float %t0, %a2
+  %t2 = fadd nsz reassoc float %t1, %a3
+  ret float %t2
+}
+
+define float @test_reassoc_fmul_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_reassoc_fmul_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.s $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmul.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc float %a0, %a1
+  %t1 = fmul nsz reassoc float %t0, %a2
+  %t2 = fmul nsz reassoc float %t1, %a3
+  ret float %t2
+}
+
+define float @test_reassoc_fsub_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_reassoc_fsub_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.s $fa1, $fa2, $fa3
+; CHECK-NEXT:    fsub.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz reassoc float %a0, %a1
+  %t1 = fsub nsz reassoc float %t0, %a2
+  %t2 = fsub nsz reassoc float %t1, %a3
+  ret float %t2
+}
+
+; Negative test: reassoc without nsz
+define double @test_reassoc_fadd_reassoc_only(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd_reassoc_only:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = fadd reassoc double %a0, %a1
+  %t1 = fadd reassoc double %t0, %a2
+  %t2 = fadd reassoc double %t1, %a3
+  ret double %t2
+}
+
+; Negative test: nsz without reassoc
+define double @test_reassoc_fadd_nsz_only(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fadd_nsz_only:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = fadd nsz double %a0, %a1
+  %t1 = fadd nsz double %t0, %a2
+  %t2 = fadd nsz double %t1, %a3
+  ret double %t2
+}
+
+; Negative test
+define double @test_reassoc_fmul_flags(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_reassoc_fmul_flags:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmul.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = fmul nsz reassoc double %a0, %a1
+  %t1 = fmul double %t0, %a2
+  %t2 = fmul nsz reassoc double %t1, %a3
+  ret double %t2
+}
+
+; Negative test: %t1 has a second use, so it cannot be reassociated away
+define i32 @test_reassoc_add_multiuse(i32 %a0, i32 %a1, i32 %a2, i32 %a3, ptr %p) {
+; LA32-LABEL: test_reassoc_add_multiuse:
+; LA32:       # %bb.0:
+; LA32-NEXT:    add.w $a0, $a0, $a1
+; LA32-NEXT:    add.w $a1, $a0, $a2
+; LA32-NEXT:    add.w $a0, $a1, $a3
+; LA32-NEXT:    st.w $a1, $a4, 0
+; LA32-NEXT:    ret
+;
+; LA64-LABEL: test_reassoc_add_multiuse:
+; LA64:       # %bb.0:
+; LA64-NEXT:    add.d $a0, $a0, $a1
+; LA64-NEXT:    add.d $a1, $a0, $a2
+; LA64-NEXT:    add.w $a0, $a1, $a3
+; LA64-NEXT:    st.w $a1, $a4, 0
+; LA64-NEXT:    ret
+  %t0 = add i32 %a0, %a1
+  %t1 = add i32 %t0, %a2
+  store i32 %t1, ptr %p
+  %t2 = add i32 %t1, %a3
+  ret i32 %t2
+}
+
+; fmin/fmax follow IEEE 754-2008 minNum/maxNum: an sNaN operand yields a qNaN,
+; which is not associative. Reassociation therefore requires nnan.
+define float @test_fmin_nnan_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_fmin_nnan_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.s $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmin.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = call nnan float @llvm.minnum.f32(float %a0, float %a1)
+  %t1 = call nnan float @llvm.minnum.f32(float %t0, float %a2)
+  %t2 = call nnan float @llvm.minnum.f32(float %t1, float %a3)
+  ret float %t2
+}
+
+define double @test_fmin_nnan_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmin_nnan_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = call nnan double @llvm.minnum.f64(double %a0, double %a1)
+  %t1 = call nnan double @llvm.minnum.f64(double %t0, double %a2)
+  %t2 = call nnan double @llvm.minnum.f64(double %t1, double %a3)
+  ret double %t2
+}
+
+define float @test_fmax_nnan_f32(float %a0, float %a1, float %a2, float %a3) {
+; CHECK-LABEL: test_fmax_nnan_f32:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmax.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmax.s $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmax.s $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = call nnan float @llvm.maxnum.f32(float %a0, float %a1)
+  %t1 = call nnan float @llvm.maxnum.f32(float %t0, float %a2)
+  %t2 = call nnan float @llvm.maxnum.f32(float %t1, float %a3)
+  ret float %t2
+}
+
+define double @test_fmax_nnan_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmax_nnan_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmax.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmax.d $fa1, $fa2, $fa3
+; CHECK-NEXT:    fmax.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    ret
+  %t0 = call nnan double @llvm.maxnum.f64(double %a0, double %a1)
+  %t1 = call nnan double @llvm.maxnum.f64(double %t0, double %a2)
+  %t2 = call nnan double @llvm.maxnum.f64(double %t1, double %a3)
+  ret double %t2
+}
+
+; Negative test: reassoc and nsz do not make fmin associative
+define double @test_fmin_reassoc_nsz_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmin_reassoc_nsz_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call nsz reassoc double @llvm.minnum.f64(double %a0, double %a1)
+  %t1 = call nsz reassoc double @llvm.minnum.f64(double %t0, double %a2)
+  %t2 = call nsz reassoc double @llvm.minnum.f64(double %t1, double %a3)
+  ret double %t2
+}
+
+; Negative test: the sibling lacks nnan
+define double @test_fmin_nnan_root_only_f64(double %a0, double %a1, double %a2, double %a3) {
+; CHECK-LABEL: test_fmin_nnan_root_only_f64:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa1
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa2
+; CHECK-NEXT:    fmin.d $fa0, $fa0, $fa3
+; CHECK-NEXT:    ret
+  %t0 = call nnan double @llvm.minnum.f64(double %a0, double %a1)
+  %t1 = call double @llvm.minnum.f64(double %t0, double %a2)
+  %t2 = call nnan double @llvm.minnum.f64(double %t1, double %a3)
+  ret double %t2
+}
diff --git a/llvm/test/CodeGen/LoongArch/opt-pipeline.ll b/llvm/test/CodeGen/LoongArch/opt-pipeline.ll
index 334dfa39081c0..f77aede43046d 100644
--- a/llvm/test/CodeGen/LoongArch/opt-pipeline.ll
+++ b/llvm/test/CodeGen/LoongArch/opt-pipeline.ll
@@ -98,9 +98,12 @@
 ; LAXX-NEXT:       Remove dead machine instructions
 ; LAXX-NEXT:       MachineDominator Tree Construction
 ; LAXX-NEXT:       Machine Natural Loop Construction
+; LAXX-NEXT:       Machine Register Class Info Analysis
+; LAXX-NEXT:       Machine Trace Metrics
+; LAXX-NEXT:       Lazy Machine Block Frequency Analysis
+; LAXX-NEXT:       Machine InstCombiner
 ; LAXX-NEXT:       Machine Cycle Info Analysis
 ; LAXX-NEXT:       Machine Block Frequency Analysis
-; LAXX-NEXT:       Machine Register Class Info Analysis
 ; LAXX-NEXT:       Early Machine Loop Invariant Code Motion
 ; LAXX-NEXT:       MachineDominator Tree Construction
 ; LAXX-NEXT:       Machine Cycle Info Analysis
diff --git a/llvm/test/CodeGen/LoongArch/rotl-rotr.ll b/llvm/test/CodeGen/LoongArch/rotl-rotr.ll
index 9e98b2de79898..01e3ede43456b 100644
--- a/llvm/test/CodeGen/LoongArch/rotl-rotr.ll
+++ b/llvm/test/CodeGen/LoongArch/rotl-rotr.ll
@@ -128,11 +128,11 @@ define i64 @rotl_64(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    sll.w $a1, $a1, $a2
 ; LA32S-NEXT:    or $a0, $a0, $a1
 ; LA32S-NEXT:    maskeqz $a0, $a0, $t0
-; LA32S-NEXT:    or $a0, $a0, $t1
 ; LA32S-NEXT:    srai.w $a1, $a7, 31
 ; LA32S-NEXT:    and $a1, $a1, $a6
 ; LA32S-NEXT:    or $a1, $a3, $a1
-; LA32S-NEXT:    or $a0, $a4, $a0
+; LA32S-NEXT:    or $a2, $a4, $t1
+; LA32S-NEXT:    or $a0, $a2, $a0
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotl_64:
@@ -219,12 +219,12 @@ define i64 @rotr_64(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    srli.w $a0, $a0, 1
 ; LA32S-NEXT:    srl.w $a0, $a0, $a2
 ; LA32S-NEXT:    or $a0, $a1, $a0
-; LA32S-NEXT:    maskeqz $a0, $a0, $t0
-; LA32S-NEXT:    or $a1, $a0, $t1
+; LA32S-NEXT:    maskeqz $a1, $a0, $t0
 ; LA32S-NEXT:    srai.w $a0, $a7, 31
 ; LA32S-NEXT:    and $a0, $a0, $a6
 ; LA32S-NEXT:    or $a0, $a3, $a0
-; LA32S-NEXT:    or $a1, $a4, $a1
+; LA32S-NEXT:    or $a2, $a4, $t1
+; LA32S-NEXT:    or $a1, $a2, $a1
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotr_64:
@@ -467,12 +467,12 @@ define i64 @rotl_64_mask(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    sll.w $a5, $t1, $a5
 ; LA32S-NEXT:    or $a0, $a0, $a5
 ; LA32S-NEXT:    maskeqz $a0, $a0, $t0
-; LA32S-NEXT:    or $a0, $a0, $a7
 ; LA32S-NEXT:    srl.w $a1, $a1, $a2
 ; LA32S-NEXT:    srai.w $a2, $a6, 31
 ; LA32S-NEXT:    and $a1, $a2, $a1
 ; LA32S-NEXT:    or $a1, $a3, $a1
-; LA32S-NEXT:    or $a0, $a4, $a0
+; LA32S-NEXT:    or $a2, $a4, $a7
+; LA32S-NEXT:    or $a0, $a2, $a0
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotl_64_mask:
@@ -559,12 +559,12 @@ define i64 @rotl_64_mask_and_127_and_63(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    sll.w $a5, $t1, $a5
 ; LA32S-NEXT:    or $a0, $a0, $a5
 ; LA32S-NEXT:    maskeqz $a0, $a0, $t0
-; LA32S-NEXT:    or $a0, $a0, $a7
 ; LA32S-NEXT:    srl.w $a1, $a1, $a2
 ; LA32S-NEXT:    srai.w $a2, $a6, 31
 ; LA32S-NEXT:    and $a1, $a2, $a1
 ; LA32S-NEXT:    or $a1, $a3, $a1
-; LA32S-NEXT:    or $a0, $a4, $a0
+; LA32S-NEXT:    or $a2, $a4, $a7
+; LA32S-NEXT:    or $a0, $a2, $a0
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotl_64_mask_and_127_and_63:
@@ -677,12 +677,12 @@ define i64 @rotr_64_mask(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    srl.w $a5, $t1, $a5
 ; LA32S-NEXT:    or $a1, $a1, $a5
 ; LA32S-NEXT:    maskeqz $a1, $a1, $t0
-; LA32S-NEXT:    or $a1, $a1, $a7
 ; LA32S-NEXT:    sll.w $a0, $a0, $a2
 ; LA32S-NEXT:    srai.w $a2, $a6, 31
 ; LA32S-NEXT:    and $a0, $a2, $a0
 ; LA32S-NEXT:    or $a0, $a3, $a0
-; LA32S-NEXT:    or $a1, $a4, $a1
+; LA32S-NEXT:    or $a2, $a4, $a7
+; LA32S-NEXT:    or $a1, $a2, $a1
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotr_64_mask:
@@ -768,12 +768,12 @@ define i64 @rotr_64_mask_and_127_and_63(i64 %x, i64 %y) nounwind {
 ; LA32S-NEXT:    srl.w $a5, $t1, $a5
 ; LA32S-NEXT:    or $a1, $a1, $a5
 ; LA32S-NEXT:    maskeqz $a1, $a1, $t0
-; LA32S-NEXT:    or $a1, $a1, $a7
 ; LA32S-NEXT:    sll.w $a0, $a0, $a2
 ; LA32S-NEXT:    srai.w $a2, $a6, 31
 ; LA32S-NEXT:    and $a0, $a2, $a0
 ; LA32S-NEXT:    or $a0, $a3, $a0
-; LA32S-NEXT:    or $a1, $a4, $a1
+; LA32S-NEXT:    or $a2, $a4, $a7
+; LA32S-NEXT:    or $a1, $a2, $a1
 ; LA32S-NEXT:    ret
 ;
 ; LA64-LABEL: rotr_64_mask_and_127_and_63:
diff --git a/llvm/test/CodeGen/LoongArch/select-binop-combine.ll b/llvm/test/CodeGen/LoongArch/select-binop-combine.ll
index b85ec309e6029..fe27ccd665563 100644
--- a/llvm/test/CodeGen/LoongArch/select-binop-combine.ll
+++ b/llvm/test/CodeGen/LoongArch/select-binop-combine.ll
@@ -677,8 +677,8 @@ define i64 @sub_imm_subtrahend_noopt(i64 %a, i32 signext %c, i32 signext %d) nou
 ; LA32:       # %bb.0: # %entry
 ; LA32-NEXT:    ori $a4, $zero, 5
 ; LA32-NEXT:    sltu $a5, $a4, $a0
-; LA32-NEXT:    add.w $a5, $a1, $a5
-; LA32-NEXT:    sub.w $a5, $zero, $a5
+; LA32-NEXT:    sub.w $a6, $zero, $a1
+; LA32-NEXT:    sub.w $a5, $a6, $a5
 ; LA32-NEXT:    sub.w $a4, $a4, $a0
 ; LA32-NEXT:    slt $a2, $a2, $a3
 ; LA32-NEXT:    masknez $a3, $a4, $a2
diff --git a/llvm/test/CodeGen/LoongArch/smul-with-overflow.ll b/llvm/test/CodeGen/LoongArch/smul-with-overflow.ll
index 968c06136225d..7e08af3a87705 100644
--- a/llvm/test/CodeGen/LoongArch/smul-with-overflow.ll
+++ b/llvm/test/CodeGen/LoongArch/smul-with-overflow.ll
@@ -145,13 +145,13 @@ define zeroext i1 @smuloi128(i128 %v1, i128 %v2, ptr %res) {
 ; LA32-NEXT:    add.w $t4, $t4, $t7
 ; LA32-NEXT:    add.w $t4, $t2, $t4
 ; LA32-NEXT:    mul.w $t5, $a7, $a3
-; LA32-NEXT:    add.w $t6, $t5, $t6
-; LA32-NEXT:    sltu $t5, $t6, $t5
-; LA32-NEXT:    add.w $t7, $t4, $t5
+; LA32-NEXT:    add.w $t7, $t5, $t6
+; LA32-NEXT:    sltu $t5, $t7, $t5
+; LA32-NEXT:    add.w $t6, $t4, $t5
 ; LA32-NEXT:    add.w $t4, $t8, $fp
-; LA32-NEXT:    beq $t7, $t2, .LBB1_2
+; LA32-NEXT:    beq $t6, $t2, .LBB1_2
 ; LA32-NEXT:  # %bb.1:
-; LA32-NEXT:    sltu $t5, $t7, $t2
+; LA32-NEXT:    sltu $t5, $t6, $t2
 ; LA32-NEXT:  .LBB1_2:
 ; LA32-NEXT:    add.w $t5, $t3, $t5
 ; LA32-NEXT:    sltu $t2, $t5, $t3
@@ -184,11 +184,11 @@ define zeroext i1 @smuloi128(i128 %v1, i128 %v2, ptr %res) {
 ; LA32-NEXT:    add.w $t1, $s0, $t1
 ; LA32-NEXT:    add.w $t1, $t1, $s3
 ; LA32-NEXT:    add.w $s0, $t2, $t1
+; LA32-NEXT:    mul.w $t2, $a4, $a6
+; LA32-NEXT:    add.w $t1, $t2, $t7
+; LA32-NEXT:    sltu $t7, $t1, $t2
 ; LA32-NEXT:    add.w $t2, $t8, $t7
-; LA32-NEXT:    mul.w $t7, $a4, $a6
-; LA32-NEXT:    add.w $t1, $t7, $t6
-; LA32-NEXT:    sltu $t7, $t1, $t7
-; LA32-NEXT:    add.w $t2, $t2, $t7
+; LA32-NEXT:    add.w $t2, $t2, $t6
 ; LA32-NEXT:    add.w $t6, $s0, $s4
 ; LA32-NEXT:    beq $t2, $t8, .LBB1_4
 ; LA32-NEXT:  # %bb.3:
@@ -206,11 +206,11 @@ define zeroext i1 @smuloi128(i128 %v1, i128 %v2, ptr %res) {
 ; LA32-NEXT:    add.w $s3, $s1, $t5
 ; LA32-NEXT:    mul.w $fp, $a7, $a5
 ; LA32-NEXT:    add.w $s2, $fp, $s3
-; LA32-NEXT:    add.w $t6, $s2, $s4
-; LA32-NEXT:    mul.w $s5, $a7, $a6
-; LA32-NEXT:    add.w $t5, $s5, $t7
-; LA32-NEXT:    sltu $t7, $t5, $s5
-; LA32-NEXT:    add.w $t6, $t6, $t7
+; LA32-NEXT:    mul.w $t6, $a7, $a6
+; LA32-NEXT:    add.w $t5, $t6, $t7
+; LA32-NEXT:    sltu $t7, $t5, $t6
+; LA32-NEXT:    add.w $t6, $s2, $t7
+; LA32-NEXT:    add.w $t6, $t6, $s4
 ; LA32-NEXT:    beq $t6, $s2, .LBB1_6
 ; LA32-NEXT:  # %bb.5:
 ; LA32-NEXT:    sltu $t7, $t6, $s2



More information about the llvm-commits mailing list