//===----------- VVPInstrPatternsVec.td - VVP_* SDNode patterns -----------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file describes how VVP_* SDNodes are lowered to machine instructions.
//
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
//
// VVP SDNode definitions.
//
//===----------------------------------------------------------------------===//
include "VVPInstrInfo.td"

multiclass VectorStore<ValueType DataVT,
    ValueType PtrVT, ValueType MaskVT,
    string STWithMask, string STNoMask> {
  // Unmasked (imm stride).
  def : Pat<(vvp_store
               DataVT:$val, PtrVT:$addr,
               (i64 simm7:$stride), (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(STNoMask#"irvl")
               (LO7 $stride), $addr, $val, $avl)>;
  // Unmasked.
  def : Pat<(vvp_store
               DataVT:$val, PtrVT:$addr,
               i64:$stride, (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(STNoMask#"rrvl")
               $stride, $addr, $val, $avl)>;
  // Masked (imm stride).
  def : Pat<(vvp_store
               DataVT:$val, PtrVT:$addr,
               (i64 simm7:$stride), MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(STWithMask#"irvml")
               (LO7 $stride), $addr, $val, $mask, $avl)>;
  // Masked.
  def : Pat<(vvp_store
               DataVT:$val, PtrVT:$addr,
               i64:$stride, MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(STWithMask#"rrvml")
               $stride, $addr, $val, $mask, $avl)>;
}

defm : VectorStore<v256f64, i64, v256i1, "VST",  "VST">;
defm : VectorStore<v256i64, i64, v256i1, "VST",  "VST">;
defm : VectorStore<v256f32, i64, v256i1, "VSTU", "VSTU">;
defm : VectorStore<v256i32, i64, v256i1, "VSTL", "VSTL">;

multiclass VectorLoad<ValueType DataVT,
    ValueType PtrVT, ValueType MaskVT,
    string GTWithMask, string LDNoMask> {
  // Unmasked (imm stride).
  def : Pat<(DataVT (vvp_load
               PtrVT:$addr, (i64 simm7:$stride),
               (MaskVT true_mask), i32:$avl)),
            (!cast<Instruction>(LDNoMask#"irl")
               (LO7 $stride), $addr, $avl)>;
  // Unmasked.
  def : Pat<(DataVT (vvp_load
               PtrVT:$addr, i64:$stride,
               (MaskVT true_mask), i32:$avl)),
            (!cast<Instruction>(LDNoMask#"rrl")
               $stride, PtrVT:$addr, $avl)>;
  // Masked (imm stride).
  def : Pat<(DataVT (vvp_load
               PtrVT:$addr, (i64 simm7:$stride),
               MaskVT:$mask, i32:$avl)),
            (!cast<Instruction>(GTWithMask#"vizml")
               (VADDULrvml $addr,
                  (VMULULivml (LO7 $stride), (VSEQl $avl), $mask, $avl),
                  $mask, $avl),
               0, 0,
               $mask,
               $avl)>;
  // Masked.
  def : Pat<(DataVT (vvp_load
               PtrVT:$addr, i64:$stride, MaskVT:$mask, i32:$avl)),
            (!cast<Instruction>(GTWithMask#"vizml")
               (VADDULrvml $addr,
                  (VMULULrvml $stride, (VSEQl $avl), $mask, $avl),
                  $mask, $avl),
               0, 0,
               $mask,
               $avl)>;
}

defm : VectorLoad<v256f64, i64, v256i1, "VGT",    "VLD">;
defm : VectorLoad<v256i64, i64, v256i1, "VGT",    "VLD">;
defm : VectorLoad<v256f32, i64, v256i1, "VGTU",   "VLDU">;
defm : VectorLoad<v256i32, i64, v256i1, "VGTLZX", "VLDLZX">;

// Vector Gather and scatter
multiclass VectorGather<ValueType DataVT,
    ValueType PtrVT, ValueType MaskVT,
    string GTPrefix> {
  // Unmasked.
  def : Pat<(DataVT (vvp_gather
               PtrVT:$addr, (MaskVT true_mask), i32:$avl)),
            (!cast<Instruction>(GTPrefix#"vizl") $addr, 0, 0, $avl)>;
  // Masked.
  def : Pat<(DataVT (vvp_gather PtrVT:$addr, MaskVT:$mask, i32:$avl)),
            (!cast<Instruction>(GTPrefix#"vizml") $addr, 0, 0, $mask, $avl)>;
}

defm : VectorGather<v256f64, v256i64, v256i1, "VGT">;
defm : VectorGather<v256i64, v256i64, v256i1, "VGT">;
defm : VectorGather<v256f32, v256i64, v256i1, "VGTU">;
defm : VectorGather<v256i32, v256i64, v256i1, "VGTLZX">;

multiclass VectorScatter<ValueType DataVT,
    ValueType PtrVT, ValueType MaskVT,
    string SCPrefix> {
  // Unmasked.
  def : Pat<(vvp_scatter
               DataVT:$data, PtrVT:$addr, (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(SCPrefix#"vizvl") $addr, 0, 0, $data, $avl)>; 
  // Masked.
  def : Pat<(vvp_scatter
               DataVT:$data, PtrVT:$addr, MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(SCPrefix#"vizvml") $addr, 0, 0, $data, $mask, $avl)>;
}

defm : VectorScatter<v256f64, v256i64, v256i1, "VSC">;
defm : VectorScatter<v256i64, v256i64, v256i1, "VSC">;
defm : VectorScatter<v256f32, v256i64, v256i1, "VSCU">;
defm : VectorScatter<v256i32, v256i64, v256i1, "VSCL">;


/// FNEG {
// Directly modify the sign bit to flip the sign.

// Set sign bits in a pack of <2 x f32>.
def packed_fneg_imm     : OutPatFrag<(ins ),
                          (i64 (SLLri (i64 (ORim 1, (i32 32))), 31))>;


multiclass FNeg<ValueType DataVT> {
  // Masked with select.
  def : Pat<(vvp_select (vvp_fneg DataVT:$vx, (v256i1 srcvalue), (i32 srcvalue)),
                        DataVT:$vfalse,
                        v256i1:$mask,
                        i32:$avl),
            (VXORmvml_v (i32 1), $vx, $mask, $avl, $vfalse)>;

  // Unmasked.
  def : Pat<(vvp_fneg DataVT:$vx, (v256i1 true_mask), i32:$avl),
            (VXORmvl (i32 1), $vx, $avl)>;

  // Masked.
  def : Pat<(vvp_fneg DataVT:$vx, v256i1:$mask, i32:$avl),
            (VXORmvml (i32 1), $vx, $mask, $avl)>;
}

defm: FNeg<v256f32>;
defm: FNeg<v256f64>;

///// Packed FNeg /////

// Masked with select.
def : Pat<(vvp_select (vvp_fneg v512f32:$vx, (v512i1 srcvalue), (i32 srcvalue)),
                      v512f32:$vfalse,
                      v512i1:$mask,
                      i32:$avl),
          (v512f32 (PVXORrvml_v (packed_fneg_imm ), $vx, $mask, $avl, $vfalse))>;

// Unmasked.
def : Pat<(vvp_fneg v512f32:$vx, (v512i1 true_mask), i32:$avl),
          (v512f32 (PVXORrvl (packed_fneg_imm ), $vx, $avl))>;

// Masked.
def : Pat<(vvp_fneg v512f32:$vx, v512i1:$mask, i32:$avl),
          (v512f32 (PVXORrvml (packed_fneg_imm ), $vx, $mask, $avl))>;

/// } FNEG

multiclass Binary_rv<SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru, broadcast.
  def : Pat<(vvp_select
                (OpNode
                    (any_broadcast ScalarVT:$sx),
                    DataVT:$vy,
                    (MaskVT srcvalue),
                    (i32 srcvalue)),
                DataVT:$vfalse,
                MaskVT:$mask,
                i32:$pivot),
            (!cast<Instruction>(OpBaseName#"rvml_v")
                ScalarVT:$sx,
                $vy,
                $mask,
                $pivot,
                $vfalse)>;

  // Unmasked, broadcast.
  def : Pat<(OpNode
                (any_broadcast ScalarVT:$sx), DataVT:$vy,
                (MaskVT true_mask),
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"rvl")
                ScalarVT:$sx, $vy, $avl)>;
  // Masked, broadcast.
  def : Pat<(OpNode
                (any_broadcast ScalarVT:$sx), DataVT:$vy,
                MaskVT:$mask,
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"rvml")
                ScalarVT:$sx, $vy, $mask, $avl)>;
}

multiclass Binary_vr<SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru, broadcast.
  def : Pat<(vvp_select
                (OpNode
                    DataVT:$vx,
                    (any_broadcast ScalarVT:$sy),
                    (MaskVT srcvalue),
                    (i32 srcvalue)),
                DataVT:$vfalse,
                MaskVT:$mask,
                i32:$pivot),
            (!cast<Instruction>(OpBaseName#"vrml_v")
                $vx,
                ScalarVT:$sy,
                $mask,
                $pivot,
                $vfalse)>;

  // Unmasked, broadcast.
  def : Pat<(OpNode
                DataVT:$vx, (any_broadcast ScalarVT:$sy),
                (MaskVT true_mask),
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"vrl")
                $vx, ScalarVT:$sy, $avl)>;
  // Masked, broadcast.
  def : Pat<(OpNode
                DataVT:$vx, (any_broadcast ScalarVT:$sy),
                MaskVT:$mask,
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"vrml")
                $vx, ScalarVT:$sy, $mask, $avl)>;
}

multiclass Binary_vv<SDPatternOperator OpNode,
    ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru, broadcast.
  def : Pat<(vvp_select
                (OpNode
                    DataVT:$vx,
                    DataVT:$vy,
                    (MaskVT srcvalue),
                    (i32 srcvalue)),
                DataVT:$vfalse,
                MaskVT:$mask,
                i32:$pivot),
            (!cast<Instruction>(OpBaseName#"vvml_v")
                $vx,
                $vy,
                $mask,
                $pivot,
                $vfalse)>;

  // Masked with select.
  // TODO

  // Unmasked.
  def : Pat<(OpNode
                DataVT:$vx, DataVT:$vy,
                (MaskVT true_mask),
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvl")
                $vx, $vy, $avl)>;

  // Masked.
  def : Pat<(OpNode
                DataVT:$vx, DataVT:$vy,
                MaskVT:$mask,
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvml")
                $vx, $vy, $mask, $avl)>;
}

multiclass Binary_rv_vv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT, ValueType MaskVT,
    string OpBaseName> {
  defm : Binary_rv<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
  defm : Binary_vv<OpNode, DataVT, MaskVT, OpBaseName>;
}

multiclass Binary_vr_vv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT, ValueType MaskVT,
    string OpBaseName> {
  defm : Binary_vr<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
  defm : Binary_vv<OpNode, DataVT, MaskVT, OpBaseName>;
}

multiclass Binary_rv_vr_vv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT, ValueType MaskVT,
    string OpBaseName> {
  defm : Binary_rv<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
  defm : Binary_vr_vv<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
}

// Expand both 64bit and 32 bit variant (256 elements)
multiclass Binary_rv_vv_ShortLong<
    SDPatternOperator OpNode,
    ValueType LongScalarVT, ValueType LongDataVT, string LongOpBaseName,
    ValueType ShortScalarVT, ValueType ShortDataVT, string ShortOpBaseName> {
  defm : Binary_rv_vv<OpNode,
                      LongScalarVT, LongDataVT, v256i1,
                      LongOpBaseName>;
  defm : Binary_rv_vv<OpNode,
                      ShortScalarVT, ShortDataVT, v256i1,
                      ShortOpBaseName>;
}

multiclass Binary_vr_vv_ShortLong<
    SDPatternOperator OpNode,
    ValueType LongScalarVT, ValueType LongDataVT, string LongOpBaseName,
    ValueType ShortScalarVT, ValueType ShortDataVT, string ShortOpBaseName> {
  defm : Binary_vr_vv<OpNode,
                      LongScalarVT, LongDataVT, v256i1,
                      LongOpBaseName>;
  defm : Binary_vr_vv<OpNode,
                      ShortScalarVT, ShortDataVT, v256i1,
                      ShortOpBaseName>;
}

multiclass Binary_rv_vr_vv_ShortLong<
    SDPatternOperator OpNode,
    ValueType LongScalarVT, ValueType LongDataVT, string LongOpBaseName,
    ValueType ShortScalarVT, ValueType ShortDataVT, string ShortOpBaseName> {
  defm : Binary_rv_vr_vv<OpNode,
                      LongScalarVT, LongDataVT, v256i1,
                      LongOpBaseName>;
  defm : Binary_rv_vr_vv<OpNode,
                      ShortScalarVT, ShortDataVT, v256i1,
                      ShortOpBaseName>;
}

defm : Binary_rv_vv_ShortLong<c_vvp_add,
                              i64, v256i64, "VADDSL",
                              i32, v256i32, "VADDSWSX">;
defm : Binary_rv_vv_ShortLong<vvp_sub,
                              i64, v256i64, "VSUBSL",
                              i32, v256i32, "VSUBSWSX">;
defm : Binary_rv_vv_ShortLong<c_vvp_mul,
                              i64, v256i64, "VMULSL",
                              i32, v256i32, "VMULSWSX">;
defm : Binary_rv_vr_vv_ShortLong<vvp_sdiv,
                              i64, v256i64, "VDIVSL",
                              i32, v256i32, "VDIVSWSX">;
defm : Binary_rv_vr_vv_ShortLong<vvp_udiv,
                              i64, v256i64, "VDIVUL",
                              i32, v256i32, "VDIVUW">;
defm : Binary_rv_vv_ShortLong<c_vvp_and,
                              i64, v256i64, "VAND",
                              i32, v256i32, "PVANDLO">;
defm : Binary_rv_vv_ShortLong<c_vvp_or,
                              i64, v256i64, "VOR",
                              i32, v256i32, "PVORLO">;
defm : Binary_rv_vv_ShortLong<c_vvp_xor,
                              i64, v256i64, "VXOR",
                              i32, v256i32, "PVXORLO">;
defm : Binary_vr_vv_ShortLong<vvp_shl,
                              i64, v256i64, "VSLL",
                              i32, v256i32, "PVSLLLO">;
defm : Binary_vr_vv_ShortLong<vvp_sra,
                              i64, v256i64, "VSRAL",
                              i32, v256i32, "PVSRALO">;
defm : Binary_vr_vv_ShortLong<vvp_srl,
                              i64, v256i64, "VSRL",
                              i32, v256i32, "PVSRLLO">;

defm : Binary_rv_vv_ShortLong<c_vvp_fadd,
                              f64, v256f64, "VFADDD",
                              f32, v256f32, "PVFADDUP">;
defm : Binary_rv_vv_ShortLong<c_vvp_fmul,
                              f64, v256f64, "VFMULD",
                              f32, v256f32, "PVFMULUP">;
defm : Binary_rv_vv_ShortLong<vvp_fsub,
                              f64, v256f64, "VFSUBD",
                              f32, v256f32, "PVFSUBUP">;
defm : Binary_rv_vr_vv_ShortLong<vvp_fdiv,
                              f64, v256f64, "VFDIVD",
                              f32, v256f32, "VFDIVS">;

defm : Binary_rv_vv<c_vvp_and,
                    i64, v512i32, v512i1, "PVAND">;
defm : Binary_rv_vv<c_vvp_or,
                    i64, v512i32, v512i1, "PVOR">;
defm : Binary_rv_vv<c_vvp_xor,
                    i64, v512i32, v512i1, "PVXOR">;

defm : Binary_rv_vv<c_vvp_add,
                    i64, v512i32, v512i1, "PVADDU">;
defm : Binary_rv_vv<vvp_sub,
                    i64, v512i32, v512i1, "PVSUBU">;
defm : Binary_vr_vv<vvp_srl,
                    i64, v512i32, v512i1, "PVSRL">;
defm : Binary_vr_vv<vvp_sra,
                    i64, v512i32, v512i1, "PVSRA">;
defm : Binary_vr_vv<vvp_shl,
                    i64, v512i32, v512i1, "PVSLL">;

defm : Binary_rv_vv<c_vvp_fadd,
                    i64, v512f32, v512i1, "PVFADD">;
defm : Binary_rv_vv<c_vvp_fmul,
                    i64, v512f32, v512i1, "PVFMUL">;
defm : Binary_rv_vv<vvp_fsub,
                    i64, v512f32, v512i1, "PVFSUB">;

multiclass Ternary_vvv<
    SDPatternOperator OpNode, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru.
  def : Pat<(vvp_select
              (OpNode DataVT:$vx, DataVT:$vy, DataVT:$vz,
                (MaskVT srcvalue), (i32 srcvalue)),
              DataVT:$vfalse,
              MaskVT:$mask,
              i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvvml_v")
              $vx, $vy, $vz, $mask, $avl, $vfalse)>;

  // Unmasked.
  def : Pat<(OpNode DataVT:$vx, DataVT:$vy, DataVT:$vz,
              (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvvl")
              $vx, $vy, $vz, $avl)>;

  // Masked.
  def : Pat<(OpNode DataVT:$vx, DataVT:$vy, DataVT:$vz,
              MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvvml")
              $vx, $vy, $vz, $mask, $avl)>;
}

multiclass Ternary_rvv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru, broadcast first.
  def : Pat<(vvp_select
              (OpNode
                (any_broadcast ScalarVT:$sx), DataVT:$vy, DataVT:$vz,
                (MaskVT srcvalue), (i32 srcvalue)),
              DataVT:$vfalse,
              MaskVT:$mask,
              i32:$avl),
            (!cast<Instruction>(OpBaseName#"rvvml_v")
              $sx, $vy, $vz, $mask, $avl, $vfalse)>;

  // Unmasked, broadcast first.
  def : Pat<(OpNode
              (any_broadcast ScalarVT:$sx), DataVT:$vy, DataVT:$vz,
              (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(OpBaseName#"rvvl")
              $sx, $vy, $vz, $avl)>;

  // Masked, broadcast first.
  def : Pat<(OpNode 
              (any_broadcast ScalarVT:$sx), DataVT:$vy, DataVT:$vz,
              MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(OpBaseName#"rvvml")
              $sx, $vy, $vz, $mask, $avl)>;
}

multiclass Ternary_vrv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  // Masked with passthru, broadcast second.
  def : Pat<(vvp_select
              (OpNode
                DataVT:$vx, (any_broadcast ScalarVT:$sy), DataVT:$vz,
                (MaskVT srcvalue), (i32 srcvalue)),
              DataVT:$vfalse,
              MaskVT:$mask,
              i32:$avl),
            (!cast<Instruction>(OpBaseName#"vrvml_v")
              $vx, $sy, $vz,
              $mask, $avl, $vfalse)>;

  // Unmasked, broadcast second.
  def : Pat<(OpNode
              DataVT:$vx, (any_broadcast ScalarVT:$sy), DataVT:$vz,
              (MaskVT true_mask), i32:$avl),
            (!cast<Instruction>(OpBaseName#"vrvl")
              $vx, $sy, $vz, $avl)>;

  // Masked, broadcast second.
  def : Pat<(OpNode
              DataVT:$vx, (any_broadcast ScalarVT:$sy), DataVT:$vz,
              MaskVT:$mask, i32:$avl),
            (!cast<Instruction>(OpBaseName#"vrvml")
              $vx, $sy, $vz, $mask, $avl)>;
}

multiclass Ternary_rvv_vrv_vvv<
    SDPatternOperator OpNode,
    ValueType ScalarVT, ValueType DataVT,
    ValueType MaskVT, string OpBaseName> {
  defm : Ternary_rvv<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
  defm : Ternary_vrv<OpNode, ScalarVT, DataVT, MaskVT, OpBaseName>;
  defm : Ternary_vvv<OpNode, DataVT, MaskVT, OpBaseName>;
}

// Expand both 64bit and 32 bit variant (256 elements)
multiclass Ternary_ShortLong<
    SDPatternOperator OpNode,
    ValueType LongScalarVT, ValueType LongDataVT, string LongOpBaseName,
    ValueType ShortScalarVT, ValueType ShortDataVT, string ShortOpBaseName> {
  defm : Ternary_rvv_vrv_vvv<OpNode, LongScalarVT, LongDataVT,
                             v256i1, LongOpBaseName>;
  defm : Ternary_rvv_vrv_vvv<OpNode, ShortScalarVT, ShortDataVT,
                             v256i1, ShortOpBaseName>;
}

defm : Ternary_ShortLong<c_vvp_ffma,
                         f64, v256f64, "VFMADD", f32, v256f32, "VFMADS">;
defm : Ternary_rvv_vrv_vvv<c_vvp_ffma,
                           i64, v512f32, v512i1, "PVFMAD">;

multiclass Merge_mvv<
    SDPatternOperator OpNode,
    ValueType DataVT, ValueType MaskVT,
    string OpBaseName> {
  // Masked.
  def : Pat<(OpNode
                DataVT:$vtrue, DataVT:$vfalse,
                MaskVT:$vm,
                i32:$avl),
            (!cast<Instruction>(OpBaseName#"vvml_v")
                $vfalse, $vtrue, $vm, $avl, $vfalse)>;
}

multiclass Merge_mvv_ShortLong<
    SDPatternOperator OpNode,
    ValueType LongDataVT, ValueType ShortDataVT,
    string OpBaseName> {
  defm : Merge_mvv<OpNode,
                   LongDataVT, v256i1,
                   OpBaseName>;
  defm : Merge_mvv<OpNode,
                   ShortDataVT, v256i1,
                   OpBaseName>;
}

defm : Merge_mvv_ShortLong<vvp_select,
                           v256f64,
                           v256f32, "VMRG">;
defm : Merge_mvv_ShortLong<vvp_select,
                           v256i64,
                           v256i32, "VMRG">;

multiclass Set_CC<ValueType DataVT, string FmkBaseName, string CmpBaseName, SDPatternOperator CCMatcher, SDNodeXForm CCConv> {
  // Unmasked.
  def : Pat<(v256i1 (vvp_setcc
              DataVT:$LHS, DataVT:$RHS, CCMatcher:$cond, (v256i1 true_mask), i32:$vl)),
              (!cast<Instruction>(FmkBaseName#"vl")
                (CCConv $cond),
                (!cast<Instruction>(CmpBaseName#"vvl")
                  $LHS, $RHS, $vl),
                $vl)>;
  // Masked.
  def : Pat<(v256i1 (vvp_setcc
              DataVT:$LHS, DataVT:$RHS, CCMatcher:$cond, v256i1:$vm, i32:$vl)),
              (!cast<Instruction>(FmkBaseName#"vml")
                (CCConv $cond),
                (!cast<Instruction>(CmpBaseName#"vvl")
                  $LHS, $RHS, $vl),
                $vm, $vl)>;
}

defm : Set_CC<v256i64,"VFMKL","VCMPUL",CCUIOp,icond2cc>;
defm : Set_CC<v256i64,"VFMKL","VCMPSL",CCSIOp,icond2cc>;
defm : Set_CC<v256f64,"VFMKL","VFCMPD",cond,fcond2cc>;

defm : Set_CC<v256i32,"VFMKW","VCMPUW",CCUIOp,icond2cc>;
defm : Set_CC<v256i32,"VFMKW","VCMPSWZX",CCSIOp,icond2cc>;
defm : Set_CC<v256f32,"VFMKS","VFCMPS",cond,fcond2cc>;

multiclass Reduce_GenericInt<ValueType VectorVT,
    RegisterClass ResRC, ValueType ResVT,
    string VVPRedOp, string RedInstName> {
  // Unmasked.
  def : Pat <(ResVT (!cast<SDPatternOperator>("vvp_reduce_"#VVPRedOp)
                VectorVT:$vx, (v256i1 true_mask), i32:$vl)),
             (COPY_TO_REGCLASS
               (!cast<Instruction>("LVSvi")
                 (!cast<Instruction>(RedInstName#"vl") $vx, $vl), 0),
                 ResRC)>;

  // Masked.
  def : Pat <(ResVT (!cast<SDPatternOperator>("vvp_reduce_"#VVPRedOp)
                VectorVT:$vx, v256i1:$vm, i32:$vl)),
             (COPY_TO_REGCLASS
                (!cast<Instruction>("LVSvi")
                   (!cast<Instruction>(RedInstName#"vml") $vx, $vm, $vl), 0),
                   ResRC)>;
}

multiclass IntReduce_ShortLong<ValueType VectorVT,
    RegisterClass ResRC, ValueType ResVT,
    string SumSuffix, string MinMaxSuffix> {
  defm: Reduce_GenericInt<VectorVT, ResRC, ResVT, "or",  "VROR">;
  defm: Reduce_GenericInt<VectorVT, ResRC, ResVT, "and", "VRAND">;
  defm: Reduce_GenericInt<VectorVT, ResRC, ResVT, "xor", "VRXOR">;
  defm: Reduce_GenericInt<VectorVT, ResRC, ResVT, "add", "VSUM"#SumSuffix>;
  defm: Reduce_GenericInt<VectorVT, ResRC, ResVT, "smax", "VRMAX"#MinMaxSuffix>;
}

defm: IntReduce_ShortLong<v256i64, I64, i64, "L","SLFST">;
defm: IntReduce_ShortLong<v256i32, I32, i32, "WSX","SWFSTSX">;