llvm/unittests/Transforms/Utils/FunctionComparatorTest.cpp

   1 //===- FunctionComparator.cpp - Unit tests for FunctionComparator ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 #include "llvm/Transforms/Utils/FunctionComparator.h"
   9 #include "llvm/IR/BasicBlock.h"
  10 #include "llvm/IR/IRBuilder.h"
  11 #include "llvm/IR/Instructions.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Module.h"
  14 #include "gtest/gtest.h"
  15
  16 using namespace llvm;
  17
  18 /// Generates a simple test function.
  19 struct TestFunction {
  20   Function *F;
  21   BasicBlock *BB;
  22   Constant *C;
  23   Instruction *I;
  24   Type *T;
  25
  26   TestFunction(LLVMContext &Ctx, Module &M, int addVal) {
  27     IRBuilder<> B(Ctx);
  28     T = B.getInt8Ty();
  29     F = Function::Create(FunctionType::get(T, {B.getInt8PtrTy()}, false),
  30                          GlobalValue::ExternalLinkage, "F", &M);
  31     BB = BasicBlock::Create(Ctx, "", F);
  32     B.SetInsertPoint(BB);
  33     Argument *PointerArg = &*F->arg_begin();
  34     LoadInst *LoadInst = B.CreateLoad(T, PointerArg);
  35     C = B.getInt8(addVal);
  36     I = cast<Instruction>(B.CreateAdd(LoadInst, C));
  37     B.CreateRet(I);
  38   }
  39 };
  40
  41 /// A class for testing the FunctionComparator API.
  42 ///
  43 /// The main purpose is to test if the required protected functions are
  44 /// accessible from a derived class of FunctionComparator.
  45 class TestComparator : public FunctionComparator {
  46 public:
  47   TestComparator(const Function *F1, const Function *F2,
  48                  GlobalNumberState *GN)
  49         : FunctionComparator(F1, F2, GN) {
  50   }
  51
  52   bool testFunctionAccess(const Function *F1, const Function *F2) {
  53     // Test if FnL and FnR are accessible.
  54     return F1 == FnL && F2 == FnR;
  55   }
  56
  57   int testCompare() {
  58     return compare();
  59   }
  60
  61   int testCompareSignature() {
  62     beginCompare();
  63     return compareSignature();
  64   }
  65
  66   int testCmpBasicBlocks(BasicBlock *BBL, BasicBlock *BBR) {
  67     beginCompare();
  68     return cmpBasicBlocks(BBL, BBR);
  69   }
  70
  71   int testCmpConstants(const Constant *L, const Constant *R) {
  72     beginCompare();
  73     return cmpConstants(L, R);
  74   }
  75
  76   int testCmpGlobalValues(GlobalValue *L, GlobalValue *R) {
  77     beginCompare();
  78     return cmpGlobalValues(L, R);
  79   }
  80
  81   int testCmpValues(const Value *L, const Value *R) {
  82     beginCompare();
  83     return cmpValues(L, R);
  84   }
  85
  86   int testCmpOperations(const Instruction *L, const Instruction *R,
  87                         bool &needToCmpOperands) {
  88     beginCompare();
  89     return cmpOperations(L, R, needToCmpOperands);
  90   }
  91
  92   int testCmpTypes(Type *TyL, Type *TyR) {
  93     beginCompare();
  94     return cmpTypes(TyL, TyR);
  95   }
  96
  97   int testCmpPrimitives() {
  98     beginCompare();
  99     return
 100       cmpNumbers(2, 3) +
 101       cmpAPInts(APInt(32, 2), APInt(32, 3)) +
 102       cmpAPFloats(APFloat(2.0), APFloat(3.0)) +
 103       cmpMem("2", "3");
 104   }
 105 };
 106
 107 /// A sanity check for the FunctionComparator API.
 108 TEST(FunctionComparatorTest, TestAPI) {
 109   LLVMContext C;
 110   Module M("test", C);
 111   TestFunction F1(C, M, 27);
 112   TestFunction F2(C, M, 28);
 113
 114   GlobalNumberState GN;
 115   TestComparator Cmp(F1.F, F2.F, &GN);
 116
 117   EXPECT_TRUE(Cmp.testFunctionAccess(F1.F, F2.F));
 118   EXPECT_EQ(Cmp.testCompare(), -1);
 119   EXPECT_EQ(Cmp.testCompareSignature(), 0);
 120   EXPECT_EQ(Cmp.testCmpBasicBlocks(F1.BB, F2.BB), -1);
 121   EXPECT_EQ(Cmp.testCmpConstants(F1.C, F2.C), -1);
 122   EXPECT_EQ(Cmp.testCmpGlobalValues(F1.F, F2.F), -1);
 123   EXPECT_EQ(Cmp.testCmpValues(F1.I, F2.I), 0);
 124   bool needToCmpOperands = false;
 125   EXPECT_EQ(Cmp.testCmpOperations(F1.I, F2.I, needToCmpOperands), 0);
 126   EXPECT_TRUE(needToCmpOperands);
 127   EXPECT_EQ(Cmp.testCmpTypes(F1.T, F2.T), 0);
 128   EXPECT_EQ(Cmp.testCmpPrimitives(), -4);
 129 }