LLVM  4.0.0
ConstantHoisting.cpp
Go to the documentation of this file.
1 //===- ConstantHoisting.cpp - Prepare code for expensive constants --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass identifies expensive constants to hoist and coalesces them to
11 // better prepare it for SelectionDAG-based code generation. This works around
12 // the limitations of the basic-block-at-a-time approach.
13 //
14 // First it scans all instructions for integer constants and calculates its
15 // cost. If the constant can be folded into the instruction (the cost is
16 // TCC_Free) or the cost is just a simple operation (TCC_BASIC), then we don't
17 // consider it expensive and leave it alone. This is the default behavior and
18 // the default implementation of getIntImmCost will always return TCC_Free.
19 //
20 // If the cost is more than TCC_BASIC, then the integer constant can't be folded
21 // into the instruction and it might be beneficial to hoist the constant.
22 // Similar constants are coalesced to reduce register pressure and
23 // materialization code.
24 //
25 // When a constant is hoisted, it is also hidden behind a bitcast to force it to
26 // be live-out of the basic block. Otherwise the constant would be just
27 // duplicated and each basic block would have its own copy in the SelectionDAG.
28 // The SelectionDAG recognizes such constants as opaque and doesn't perform
29 // certain transformations on them, which would create a new expensive constant.
30 //
31 // This optimization is only applied to integer constants in instructions and
32 // simple (this means not nested) constant cast expressions. For example:
33 // %0 = load i64* inttoptr (i64 big_constant to i64*)
34 //===----------------------------------------------------------------------===//
35 
37 #include "llvm/ADT/SmallSet.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/ADT/Statistic.h"
40 #include "llvm/IR/Constants.h"
41 #include "llvm/IR/IntrinsicInst.h"
42 #include "llvm/Pass.h"
43 #include "llvm/Support/Debug.h"
45 #include "llvm/Transforms/Scalar.h"
46 #include <tuple>
47 
48 using namespace llvm;
49 using namespace consthoist;
50 
51 #define DEBUG_TYPE "consthoist"
52 
53 STATISTIC(NumConstantsHoisted, "Number of constants hoisted");
54 STATISTIC(NumConstantsRebased, "Number of constants rebased");
55 
56 namespace {
57 /// \brief The constant hoisting pass.
58 class ConstantHoistingLegacyPass : public FunctionPass {
59 public:
60  static char ID; // Pass identification, replacement for typeid
61  ConstantHoistingLegacyPass() : FunctionPass(ID) {
63  }
64 
65  bool runOnFunction(Function &Fn) override;
66 
67  StringRef getPassName() const override { return "Constant Hoisting"; }
68 
69  void getAnalysisUsage(AnalysisUsage &AU) const override {
70  AU.setPreservesCFG();
73  }
74 
75  void releaseMemory() override { Impl.releaseMemory(); }
76 
77 private:
79 };
80 }
81 
83 INITIALIZE_PASS_BEGIN(ConstantHoistingLegacyPass, "consthoist",
84  "Constant Hoisting", false, false)
87 INITIALIZE_PASS_END(ConstantHoistingLegacyPass, "consthoist",
88  "Constant Hoisting", false, false)
89 
91  return new ConstantHoistingLegacyPass();
92 }
93 
94 /// \brief Perform the constant hoisting optimization for the given function.
95 bool ConstantHoistingLegacyPass::runOnFunction(Function &Fn) {
96  if (skipFunction(Fn))
97  return false;
98 
99  DEBUG(dbgs() << "********** Begin Constant Hoisting **********\n");
100  DEBUG(dbgs() << "********** Function: " << Fn.getName() << '\n');
101 
102  bool MadeChange = Impl.runImpl(
103  Fn, getAnalysis<TargetTransformInfoWrapperPass>().getTTI(Fn),
104  getAnalysis<DominatorTreeWrapperPass>().getDomTree(), Fn.getEntryBlock());
105 
106  if (MadeChange) {
107  DEBUG(dbgs() << "********** Function after Constant Hoisting: "
108  << Fn.getName() << '\n');
109  DEBUG(dbgs() << Fn);
110  }
111  DEBUG(dbgs() << "********** End Constant Hoisting **********\n");
112 
113  return MadeChange;
114 }
115 
116 
117 /// \brief Find the constant materialization insertion point.
118 Instruction *ConstantHoistingPass::findMatInsertPt(Instruction *Inst,
119  unsigned Idx) const {
120  // If the operand is a cast instruction, then we have to materialize the
121  // constant before the cast instruction.
122  if (Idx != ~0U) {
123  Value *Opnd = Inst->getOperand(Idx);
124  if (auto CastInst = dyn_cast<Instruction>(Opnd))
125  if (CastInst->isCast())
126  return CastInst;
127  }
128 
129  // The simple and common case. This also includes constant expressions.
130  if (!isa<PHINode>(Inst) && !Inst->isEHPad())
131  return Inst;
132 
133  // We can't insert directly before a phi node or an eh pad. Insert before
134  // the terminator of the incoming or dominating block.
135  assert(Entry != Inst->getParent() && "PHI or landing pad in entry block!");
136  if (Idx != ~0U && isa<PHINode>(Inst))
137  return cast<PHINode>(Inst)->getIncomingBlock(Idx)->getTerminator();
138 
139  BasicBlock *IDom = DT->getNode(Inst->getParent())->getIDom()->getBlock();
140  return IDom->getTerminator();
141 }
142 
143 /// \brief Find an insertion point that dominates all uses.
144 Instruction *ConstantHoistingPass::findConstantInsertionPoint(
145  const ConstantInfo &ConstInfo) const {
146  assert(!ConstInfo.RebasedConstants.empty() && "Invalid constant info entry.");
147  // Collect all basic blocks.
149  for (auto const &RCI : ConstInfo.RebasedConstants)
150  for (auto const &U : RCI.Uses)
151  BBs.insert(findMatInsertPt(U.Inst, U.OpndIdx)->getParent());
152 
153  if (BBs.count(Entry))
154  return &Entry->front();
155 
156  while (BBs.size() >= 2) {
157  BasicBlock *BB, *BB1, *BB2;
158  BB1 = *BBs.begin();
159  BB2 = *std::next(BBs.begin());
160  BB = DT->findNearestCommonDominator(BB1, BB2);
161  if (BB == Entry)
162  return &Entry->front();
163  BBs.erase(BB1);
164  BBs.erase(BB2);
165  BBs.insert(BB);
166  }
167  assert((BBs.size() == 1) && "Expected only one element.");
168  Instruction &FirstInst = (*BBs.begin())->front();
169  return findMatInsertPt(&FirstInst);
170 }
171 
172 
173 /// \brief Record constant integer ConstInt for instruction Inst at operand
174 /// index Idx.
175 ///
176 /// The operand at index Idx is not necessarily the constant integer itself. It
177 /// could also be a cast instruction or a constant expression that uses the
178 // constant integer.
179 void ConstantHoistingPass::collectConstantCandidates(
180  ConstCandMapType &ConstCandMap, Instruction *Inst, unsigned Idx,
181  ConstantInt *ConstInt) {
182  unsigned Cost;
183  // Ask the target about the cost of materializing the constant for the given
184  // instruction and operand index.
185  if (auto IntrInst = dyn_cast<IntrinsicInst>(Inst))
186  Cost = TTI->getIntImmCost(IntrInst->getIntrinsicID(), Idx,
187  ConstInt->getValue(), ConstInt->getType());
188  else
189  Cost = TTI->getIntImmCost(Inst->getOpcode(), Idx, ConstInt->getValue(),
190  ConstInt->getType());
191 
192  // Ignore cheap integer constants.
193  if (Cost > TargetTransformInfo::TCC_Basic) {
194  ConstCandMapType::iterator Itr;
195  bool Inserted;
196  std::tie(Itr, Inserted) = ConstCandMap.insert(std::make_pair(ConstInt, 0));
197  if (Inserted) {
198  ConstCandVec.push_back(ConstantCandidate(ConstInt));
199  Itr->second = ConstCandVec.size() - 1;
200  }
201  ConstCandVec[Itr->second].addUser(Inst, Idx, Cost);
202  DEBUG(if (isa<ConstantInt>(Inst->getOperand(Idx)))
203  dbgs() << "Collect constant " << *ConstInt << " from " << *Inst
204  << " with cost " << Cost << '\n';
205  else
206  dbgs() << "Collect constant " << *ConstInt << " indirectly from "
207  << *Inst << " via " << *Inst->getOperand(Idx) << " with cost "
208  << Cost << '\n';
209  );
210  }
211 }
212 
213 /// \brief Scan the instruction for expensive integer constants and record them
214 /// in the constant candidate vector.
215 void ConstantHoistingPass::collectConstantCandidates(
216  ConstCandMapType &ConstCandMap, Instruction *Inst) {
217  // Skip all cast instructions. They are visited indirectly later on.
218  if (Inst->isCast())
219  return;
220 
221  // Can't handle inline asm. Skip it.
222  if (auto Call = dyn_cast<CallInst>(Inst))
223  if (isa<InlineAsm>(Call->getCalledValue()))
224  return;
225 
226  // Switch cases must remain constant, and if the value being tested is
227  // constant the entire thing should disappear.
228  if (isa<SwitchInst>(Inst))
229  return;
230 
231  // Static allocas (constant size in the entry block) are handled by
232  // prologue/epilogue insertion so they're free anyway. We definitely don't
233  // want to make them non-constant.
234  auto AI = dyn_cast<AllocaInst>(Inst);
235  if (AI && AI->isStaticAlloca())
236  return;
237 
238  // Scan all operands.
239  for (unsigned Idx = 0, E = Inst->getNumOperands(); Idx != E; ++Idx) {
240  Value *Opnd = Inst->getOperand(Idx);
241 
242  // Visit constant integers.
243  if (auto ConstInt = dyn_cast<ConstantInt>(Opnd)) {
244  collectConstantCandidates(ConstCandMap, Inst, Idx, ConstInt);
245  continue;
246  }
247 
248  // Visit cast instructions that have constant integers.
249  if (auto CastInst = dyn_cast<Instruction>(Opnd)) {
250  // Only visit cast instructions, which have been skipped. All other
251  // instructions should have already been visited.
252  if (!CastInst->isCast())
253  continue;
254 
255  if (auto *ConstInt = dyn_cast<ConstantInt>(CastInst->getOperand(0))) {
256  // Pretend the constant is directly used by the instruction and ignore
257  // the cast instruction.
258  collectConstantCandidates(ConstCandMap, Inst, Idx, ConstInt);
259  continue;
260  }
261  }
262 
263  // Visit constant expressions that have constant integers.
264  if (auto ConstExpr = dyn_cast<ConstantExpr>(Opnd)) {
265  // Only visit constant cast expressions.
266  if (!ConstExpr->isCast())
267  continue;
268 
269  if (auto ConstInt = dyn_cast<ConstantInt>(ConstExpr->getOperand(0))) {
270  // Pretend the constant is directly used by the instruction and ignore
271  // the constant expression.
272  collectConstantCandidates(ConstCandMap, Inst, Idx, ConstInt);
273  continue;
274  }
275  }
276  } // end of for all operands
277 }
278 
279 /// \brief Collect all integer constants in the function that cannot be folded
280 /// into an instruction itself.
281 void ConstantHoistingPass::collectConstantCandidates(Function &Fn) {
282  ConstCandMapType ConstCandMap;
283  for (BasicBlock &BB : Fn)
284  for (Instruction &Inst : BB)
285  collectConstantCandidates(ConstCandMap, &Inst);
286 }
287 
288 // This helper function is necessary to deal with values that have different
289 // bit widths (APInt Operator- does not like that). If the value cannot be
290 // represented in uint64 we return an "empty" APInt. This is then interpreted
291 // as the value is not in range.
293 {
295  unsigned BW = V1.getBitWidth() > V2.getBitWidth() ?
296  V1.getBitWidth() : V2.getBitWidth();
297  uint64_t LimVal1 = V1.getLimitedValue();
298  uint64_t LimVal2 = V2.getLimitedValue();
299 
300  if (LimVal1 == ~0ULL || LimVal2 == ~0ULL)
301  return Res;
302 
303  uint64_t Diff = LimVal1 - LimVal2;
304  return APInt(BW, Diff, true);
305 }
306 
307 // From a list of constants, one needs to picked as the base and the other
308 // constants will be transformed into an offset from that base constant. The
309 // question is which we can pick best? For example, consider these constants
310 // and their number of uses:
311 //
312 // Constants| 2 | 4 | 12 | 42 |
313 // NumUses | 3 | 2 | 8 | 7 |
314 //
315 // Selecting constant 12 because it has the most uses will generate negative
316 // offsets for constants 2 and 4 (i.e. -10 and -8 respectively). If negative
317 // offsets lead to less optimal code generation, then there might be better
318 // solutions. Suppose immediates in the range of 0..35 are most optimally
319 // supported by the architecture, then selecting constant 2 is most optimal
320 // because this will generate offsets: 0, 2, 10, 40. Offsets 0, 2 and 10 are in
321 // range 0..35, and thus 3 + 2 + 8 = 13 uses are in range. Selecting 12 would
322 // have only 8 uses in range, so choosing 2 as a base is more optimal. Thus, in
323 // selecting the base constant the range of the offsets is a very important
324 // factor too that we take into account here. This algorithm calculates a total
325 // costs for selecting a constant as the base and substract the costs if
326 // immediates are out of range. It has quadratic complexity, so we call this
327 // function only when we're optimising for size and there are less than 100
328 // constants, we fall back to the straightforward algorithm otherwise
329 // which does not do all the offset calculations.
330 unsigned
331 ConstantHoistingPass::maximizeConstantsInRange(ConstCandVecType::iterator S,
332  ConstCandVecType::iterator E,
333  ConstCandVecType::iterator &MaxCostItr) {
334  unsigned NumUses = 0;
335 
336  if(!Entry->getParent()->optForSize() || std::distance(S,E) > 100) {
337  for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
338  NumUses += ConstCand->Uses.size();
339  if (ConstCand->CumulativeCost > MaxCostItr->CumulativeCost)
340  MaxCostItr = ConstCand;
341  }
342  return NumUses;
343  }
344 
345  DEBUG(dbgs() << "== Maximize constants in range ==\n");
346  int MaxCost = -1;
347  for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
348  auto Value = ConstCand->ConstInt->getValue();
349  Type *Ty = ConstCand->ConstInt->getType();
350  int Cost = 0;
351  NumUses += ConstCand->Uses.size();
352  DEBUG(dbgs() << "= Constant: " << ConstCand->ConstInt->getValue() << "\n");
353 
354  for (auto User : ConstCand->Uses) {
355  unsigned Opcode = User.Inst->getOpcode();
356  unsigned OpndIdx = User.OpndIdx;
357  Cost += TTI->getIntImmCost(Opcode, OpndIdx, Value, Ty);
358  DEBUG(dbgs() << "Cost: " << Cost << "\n");
359 
360  for (auto C2 = S; C2 != E; ++C2) {
362  C2->ConstInt->getValue(),
363  ConstCand->ConstInt->getValue());
364  if (Diff) {
365  const int ImmCosts =
366  TTI->getIntImmCodeSizeCost(Opcode, OpndIdx, Diff.getValue(), Ty);
367  Cost -= ImmCosts;
368  DEBUG(dbgs() << "Offset " << Diff.getValue() << " "
369  << "has penalty: " << ImmCosts << "\n"
370  << "Adjusted cost: " << Cost << "\n");
371  }
372  }
373  }
374  DEBUG(dbgs() << "Cumulative cost: " << Cost << "\n");
375  if (Cost > MaxCost) {
376  MaxCost = Cost;
377  MaxCostItr = ConstCand;
378  DEBUG(dbgs() << "New candidate: " << MaxCostItr->ConstInt->getValue()
379  << "\n");
380  }
381  }
382  return NumUses;
383 }
384 
385 /// \brief Find the base constant within the given range and rebase all other
386 /// constants with respect to the base constant.
387 void ConstantHoistingPass::findAndMakeBaseConstant(
388  ConstCandVecType::iterator S, ConstCandVecType::iterator E) {
389  auto MaxCostItr = S;
390  unsigned NumUses = maximizeConstantsInRange(S, E, MaxCostItr);
391 
392  // Don't hoist constants that have only one use.
393  if (NumUses <= 1)
394  return;
395 
396  ConstantInfo ConstInfo;
397  ConstInfo.BaseConstant = MaxCostItr->ConstInt;
398  Type *Ty = ConstInfo.BaseConstant->getType();
399 
400  // Rebase the constants with respect to the base constant.
401  for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
402  APInt Diff = ConstCand->ConstInt->getValue() -
403  ConstInfo.BaseConstant->getValue();
404  Constant *Offset = Diff == 0 ? nullptr : ConstantInt::get(Ty, Diff);
405  ConstInfo.RebasedConstants.push_back(
406  RebasedConstantInfo(std::move(ConstCand->Uses), Offset));
407  }
408  ConstantVec.push_back(std::move(ConstInfo));
409 }
410 
411 /// \brief Finds and combines constant candidates that can be easily
412 /// rematerialized with an add from a common base constant.
413 void ConstantHoistingPass::findBaseConstants() {
414  // Sort the constants by value and type. This invalidates the mapping!
415  std::sort(ConstCandVec.begin(), ConstCandVec.end(),
416  [](const ConstantCandidate &LHS, const ConstantCandidate &RHS) {
417  if (LHS.ConstInt->getType() != RHS.ConstInt->getType())
418  return LHS.ConstInt->getType()->getBitWidth() <
419  RHS.ConstInt->getType()->getBitWidth();
420  return LHS.ConstInt->getValue().ult(RHS.ConstInt->getValue());
421  });
422 
423  // Simple linear scan through the sorted constant candidate vector for viable
424  // merge candidates.
425  auto MinValItr = ConstCandVec.begin();
426  for (auto CC = std::next(ConstCandVec.begin()), E = ConstCandVec.end();
427  CC != E; ++CC) {
428  if (MinValItr->ConstInt->getType() == CC->ConstInt->getType()) {
429  // Check if the constant is in range of an add with immediate.
430  APInt Diff = CC->ConstInt->getValue() - MinValItr->ConstInt->getValue();
431  if ((Diff.getBitWidth() <= 64) &&
432  TTI->isLegalAddImmediate(Diff.getSExtValue()))
433  continue;
434  }
435  // We either have now a different constant type or the constant is not in
436  // range of an add with immediate anymore.
437  findAndMakeBaseConstant(MinValItr, CC);
438  // Start a new base constant search.
439  MinValItr = CC;
440  }
441  // Finalize the last base constant search.
442  findAndMakeBaseConstant(MinValItr, ConstCandVec.end());
443 }
444 
445 /// \brief Updates the operand at Idx in instruction Inst with the result of
446 /// instruction Mat. If the instruction is a PHI node then special
447 /// handling for duplicate values form the same incoming basic block is
448 /// required.
449 /// \return The update will always succeed, but the return value indicated if
450 /// Mat was used for the update or not.
451 static bool updateOperand(Instruction *Inst, unsigned Idx, Instruction *Mat) {
452  if (auto PHI = dyn_cast<PHINode>(Inst)) {
453  // Check if any previous operand of the PHI node has the same incoming basic
454  // block. This is a very odd case that happens when the incoming basic block
455  // has a switch statement. In this case use the same value as the previous
456  // operand(s), otherwise we will fail verification due to different values.
457  // The values are actually the same, but the variable names are different
458  // and the verifier doesn't like that.
459  BasicBlock *IncomingBB = PHI->getIncomingBlock(Idx);
460  for (unsigned i = 0; i < Idx; ++i) {
461  if (PHI->getIncomingBlock(i) == IncomingBB) {
462  Value *IncomingVal = PHI->getIncomingValue(i);
463  Inst->setOperand(Idx, IncomingVal);
464  return false;
465  }
466  }
467  }
468 
469  Inst->setOperand(Idx, Mat);
470  return true;
471 }
472 
473 /// \brief Emit materialization code for all rebased constants and update their
474 /// users.
475 void ConstantHoistingPass::emitBaseConstants(Instruction *Base,
476  Constant *Offset,
477  const ConstantUser &ConstUser) {
478  Instruction *Mat = Base;
479  if (Offset) {
480  Instruction *InsertionPt = findMatInsertPt(ConstUser.Inst,
481  ConstUser.OpndIdx);
482  Mat = BinaryOperator::Create(Instruction::Add, Base, Offset,
483  "const_mat", InsertionPt);
484 
485  DEBUG(dbgs() << "Materialize constant (" << *Base->getOperand(0)
486  << " + " << *Offset << ") in BB "
487  << Mat->getParent()->getName() << '\n' << *Mat << '\n');
488  Mat->setDebugLoc(ConstUser.Inst->getDebugLoc());
489  }
490  Value *Opnd = ConstUser.Inst->getOperand(ConstUser.OpndIdx);
491 
492  // Visit constant integer.
493  if (isa<ConstantInt>(Opnd)) {
494  DEBUG(dbgs() << "Update: " << *ConstUser.Inst << '\n');
495  if (!updateOperand(ConstUser.Inst, ConstUser.OpndIdx, Mat) && Offset)
496  Mat->eraseFromParent();
497  DEBUG(dbgs() << "To : " << *ConstUser.Inst << '\n');
498  return;
499  }
500 
501  // Visit cast instruction.
502  if (auto CastInst = dyn_cast<Instruction>(Opnd)) {
503  assert(CastInst->isCast() && "Expected an cast instruction!");
504  // Check if we already have visited this cast instruction before to avoid
505  // unnecessary cloning.
506  Instruction *&ClonedCastInst = ClonedCastMap[CastInst];
507  if (!ClonedCastInst) {
508  ClonedCastInst = CastInst->clone();
509  ClonedCastInst->setOperand(0, Mat);
510  ClonedCastInst->insertAfter(CastInst);
511  // Use the same debug location as the original cast instruction.
512  ClonedCastInst->setDebugLoc(CastInst->getDebugLoc());
513  DEBUG(dbgs() << "Clone instruction: " << *CastInst << '\n'
514  << "To : " << *ClonedCastInst << '\n');
515  }
516 
517  DEBUG(dbgs() << "Update: " << *ConstUser.Inst << '\n');
518  updateOperand(ConstUser.Inst, ConstUser.OpndIdx, ClonedCastInst);
519  DEBUG(dbgs() << "To : " << *ConstUser.Inst << '\n');
520  return;
521  }
522 
523  // Visit constant expression.
524  if (auto ConstExpr = dyn_cast<ConstantExpr>(Opnd)) {
525  Instruction *ConstExprInst = ConstExpr->getAsInstruction();
526  ConstExprInst->setOperand(0, Mat);
527  ConstExprInst->insertBefore(findMatInsertPt(ConstUser.Inst,
528  ConstUser.OpndIdx));
529 
530  // Use the same debug location as the instruction we are about to update.
531  ConstExprInst->setDebugLoc(ConstUser.Inst->getDebugLoc());
532 
533  DEBUG(dbgs() << "Create instruction: " << *ConstExprInst << '\n'
534  << "From : " << *ConstExpr << '\n');
535  DEBUG(dbgs() << "Update: " << *ConstUser.Inst << '\n');
536  if (!updateOperand(ConstUser.Inst, ConstUser.OpndIdx, ConstExprInst)) {
537  ConstExprInst->eraseFromParent();
538  if (Offset)
539  Mat->eraseFromParent();
540  }
541  DEBUG(dbgs() << "To : " << *ConstUser.Inst << '\n');
542  return;
543  }
544 }
545 
546 /// \brief Hoist and hide the base constant behind a bitcast and emit
547 /// materialization code for derived constants.
548 bool ConstantHoistingPass::emitBaseConstants() {
549  bool MadeChange = false;
550  for (auto const &ConstInfo : ConstantVec) {
551  // Hoist and hide the base constant behind a bitcast.
552  Instruction *IP = findConstantInsertionPoint(ConstInfo);
553  IntegerType *Ty = ConstInfo.BaseConstant->getType();
554  Instruction *Base =
555  new BitCastInst(ConstInfo.BaseConstant, Ty, "const", IP);
556  DEBUG(dbgs() << "Hoist constant (" << *ConstInfo.BaseConstant << ") to BB "
557  << IP->getParent()->getName() << '\n' << *Base << '\n');
558  NumConstantsHoisted++;
559 
560  // Emit materialization code for all rebased constants.
561  for (auto const &RCI : ConstInfo.RebasedConstants) {
562  NumConstantsRebased++;
563  for (auto const &U : RCI.Uses)
564  emitBaseConstants(Base, RCI.Offset, U);
565  }
566 
567  // Use the same debug location as the last user of the constant.
568  assert(!Base->use_empty() && "The use list is empty!?");
569  assert(isa<Instruction>(Base->user_back()) &&
570  "All uses should be instructions.");
571  Base->setDebugLoc(cast<Instruction>(Base->user_back())->getDebugLoc());
572 
573  // Correct for base constant, which we counted above too.
574  NumConstantsRebased--;
575  MadeChange = true;
576  }
577  return MadeChange;
578 }
579 
580 /// \brief Check all cast instructions we made a copy of and remove them if they
581 /// have no more users.
582 void ConstantHoistingPass::deleteDeadCastInst() const {
583  for (auto const &I : ClonedCastMap)
584  if (I.first->use_empty())
585  I.first->eraseFromParent();
586 }
587 
588 /// \brief Optimize expensive integer constants in the given function.
590  DominatorTree &DT, BasicBlock &Entry) {
591  this->TTI = &TTI;
592  this->DT = &DT;
593  this->Entry = &Entry;
594  // Collect all constant candidates.
595  collectConstantCandidates(Fn);
596 
597  // There are no constant candidates to worry about.
598  if (ConstCandVec.empty())
599  return false;
600 
601  // Combine constants that can be easily materialized with an add from a common
602  // base constant.
603  findBaseConstants();
604 
605  // There are no constants to emit.
606  if (ConstantVec.empty())
607  return false;
608 
609  // Finally hoist the base constant and emit materialization code for dependent
610  // constants.
611  bool MadeChange = emitBaseConstants();
612 
613  // Cleanup dead instructions.
614  deleteDeadCastInst();
615 
616  return MadeChange;
617 }
618 
621  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
622  auto &TTI = AM.getResult<TargetIRAnalysis>(F);
623  if (!runImpl(F, TTI, DT, F.getEntryBlock()))
624  return PreservedAnalyses::all();
625 
626  // FIXME: This should also 'preserve the CFG'.
627  return PreservedAnalyses::none();
628 }
const NoneType None
Definition: None.h:23
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
void push_back(const T &Elt)
Definition: SmallVector.h:211
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
Definition: Constants.h:177
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A base constant and all its rebased constants.
STATISTIC(NumFunctions,"Total number of functions")
size_t i
void initializeConstantHoistingLegacyPassPass(PassRegistry &)
virtual void releaseMemory()
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Definition: Pass.cpp:88
Keeps track of a constant candidate and its uses.
Analysis pass providing the TargetTransformInfo.
static bool updateOperand(Instruction *Inst, unsigned Idx, Instruction *Mat)
Updates the operand at Idx in instruction Inst with the result of instruction Mat.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
If this value is smaller than the specified limit, return it, otherwise return the limit value...
Definition: APInt.h:409
const Instruction & front() const
Definition: BasicBlock.h:240
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:189
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:65
Constant false
This represents a constant that has been rebased with respect to a base constant. ...
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
bool isCast() const
Definition: Instruction.h:117
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:578
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:143
Constant Hoisting
bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT, BasicBlock &Entry)
Optimize expensive integer constants in the given function.
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following: ...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
#define F(x, y, z)
Definition: MD5.cpp:51
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:121
This class represents a no-op cast from one type to another.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.cpp:501
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
Wrapper pass for TargetTransformInfo.
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:256
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction...
Definition: Instruction.cpp:82
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important base class in LLVM.
Definition: Constant.h:42
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1321
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
Represent the analysis usage information of a pass.
uint32_t Offset
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1255
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
Value * getOperand(unsigned i) const
Definition: User.h:145
Class to represent integer types.
Definition: DerivedTypes.h:39
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
static llvm::Optional< APInt > calculateOffsetDiff(APInt V1, APInt V2)
Keeps track of the user of a constant and the operand index where the constant is used...
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:59
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
void setOperand(unsigned i, Value *Val)
Definition: User.h:150
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Class for arbitrary precision integers.
Definition: APInt.h:77
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
INITIALIZE_PASS_BEGIN(ConstantHoistingLegacyPass,"consthoist","Constant Hoisting", false, false) INITIALIZE_PASS_END(ConstantHoistingLegacyPass
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:453
static bool runImpl(CallGraphSCC &SCC, CallGraph &CG, function_ref< AAResults &(Function &F)> AARGetter, unsigned MaxElements)
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
bool use_empty() const
Definition: Value.h:299
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
The cost of a typical 'add' instruction.
LLVM Value Representation.
Definition: Value.h:71
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
#define DEBUG(X)
Definition: Debug.h:100
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
A container for analyses that lazily runs them and caches their results.
RebasedConstantListType RebasedConstants
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:217
consthoist
const BasicBlock * getParent() const
Definition: Instruction.h:62
FunctionPass * createConstantHoistingPass()
an instruction to allocate memory on the stack
Definition: Instructions.h:60