LLVM  14.0.0git
GVNHoist.cpp
Go to the documentation of this file.
1 //===- GVNHoist.cpp - Hoist scalar and load expressions -------------------===//
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 pass hoists expressions from branches to a common dominator. It uses
10 // GVN (global value numbering) to discover expressions computing the same
11 // values. The primary goals of code-hoisting are:
12 // 1. To reduce the code size.
13 // 2. In some cases reduce critical path (by exposing more ILP).
14 //
15 // The algorithm factors out the reachability of values such that multiple
16 // queries to find reachability of values are fast. This is based on finding the
17 // ANTIC points in the CFG which do not change during hoisting. The ANTIC points
18 // are basically the dominance-frontiers in the inverse graph. So we introduce a
19 // data structure (CHI nodes) to keep track of values flowing out of a basic
20 // block. We only do this for values with multiple occurrences in the function
21 // as they are the potential hoistable candidates. This approach allows us to
22 // hoist instructions to a basic block with more than two successors, as well as
23 // deal with infinite loops in a trivial way.
24 //
25 // Limitations: This pass does not hoist fully redundant expressions because
26 // they are already handled by GVN-PRE. It is advisable to run gvn-hoist before
27 // and after gvn-pre because gvn-pre creates opportunities for more instructions
28 // to be hoisted.
29 //
30 // Hoisting may affect the performance in some cases. To mitigate that, hoisting
31 // is disabled in the following cases.
32 // 1. Scalars across calls.
33 // 2. geps when corresponding load/store cannot be hoisted.
34 //===----------------------------------------------------------------------===//
35 
36 #include "llvm/ADT/DenseMap.h"
37 #include "llvm/ADT/DenseSet.h"
38 #include "llvm/ADT/STLExtras.h"
39 #include "llvm/ADT/SmallPtrSet.h"
40 #include "llvm/ADT/SmallVector.h"
41 #include "llvm/ADT/Statistic.h"
51 #include "llvm/IR/Argument.h"
52 #include "llvm/IR/BasicBlock.h"
53 #include "llvm/IR/CFG.h"
54 #include "llvm/IR/Constants.h"
55 #include "llvm/IR/Dominators.h"
56 #include "llvm/IR/Function.h"
57 #include "llvm/IR/InstrTypes.h"
58 #include "llvm/IR/Instruction.h"
59 #include "llvm/IR/Instructions.h"
60 #include "llvm/IR/IntrinsicInst.h"
61 #include "llvm/IR/Intrinsics.h"
62 #include "llvm/IR/LLVMContext.h"
63 #include "llvm/IR/PassManager.h"
64 #include "llvm/IR/Use.h"
65 #include "llvm/IR/User.h"
66 #include "llvm/IR/Value.h"
67 #include "llvm/InitializePasses.h"
68 #include "llvm/Pass.h"
69 #include "llvm/Support/Casting.h"
71 #include "llvm/Support/Debug.h"
73 #include "llvm/Transforms/Scalar.h"
76 #include <algorithm>
77 #include <cassert>
78 #include <iterator>
79 #include <memory>
80 #include <utility>
81 #include <vector>
82 
83 using namespace llvm;
84 
85 #define DEBUG_TYPE "gvn-hoist"
86 
87 STATISTIC(NumHoisted, "Number of instructions hoisted");
88 STATISTIC(NumRemoved, "Number of instructions removed");
89 STATISTIC(NumLoadsHoisted, "Number of loads hoisted");
90 STATISTIC(NumLoadsRemoved, "Number of loads removed");
91 STATISTIC(NumStoresHoisted, "Number of stores hoisted");
92 STATISTIC(NumStoresRemoved, "Number of stores removed");
93 STATISTIC(NumCallsHoisted, "Number of calls hoisted");
94 STATISTIC(NumCallsRemoved, "Number of calls removed");
95 
96 static cl::opt<int>
97  MaxHoistedThreshold("gvn-max-hoisted", cl::Hidden, cl::init(-1),
98  cl::desc("Max number of instructions to hoist "
99  "(default unlimited = -1)"));
100 
102  "gvn-hoist-max-bbs", cl::Hidden, cl::init(4),
103  cl::desc("Max number of basic blocks on the path between "
104  "hoisting locations (default = 4, unlimited = -1)"));
105 
107  "gvn-hoist-max-depth", cl::Hidden, cl::init(100),
108  cl::desc("Hoist instructions from the beginning of the BB up to the "
109  "maximum specified depth (default = 100, unlimited = -1)"));
110 
111 static cl::opt<int>
112  MaxChainLength("gvn-hoist-max-chain-length", cl::Hidden, cl::init(10),
113  cl::desc("Maximum length of dependent chains to hoist "
114  "(default = 10, unlimited = -1)"));
115 
116 namespace llvm {
117 
121 
122 // Each element of a hoisting list contains the basic block where to hoist and
123 // a list of instructions to be hoisted.
124 using HoistingPointInfo = std::pair<BasicBlock *, SmallVecInsn>;
125 
127 
128 // A map from a pair of VNs to all the instructions with those VNs.
129 using VNType = std::pair<unsigned, unsigned>;
130 
132 
133 // CHI keeps information about values flowing out of a basic block. It is
134 // similar to PHI but in the inverse graph, and used for outgoing values on each
135 // edge. For conciseness, it is computed only for instructions with multiple
136 // occurrences in the CFG because they are the only hoistable candidates.
137 // A (CHI[{V, B, I1}, {V, C, I2}]
138 // / \
139 // / \
140 // B(I1) C (I2)
141 // The Value number for both I1 and I2 is V, the CHI node will save the
142 // instruction as well as the edge where the value is flowing to.
143 struct CHIArg {
145 
146  // Edge destination (shows the direction of flow), may not be where the I is.
148 
149  // The instruction (VN) which uses the values flowing out of CHI.
151 
152  bool operator==(const CHIArg &A) const { return VN == A.VN; }
153  bool operator!=(const CHIArg &A) const { return !(*this == A); }
154 };
155 
159 using InValuesType =
161 
162 // An invalid value number Used when inserting a single value number into
163 // VNtoInsns.
164 enum : unsigned { InvalidVN = ~2U };
165 
166 // Records all scalar instructions candidate for code hoisting.
167 class InsnInfo {
168  VNtoInsns VNtoScalars;
169 
170 public:
171  // Inserts I and its value number in VNtoScalars.
173  // Scalar instruction.
174  unsigned V = VN.lookupOrAdd(I);
175  VNtoScalars[{V, InvalidVN}].push_back(I);
176  }
177 
178  const VNtoInsns &getVNTable() const { return VNtoScalars; }
179 };
180 
181 // Records all load instructions candidate for code hoisting.
182 class LoadInfo {
183  VNtoInsns VNtoLoads;
184 
185 public:
186  // Insert Load and the value number of its memory address in VNtoLoads.
188  if (Load->isSimple()) {
189  unsigned V = VN.lookupOrAdd(Load->getPointerOperand());
190  VNtoLoads[{V, InvalidVN}].push_back(Load);
191  }
192  }
193 
194  const VNtoInsns &getVNTable() const { return VNtoLoads; }
195 };
196 
197 // Records all store instructions candidate for code hoisting.
198 class StoreInfo {
199  VNtoInsns VNtoStores;
200 
201 public:
202  // Insert the Store and a hash number of the store address and the stored
203  // value in VNtoStores.
205  if (!Store->isSimple())
206  return;
207  // Hash the store address and the stored value.
208  Value *Ptr = Store->getPointerOperand();
209  Value *Val = Store->getValueOperand();
210  VNtoStores[{VN.lookupOrAdd(Ptr), VN.lookupOrAdd(Val)}].push_back(Store);
211  }
212 
213  const VNtoInsns &getVNTable() const { return VNtoStores; }
214 };
215 
216 // Records all call instructions candidate for code hoisting.
217 class CallInfo {
218  VNtoInsns VNtoCallsScalars;
219  VNtoInsns VNtoCallsLoads;
220  VNtoInsns VNtoCallsStores;
221 
222 public:
223  // Insert Call and its value numbering in one of the VNtoCalls* containers.
224  void insert(CallInst *Call, GVN::ValueTable &VN) {
225  // A call that doesNotAccessMemory is handled as a Scalar,
226  // onlyReadsMemory will be handled as a Load instruction,
227  // all other calls will be handled as stores.
228  unsigned V = VN.lookupOrAdd(Call);
229  auto Entry = std::make_pair(V, InvalidVN);
230 
231  if (Call->doesNotAccessMemory())
232  VNtoCallsScalars[Entry].push_back(Call);
233  else if (Call->onlyReadsMemory())
234  VNtoCallsLoads[Entry].push_back(Call);
235  else
236  VNtoCallsStores[Entry].push_back(Call);
237  }
238 
239  const VNtoInsns &getScalarVNTable() const { return VNtoCallsScalars; }
240  const VNtoInsns &getLoadVNTable() const { return VNtoCallsLoads; }
241  const VNtoInsns &getStoreVNTable() const { return VNtoCallsStores; }
242 };
243 
244 static void combineKnownMetadata(Instruction *ReplInst, Instruction *I) {
245  static const unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
246  LLVMContext::MD_alias_scope,
247  LLVMContext::MD_noalias,
248  LLVMContext::MD_range,
249  LLVMContext::MD_fpmath,
250  LLVMContext::MD_invariant_load,
251  LLVMContext::MD_invariant_group,
252  LLVMContext::MD_access_group};
253  combineMetadata(ReplInst, I, KnownIDs, true);
254 }
255 
256 // This pass hoists common computations across branches sharing common
257 // dominator. The primary goal is to reduce the code size, and in some
258 // cases reduce critical path (by exposing more ILP).
259 class GVNHoist {
260 public:
263  : DT(DT), PDT(PDT), AA(AA), MD(MD), MSSA(MSSA),
264  MSSAUpdater(std::make_unique<MemorySSAUpdater>(MSSA)) {}
265 
266  bool run(Function &F);
267 
268  // Copied from NewGVN.cpp
269  // This function provides global ranking of operations so that we can place
270  // them in a canonical order. Note that rank alone is not necessarily enough
271  // for a complete ordering, as constants all have the same rank. However,
272  // generally, we will simplify an operation with all constants so that it
273  // doesn't matter what order they appear in.
274  unsigned int rank(const Value *V) const;
275 
276 private:
277  GVN::ValueTable VN;
278  DominatorTree *DT;
279  PostDominatorTree *PDT;
280  AliasAnalysis *AA;
282  MemorySSA *MSSA;
283  std::unique_ptr<MemorySSAUpdater> MSSAUpdater;
285  BBSideEffectsSet BBSideEffects;
286  DenseSet<const BasicBlock *> HoistBarrier;
288  unsigned NumFuncArgs;
289  const bool HoistingGeps = false;
290 
291  enum InsKind { Unknown, Scalar, Load, Store };
292 
293  // Return true when there are exception handling in BB.
294  bool hasEH(const BasicBlock *BB);
295 
296  // Return true when I1 appears before I2 in the instructions of BB.
297  bool firstInBB(const Instruction *I1, const Instruction *I2) {
298  assert(I1->getParent() == I2->getParent());
299  unsigned I1DFS = DFSNumber.lookup(I1);
300  unsigned I2DFS = DFSNumber.lookup(I2);
301  assert(I1DFS && I2DFS);
302  return I1DFS < I2DFS;
303  }
304 
305  // Return true when there are memory uses of Def in BB.
306  bool hasMemoryUse(const Instruction *NewPt, MemoryDef *Def,
307  const BasicBlock *BB);
308 
309  bool hasEHhelper(const BasicBlock *BB, const BasicBlock *SrcBB,
310  int &NBBsOnAllPaths);
311 
312  // Return true when there are exception handling or loads of memory Def
313  // between Def and NewPt. This function is only called for stores: Def is
314  // the MemoryDef of the store to be hoisted.
315 
316  // Decrement by 1 NBBsOnAllPaths for each block between HoistPt and BB, and
317  // return true when the counter NBBsOnAllPaths reaces 0, except when it is
318  // initialized to -1 which is unlimited.
319  bool hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
320  int &NBBsOnAllPaths);
321 
322  // Return true when there are exception handling between HoistPt and BB.
323  // Decrement by 1 NBBsOnAllPaths for each block between HoistPt and BB, and
324  // return true when the counter NBBsOnAllPaths reaches 0, except when it is
325  // initialized to -1 which is unlimited.
326  bool hasEHOnPath(const BasicBlock *HoistPt, const BasicBlock *SrcBB,
327  int &NBBsOnAllPaths);
328 
329  // Return true when it is safe to hoist a memory load or store U from OldPt
330  // to NewPt.
331  bool safeToHoistLdSt(const Instruction *NewPt, const Instruction *OldPt,
332  MemoryUseOrDef *U, InsKind K, int &NBBsOnAllPaths);
333 
334  // Return true when it is safe to hoist scalar instructions from all blocks in
335  // WL to HoistBB.
336  bool safeToHoistScalar(const BasicBlock *HoistBB, const BasicBlock *BB,
337  int &NBBsOnAllPaths) {
338  return !hasEHOnPath(HoistBB, BB, NBBsOnAllPaths);
339  }
340 
341  // In the inverse CFG, the dominance frontier of basic block (BB) is the
342  // point where ANTIC needs to be computed for instructions which are going
343  // to be hoisted. Since this point does not change during gvn-hoist,
344  // we compute it only once (on demand).
345  // The ides is inspired from:
346  // "Partial Redundancy Elimination in SSA Form"
347  // ROBERT KENNEDY, SUN CHAN, SHIN-MING LIU, RAYMOND LO, PENG TU and FRED CHOW
348  // They use similar idea in the forward graph to find fully redundant and
349  // partially redundant expressions, here it is used in the inverse graph to
350  // find fully anticipable instructions at merge point (post-dominator in
351  // the inverse CFG).
352  // Returns the edge via which an instruction in BB will get the values from.
353 
354  // Returns true when the values are flowing out to each edge.
355  bool valueAnticipable(CHIArgs C, Instruction *TI) const;
356 
357  // Check if it is safe to hoist values tracked by CHI in the range
358  // [Begin, End) and accumulate them in Safe.
359  void checkSafety(CHIArgs C, BasicBlock *BB, InsKind K,
361 
362  using RenameStackType = DenseMap<VNType, SmallVector<Instruction *, 2>>;
363 
364  // Push all the VNs corresponding to BB into RenameStack.
365  void fillRenameStack(BasicBlock *BB, InValuesType &ValueBBs,
366  RenameStackType &RenameStack);
367 
368  void fillChiArgs(BasicBlock *BB, OutValuesType &CHIBBs,
369  RenameStackType &RenameStack);
370 
371  // Walk the post-dominator tree top-down and use a stack for each value to
372  // store the last value you see. When you hit a CHI from a given edge, the
373  // value to use as the argument is at the top of the stack, add the value to
374  // CHI and pop.
375  void insertCHI(InValuesType &ValueBBs, OutValuesType &CHIBBs) {
376  auto Root = PDT->getNode(nullptr);
377  if (!Root)
378  return;
379  // Depth first walk on PDom tree to fill the CHIargs at each PDF.
380  for (auto Node : depth_first(Root)) {
381  BasicBlock *BB = Node->getBlock();
382  if (!BB)
383  continue;
384 
385  RenameStackType RenameStack;
386  // Collect all values in BB and push to stack.
387  fillRenameStack(BB, ValueBBs, RenameStack);
388 
389  // Fill outgoing values in each CHI corresponding to BB.
390  fillChiArgs(BB, CHIBBs, RenameStack);
391  }
392  }
393 
394  // Walk all the CHI-nodes to find ones which have a empty-entry and remove
395  // them Then collect all the instructions which are safe to hoist and see if
396  // they form a list of anticipable values. OutValues contains CHIs
397  // corresponding to each basic block.
398  void findHoistableCandidates(OutValuesType &CHIBBs, InsKind K,
399  HoistingPointList &HPL);
400 
401  // Compute insertion points for each values which can be fully anticipated at
402  // a dominator. HPL contains all such values.
403  void computeInsertionPoints(const VNtoInsns &Map, HoistingPointList &HPL,
404  InsKind K) {
405  // Sort VNs based on their rankings
406  std::vector<VNType> Ranks;
407  for (const auto &Entry : Map) {
408  Ranks.push_back(Entry.first);
409  }
410 
411  // TODO: Remove fully-redundant expressions.
412  // Get instruction from the Map, assume that all the Instructions
413  // with same VNs have same rank (this is an approximation).
414  llvm::sort(Ranks, [this, &Map](const VNType &r1, const VNType &r2) {
415  return (rank(*Map.lookup(r1).begin()) < rank(*Map.lookup(r2).begin()));
416  });
417 
418  // - Sort VNs according to their rank, and start with lowest ranked VN
419  // - Take a VN and for each instruction with same VN
420  // - Find the dominance frontier in the inverse graph (PDF)
421  // - Insert the chi-node at PDF
422  // - Remove the chi-nodes with missing entries
423  // - Remove values from CHI-nodes which do not truly flow out, e.g.,
424  // modified along the path.
425  // - Collect the remaining values that are still anticipable
427  ReverseIDFCalculator IDFs(*PDT);
428  OutValuesType OutValue;
429  InValuesType InValue;
430  for (const auto &R : Ranks) {
431  const SmallVecInsn &V = Map.lookup(R);
432  if (V.size() < 2)
433  continue;
434  const VNType &VN = R;
436  for (auto &I : V) {
437  BasicBlock *BBI = I->getParent();
438  if (!hasEH(BBI))
439  VNBlocks.insert(BBI);
440  }
441  // Compute the Post Dominance Frontiers of each basic block
442  // The dominance frontier of a live block X in the reverse
443  // control graph is the set of blocks upon which X is control
444  // dependent. The following sequence computes the set of blocks
445  // which currently have dead terminators that are control
446  // dependence sources of a block which is in NewLiveBlocks.
447  IDFs.setDefiningBlocks(VNBlocks);
448  IDFBlocks.clear();
449  IDFs.calculate(IDFBlocks);
450 
451  // Make a map of BB vs instructions to be hoisted.
452  for (unsigned i = 0; i < V.size(); ++i) {
453  InValue[V[i]->getParent()].push_back(std::make_pair(VN, V[i]));
454  }
455  // Insert empty CHI node for this VN. This is used to factor out
456  // basic blocks where the ANTIC can potentially change.
457  CHIArg EmptyChi = {VN, nullptr, nullptr};
458  for (auto *IDFBB : IDFBlocks) {
459  for (unsigned i = 0; i < V.size(); ++i) {
460  // Ignore spurious PDFs.
461  if (DT->properlyDominates(IDFBB, V[i]->getParent())) {
462  OutValue[IDFBB].push_back(EmptyChi);
463  LLVM_DEBUG(dbgs() << "\nInserting a CHI for BB: "
464  << IDFBB->getName() << ", for Insn: " << *V[i]);
465  }
466  }
467  }
468  }
469 
470  // Insert CHI args at each PDF to iterate on factored graph of
471  // control dependence.
472  insertCHI(InValue, OutValue);
473  // Using the CHI args inserted at each PDF, find fully anticipable values.
474  findHoistableCandidates(OutValue, K, HPL);
475  }
476 
477  // Return true when all operands of Instr are available at insertion point
478  // HoistPt. When limiting the number of hoisted expressions, one could hoist
479  // a load without hoisting its access function. So before hoisting any
480  // expression, make sure that all its operands are available at insert point.
481  bool allOperandsAvailable(const Instruction *I,
482  const BasicBlock *HoistPt) const;
483 
484  // Same as allOperandsAvailable with recursive check for GEP operands.
485  bool allGepOperandsAvailable(const Instruction *I,
486  const BasicBlock *HoistPt) const;
487 
488  // Make all operands of the GEP available.
489  void makeGepsAvailable(Instruction *Repl, BasicBlock *HoistPt,
490  const SmallVecInsn &InstructionsToHoist,
491  Instruction *Gep) const;
492 
493  void updateAlignment(Instruction *I, Instruction *Repl);
494 
495  // Remove all the instructions in Candidates and replace their usage with
496  // Repl. Returns the number of instructions removed.
497  unsigned rauw(const SmallVecInsn &Candidates, Instruction *Repl,
498  MemoryUseOrDef *NewMemAcc);
499 
500  // Replace all Memory PHI usage with NewMemAcc.
501  void raMPHIuw(MemoryUseOrDef *NewMemAcc);
502 
503  // Remove all other instructions and replace them with Repl.
504  unsigned removeAndReplace(const SmallVecInsn &Candidates, Instruction *Repl,
505  BasicBlock *DestBB, bool MoveAccess);
506 
507  // In the case Repl is a load or a store, we make all their GEPs
508  // available: GEPs are not hoisted by default to avoid the address
509  // computations to be hoisted without the associated load or store.
510  bool makeGepOperandsAvailable(Instruction *Repl, BasicBlock *HoistPt,
511  const SmallVecInsn &InstructionsToHoist) const;
512 
513  std::pair<unsigned, unsigned> hoist(HoistingPointList &HPL);
514 
515  // Hoist all expressions. Returns Number of scalars hoisted
516  // and number of non-scalars hoisted.
517  std::pair<unsigned, unsigned> hoistExpressions(Function &F);
518 };
519 
521 public:
522  static char ID;
523 
526  }
527 
528  bool runOnFunction(Function &F) override {
529  if (skipFunction(F))
530  return false;
531  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
532  auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
533  auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
534  auto &MD = getAnalysis<MemoryDependenceWrapperPass>().getMemDep();
535  auto &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
536 
537  GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
538  return G.run(F);
539  }
540 
541  void getAnalysisUsage(AnalysisUsage &AU) const override {
550  }
551 };
552 
554  NumFuncArgs = F.arg_size();
555  VN.setDomTree(DT);
556  VN.setAliasAnalysis(AA);
557  VN.setMemDep(MD);
558  bool Res = false;
559  // Perform DFS Numbering of instructions.
560  unsigned BBI = 0;
561  for (const BasicBlock *BB : depth_first(&F.getEntryBlock())) {
562  DFSNumber[BB] = ++BBI;
563  unsigned I = 0;
564  for (auto &Inst : *BB)
565  DFSNumber[&Inst] = ++I;
566  }
567 
568  int ChainLength = 0;
569 
570  // FIXME: use lazy evaluation of VN to avoid the fix-point computation.
571  while (true) {
572  if (MaxChainLength != -1 && ++ChainLength >= MaxChainLength)
573  return Res;
574 
575  auto HoistStat = hoistExpressions(F);
576  if (HoistStat.first + HoistStat.second == 0)
577  return Res;
578 
579  if (HoistStat.second > 0)
580  // To address a limitation of the current GVN, we need to rerun the
581  // hoisting after we hoisted loads or stores in order to be able to
582  // hoist all scalars dependent on the hoisted ld/st.
583  VN.clear();
584 
585  Res = true;
586  }
587 
588  return Res;
589 }
590 
591 unsigned int GVNHoist::rank(const Value *V) const {
592  // Prefer constants to undef to anything else
593  // Undef is a constant, have to check it first.
594  // Prefer smaller constants to constantexprs
595  if (isa<ConstantExpr>(V))
596  return 2;
597  if (isa<UndefValue>(V))
598  return 1;
599  if (isa<Constant>(V))
600  return 0;
601  else if (auto *A = dyn_cast<Argument>(V))
602  return 3 + A->getArgNo();
603 
604  // Need to shift the instruction DFS by number of arguments + 3 to account
605  // for the constant and argument ranking above.
606  auto Result = DFSNumber.lookup(V);
607  if (Result > 0)
608  return 4 + NumFuncArgs + Result;
609  // Unreachable or something else, just return a really large number.
610  return ~0;
611 }
612 
613 bool GVNHoist::hasEH(const BasicBlock *BB) {
614  auto It = BBSideEffects.find(BB);
615  if (It != BBSideEffects.end())
616  return It->second;
617 
618  if (BB->isEHPad() || BB->hasAddressTaken()) {
619  BBSideEffects[BB] = true;
620  return true;
621  }
622 
623  if (BB->getTerminator()->mayThrow()) {
624  BBSideEffects[BB] = true;
625  return true;
626  }
627 
628  BBSideEffects[BB] = false;
629  return false;
630 }
631 
632 bool GVNHoist::hasMemoryUse(const Instruction *NewPt, MemoryDef *Def,
633  const BasicBlock *BB) {
634  const MemorySSA::AccessList *Acc = MSSA->getBlockAccesses(BB);
635  if (!Acc)
636  return false;
637 
638  Instruction *OldPt = Def->getMemoryInst();
639  const BasicBlock *OldBB = OldPt->getParent();
640  const BasicBlock *NewBB = NewPt->getParent();
641  bool ReachedNewPt = false;
642 
643  for (const MemoryAccess &MA : *Acc)
644  if (const MemoryUse *MU = dyn_cast<MemoryUse>(&MA)) {
645  Instruction *Insn = MU->getMemoryInst();
646 
647  // Do not check whether MU aliases Def when MU occurs after OldPt.
648  if (BB == OldBB && firstInBB(OldPt, Insn))
649  break;
650 
651  // Do not check whether MU aliases Def when MU occurs before NewPt.
652  if (BB == NewBB) {
653  if (!ReachedNewPt) {
654  if (firstInBB(Insn, NewPt))
655  continue;
656  ReachedNewPt = true;
657  }
658  }
660  return true;
661  }
662 
663  return false;
664 }
665 
666 bool GVNHoist::hasEHhelper(const BasicBlock *BB, const BasicBlock *SrcBB,
667  int &NBBsOnAllPaths) {
668  // Stop walk once the limit is reached.
669  if (NBBsOnAllPaths == 0)
670  return true;
671 
672  // Impossible to hoist with exceptions on the path.
673  if (hasEH(BB))
674  return true;
675 
676  // No such instruction after HoistBarrier in a basic block was
677  // selected for hoisting so instructions selected within basic block with
678  // a hoist barrier can be hoisted.
679  if ((BB != SrcBB) && HoistBarrier.count(BB))
680  return true;
681 
682  return false;
683 }
684 
685 bool GVNHoist::hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
686  int &NBBsOnAllPaths) {
687  const BasicBlock *NewBB = NewPt->getParent();
688  const BasicBlock *OldBB = Def->getBlock();
689  assert(DT->dominates(NewBB, OldBB) && "invalid path");
690  assert(DT->dominates(Def->getDefiningAccess()->getBlock(), NewBB) &&
691  "def does not dominate new hoisting point");
692 
693  // Walk all basic blocks reachable in depth-first iteration on the inverse
694  // CFG from OldBB to NewBB. These blocks are all the blocks that may be
695  // executed between the execution of NewBB and OldBB. Hoisting an expression
696  // from OldBB into NewBB has to be safe on all execution paths.
697  for (auto I = idf_begin(OldBB), E = idf_end(OldBB); I != E;) {
698  const BasicBlock *BB = *I;
699  if (BB == NewBB) {
700  // Stop traversal when reaching HoistPt.
701  I.skipChildren();
702  continue;
703  }
704 
705  if (hasEHhelper(BB, OldBB, NBBsOnAllPaths))
706  return true;
707 
708  // Check that we do not move a store past loads.
709  if (hasMemoryUse(NewPt, Def, BB))
710  return true;
711 
712  // -1 is unlimited number of blocks on all paths.
713  if (NBBsOnAllPaths != -1)
714  --NBBsOnAllPaths;
715 
716  ++I;
717  }
718 
719  return false;
720 }
721 
722 bool GVNHoist::hasEHOnPath(const BasicBlock *HoistPt, const BasicBlock *SrcBB,
723  int &NBBsOnAllPaths) {
724  assert(DT->dominates(HoistPt, SrcBB) && "Invalid path");
725 
726  // Walk all basic blocks reachable in depth-first iteration on
727  // the inverse CFG from BBInsn to NewHoistPt. These blocks are all the
728  // blocks that may be executed between the execution of NewHoistPt and
729  // BBInsn. Hoisting an expression from BBInsn into NewHoistPt has to be safe
730  // on all execution paths.
731  for (auto I = idf_begin(SrcBB), E = idf_end(SrcBB); I != E;) {
732  const BasicBlock *BB = *I;
733  if (BB == HoistPt) {
734  // Stop traversal when reaching NewHoistPt.
735  I.skipChildren();
736  continue;
737  }
738 
739  if (hasEHhelper(BB, SrcBB, NBBsOnAllPaths))
740  return true;
741 
742  // -1 is unlimited number of blocks on all paths.
743  if (NBBsOnAllPaths != -1)
744  --NBBsOnAllPaths;
745 
746  ++I;
747  }
748 
749  return false;
750 }
751 
752 bool GVNHoist::safeToHoistLdSt(const Instruction *NewPt,
753  const Instruction *OldPt, MemoryUseOrDef *U,
754  GVNHoist::InsKind K, int &NBBsOnAllPaths) {
755  // In place hoisting is safe.
756  if (NewPt == OldPt)
757  return true;
758 
759  const BasicBlock *NewBB = NewPt->getParent();
760  const BasicBlock *OldBB = OldPt->getParent();
761  const BasicBlock *UBB = U->getBlock();
762 
763  // Check for dependences on the Memory SSA.
765  BasicBlock *DBB = D->getBlock();
766  if (DT->properlyDominates(NewBB, DBB))
767  // Cannot move the load or store to NewBB above its definition in DBB.
768  return false;
769 
770  if (NewBB == DBB && !MSSA->isLiveOnEntryDef(D))
771  if (auto *UD = dyn_cast<MemoryUseOrDef>(D))
772  if (!firstInBB(UD->getMemoryInst(), NewPt))
773  // Cannot move the load or store to NewPt above its definition in D.
774  return false;
775 
776  // Check for unsafe hoistings due to side effects.
777  if (K == InsKind::Store) {
778  if (hasEHOrLoadsOnPath(NewPt, cast<MemoryDef>(U), NBBsOnAllPaths))
779  return false;
780  } else if (hasEHOnPath(NewBB, OldBB, NBBsOnAllPaths))
781  return false;
782 
783  if (UBB == NewBB) {
784  if (DT->properlyDominates(DBB, NewBB))
785  return true;
786  assert(UBB == DBB);
787  assert(MSSA->locallyDominates(D, U));
788  }
789 
790  // No side effects: it is safe to hoist.
791  return true;
792 }
793 
794 bool GVNHoist::valueAnticipable(CHIArgs C, Instruction *TI) const {
795  if (TI->getNumSuccessors() > (unsigned)size(C))
796  return false; // Not enough args in this CHI.
797 
798  for (auto CHI : C) {
799  // Find if all the edges have values flowing out of BB.
800  if (!llvm::is_contained(successors(TI), CHI.Dest))
801  return false;
802  }
803  return true;
804 }
805 
806 void GVNHoist::checkSafety(CHIArgs C, BasicBlock *BB, GVNHoist::InsKind K,
807  SmallVectorImpl<CHIArg> &Safe) {
808  int NumBBsOnAllPaths = MaxNumberOfBBSInPath;
809  for (auto CHI : C) {
810  Instruction *Insn = CHI.I;
811  if (!Insn) // No instruction was inserted in this CHI.
812  continue;
813  if (K == InsKind::Scalar) {
814  if (safeToHoistScalar(BB, Insn->getParent(), NumBBsOnAllPaths))
815  Safe.push_back(CHI);
816  } else {
817  auto *T = BB->getTerminator();
818  if (MemoryUseOrDef *UD = MSSA->getMemoryAccess(Insn))
819  if (safeToHoistLdSt(T, Insn, UD, K, NumBBsOnAllPaths))
820  Safe.push_back(CHI);
821  }
822  }
823 }
824 
825 void GVNHoist::fillRenameStack(BasicBlock *BB, InValuesType &ValueBBs,
826  GVNHoist::RenameStackType &RenameStack) {
827  auto it1 = ValueBBs.find(BB);
828  if (it1 != ValueBBs.end()) {
829  // Iterate in reverse order to keep lower ranked values on the top.
830  LLVM_DEBUG(dbgs() << "\nVisiting: " << BB->getName()
831  << " for pushing instructions on stack";);
832  for (std::pair<VNType, Instruction *> &VI : reverse(it1->second)) {
833  // Get the value of instruction I
834  LLVM_DEBUG(dbgs() << "\nPushing on stack: " << *VI.second);
835  RenameStack[VI.first].push_back(VI.second);
836  }
837  }
838 }
839 
840 void GVNHoist::fillChiArgs(BasicBlock *BB, OutValuesType &CHIBBs,
841  GVNHoist::RenameStackType &RenameStack) {
842  // For each *predecessor* (because Post-DOM) of BB check if it has a CHI
843  for (auto Pred : predecessors(BB)) {
844  auto P = CHIBBs.find(Pred);
845  if (P == CHIBBs.end()) {
846  continue;
847  }
848  LLVM_DEBUG(dbgs() << "\nLooking at CHIs in: " << Pred->getName(););
849  // A CHI is found (BB -> Pred is an edge in the CFG)
850  // Pop the stack until Top(V) = Ve.
851  auto &VCHI = P->second;
852  for (auto It = VCHI.begin(), E = VCHI.end(); It != E;) {
853  CHIArg &C = *It;
854  if (!C.Dest) {
855  auto si = RenameStack.find(C.VN);
856  // The Basic Block where CHI is must dominate the value we want to
857  // track in a CHI. In the PDom walk, there can be values in the
858  // stack which are not control dependent e.g., nested loop.
859  if (si != RenameStack.end() && si->second.size() &&
860  DT->properlyDominates(Pred, si->second.back()->getParent())) {
861  C.Dest = BB; // Assign the edge
862  C.I = si->second.pop_back_val(); // Assign the argument
863  LLVM_DEBUG(dbgs()
864  << "\nCHI Inserted in BB: " << C.Dest->getName() << *C.I
865  << ", VN: " << C.VN.first << ", " << C.VN.second);
866  }
867  // Move to next CHI of a different value
868  It = std::find_if(It, VCHI.end(), [It](CHIArg &A) { return A != *It; });
869  } else
870  ++It;
871  }
872  }
873 }
874 
875 void GVNHoist::findHoistableCandidates(OutValuesType &CHIBBs,
876  GVNHoist::InsKind K,
877  HoistingPointList &HPL) {
878  auto cmpVN = [](const CHIArg &A, const CHIArg &B) { return A.VN < B.VN; };
879 
880  // CHIArgs now have the outgoing values, so check for anticipability and
881  // accumulate hoistable candidates in HPL.
882  for (std::pair<BasicBlock *, SmallVector<CHIArg, 2>> &A : CHIBBs) {
883  BasicBlock *BB = A.first;
884  SmallVectorImpl<CHIArg> &CHIs = A.second;
885  // Vector of PHIs contains PHIs for different instructions.
886  // Sort the args according to their VNs, such that identical
887  // instructions are together.
888  llvm::stable_sort(CHIs, cmpVN);
889  auto TI = BB->getTerminator();
890  auto B = CHIs.begin();
891  // [PreIt, PHIIt) form a range of CHIs which have identical VNs.
892  auto PHIIt = llvm::find_if(CHIs, [B](CHIArg &A) { return A != *B; });
893  auto PrevIt = CHIs.begin();
894  while (PrevIt != PHIIt) {
895  // Collect values which satisfy safety checks.
897  // We check for safety first because there might be multiple values in
898  // the same path, some of which are not safe to be hoisted, but overall
899  // each edge has at least one value which can be hoisted, making the
900  // value anticipable along that path.
901  checkSafety(make_range(PrevIt, PHIIt), BB, K, Safe);
902 
903  // List of safe values should be anticipable at TI.
904  if (valueAnticipable(make_range(Safe.begin(), Safe.end()), TI)) {
905  HPL.push_back({BB, SmallVecInsn()});
906  SmallVecInsn &V = HPL.back().second;
907  for (auto B : Safe)
908  V.push_back(B.I);
909  }
910 
911  // Check other VNs
912  PrevIt = PHIIt;
913  PHIIt = std::find_if(PrevIt, CHIs.end(),
914  [PrevIt](CHIArg &A) { return A != *PrevIt; });
915  }
916  }
917 }
918 
919 bool GVNHoist::allOperandsAvailable(const Instruction *I,
920  const BasicBlock *HoistPt) const {
921  for (const Use &Op : I->operands())
922  if (const auto *Inst = dyn_cast<Instruction>(&Op))
923  if (!DT->dominates(Inst->getParent(), HoistPt))
924  return false;
925 
926  return true;
927 }
928 
929 bool GVNHoist::allGepOperandsAvailable(const Instruction *I,
930  const BasicBlock *HoistPt) const {
931  for (const Use &Op : I->operands())
932  if (const auto *Inst = dyn_cast<Instruction>(&Op))
933  if (!DT->dominates(Inst->getParent(), HoistPt)) {
934  if (const GetElementPtrInst *GepOp =
935  dyn_cast<GetElementPtrInst>(Inst)) {
936  if (!allGepOperandsAvailable(GepOp, HoistPt))
937  return false;
938  // Gep is available if all operands of GepOp are available.
939  } else {
940  // Gep is not available if it has operands other than GEPs that are
941  // defined in blocks not dominating HoistPt.
942  return false;
943  }
944  }
945  return true;
946 }
947 
948 void GVNHoist::makeGepsAvailable(Instruction *Repl, BasicBlock *HoistPt,
949  const SmallVecInsn &InstructionsToHoist,
950  Instruction *Gep) const {
951  assert(allGepOperandsAvailable(Gep, HoistPt) && "GEP operands not available");
952 
953  Instruction *ClonedGep = Gep->clone();
954  for (unsigned i = 0, e = Gep->getNumOperands(); i != e; ++i)
955  if (Instruction *Op = dyn_cast<Instruction>(Gep->getOperand(i))) {
956  // Check whether the operand is already available.
957  if (DT->dominates(Op->getParent(), HoistPt))
958  continue;
959 
960  // As a GEP can refer to other GEPs, recursively make all the operands
961  // of this GEP available at HoistPt.
962  if (GetElementPtrInst *GepOp = dyn_cast<GetElementPtrInst>(Op))
963  makeGepsAvailable(ClonedGep, HoistPt, InstructionsToHoist, GepOp);
964  }
965 
966  // Copy Gep and replace its uses in Repl with ClonedGep.
967  ClonedGep->insertBefore(HoistPt->getTerminator());
968 
969  // Conservatively discard any optimization hints, they may differ on the
970  // other paths.
971  ClonedGep->dropUnknownNonDebugMetadata();
972 
973  // If we have optimization hints which agree with each other along different
974  // paths, preserve them.
975  for (const Instruction *OtherInst : InstructionsToHoist) {
976  const GetElementPtrInst *OtherGep;
977  if (auto *OtherLd = dyn_cast<LoadInst>(OtherInst))
978  OtherGep = cast<GetElementPtrInst>(OtherLd->getPointerOperand());
979  else
980  OtherGep = cast<GetElementPtrInst>(
981  cast<StoreInst>(OtherInst)->getPointerOperand());
982  ClonedGep->andIRFlags(OtherGep);
983  }
984 
985  // Replace uses of Gep with ClonedGep in Repl.
986  Repl->replaceUsesOfWith(Gep, ClonedGep);
987 }
988 
989 void GVNHoist::updateAlignment(Instruction *I, Instruction *Repl) {
990  if (auto *ReplacementLoad = dyn_cast<LoadInst>(Repl)) {
991  ReplacementLoad->setAlignment(
992  std::min(ReplacementLoad->getAlign(), cast<LoadInst>(I)->getAlign()));
993  ++NumLoadsRemoved;
994  } else if (auto *ReplacementStore = dyn_cast<StoreInst>(Repl)) {
995  ReplacementStore->setAlignment(
996  std::min(ReplacementStore->getAlign(), cast<StoreInst>(I)->getAlign()));
997  ++NumStoresRemoved;
998  } else if (auto *ReplacementAlloca = dyn_cast<AllocaInst>(Repl)) {
999  ReplacementAlloca->setAlignment(std::max(ReplacementAlloca->getAlign(),
1000  cast<AllocaInst>(I)->getAlign()));
1001  } else if (isa<CallInst>(Repl)) {
1002  ++NumCallsRemoved;
1003  }
1004 }
1005 
1006 unsigned GVNHoist::rauw(const SmallVecInsn &Candidates, Instruction *Repl,
1007  MemoryUseOrDef *NewMemAcc) {
1008  unsigned NR = 0;
1009  for (Instruction *I : Candidates) {
1010  if (I != Repl) {
1011  ++NR;
1012  updateAlignment(I, Repl);
1013  if (NewMemAcc) {
1014  // Update the uses of the old MSSA access with NewMemAcc.
1015  MemoryAccess *OldMA = MSSA->getMemoryAccess(I);
1016  OldMA->replaceAllUsesWith(NewMemAcc);
1017  MSSAUpdater->removeMemoryAccess(OldMA);
1018  }
1019 
1020  Repl->andIRFlags(I);
1021  combineKnownMetadata(Repl, I);
1022  I->replaceAllUsesWith(Repl);
1023  // Also invalidate the Alias Analysis cache.
1024  MD->removeInstruction(I);
1025  I->eraseFromParent();
1026  }
1027  }
1028  return NR;
1029 }
1030 
1031 void GVNHoist::raMPHIuw(MemoryUseOrDef *NewMemAcc) {
1033  for (User *U : NewMemAcc->users())
1034  if (MemoryPhi *Phi = dyn_cast<MemoryPhi>(U))
1035  UsePhis.insert(Phi);
1036 
1037  for (MemoryPhi *Phi : UsePhis) {
1038  auto In = Phi->incoming_values();
1039  if (llvm::all_of(In, [&](Use &U) { return U == NewMemAcc; })) {
1040  Phi->replaceAllUsesWith(NewMemAcc);
1041  MSSAUpdater->removeMemoryAccess(Phi);
1042  }
1043  }
1044 }
1045 
1046 unsigned GVNHoist::removeAndReplace(const SmallVecInsn &Candidates,
1047  Instruction *Repl, BasicBlock *DestBB,
1048  bool MoveAccess) {
1049  MemoryUseOrDef *NewMemAcc = MSSA->getMemoryAccess(Repl);
1050  if (MoveAccess && NewMemAcc) {
1051  // The definition of this ld/st will not change: ld/st hoisting is
1052  // legal when the ld/st is not moved past its current definition.
1053  MSSAUpdater->moveToPlace(NewMemAcc, DestBB, MemorySSA::BeforeTerminator);
1054  }
1055 
1056  // Replace all other instructions with Repl with memory access NewMemAcc.
1057  unsigned NR = rauw(Candidates, Repl, NewMemAcc);
1058 
1059  // Remove MemorySSA phi nodes with the same arguments.
1060  if (NewMemAcc)
1061  raMPHIuw(NewMemAcc);
1062  return NR;
1063 }
1064 
1065 bool GVNHoist::makeGepOperandsAvailable(
1066  Instruction *Repl, BasicBlock *HoistPt,
1067  const SmallVecInsn &InstructionsToHoist) const {
1068  // Check whether the GEP of a ld/st can be synthesized at HoistPt.
1069  GetElementPtrInst *Gep = nullptr;
1070  Instruction *Val = nullptr;
1071  if (auto *Ld = dyn_cast<LoadInst>(Repl)) {
1072  Gep = dyn_cast<GetElementPtrInst>(Ld->getPointerOperand());
1073  } else if (auto *St = dyn_cast<StoreInst>(Repl)) {
1074  Gep = dyn_cast<GetElementPtrInst>(St->getPointerOperand());
1075  Val = dyn_cast<Instruction>(St->getValueOperand());
1076  // Check that the stored value is available.
1077  if (Val) {
1078  if (isa<GetElementPtrInst>(Val)) {
1079  // Check whether we can compute the GEP at HoistPt.
1080  if (!allGepOperandsAvailable(Val, HoistPt))
1081  return false;
1082  } else if (!DT->dominates(Val->getParent(), HoistPt))
1083  return false;
1084  }
1085  }
1086 
1087  // Check whether we can compute the Gep at HoistPt.
1088  if (!Gep || !allGepOperandsAvailable(Gep, HoistPt))
1089  return false;
1090 
1091  makeGepsAvailable(Repl, HoistPt, InstructionsToHoist, Gep);
1092 
1093  if (Val && isa<GetElementPtrInst>(Val))
1094  makeGepsAvailable(Repl, HoistPt, InstructionsToHoist, Val);
1095 
1096  return true;
1097 }
1098 
1099 std::pair<unsigned, unsigned> GVNHoist::hoist(HoistingPointList &HPL) {
1100  unsigned NI = 0, NL = 0, NS = 0, NC = 0, NR = 0;
1101  for (const HoistingPointInfo &HP : HPL) {
1102  // Find out whether we already have one of the instructions in HoistPt,
1103  // in which case we do not have to move it.
1104  BasicBlock *DestBB = HP.first;
1105  const SmallVecInsn &InstructionsToHoist = HP.second;
1106  Instruction *Repl = nullptr;
1107  for (Instruction *I : InstructionsToHoist)
1108  if (I->getParent() == DestBB)
1109  // If there are two instructions in HoistPt to be hoisted in place:
1110  // update Repl to be the first one, such that we can rename the uses
1111  // of the second based on the first.
1112  if (!Repl || firstInBB(I, Repl))
1113  Repl = I;
1114 
1115  // Keep track of whether we moved the instruction so we know whether we
1116  // should move the MemoryAccess.
1117  bool MoveAccess = true;
1118  if (Repl) {
1119  // Repl is already in HoistPt: it remains in place.
1120  assert(allOperandsAvailable(Repl, DestBB) &&
1121  "instruction depends on operands that are not available");
1122  MoveAccess = false;
1123  } else {
1124  // When we do not find Repl in HoistPt, select the first in the list
1125  // and move it to HoistPt.
1126  Repl = InstructionsToHoist.front();
1127 
1128  // We can move Repl in HoistPt only when all operands are available.
1129  // The order in which hoistings are done may influence the availability
1130  // of operands.
1131  if (!allOperandsAvailable(Repl, DestBB)) {
1132  // When HoistingGeps there is nothing more we can do to make the
1133  // operands available: just continue.
1134  if (HoistingGeps)
1135  continue;
1136 
1137  // When not HoistingGeps we need to copy the GEPs.
1138  if (!makeGepOperandsAvailable(Repl, DestBB, InstructionsToHoist))
1139  continue;
1140  }
1141 
1142  // Move the instruction at the end of HoistPt.
1143  Instruction *Last = DestBB->getTerminator();
1144  MD->removeInstruction(Repl);
1145  Repl->moveBefore(Last);
1146 
1147  DFSNumber[Repl] = DFSNumber[Last]++;
1148  }
1149 
1150  NR += removeAndReplace(InstructionsToHoist, Repl, DestBB, MoveAccess);
1151 
1152  if (isa<LoadInst>(Repl))
1153  ++NL;
1154  else if (isa<StoreInst>(Repl))
1155  ++NS;
1156  else if (isa<CallInst>(Repl))
1157  ++NC;
1158  else // Scalar
1159  ++NI;
1160  }
1161 
1162  if (MSSA && VerifyMemorySSA)
1163  MSSA->verifyMemorySSA();
1164 
1165  NumHoisted += NL + NS + NC + NI;
1166  NumRemoved += NR;
1167  NumLoadsHoisted += NL;
1168  NumStoresHoisted += NS;
1169  NumCallsHoisted += NC;
1170  return {NI, NL + NC + NS};
1171 }
1172 
1173 std::pair<unsigned, unsigned> GVNHoist::hoistExpressions(Function &F) {
1174  InsnInfo II;
1175  LoadInfo LI;
1176  StoreInfo SI;
1177  CallInfo CI;
1178  for (BasicBlock *BB : depth_first(&F.getEntryBlock())) {
1179  int InstructionNb = 0;
1180  for (Instruction &I1 : *BB) {
1181  // If I1 cannot guarantee progress, subsequent instructions
1182  // in BB cannot be hoisted anyways.
1184  HoistBarrier.insert(BB);
1185  break;
1186  }
1187  // Only hoist the first instructions in BB up to MaxDepthInBB. Hoisting
1188  // deeper may increase the register pressure and compilation time.
1189  if (MaxDepthInBB != -1 && InstructionNb++ >= MaxDepthInBB)
1190  break;
1191 
1192  // Do not value number terminator instructions.
1193  if (I1.isTerminator())
1194  break;
1195 
1196  if (auto *Load = dyn_cast<LoadInst>(&I1))
1197  LI.insert(Load, VN);
1198  else if (auto *Store = dyn_cast<StoreInst>(&I1))
1199  SI.insert(Store, VN);
1200  else if (auto *Call = dyn_cast<CallInst>(&I1)) {
1201  if (auto *Intr = dyn_cast<IntrinsicInst>(Call)) {
1202  if (isa<DbgInfoIntrinsic>(Intr) ||
1203  Intr->getIntrinsicID() == Intrinsic::assume ||
1204  Intr->getIntrinsicID() == Intrinsic::sideeffect)
1205  continue;
1206  }
1207  if (Call->mayHaveSideEffects())
1208  break;
1209 
1210  if (Call->isConvergent())
1211  break;
1212 
1213  CI.insert(Call, VN);
1214  } else if (HoistingGeps || !isa<GetElementPtrInst>(&I1))
1215  // Do not hoist scalars past calls that may write to memory because
1216  // that could result in spills later. geps are handled separately.
1217  // TODO: We can relax this for targets like AArch64 as they have more
1218  // registers than X86.
1219  II.insert(&I1, VN);
1220  }
1221  }
1222 
1223  HoistingPointList HPL;
1224  computeInsertionPoints(II.getVNTable(), HPL, InsKind::Scalar);
1225  computeInsertionPoints(LI.getVNTable(), HPL, InsKind::Load);
1226  computeInsertionPoints(SI.getVNTable(), HPL, InsKind::Store);
1227  computeInsertionPoints(CI.getScalarVNTable(), HPL, InsKind::Scalar);
1228  computeInsertionPoints(CI.getLoadVNTable(), HPL, InsKind::Load);
1229  computeInsertionPoints(CI.getStoreVNTable(), HPL, InsKind::Store);
1230  return hoist(HPL);
1231 }
1232 
1233 } // end namespace llvm
1234 
1238  AliasAnalysis &AA = AM.getResult<AAManager>(F);
1240  MemorySSA &MSSA = AM.getResult<MemorySSAAnalysis>(F).getMSSA();
1241  GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
1242  if (!G.run(F))
1243  return PreservedAnalyses::all();
1244 
1245  PreservedAnalyses PA;
1248  return PA;
1249 }
1250 
1251 char GVNHoistLegacyPass::ID = 0;
1252 
1254  "Early GVN Hoisting of Expressions", false, false)
1262 
i
i
Definition: README.txt:29
Hoisting
Constant Hoisting
Definition: ConstantHoisting.cpp:136
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm::MemoryDependenceResults::removeInstruction
void removeInstruction(Instruction *InstToRemove)
Removes an instruction from the dependence analysis, updating the dependence of instructions that pre...
Definition: MemoryDependenceAnalysis.cpp:1514
llvm::StoreInfo::getVNTable
const VNtoInsns & getVNTable() const
Definition: GVNHoist.cpp:213
llvm::Instruction::isTerminator
bool isTerminator() const
Definition: Instruction.h:163
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1288
llvm::predecessors
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:127
llvm::CallInfo::getLoadVNTable
const VNtoInsns & getLoadVNTable() const
Definition: GVNHoist.cpp:240
llvm::combineMetadata
void combineMetadata(Instruction *K, const Instruction *J, ArrayRef< unsigned > KnownIDs, bool DoesKMove)
Combine the metadata of two instructions so that K can replace J.
Definition: Local.cpp:2483
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::tgtok::Def
@ Def
Definition: TGLexer.h:50
llvm::MemorySSA::verifyMemorySSA
void verifyMemorySSA(VerificationLevel=VerificationLevel::Fast) const
Verify that MemorySSA is self consistent (IE definitions dominate all uses, uses appear in the right ...
Definition: MemorySSA.cpp:1899
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(GVNHoistLegacyPass, "gvn-hoist", "Early GVN Hoisting of Expressions", false, false) INITIALIZE_PASS_END(GVNHoistLegacyPass
llvm::CallInfo::getStoreVNTable
const VNtoInsns & getStoreVNTable() const
Definition: GVNHoist.cpp:241
MaxChainLength
static cl::opt< int > MaxChainLength("gvn-hoist-max-chain-length", cl::Hidden, cl::init(10), cl::desc("Maximum length of dependent chains to hoist " "(default = 10, unlimited = -1)"))
llvm::CHIArg::Dest
BasicBlock * Dest
Definition: GVNHoist.cpp:147
IntrinsicInst.h
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:779
Scalar.h
T
MemorySSAUpdater.h
llvm::Function
Definition: Function.h:61
llvm::DenseMapBase::lookup
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:197
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
Pass.h
llvm::GVNHoist::GVNHoist
GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA, MemoryDependenceResults *MD, MemorySSA *MSSA)
Definition: GVNHoist.cpp:261
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
Statistic.h
llvm::FunctionPass::skipFunction
bool skipFunction(const Function &F) const
Optional passes call this function to check whether the pass should be skipped.
Definition: Pass.cpp:163
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
ValueTracking.h
Local.h
llvm::Instruction::insertBefore
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
Definition: Instruction.cpp:84
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:151
GlobalsModRef.h
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::CHIArg::operator==
bool operator==(const CHIArg &A) const
Definition: GVNHoist.cpp:152
NL
#define NL
Definition: DetailedRecordsBackend.cpp:30
DenseMap.h
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:333
llvm::LoadInfo::getVNTable
const VNtoInsns & getVNTable() const
Definition: GVNHoist.cpp:194
llvm::CHIArg::VN
VNType VN
Definition: GVNHoist.cpp:144
llvm::DominatorTreeBase::getNode
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Definition: GenericDomTree.h:351
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
llvm::GVN::ValueTable
This class holds the mapping between values and value numbers.
Definition: GVN.h:152
llvm::MemoryPhi
Represents phi nodes for memory accesses.
Definition: MemorySSA.h:484
STLExtras.h
MemoryDependenceAnalysis.h
llvm::MemoryUse
Represents read-only accesses to memory.
Definition: MemorySSA.h:320
llvm::successors
succ_range successors(Instruction *I)
Definition: CFG.h:262
llvm::detail::DenseSetImpl::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::detail::DenseSetImpl::count
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:97
Use.h
llvm::iplist
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:390
llvm::StoreInfo
Definition: GVNHoist.cpp:198
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:198
llvm::CHIArg::operator!=
bool operator!=(const CHIArg &A) const
Definition: GVNHoist.cpp:153
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
r1
__Z6slow4bii r1 movgt r1
Definition: README.txt:62
AliasAnalysis.h
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::DominatorTree::dominates
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Definition: Dominators.cpp:115
llvm::idf_begin
idf_iterator< T > idf_begin(const T &G)
Definition: DepthFirstIterator.h:267
llvm::CallInfo
Definition: GVNHoist.cpp:217
Instruction.h
CommandLine.h
llvm::HoistingPointInfo
std::pair< BasicBlock *, SmallVecInsn > HoistingPointInfo
Definition: GVNHoist.cpp:124
llvm::Instruction::getNumSuccessors
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Definition: Instruction.cpp:765
llvm::idf_end
idf_iterator< T > idf_end(const T &G)
Definition: DepthFirstIterator.h:272
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1551
llvm::MemorySSAWrapperPass
Legacy analysis pass which computes MemorySSA.
Definition: MemorySSA.h:981
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
Constants.h
llvm::msgpack::Type::Map
@ Map
llvm::AAResults
Definition: AliasAnalysis.h:508
PostDominators.h
llvm::MemorySSA::isLiveOnEntryDef
bool isLiveOnEntryDef(const MemoryAccess *MA) const
Return true if MA represents the live on entry value.
Definition: MemorySSA.h:742
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::GVNHoist
Definition: GVNHoist.cpp:259
llvm::User
Definition: User.h:44
Intr
unsigned Intr
Definition: AMDGPUBaseInfo.cpp:1988
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
InstrTypes.h
llvm::PostDominatorTreeWrapperPass
Definition: PostDominators.h:73
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
DenseSet.h
llvm::CHIArg
Definition: GVNHoist.cpp:143
false
Definition: StackSlotColoring.cpp:142
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Instruction
Definition: Instruction.h:45
hoist
gvn hoist
When an instruction is found to only use loop invariant operands that is safe to hoist,...
Definition: GVNHoist.cpp:1260
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:287
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::MemorySSA::getBlockAccesses
const AccessList * getBlockAccesses(const BasicBlock *BB) const
Return the list of MemoryAccess's for a given basic block.
Definition: MemorySSA.h:762
GVN.h
llvm::GVNHoistLegacyPass::ID
static char ID
Definition: GVNHoist.cpp:522
SmallPtrSet.h
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:153
llvm::NVPTX::PTXLdStInstCode::Scalar
@ Scalar
Definition: NVPTX.h:122
llvm::GVNHoistLegacyPass
Definition: GVNHoist.cpp:520
llvm::MemoryAccess::getBlock
BasicBlock * getBlock() const
Definition: MemorySSA.h:159
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::MemorySSA::locallyDominates
bool locallyDominates(const MemoryAccess *A, const MemoryAccess *B) const
Given two memory accesses in the same basic block, determine whether MemoryAccess A dominates MemoryA...
Definition: MemorySSA.cpp:2121
CFG.h
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::Instruction::andIRFlags
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
Definition: Instruction.cpp:313
llvm::DenseSet< const BasicBlock * >
llvm::tgtok::In
@ In
Definition: TGLexer.h:51
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1434
llvm::rank
Utility type to build an inheritance chain that makes it easy to rank overload candidates.
Definition: STLExtras.h:1306
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:304
VI
@ VI
Definition: SIInstrInfo.cpp:7679
llvm::createGVNHoistPass
FunctionPass * createGVNHoistPass()
Definition: GVNHoist.cpp:1263
llvm::GVN
The core GVN pass object.
Definition: GVN.h:118
llvm::LoadInfo
Definition: GVNHoist.cpp:182
llvm::getPointerOperand
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
Definition: Instructions.h:5315
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::MemorySSAUpdater
Definition: MemorySSAUpdater.h:56
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::PreservedAnalyses::preserve
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:176
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::DenseMap< const BasicBlock *, bool >
llvm::MemorySSA
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:705
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MemorySSA::getMemoryAccess
MemoryUseOrDef * getMemoryAccess(const Instruction *I) const
Given a memory Mod/Ref'ing instruction, get the MemorySSA access associated with it.
Definition: MemorySSA.h:722
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:928
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1616
llvm::MemoryDef
Represents a read-write access to memory, whether it is a must-alias, or a may-alias.
Definition: MemorySSA.h:377
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
llvm::GVNHoist::rank
unsigned int rank(const Value *V) const
Definition: GVNHoist.cpp:591
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::IndexedInstrProf::HashT::Last
@ Last
llvm::User::replaceUsesOfWith
void replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
Definition: User.cpp:21
llvm::IDFCalculator
Definition: IteratedDominanceFrontier.h:39
iterator_range.h
llvm::MemorySSAAnalysis
An analysis that produces MemorySSA for a function.
Definition: MemorySSA.h:931
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1532
llvm::combineKnownMetadata
static void combineKnownMetadata(Instruction *ReplInst, Instruction *I)
Definition: GVNHoist.cpp:244
llvm::Instruction::clone
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
Definition: Instruction.cpp:850
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::initializeGVNHoistLegacyPassPass
void initializeGVNHoistLegacyPassPass(PassRegistry &)
llvm::CHIIt
SmallVectorImpl< CHIArg >::iterator CHIIt
Definition: GVNHoist.cpp:156
llvm::InsnInfo::insert
void insert(Instruction *I, GVN::ValueTable &VN)
Definition: GVNHoist.cpp:172
llvm::PostDominatorTree
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
Definition: PostDominators.h:28
MaxHoistedThreshold
static cl::opt< int > MaxHoistedThreshold("gvn-max-hoisted", cl::Hidden, cl::init(-1), cl::desc("Max number of instructions to hoist " "(default unlimited = -1)"))
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:532
llvm::DominatorTreeBase::properlyDominates
bool properlyDominates(const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
properlyDominates - Returns true iff A dominates B and A != B.
Definition: GenericDomTree.h:392
llvm::MemoryAccess
Definition: MemorySSA.h:137
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:175
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:148
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::SmallVecInsn
SmallVector< Instruction *, 4 > SmallVecInsn
Definition: GVNHoist.cpp:119
Argument.h
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1578
llvm::depth_first
iterator_range< df_iterator< T > > depth_first(const T &G)
Definition: DepthFirstIterator.h:229
llvm::MemoryDependenceResults
Provides a lazy, caching interface for making common memory aliasing information queries,...
Definition: MemoryDependenceAnalysis.h:264
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1686
Insn
SmallVector< AArch64_IMM::ImmInsnModel, 4 > Insn
Definition: AArch64MIPeepholeOpt.cpp:74
llvm::Instruction::dropUnknownNonDebugMetadata
void dropUnknownNonDebugMetadata(ArrayRef< unsigned > KnownIDs)
Drop all unknown metadata except for debug locations.
Definition: Metadata.cpp:1310
std
Definition: BitVector.h:838
MaxNumberOfBBSInPath
static cl::opt< int > MaxNumberOfBBSInPath("gvn-hoist-max-bbs", cl::Hidden, cl::init(4), cl::desc("Max number of basic blocks on the path between " "hoisting locations (default = 4, unlimited = -1)"))
llvm::MemoryDependenceWrapperPass
A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance.
Definition: MemoryDependenceAnalysis.h:525
llvm::MemoryUseOrDef::getDefiningAccess
MemoryAccess * getDefiningAccess() const
Get the access that produces the memory state used by this Use.
Definition: MemorySSA.h:257
NC
#define NC
Definition: regutils.h:42
llvm::DenseMapBase::end
iterator end()
Definition: DenseMap.h:83
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:321
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
llvm::StoreInfo::insert
void insert(StoreInst *Store, GVN::ValueTable &VN)
Definition: GVNHoist.cpp:204
llvm::MemorySSA::BeforeTerminator
@ BeforeTerminator
Definition: MemorySSA.h:793
llvm::isGuaranteedToTransferExecutionToSuccessor
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
Definition: ValueTracking.cpp:5294
Casting.h
Function.h
llvm::InsnInfo
Definition: GVNHoist.cpp:167
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1492
PassManager.h
llvm::GVNHoistLegacyPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: GVNHoist.cpp:541
llvm::MemoryUseOrDef
Class that has the common methods + fields of memory uses/defs.
Definition: MemorySSA.h:247
llvm::LoadInfo::insert
void insert(LoadInst *Load, GVN::ValueTable &VN)
Definition: GVNHoist.cpp:187
llvm::GVNHoistLegacyPass::runOnFunction
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
Definition: GVNHoist.cpp:528
IteratedDominanceFrontier.h
llvm::VNType
std::pair< unsigned, unsigned > VNType
Definition: GVNHoist.cpp:129
llvm::DominatorTreeAnalysis
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:252
MemorySSA.h
Instructions.h
llvm::User::getNumOperands
unsigned getNumOperands() const
Definition: User.h:191
SmallVector.h
llvm::GVN::ValueTable::lookupOrAdd
uint32_t lookupOrAdd(Value *V)
lookup_or_add - Returns the value number for the specified value, assigning it a new number if it did...
Definition: GVN.cpp:507
llvm::InsnInfo::getVNTable
const VNtoInsns & getVNTable() const
Definition: GVNHoist.cpp:178
User.h
Dominators.h
llvm::SmallVectorImpl::iterator
typename SuperClass::iterator iterator
Definition: SmallVector.h:562
llvm::AAResultsWrapperPass
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
Definition: AliasAnalysis.h:1336
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
Expressions
gvn Early GVN Hoisting of Expressions
Definition: GVNHoist.cpp:1261
llvm::GVNHoist::run
bool run(Function &F)
Definition: GVNHoist.cpp:553
llvm::GlobalsAAWrapperPass
Legacy wrapper pass to provide the GlobalsAAResult object.
Definition: GlobalsModRef.h:143
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::CHIArg::I
Instruction * I
Definition: GVNHoist.cpp:150
llvm::SmallVectorImpl< Instruction * >
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::PostDominatorTreeAnalysis
Analysis pass which computes a PostDominatorTree.
Definition: PostDominators.h:47
llvm::MemorySSAUtil::defClobbersUseOrDef
static bool defClobbersUseOrDef(MemoryDef *MD, const MemoryUseOrDef *MU, AliasAnalysis &AA)
Definition: MemorySSA.cpp:354
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::VerifyMemorySSA
bool VerifyMemorySSA
Enables verification of MemorySSA.
Definition: MemorySSA.cpp:91
LLVMContext.h
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::cl::desc
Definition: CommandLine.h:414
raw_ostream.h
llvm::GVNHoistLegacyPass::GVNHoistLegacyPass
GVNHoistLegacyPass()
Definition: GVNHoist.cpp:524
Value.h
llvm::InvalidVN
@ InvalidVN
Definition: GVNHoist.cpp:164
r2
llvm ldr r2
Definition: README.txt:126
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
Debug.h
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:422
llvm::CallInfo::getScalarVNTable
const VNtoInsns & getScalarVNTable() const
Definition: GVNHoist.cpp:239
MaxDepthInBB
static cl::opt< int > MaxDepthInBB("gvn-hoist-max-depth", cl::Hidden, cl::init(100), cl::desc("Hoist instructions from the beginning of the BB up to the " "maximum specified depth (default = 100, unlimited = -1)"))
llvm::Instruction::moveBefore
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:97
of
Add support for conditional and other related patterns Instead of
Definition: README.txt:134
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::MemoryDependenceAnalysis
An analysis that produces MemoryDependenceResults for a function.
Definition: MemoryDependenceAnalysis.h:506
llvm::CallInfo::insert
void insert(CallInst *Call, GVN::ValueTable &VN)
Definition: GVNHoist.cpp:224
llvm::SmallPtrSetImpl::insert
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:364