[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