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
93
94
95
96
97
98
99
100
101
102
|
//===- ReplaceConstant.cpp - Replace LLVM constant expression--------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements a utility function for replacing LLVM constant
// expressions by instructions.
//
//===----------------------------------------------------------------------===//
#include "llvm/IR/ReplaceConstant.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Instructions.h"
namespace llvm {
static bool isExpandableUser(User *U) {
return isa<ConstantExpr>(U) || isa<ConstantAggregate>(U);
}
static Instruction *expandUser(Instruction *InsertPt, Constant *C) {
if (auto *CE = dyn_cast<ConstantExpr>(C)) {
return CE->getAsInstruction(InsertPt);
} else if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
Value *V = PoisonValue::get(C->getType());
for (auto [Idx, Op] : enumerate(C->operands()))
V = InsertValueInst::Create(V, Op, Idx, "", InsertPt);
return cast<Instruction>(V);
} else if (isa<ConstantVector>(C)) {
Type *IdxTy = Type::getInt32Ty(C->getContext());
Value *V = PoisonValue::get(C->getType());
for (auto [Idx, Op] : enumerate(C->operands()))
V = InsertElementInst::Create(V, Op, ConstantInt::get(IdxTy, Idx), "",
InsertPt);
return cast<Instruction>(V);
} else {
llvm_unreachable("Not an expandable user");
}
}
bool convertUsersOfConstantsToInstructions(ArrayRef<Constant *> Consts) {
// Find all expandable direct users of Consts.
SmallVector<Constant *> Stack;
for (Constant *C : Consts)
for (User *U : C->users())
if (isExpandableUser(U))
Stack.push_back(cast<Constant>(U));
// Include transitive users.
SetVector<Constant *> ExpandableUsers;
while (!Stack.empty()) {
Constant *C = Stack.pop_back_val();
if (!ExpandableUsers.insert(C))
continue;
for (auto *Nested : C->users())
if (isExpandableUser(Nested))
Stack.push_back(cast<Constant>(Nested));
}
// Find all instructions that use any of the expandable users
SetVector<Instruction *> InstructionWorklist;
for (Constant *C : ExpandableUsers)
for (User *U : C->users())
if (auto *I = dyn_cast<Instruction>(U))
InstructionWorklist.insert(I);
// Replace those expandable operands with instructions
bool Changed = false;
while (!InstructionWorklist.empty()) {
Instruction *I = InstructionWorklist.pop_back_val();
for (Use &U : I->operands()) {
auto *BI = I;
if (auto *Phi = dyn_cast<PHINode>(I)) {
BasicBlock *BB = Phi->getIncomingBlock(U);
BasicBlock::iterator It = BB->getFirstInsertionPt();
assert(It != BB->end() && "Unexpected empty basic block");
BI = &*It;
}
if (auto *C = dyn_cast<Constant>(U.get())) {
if (ExpandableUsers.contains(C)) {
Changed = true;
Instruction *NI = expandUser(BI, C);
InstructionWorklist.insert(NI);
U.set(NI);
}
}
}
}
for (Constant *C : Consts)
C->removeDeadConstantUsers();
return Changed;
}
} // namespace llvm
|
