1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
//===-- BPFASpaceCastSimplifyPass.cpp - BPF addrspacecast simplications --===//
//
// 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 "BPF.h"
#include <optional>
#define DEBUG_TYPE "bpf-aspace-simplify"
using namespace llvm;
namespace {
struct CastGEPCast {
AddrSpaceCastInst *OuterCast;
// Match chain of instructions:
// %inner = addrspacecast N->M
// %gep = getelementptr %inner, ...
// %outer = addrspacecast M->N %gep
// Where I is %outer.
static std::optional<CastGEPCast> match(Value *I) {
auto *OuterCast = dyn_cast<AddrSpaceCastInst>(I);
if (!OuterCast)
return std::nullopt;
auto *GEP = dyn_cast<GetElementPtrInst>(OuterCast->getPointerOperand());
if (!GEP)
return std::nullopt;
auto *InnerCast = dyn_cast<AddrSpaceCastInst>(GEP->getPointerOperand());
if (!InnerCast)
return std::nullopt;
if (InnerCast->getSrcAddressSpace() != OuterCast->getDestAddressSpace())
return std::nullopt;
if (InnerCast->getDestAddressSpace() != OuterCast->getSrcAddressSpace())
return std::nullopt;
return CastGEPCast{OuterCast};
}
static PointerType *changeAddressSpace(PointerType *Ty, unsigned AS) {
return Ty->get(Ty->getContext(), AS);
}
// Assuming match(this->OuterCast) is true, convert:
// (addrspacecast M->N (getelementptr (addrspacecast N->M ptr) ...))
// To:
// (getelementptr ptr ...)
GetElementPtrInst *rewrite() {
auto *GEP = cast<GetElementPtrInst>(OuterCast->getPointerOperand());
auto *InnerCast = cast<AddrSpaceCastInst>(GEP->getPointerOperand());
unsigned AS = OuterCast->getDestAddressSpace();
auto *NewGEP = cast<GetElementPtrInst>(GEP->clone());
NewGEP->setName(GEP->getName());
NewGEP->insertAfter(OuterCast);
NewGEP->setOperand(0, InnerCast->getPointerOperand());
auto *GEPTy = cast<PointerType>(GEP->getType());
NewGEP->mutateType(changeAddressSpace(GEPTy, AS));
OuterCast->replaceAllUsesWith(NewGEP);
OuterCast->eraseFromParent();
if (GEP->use_empty())
GEP->eraseFromParent();
if (InnerCast->use_empty())
InnerCast->eraseFromParent();
return NewGEP;
}
};
} // anonymous namespace
PreservedAnalyses BPFASpaceCastSimplifyPass::run(Function &F,
FunctionAnalysisManager &AM) {
SmallVector<CastGEPCast, 16> WorkList;
bool Changed = false;
for (BasicBlock &BB : F) {
for (Instruction &I : BB)
if (auto It = CastGEPCast::match(&I))
WorkList.push_back(It.value());
Changed |= !WorkList.empty();
while (!WorkList.empty()) {
CastGEPCast InsnChain = WorkList.pop_back_val();
GetElementPtrInst *NewGEP = InsnChain.rewrite();
for (User *U : NewGEP->users())
if (auto It = CastGEPCast::match(U))
WorkList.push_back(It.value());
}
}
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
}
|
