//===- VPIntrinsicTest.cpp - VPIntrinsic unit tests ---------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/SmallVector.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/CodeGen/ISDOpcodes.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"
#include <optional>
#include <sstream>

using namespace llvm;

namespace {

static const char *ReductionIntOpcodes[] = {
    "add", "mul", "and", "or", "xor", "smin", "smax", "umin", "umax"};

static const char *ReductionFPOpcodes[] = {"fadd", "fmul",     "fmin",
                                           "fmax", "fminimum", "fmaximum"};

class VPIntrinsicTest : public testing::Test {
protected:
  LLVMContext Context;

  VPIntrinsicTest() : Context() {}

  LLVMContext C;
  SMDiagnostic Err;

  std::unique_ptr<Module> createVPDeclarationModule() {
    const char *BinaryIntOpcodes[] = {"add",  "sub",  "mul", "sdiv", "srem",
                                      "udiv", "urem", "and", "xor",  "or",
                                      "ashr", "lshr", "shl", "smin", "smax",
                                      "umin", "umax"};
    std::stringstream Str;
    for (const char *BinaryIntOpcode : BinaryIntOpcodes)
      Str << " declare <8 x i32> @llvm.vp." << BinaryIntOpcode
          << ".v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) ";

    const char *BinaryFPOpcodes[] = {"fadd",    "fsub",    "fmul",   "fdiv",
                                     "frem",    "minnum",  "maxnum", "minimum",
                                     "maximum", "copysign"};
    for (const char *BinaryFPOpcode : BinaryFPOpcodes)
      Str << " declare <8 x float> @llvm.vp." << BinaryFPOpcode
          << ".v8f32(<8 x float>, <8 x float>, <8 x i1>, i32) ";

    Str << " declare <8 x float> @llvm.vp.floor.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.round.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.roundeven.v8f32(<8 x float>, <8 x "
           "i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.roundtozero.v8f32(<8 x float>, <8 x "
           "i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.rint.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.nearbyint.v8f32(<8 x float>, <8 x "
           "i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.ceil.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x i32> @llvm.vp.lrint.v8i32.v8f32(<8 x float>, "
           "<8 x i1>, i32)";
    Str << " declare <8 x i64> @llvm.vp.llrint.v8i64.v8f32(<8 x float>, "
           "<8 x i1>, i32)";
    Str << " declare <8 x float> @llvm.vp.fneg.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.fabs.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.sqrt.v8f32(<8 x float>, <8 x i1>, "
           "i32)";
    Str << " declare <8 x float> @llvm.vp.fma.v8f32(<8 x float>, <8 x float>, "
           "<8 x float>, <8 x i1>, i32) ";
    Str << " declare <8 x float> @llvm.vp.fmuladd.v8f32(<8 x float>, "
           "<8 x float>, <8 x float>, <8 x i1>, i32) ";

    Str << " declare void @llvm.vp.store.v8i32.p0v8i32(<8 x i32>, <8 x i32>*, "
           "<8 x i1>, i32) ";
    Str << "declare void "
           "@llvm.experimental.vp.strided.store.v8i32.i32(<8 x i32>, "
           "i32*, i32, <8 x i1>, i32) ";
    Str << "declare void "
           "@llvm.experimental.vp.strided.store.v8i32.p1i32.i32(<8 x i32>, "
           "i32 addrspace(1)*, i32, <8 x i1>, i32) ";
    Str << " declare void @llvm.vp.scatter.v8i32.v8p0i32(<8 x i32>, <8 x "
           "i32*>, <8 x i1>, i32) ";
    Str << " declare <8 x i32> @llvm.vp.load.v8i32.p0v8i32(<8 x i32>*, <8 x "
           "i1>, i32) ";
    Str << " declare {<8 x i32>, i32} "
           "@llvm.vp.load.ff.v8i32.p0v8i32(<8 x "
           "i32>*, <8 x i1>, i32) ";
    Str << "declare <8 x i32> "
           "@llvm.experimental.vp.strided.load.v8i32.i32(i32*, i32, <8 "
           "x i1>, i32) ";
    Str << "declare <8 x i32> "
           "@llvm.experimental.vp.strided.load.v8i32.p1i32.i32(i32 "
           "addrspace(1)*, i32, <8 x i1>, i32) ";
    Str << " declare <8 x i32> @llvm.vp.gather.v8i32.v8p0i32(<8 x i32*>, <8 x "
           "i1>, i32) ";
    Str << " declare <8 x i32> @llvm.experimental.vp.splat.v8i32(i32, <8 x "
           "i1>, i32) ";

    for (const char *ReductionOpcode : ReductionIntOpcodes)
      Str << " declare i32 @llvm.vp.reduce." << ReductionOpcode
          << ".v8i32(i32, <8 x i32>, <8 x i1>, i32) ";

    for (const char *ReductionOpcode : ReductionFPOpcodes)
      Str << " declare float @llvm.vp.reduce." << ReductionOpcode
          << ".v8f32(float, <8 x float>, <8 x i1>, i32) ";

    Str << " declare <8 x i32> @llvm.vp.merge.v8i32(<8 x i1>, <8 x i32>, <8 x "
           "i32>, i32)";
    Str << " declare <8 x i32> @llvm.vp.select.v8i32(<8 x i1>, <8 x i32>, <8 x "
           "i32>, i32)";
    Str << " declare <8 x i1> @llvm.vp.is.fpclass.v8f32(<8 x float>, i32, <8 x "
           "i1>, i32)";
    Str << " declare <8 x i32> @llvm.experimental.vp.splice.v8i32(<8 x "
           "i32>, <8 x i32>, i32, <8 x i1>, i32, i32) ";

    Str << " declare <8 x i32> @llvm.vp.fptoui.v8i32"
        << ".v8f32(<8 x float>, <8 x i1>, i32) ";
    Str << " declare <8 x i32> @llvm.vp.fptosi.v8i32"
        << ".v8f32(<8 x float>, <8 x i1>, i32) ";
    Str << " declare <8 x float> @llvm.vp.uitofp.v8f32"
        << ".v8i32(<8 x i32>, <8 x i1>, i32) ";
    Str << " declare <8 x float> @llvm.vp.sitofp.v8f32"
        << ".v8i32(<8 x i32>, <8 x i1>, i32) ";
    Str << " declare <8 x float> @llvm.vp.fptrunc.v8f32"
        << ".v8f64(<8 x double>, <8 x i1>, i32) ";
    Str << " declare <8 x double> @llvm.vp.fpext.v8f64"
        << ".v8f32(<8 x float>, <8 x i1>, i32) ";
    Str << " declare <8 x i32> @llvm.vp.trunc.v8i32"
        << ".v8i64(<8 x i64>, <8 x i1>, i32) ";
    Str << " declare <8 x i64> @llvm.vp.zext.v8i64"
        << ".v8i32(<8 x i32>, <8 x i1>, i32) ";
    Str << " declare <8 x i64> @llvm.vp.sext.v8i64"
        << ".v8i32(<8 x i32>, <8 x i1>, i32) ";
    Str << " declare <8 x i32> @llvm.vp.ptrtoint.v8i32"
        << ".v8p0i32(<8 x i32*>, <8 x i1>, i32) ";
    Str << " declare <8 x i32*> @llvm.vp.inttoptr.v8p0i32"
        << ".v8i32(<8 x i32>, <8 x i1>, i32) ";

    Str << " declare <8 x i1> @llvm.vp.fcmp.v8f32"
        << "(<8 x float>, <8 x float>, metadata, <8 x i1>, i32) ";
    Str << " declare <8 x i1> @llvm.vp.icmp.v8i16"
        << "(<8 x i16>, <8 x i16>, metadata, <8 x i1>, i32) ";

    Str << " declare <8 x i32> @llvm.experimental.vp.reverse.v8i32(<8 x i32>, "
           "<8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.abs.v8i16"
        << "(<8 x i16>, i1 immarg, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.bitreverse.v8i16"
        << "(<8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.bswap.v8i16"
        << "(<8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.ctpop.v8i16"
        << "(<8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.ctlz.v8i16"
        << "(<8 x i16>, i1 immarg, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.cttz.v8i16"
        << "(<8 x i16>, i1 immarg, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.sadd.sat.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.uadd.sat.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.ssub.sat.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.usub.sat.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.fshl.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare <8 x i16> @llvm.vp.fshr.v8i16"
        << "(<8 x i16>, <8 x i16>, <8 x i16>, <8 x i1>, i32) ";
    Str << " declare i32 @llvm.vp.cttz.elts.i32.v8i16"
        << "(<8 x i16>, i1 immarg, <8 x i1>, i32) ";

    return parseAssemblyString(Str.str(), Err, C);
  }
};

/// Check that the property scopes include/llvm/IR/VPIntrinsics.def are closed.
TEST_F(VPIntrinsicTest, VPIntrinsicsDefScopes) {
  std::optional<Intrinsic::ID> ScopeVPID;
#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...)                                 \
  ASSERT_FALSE(ScopeVPID.has_value());                                         \
  ScopeVPID = Intrinsic::VPID;
#define END_REGISTER_VP_INTRINSIC(VPID)                                        \
  ASSERT_TRUE(ScopeVPID.has_value());                                          \
  ASSERT_EQ(*ScopeVPID, Intrinsic::VPID);                                      \
  ScopeVPID = std::nullopt;

  std::optional<ISD::NodeType> ScopeOPC;
#define BEGIN_REGISTER_VP_SDNODE(SDOPC, ...)                                   \
  ASSERT_FALSE(ScopeOPC.has_value());                                          \
  ScopeOPC = ISD::SDOPC;
#define END_REGISTER_VP_SDNODE(SDOPC)                                          \
  ASSERT_TRUE(ScopeOPC.has_value());                                           \
  ASSERT_EQ(*ScopeOPC, ISD::SDOPC);                                            \
  ScopeOPC = std::nullopt;
#include "llvm/IR/VPIntrinsics.def"

  ASSERT_FALSE(ScopeVPID.has_value());
  ASSERT_FALSE(ScopeOPC.has_value());
}

/// Check that every VP intrinsic in the test module is recognized as a VP
/// intrinsic.
TEST_F(VPIntrinsicTest, VPModuleComplete) {
  std::unique_ptr<Module> M = createVPDeclarationModule();
  assert(M);

  // Check that all @llvm.vp.* functions in the module are recognized vp
  // intrinsics.
  std::set<Intrinsic::ID> SeenIDs;
  for (const auto &VPDecl : *M) {
    ASSERT_TRUE(VPDecl.isIntrinsic());
    ASSERT_TRUE(VPIntrinsic::isVPIntrinsic(VPDecl.getIntrinsicID()));
    SeenIDs.insert(VPDecl.getIntrinsicID());
  }

  // Check that every registered VP intrinsic has an instance in the test
  // module.
#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...)                                 \
  ASSERT_TRUE(SeenIDs.count(Intrinsic::VPID));
#include "llvm/IR/VPIntrinsics.def"
}

/// Check that VPIntrinsic:canIgnoreVectorLengthParam() returns true
/// if the vector length parameter does not mask off any lanes.
TEST_F(VPIntrinsicTest, CanIgnoreVectorLength) {
  LLVMContext C;
  SMDiagnostic Err;

  std::unique_ptr<Module> M =
      parseAssemblyString(
"declare <256 x i64> @llvm.vp.mul.v256i64(<256 x i64>, <256 x i64>, <256 x i1>, i32)"
"declare <vscale x 2 x i64> @llvm.vp.mul.nxv2i64(<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i1>, i32)"
"declare <vscale x 1 x i64> @llvm.vp.mul.nxv1i64(<vscale x 1 x i64>, <vscale x 1 x i64>, <vscale x 1 x i1>, i32)"
"declare i32 @llvm.vscale.i32()"
"define void @test_static_vlen( "
"      <256 x i64> %i0, <vscale x 2 x i64> %si0x2, <vscale x 1 x i64> %si0x1,"
"      <256 x i64> %i1, <vscale x 2 x i64> %si1x2, <vscale x 1 x i64> %si1x1,"
"      <256 x i1> %m, <vscale x 2 x i1> %smx2, <vscale x 1 x i1> %smx1, i32 %vl) { "
"  %r0 = call <256 x i64> @llvm.vp.mul.v256i64(<256 x i64> %i0, <256 x i64> %i1, <256 x i1> %m, i32 %vl)"
"  %r1 = call <256 x i64> @llvm.vp.mul.v256i64(<256 x i64> %i0, <256 x i64> %i1, <256 x i1> %m, i32 256)"
"  %r2 = call <256 x i64> @llvm.vp.mul.v256i64(<256 x i64> %i0, <256 x i64> %i1, <256 x i1> %m, i32 0)"
"  %r3 = call <256 x i64> @llvm.vp.mul.v256i64(<256 x i64> %i0, <256 x i64> %i1, <256 x i1> %m, i32 7)"
"  %r4 = call <256 x i64> @llvm.vp.mul.v256i64(<256 x i64> %i0, <256 x i64> %i1, <256 x i1> %m, i32 123)"
"  %vs = call i32 @llvm.vscale.i32()"
"  %vs.x2 = mul i32 %vs, 2"
"  %r5 = call <vscale x 2 x i64> @llvm.vp.mul.nxv2i64(<vscale x 2 x i64> %si0x2, <vscale x 2 x i64> %si1x2, <vscale x 2 x i1> %smx2, i32 %vs.x2)"
"  %r6 = call <vscale x 2 x i64> @llvm.vp.mul.nxv2i64(<vscale x 2 x i64> %si0x2, <vscale x 2 x i64> %si1x2, <vscale x 2 x i1> %smx2, i32 %vs)"
"  %r7 = call <vscale x 2 x i64> @llvm.vp.mul.nxv2i64(<vscale x 2 x i64> %si0x2, <vscale x 2 x i64> %si1x2, <vscale x 2 x i1> %smx2, i32 99999)"
"  %r8 = call <vscale x 1 x i64> @llvm.vp.mul.nxv1i64(<vscale x 1 x i64> %si0x1, <vscale x 1 x i64> %si1x1, <vscale x 1 x i1> %smx1, i32 %vs)"
"  %r9 = call <vscale x 1 x i64> @llvm.vp.mul.nxv1i64(<vscale x 1 x i64> %si0x1, <vscale x 1 x i64> %si1x1, <vscale x 1 x i1> %smx1, i32 1)"
"  %r10 = call <vscale x 1 x i64> @llvm.vp.mul.nxv1i64(<vscale x 1 x i64> %si0x1, <vscale x 1 x i64> %si1x1, <vscale x 1 x i1> %smx1, i32 %vs.x2)"
"  %vs.wat = add i32 %vs, 2"
"  %r11 = call <vscale x 2 x i64> @llvm.vp.mul.nxv2i64(<vscale x 2 x i64> %si0x2, <vscale x 2 x i64> %si1x2, <vscale x 2 x i1> %smx2, i32 %vs.wat)"
"  ret void "
"}",
          Err, C);

  auto *F = M->getFunction("test_static_vlen");
  assert(F);

  const bool Expected[] = {false, true,  false, false, false, true,
                           false, false, true,  false, true,  false};
  const auto *ExpectedIt = std::begin(Expected);
  for (auto &I : F->getEntryBlock()) {
    VPIntrinsic *VPI = dyn_cast<VPIntrinsic>(&I);
    if (!VPI)
      continue;

    ASSERT_NE(ExpectedIt, std::end(Expected));
    ASSERT_EQ(*ExpectedIt, VPI->canIgnoreVectorLengthParam());
    ++ExpectedIt;
  }
}

/// Check that the argument returned by
/// VPIntrinsic::get<X>ParamPos(Intrinsic::ID) has the expected type.
TEST_F(VPIntrinsicTest, GetParamPos) {
  std::unique_ptr<Module> M = createVPDeclarationModule();
  assert(M);

  for (Function &F : *M) {
    ASSERT_TRUE(F.isIntrinsic());
    std::optional<unsigned> MaskParamPos =
        VPIntrinsic::getMaskParamPos(F.getIntrinsicID());
    if (MaskParamPos) {
      Type *MaskParamType = F.getArg(*MaskParamPos)->getType();
      ASSERT_TRUE(MaskParamType->isVectorTy());
      ASSERT_TRUE(
          cast<VectorType>(MaskParamType)->getElementType()->isIntegerTy(1));
    }

    std::optional<unsigned> VecLenParamPos =
        VPIntrinsic::getVectorLengthParamPos(F.getIntrinsicID());
    if (VecLenParamPos) {
      Type *VecLenParamType = F.getArg(*VecLenParamPos)->getType();
      ASSERT_TRUE(VecLenParamType->isIntegerTy(32));
    }
  }
}

/// Check that going from Opcode to VP intrinsic and back results in the same
/// Opcode.
TEST_F(VPIntrinsicTest, OpcodeRoundTrip) {
  std::vector<unsigned> Opcodes;
  Opcodes.reserve(100);

  {
#define HANDLE_INST(OCNum, OCName, Class) Opcodes.push_back(OCNum);
#include "llvm/IR/Instruction.def"
  }

  unsigned FullTripCounts = 0;
  for (unsigned OC : Opcodes) {
    Intrinsic::ID VPID = VPIntrinsic::getForOpcode(OC);
    // No equivalent VP intrinsic available.
    if (VPID == Intrinsic::not_intrinsic)
      continue;

    std::optional<unsigned> RoundTripOC =
        VPIntrinsic::getFunctionalOpcodeForVP(VPID);
    // No equivalent Opcode available.
    if (!RoundTripOC)
      continue;

    ASSERT_EQ(*RoundTripOC, OC);
    ++FullTripCounts;
  }
  ASSERT_NE(FullTripCounts, 0u);
}

/// Check that going from VP intrinsic to Opcode and back results in the same
/// intrinsic id.
TEST_F(VPIntrinsicTest, IntrinsicIDRoundTrip) {
  std::unique_ptr<Module> M = createVPDeclarationModule();
  assert(M);

  unsigned FullTripCounts = 0;
  for (const auto &VPDecl : *M) {
    auto VPID = VPDecl.getIntrinsicID();
    std::optional<unsigned> OC = VPIntrinsic::getFunctionalOpcodeForVP(VPID);

    // no equivalent Opcode available
    if (!OC)
      continue;

    Intrinsic::ID RoundTripVPID = VPIntrinsic::getForOpcode(*OC);

    ASSERT_EQ(RoundTripVPID, VPID);
    ++FullTripCounts;
  }
  ASSERT_NE(FullTripCounts, 0u);
}

/// Check that going from intrinsic to VP intrinsic and back results in the same
/// intrinsic.
TEST_F(VPIntrinsicTest, IntrinsicToVPRoundTrip) {
  bool IsFullTrip = false;
  Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic + 1;
  for (; IntrinsicID < Intrinsic::num_intrinsics; IntrinsicID++) {
    Intrinsic::ID VPID = VPIntrinsic::getForIntrinsic(IntrinsicID);
    // No equivalent VP intrinsic available.
    if (VPID == Intrinsic::not_intrinsic)
      continue;

    // Return itself if passed intrinsic ID is VP intrinsic.
    if (VPIntrinsic::isVPIntrinsic(IntrinsicID)) {
      ASSERT_EQ(IntrinsicID, VPID);
      continue;
    }

    std::optional<Intrinsic::ID> RoundTripIntrinsicID =
        VPIntrinsic::getFunctionalIntrinsicIDForVP(VPID);
    // No equivalent non-predicated intrinsic available.
    if (!RoundTripIntrinsicID)
      continue;

    ASSERT_EQ(*RoundTripIntrinsicID, IntrinsicID);
    IsFullTrip = true;
  }
  ASSERT_TRUE(IsFullTrip);
}

/// Check that going from VP intrinsic to equivalent non-predicated intrinsic
/// and back results in the same intrinsic.
TEST_F(VPIntrinsicTest, VPToNonPredIntrinsicRoundTrip) {
  std::unique_ptr<Module> M = createVPDeclarationModule();
  assert(M);

  bool IsFullTrip = false;
  for (const auto &VPDecl : *M) {
    auto VPID = VPDecl.getIntrinsicID();
    std::optional<Intrinsic::ID> NonPredID =
        VPIntrinsic::getFunctionalIntrinsicIDForVP(VPID);

    // No equivalent non-predicated intrinsic available
    if (!NonPredID)
      continue;

    Intrinsic::ID RoundTripVPID = VPIntrinsic::getForIntrinsic(*NonPredID);

    ASSERT_EQ(RoundTripVPID, VPID);
    IsFullTrip = true;
  }
  ASSERT_TRUE(IsFullTrip);
}

/// Check that VPIntrinsic::getOrInsertDeclarationForParams works.
TEST_F(VPIntrinsicTest, VPIntrinsicDeclarationForParams) {
  std::unique_ptr<Module> M = createVPDeclarationModule();
  assert(M);

  auto OutM = std::make_unique<Module>("", M->getContext());

  for (auto &F : *M) {
    auto *FuncTy = F.getFunctionType();

    // Declare intrinsic anew with explicit types.
    std::vector<Value *> Values;
    for (auto *ParamTy : FuncTy->params())
      Values.push_back(UndefValue::get(ParamTy));

    ASSERT_NE(F.getIntrinsicID(), Intrinsic::not_intrinsic);
    auto *NewDecl = VPIntrinsic::getOrInsertDeclarationForParams(
        OutM.get(), F.getIntrinsicID(), FuncTy->getReturnType(), Values);
    ASSERT_TRUE(NewDecl);

    // Check that 'old decl' == 'new decl'.
    ASSERT_EQ(F.getIntrinsicID(), NewDecl->getIntrinsicID());
    FunctionType::param_iterator ItNewParams =
        NewDecl->getFunctionType()->param_begin();
    FunctionType::param_iterator EndItNewParams =
        NewDecl->getFunctionType()->param_end();
    for (auto *ParamTy : FuncTy->params()) {
      ASSERT_NE(ItNewParams, EndItNewParams);
      ASSERT_EQ(*ItNewParams, ParamTy);
      ++ItNewParams;
    }
  }
}

} // end anonymous namespace

