xref: /freebsd/contrib/llvm-project/llvm/lib/IR/ReplaceConstant.cpp (revision cb14a3fe5122c879eae1fb480ed7ce82a699ddb6)
1 //===- ReplaceConstant.cpp - Replace LLVM constant expression--------------===//
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 // This file implements a utility function for replacing LLVM constant
10 // expressions by instructions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/ReplaceConstant.h"
15 #include "llvm/ADT/SetVector.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Instructions.h"
18 
19 namespace llvm {
20 
21 static bool isExpandableUser(User *U) {
22   return isa<ConstantExpr>(U) || isa<ConstantAggregate>(U);
23 }
24 
25 static SmallVector<Instruction *, 4> expandUser(Instruction *InsertPt,
26                                                 Constant *C) {
27   SmallVector<Instruction *, 4> NewInsts;
28   if (auto *CE = dyn_cast<ConstantExpr>(C)) {
29     NewInsts.push_back(CE->getAsInstruction(InsertPt));
30   } else if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
31     Value *V = PoisonValue::get(C->getType());
32     for (auto [Idx, Op] : enumerate(C->operands())) {
33       V = InsertValueInst::Create(V, Op, Idx, "", InsertPt);
34       NewInsts.push_back(cast<Instruction>(V));
35     }
36   } else if (isa<ConstantVector>(C)) {
37     Type *IdxTy = Type::getInt32Ty(C->getContext());
38     Value *V = PoisonValue::get(C->getType());
39     for (auto [Idx, Op] : enumerate(C->operands())) {
40       V = InsertElementInst::Create(V, Op, ConstantInt::get(IdxTy, Idx), "",
41                                     InsertPt);
42       NewInsts.push_back(cast<Instruction>(V));
43     }
44   } else {
45     llvm_unreachable("Not an expandable user");
46   }
47   return NewInsts;
48 }
49 
50 bool convertUsersOfConstantsToInstructions(ArrayRef<Constant *> Consts) {
51   // Find all expandable direct users of Consts.
52   SmallVector<Constant *> Stack;
53   for (Constant *C : Consts)
54     for (User *U : C->users())
55       if (isExpandableUser(U))
56         Stack.push_back(cast<Constant>(U));
57 
58   // Include transitive users.
59   SetVector<Constant *> ExpandableUsers;
60   while (!Stack.empty()) {
61     Constant *C = Stack.pop_back_val();
62     if (!ExpandableUsers.insert(C))
63       continue;
64 
65     for (auto *Nested : C->users())
66       if (isExpandableUser(Nested))
67         Stack.push_back(cast<Constant>(Nested));
68   }
69 
70   // Find all instructions that use any of the expandable users
71   SetVector<Instruction *> InstructionWorklist;
72   for (Constant *C : ExpandableUsers)
73     for (User *U : C->users())
74       if (auto *I = dyn_cast<Instruction>(U))
75         InstructionWorklist.insert(I);
76 
77   // Replace those expandable operands with instructions
78   bool Changed = false;
79   while (!InstructionWorklist.empty()) {
80     Instruction *I = InstructionWorklist.pop_back_val();
81     DebugLoc Loc = I->getDebugLoc();
82     for (Use &U : I->operands()) {
83       auto *BI = I;
84       if (auto *Phi = dyn_cast<PHINode>(I)) {
85         BasicBlock *BB = Phi->getIncomingBlock(U);
86         BasicBlock::iterator It = BB->getFirstInsertionPt();
87         assert(It != BB->end() && "Unexpected empty basic block");
88         BI = &*It;
89       }
90 
91       if (auto *C = dyn_cast<Constant>(U.get())) {
92         if (ExpandableUsers.contains(C)) {
93           Changed = true;
94           auto NewInsts = expandUser(BI, C);
95           for (auto *NI : NewInsts)
96             NI->setDebugLoc(Loc);
97           InstructionWorklist.insert(NewInsts.begin(), NewInsts.end());
98           U.set(NewInsts.back());
99         }
100       }
101     }
102   }
103 
104   for (Constant *C : Consts)
105     C->removeDeadConstantUsers();
106 
107   return Changed;
108 }
109 
110 } // namespace llvm
111