llvm/lib/IR/ReplaceConstant.cpp

   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(BasicBlock::iterator InsertPt,
  26                                                 Constant *C) {
  27   SmallVector<Instruction *, 4> NewInsts;
  28   if (auto *CE = dyn_cast<ConstantExpr>(C)) {
  29     Instruction *ConstInst = CE->getAsInstruction();
  30     ConstInst->insertBefore(*InsertPt->getParent(), InsertPt);
  31     NewInsts.push_back(ConstInst);
  32   } else if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
  33     Value *V = PoisonValue::get(C->getType());
  34     for (auto [Idx, Op] : enumerate(C->operands())) {
  35       V = InsertValueInst::Create(V, Op, Idx, "", InsertPt);
  36       NewInsts.push_back(cast<Instruction>(V));
  37     }
  38   } else if (isa<ConstantVector>(C)) {
  39     Type *IdxTy = Type::getInt32Ty(C->getContext());
  40     Value *V = PoisonValue::get(C->getType());
  41     for (auto [Idx, Op] : enumerate(C->operands())) {
  42       V = InsertElementInst::Create(V, Op, ConstantInt::get(IdxTy, Idx), "",
  43                                     InsertPt);
  44       NewInsts.push_back(cast<Instruction>(V));
  45     }
  46   } else {
  47     llvm_unreachable("Not an expandable user");
  48   }
  49   return NewInsts;
  50 }
  51
  52 bool convertUsersOfConstantsToInstructions(ArrayRef<Constant *> Consts,
  53                                            Function *RestrictToFunc,
  54                                            bool RemoveDeadConstants,
  55                                            bool IncludeSelf) {
  56   // Find all expandable direct users of Consts.
  57   SmallVector<Constant *> Stack;
  58   for (Constant *C : Consts) {
  59     if (IncludeSelf) {
  60       assert(isExpandableUser(C) && "One of the constants is not expandable");
  61       Stack.push_back(C);
  62     } else {
  63       for (User *U : C->users())
  64         if (isExpandableUser(U))
  65           Stack.push_back(cast<Constant>(U));
  66     }
  67   }
  68
  69   // Include transitive users.
  70   SetVector<Constant *> ExpandableUsers;
  71   while (!Stack.empty()) {
  72     Constant *C = Stack.pop_back_val();
  73     if (!ExpandableUsers.insert(C))
  74       continue;
  75
  76     for (auto *Nested : C->users())
  77       if (isExpandableUser(Nested))
  78         Stack.push_back(cast<Constant>(Nested));
  79   }
  80
  81   // Find all instructions that use any of the expandable users
  82   SetVector<Instruction *> InstructionWorklist;
  83   for (Constant *C : ExpandableUsers)
  84     for (User *U : C->users())
  85       if (auto *I = dyn_cast<Instruction>(U))
  86         if (!RestrictToFunc || I->getFunction() == RestrictToFunc)
  87           InstructionWorklist.insert(I);
  88
  89   // Replace those expandable operands with instructions
  90   bool Changed = false;
  91   while (!InstructionWorklist.empty()) {
  92     Instruction *I = InstructionWorklist.pop_back_val();
  93     DebugLoc Loc = I->getDebugLoc();
  94     for (Use &U : I->operands()) {
  95       BasicBlock::iterator BI = I->getIterator();
  96       if (auto *Phi = dyn_cast<PHINode>(I)) {
  97         BasicBlock *BB = Phi->getIncomingBlock(U);
  98         BI = BB->getFirstInsertionPt();
  99         assert(BI != BB->end() && "Unexpected empty basic block");
 100       }
 101
 102       if (auto *C = dyn_cast<Constant>(U.get())) {
 103         if (ExpandableUsers.contains(C)) {
 104           Changed = true;
 105           auto NewInsts = expandUser(BI, C);
 106           for (auto *NI : NewInsts)
 107             NI->setDebugLoc(Loc);
 108           InstructionWorklist.insert(NewInsts.begin(), NewInsts.end());
 109           U.set(NewInsts.back());
 110         }
 111       }
 112     }
 113   }
 114
 115   if (RemoveDeadConstants)
 116     for (Constant *C : Consts)
 117       C->removeDeadConstantUsers();
 118
 119   return Changed;
 120 }
 121
 122 } // namespace llvm