| 1 |
//===- AttributorTest.cpp - Attributor unit tests ------------------------===// |
| 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 |
|
| 9 |
#include "llvm/Transforms/IPO/Attributor.h" |
| 10 |
#include "AttributorTestBase.h" |
| 11 |
#include "llvm/ADT/StringRef.h" |
| 12 |
#include "llvm/Analysis/CGSCCPassManager.h" |
| 13 |
#include "llvm/Analysis/CallGraphSCCPass.h" |
| 14 |
#include "llvm/Analysis/LoopAnalysisManager.h" |
| 15 |
#include "llvm/AsmParser/Parser.h" |
| 16 |
#include "llvm/Support/Allocator.h" |
| 17 |
#include "llvm/Testing/Support/Error.h" |
| 18 |
#include "llvm/Transforms/Utils/CallGraphUpdater.h" |
| 19 |
#include "gtest/gtest.h" |
| 20 |
#include <memory> |
| 21 |
|
| 22 |
namespace llvm { |
| 23 |
|
| 24 |
TEST_F(AttributorTestBase, IRPPositionCallBaseContext) { |
| 25 |
const char *ModuleString = R"( |
| 26 |
define i32 @foo(i32 %a) { |
| 27 |
entry: |
| 28 |
ret i32 %a |
| 29 |
} |
| 30 |
)"; |
| 31 |
|
| 32 |
parseModule(ModuleString); |
| 33 |
|
| 34 |
Function *F = M->getFunction("foo"); |
| 35 |
IRPosition Pos = |
| 36 |
IRPosition::function(*F, (const llvm::CallBase *)(uintptr_t)0xDEADBEEF); |
| 37 |
EXPECT_TRUE(Pos.hasCallBaseContext()); |
| 38 |
EXPECT_FALSE(Pos.stripCallBaseContext().hasCallBaseContext()); |
| 39 |
} |
| 40 |
|
| 41 |
TEST_F(AttributorTestBase, TestCast) { |
| 42 |
const char *ModuleString = R"( |
| 43 |
define i32 @foo(i32 %a, i32 %b) { |
| 44 |
entry: |
| 45 |
%c = add i32 %a, %b |
| 46 |
ret i32 %c |
| 47 |
} |
| 48 |
)"; |
| 49 |
|
| 50 |
Module &M = parseModule(ModuleString); |
| 51 |
|
| 52 |
SetVector<Function *> Functions; |
| 53 |
AnalysisGetter AG; |
| 54 |
for (Function &F : M) |
| 55 |
Functions.insert(&F); |
| 56 |
|
| 57 |
CallGraphUpdater CGUpdater; |
| 58 |
BumpPtrAllocator Allocator; |
| 59 |
InformationCache InfoCache(M, AG, Allocator, nullptr); |
| 60 |
AttributorConfig AC(CGUpdater); |
| 61 |
Attributor A(Functions, InfoCache, AC); |
| 62 |
|
| 63 |
Function *F = M.getFunction("foo"); |
| 64 |
|
| 65 |
const AbstractAttribute *AA = |
| 66 |
&A.getOrCreateAAFor<AAIsDead>(IRPosition::function(*F)); |
| 67 |
|
| 68 |
EXPECT_TRUE(AA); |
| 69 |
|
| 70 |
const auto *SFail = dyn_cast<AAAlign>(AA); |
| 71 |
const auto *SSucc = dyn_cast<AAIsDead>(AA); |
| 72 |
|
| 73 |
ASSERT_EQ(SFail, nullptr); |
| 74 |
ASSERT_TRUE(SSucc); |
| 75 |
} |
| 76 |
|
| 77 |
TEST_F(AttributorTestBase, AAReachabilityTest) { |
| 78 |
const char *ModuleString = R"( |
| 79 |
@x = external global i32 |
| 80 |
define void @func4() { |
| 81 |
store i32 0, i32* @x |
| 82 |
ret void |
| 83 |
} |
| 84 |
|
| 85 |
define internal void @func3() { |
| 86 |
store i32 0, i32* @x |
| 87 |
ret void |
| 88 |
} |
| 89 |
|
| 90 |
define internal void @func8() { |
| 91 |
store i32 0, i32* @x |
| 92 |
ret void |
| 93 |
} |
| 94 |
|
| 95 |
define internal void @func2() { |
| 96 |
entry: |
| 97 |
call void @func3() |
| 98 |
ret void |
| 99 |
} |
| 100 |
|
| 101 |
define void @func1() { |
| 102 |
entry: |
| 103 |
call void @func2() |
| 104 |
ret void |
| 105 |
} |
| 106 |
|
| 107 |
declare void @unknown() |
| 108 |
define internal void @func5(void ()* %ptr) { |
| 109 |
entry: |
| 110 |
call void %ptr() |
| 111 |
call void @unknown() |
| 112 |
ret void |
| 113 |
} |
| 114 |
|
| 115 |
define void @func6() { |
| 116 |
entry: |
| 117 |
store i32 0, i32* @x |
| 118 |
call void @func5(void ()* @func3) |
| 119 |
ret void |
| 120 |
} |
| 121 |
|
| 122 |
define void @func7() { |
| 123 |
entry: |
| 124 |
call void @func2() |
| 125 |
call void @func4() |
| 126 |
ret void |
| 127 |
} |
| 128 |
|
| 129 |
define internal void @func9() { |
| 130 |
entry: |
| 131 |
call void @func2() |
| 132 |
call void @func8() |
| 133 |
ret void |
| 134 |
} |
| 135 |
|
| 136 |
define void @func10() { |
| 137 |
entry: |
| 138 |
call void @func9() |
| 139 |
call void @func4() |
| 140 |
ret void |
| 141 |
} |
| 142 |
|
| 143 |
)"; |
| 144 |
|
| 145 |
Module &M = parseModule(ModuleString); |
| 146 |
|
| 147 |
SetVector<Function *> Functions; |
| 148 |
AnalysisGetter AG; |
| 149 |
for (Function &F : M) |
| 150 |
Functions.insert(&F); |
| 151 |
|
| 152 |
CallGraphUpdater CGUpdater; |
| 153 |
BumpPtrAllocator Allocator; |
| 154 |
InformationCache InfoCache(M, AG, Allocator, nullptr); |
| 155 |
AttributorConfig AC(CGUpdater); |
| 156 |
AC.DeleteFns = false; |
| 157 |
Attributor A(Functions, InfoCache, AC); |
| 158 |
|
| 159 |
Function &F1 = *M.getFunction("func1"); |
| 160 |
Function &F3 = *M.getFunction("func3"); |
| 161 |
Function &F4 = *M.getFunction("func4"); |
| 162 |
Function &F6 = *M.getFunction("func6"); |
| 163 |
Function &F7 = *M.getFunction("func7"); |
| 164 |
Function &F9 = *M.getFunction("func9"); |
| 165 |
|
| 166 |
// call void @func2() |
| 167 |
CallBase &F7FirstCB = static_cast<CallBase &>(*F7.getEntryBlock().begin()); |
| 168 |
// call void @func2() |
| 169 |
Instruction &F9FirstInst = *F9.getEntryBlock().begin(); |
| 170 |
// call void @func8 |
| 171 |
Instruction &F9SecondInst = *++(F9.getEntryBlock().begin()); |
| 172 |
|
| 173 |
const AAInterFnReachability &F1AA = |
| 174 |
A.getOrCreateAAFor<AAInterFnReachability>(IRPosition::function(F1)); |
| 175 |
|
| 176 |
const AAInterFnReachability &F6AA = |
| 177 |
A.getOrCreateAAFor<AAInterFnReachability>(IRPosition::function(F6)); |
| 178 |
|
| 179 |
const AAInterFnReachability &F7AA = |
| 180 |
A.getOrCreateAAFor<AAInterFnReachability>(IRPosition::function(F7)); |
| 181 |
|
| 182 |
const AAInterFnReachability &F9AA = |
| 183 |
A.getOrCreateAAFor<AAInterFnReachability>(IRPosition::function(F9)); |
| 184 |
|
| 185 |
F1AA.canReach(A, F3); |
| 186 |
F1AA.canReach(A, F4); |
| 187 |
F6AA.canReach(A, F4); |
| 188 |
F7AA.instructionCanReach(A, F7FirstCB, F3); |
| 189 |
F7AA.instructionCanReach(A, F7FirstCB, F4); |
| 190 |
F9AA.instructionCanReach(A, F9SecondInst, F3); |
| 191 |
F9AA.instructionCanReach(A, F9FirstInst, F3); |
| 192 |
F9AA.instructionCanReach(A, F9FirstInst, F4); |
| 193 |
|
| 194 |
A.run(); |
| 195 |
|
| 196 |
ASSERT_TRUE(F1AA.canReach(A, F3)); |
| 197 |
ASSERT_FALSE(F1AA.canReach(A, F4)); |
| 198 |
|
| 199 |
ASSERT_TRUE(F7AA.instructionCanReach(A, F7FirstCB, F3)); |
| 200 |
ASSERT_TRUE(F7AA.instructionCanReach(A, F7FirstCB, F4)); |
| 201 |
|
| 202 |
// Assumed to be reacahable, since F6 can reach a function with |
| 203 |
// a unknown callee. |
| 204 |
ASSERT_TRUE(F6AA.canReach(A, F4)); |
| 205 |
|
| 206 |
// The second instruction of F9 can't reach the first call. |
| 207 |
ASSERT_FALSE(F9AA.instructionCanReach(A, F9SecondInst, F3)); |
| 208 |
|
| 209 |
// The first instruction of F9 can reach the first call. |
| 210 |
ASSERT_TRUE(F9AA.instructionCanReach(A, F9FirstInst, F3)); |
| 211 |
// Because func10 calls the func4 after the call to func9 it is reachable but |
| 212 |
// as it requires backwards logic we would need AA::isPotentiallyReachable. |
| 213 |
ASSERT_FALSE(F9AA.instructionCanReach(A, F9FirstInst, F4)); |
| 214 |
} |
| 215 |
|
| 216 |
} // namespace llvm |