Mercurial > hg > CbC > CbC_llvm

comparison unittests/Transforms/Utils/FunctionComparatorTest.cpp @ 148:63bd29f05246

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merged
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 14 Aug 2019 19:46:37 +0900
parents c2174574ed3a
children
comparison
equal deleted inserted replaced
146:3fc4d5c3e21e 148:63bd29f05246
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 }