ScalarEvolutionTest.cpp | Explore in Territory

//===- ScalarEvolutionsTest.cpp - ScalarEvolution 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/Analysis/AssumptionCache.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/ScalarEvolutionNormalization.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstIterator.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"

namespace llvm {

// We use this fixture to ensure that we clean up ScalarEvolution before
// deleting the PassManager.
class ScalarEvolutionsTest : public testing::Test { … };

TEST_F(ScalarEvolutionsTest, SCEVUnknownRAUW) { … }

TEST_F(ScalarEvolutionsTest, SimplifiedPHI) { … }


static Instruction *getInstructionByName(Function &F, StringRef Name) { … }

static Value *getArgByName(Function &F, StringRef Name) { … }
TEST_F(ScalarEvolutionsTest, CommutativeExprOperandOrder) { … }

TEST_F(ScalarEvolutionsTest, CompareSCEVComplexity) { … }

TEST_F(ScalarEvolutionsTest, CompareValueComplexity) { … }

TEST_F(ScalarEvolutionsTest, SCEVAddExpr) { … }

static Instruction &GetInstByName(Function &F, StringRef Name) { … }

TEST_F(ScalarEvolutionsTest, SCEVNormalization) { … }

// Expect the call of getZeroExtendExpr will not cost exponential time.
TEST_F(ScalarEvolutionsTest, SCEVZeroExtendExpr) { … }

// Make sure that SCEV invalidates exit limits after invalidating the values it
// depends on when we forget a loop.
TEST_F(ScalarEvolutionsTest, SCEVExitLimitForgetLoop) { … }

// Make sure that SCEV invalidates exit limits after invalidating the values it
// depends on when we forget a value.
TEST_F(ScalarEvolutionsTest, SCEVExitLimitForgetValue) { … }

TEST_F(ScalarEvolutionsTest, SCEVAddRecFromPHIwithLargeConstants) { … }

TEST_F(ScalarEvolutionsTest, SCEVAddRecFromPHIwithLargeConstantAccum) { … }

TEST_F(ScalarEvolutionsTest, SCEVFoldSumOfTruncs) { … }

// Check logic of SCEV expression size computation.
TEST_F(ScalarEvolutionsTest, SCEVComputeExpressionSize) { … }

TEST_F(ScalarEvolutionsTest, SCEVLoopDecIntrinsic) { … }

TEST_F(ScalarEvolutionsTest, SCEVComputeConstantDifference) { … }

TEST_F(ScalarEvolutionsTest, SCEVrewriteUnknowns) { … }

TEST_F(ScalarEvolutionsTest, SCEVAddNUW) { … }

TEST_F(ScalarEvolutionsTest, SCEVgetRanges) { … }

TEST_F(ScalarEvolutionsTest, SCEVgetExitLimitForGuardedLoop) { … }

TEST_F(ScalarEvolutionsTest, ImpliedViaAddRecStart) { … }

TEST_F(ScalarEvolutionsTest, UnsignedIsImpliedViaOperations) { … }

TEST_F(ScalarEvolutionsTest, ProveImplicationViaNarrowing) { … }

TEST_F(ScalarEvolutionsTest, ImpliedCond) { … }

TEST_F(ScalarEvolutionsTest, MatchURem) { … }

TEST_F(ScalarEvolutionsTest, SCEVUDivFloorCeiling) { … }

TEST_F(ScalarEvolutionsTest, CheckGetPowerOfTwo) { … }

TEST_F(ScalarEvolutionsTest, ApplyLoopGuards) { … }

TEST_F(ScalarEvolutionsTest, ForgetValueWithOverflowInst) { … }

TEST_F(ScalarEvolutionsTest, ComplexityComparatorIsStrictWeakOrdering) { … }

}  // end namespace llvm
llvm/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