/// Check various properties of VPReductionIntrinsics
TEST_F(VPIntrinsicTest, VPReductions) {
  LLVMContext C;
  SMDiagnostic Err;

  std::stringstream Str;
  Str << "declare <8 x i32> @llvm.vp.mul.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, "
         "i32)";
  for (const char *ReductionOpcode : ReductionIntOpcodes)
    Str << " declare i32 @llvm.vp.reduce." << ReductionOpcode
        << ".v8i32(i32, <8 x i32>, <8 x i1>, i32) ";

  for (const char *ReductionOpcode : ReductionFPOpcodes)
    Str << " declare float @llvm.vp.reduce." << ReductionOpcode
        << ".v8f32(float, <8 x float>, <8 x i1>, i32) ";

  Str << "define void @test_reductions(i32 %start, <8 x i32> %val, float "
         "%fpstart, <8 x float> %fpval, <8 x i1> %m, i32 %vl) {";

  // Mix in a regular non-reduction intrinsic to check that the
  // VPReductionIntrinsic subclass works as intended.
  Str << "  %r0 = call <8 x i32> @llvm.vp.mul.v8i32(<8 x i32> %val, <8 x i32> "
         "%val, <8 x i1> %m, i32 %vl)";

  unsigned Idx = 1;
  for (const char *ReductionOpcode : ReductionIntOpcodes)
    Str << "  %r" << Idx++ << " = call i32 @llvm.vp.reduce." << ReductionOpcode
        << ".v8i32(i32 %start, <8 x i32> %val, <8 x i1> %m, i32 %vl)";
  for (const char *ReductionOpcode : ReductionFPOpcodes)
    Str << "  %r" << Idx++ << " = call float @llvm.vp.reduce."
        << ReductionOpcode
        << ".v8f32(float %fpstart, <8 x float> %fpval, <8 x i1> %m, i32 %vl)";

  Str << "  ret void"
         "}";

  std::unique_ptr<Module> M = parseAssemblyString(Str.str(), Err, C);
  assert(M);

  auto *F = M->getFunction("test_reductions");
  assert(F);

  for (const auto &I : F->getEntryBlock()) {
    const VPIntrinsic *VPI = dyn_cast<VPIntrinsic>(&I);
    if (!VPI)
      continue;

    Intrinsic::ID ID = VPI->getIntrinsicID();
    const auto *VPRedI = dyn_cast<VPReductionIntrinsic>(&I);

    if (!VPReductionIntrinsic::isVPReduction(ID)) {
      EXPECT_EQ(VPRedI, nullptr);
      EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), false);
      EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), false);
      continue;
    }

    EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), true);
    EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), true);
    ASSERT_NE(VPRedI, nullptr);
    EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID),
              VPRedI->getStartParamPos());
    EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID),
              VPRedI->getVectorParamPos());
    EXPECT_EQ(VPRedI->getStartParamPos(), 0u);
    EXPECT_EQ(VPRedI->getVectorParamPos(), 1u);
  }
}