llvm/llvm/unittests/Analysis/VectorUtilsTest.cpp

//===- VectorUtilsTest.cpp - VectorUtils 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/Analysis/VectorUtils.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/NoFolder.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"

usingnamespacellvm;

namespace {

class VectorUtilsTest : public testing::Test { … };

struct BasicTest : public testing::Test { … };


} // namespace

TEST_F(BasicTest, isSplat) { … }

TEST_F(BasicTest, narrowShuffleMaskElts) { … }

TEST_F(BasicTest, widenShuffleMaskElts) { … }

TEST_F(BasicTest, getShuffleMaskWithWidestElts) { … }

TEST_F(BasicTest, getShuffleDemandedElts) { … }

TEST_F(BasicTest, getHorizontalDemandedEltsForFirstOperand) { … }

TEST_F(BasicTest, getSplatIndex) { … }

TEST_F(VectorUtilsTest, isSplatValue_00) { … }

TEST_F(VectorUtilsTest, isSplatValue_00_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_00_index1) { … }

TEST_F(VectorUtilsTest, isSplatValue_11) { … }

TEST_F(VectorUtilsTest, isSplatValue_11_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_11_index1) { … }

TEST_F(VectorUtilsTest, isSplatValue_01) { … }

TEST_F(VectorUtilsTest, isSplatValue_01_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_01_index1) { … }

// FIXME: Allow undef matching with Constant (mask) splat analysis.

TEST_F(VectorUtilsTest, isSplatValue_0u) { … }

// FIXME: Allow undef matching with Constant (mask) splat analysis.

TEST_F(VectorUtilsTest, isSplatValue_0u_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_0u_index1) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_index1) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index0) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index1) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op0) { … }

TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op1) { … }

TEST_F(VectorUtilsTest, isSplatValue_Select) { … }

TEST_F(VectorUtilsTest, isSplatValue_Select_ConstantOp) { … }

TEST_F(VectorUtilsTest, isSplatValue_Select_NotCond) { … }

TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp1) { … }

TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp2) { … }

TEST_F(VectorUtilsTest, isSplatValue_SelectBinop) { … }

TEST_F(VectorUtilsTest, getSplatValueElt0) { … }

TEST_F(VectorUtilsTest, getSplatValueEltMismatch) { … }

// TODO: This is a splat, but we don't recognize it.

TEST_F(VectorUtilsTest, getSplatValueElt1) { … }

////////////////////////////////////////////////////////////////////////////////
// VFShape API tests.
////////////////////////////////////////////////////////////////////////////////

class VFShapeAPITest : public testing::Test { … };

TEST_F(VFShapeAPITest, API_buildVFShape) { … }

TEST_F(VFShapeAPITest, API_getScalarShape) { … }

TEST_F(VFShapeAPITest, API_getVectorizedFunction) { … }

TEST_F(VFShapeAPITest, API_updateVFShape) { … }

TEST_F(VFShapeAPITest, API_updateVFShape_GlobalPredicate) { … }

TEST_F(VFShapeAPITest, Parameters_Valid) { … }

TEST_F(VFShapeAPITest, Parameters_ValidOpenMPLinear) { … }

TEST_F(VFShapeAPITest, Parameters_Invalid) { … }

TEST_F(VFShapeAPITest, Parameters_InvalidOpenMPLinear) { … }