LLVM  3.7.0
NaryReassociate.cpp
Go to the documentation of this file.
1 //===- NaryReassociate.cpp - Reassociate n-ary expressions ----------------===//
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 reassociates n-ary add expressions and eliminates the redundancy
11 // exposed by the reassociation.
12 //
13 // A motivating example:
14 //
15 // void foo(int a, int b) {
16 // bar(a + b);
17 // bar((a + 2) + b);
18 // }
19 //
20 // An ideal compiler should reassociate (a + 2) + b to (a + b) + 2 and simplify
21 // the above code to
22 //
23 // int t = a + b;
24 // bar(t);
25 // bar(t + 2);
26 //
27 // However, the Reassociate pass is unable to do that because it processes each
28 // instruction individually and believes (a + 2) + b is the best form according
29 // to its rank system.
30 //
31 // To address this limitation, NaryReassociate reassociates an expression in a
32 // form that reuses existing instructions. As a result, NaryReassociate can
33 // reassociate (a + 2) + b in the example to (a + b) + 2 because it detects that
34 // (a + b) is computed before.
35 //
36 // NaryReassociate works as follows. For every instruction in the form of (a +
37 // b) + c, it checks whether a + c or b + c is already computed by a dominating
38 // instruction. If so, it then reassociates (a + b) + c into (a + c) + b or (b +
39 // c) + a and removes the redundancy accordingly. To efficiently look up whether
40 // an expression is computed before, we store each instruction seen and its SCEV
41 // into an SCEV-to-instruction map.
42 //
43 // Although the algorithm pattern-matches only ternary additions, it
44 // automatically handles many >3-ary expressions by walking through the function
45 // in the depth-first order. For example, given
46 //
47 // (a + c) + d
48 // ((a + b) + c) + d
49 //
50 // NaryReassociate first rewrites (a + b) + c to (a + c) + b, and then rewrites
51 // ((a + c) + b) + d into ((a + c) + d) + b.
52 //
53 // Finally, the above dominator-based algorithm may need to be run multiple
54 // iterations before emitting optimal code. One source of this need is that we
55 // only split an operand when it is used only once. The above algorithm can
56 // eliminate an instruction and decrease the usage count of its operands. As a
57 // result, an instruction that previously had multiple uses may become a
58 // single-use instruction and thus eligible for split consideration. For
59 // example,
60 //
61 // ac = a + c
62 // ab = a + b
63 // abc = ab + c
64 // ab2 = ab + b
65 // ab2c = ab2 + c
66 //
67 // In the first iteration, we cannot reassociate abc to ac+b because ab is used
68 // twice. However, we can reassociate ab2c to abc+b in the first iteration. As a
69 // result, ab2 becomes dead and ab will be used only once in the second
70 // iteration.
71 //
72 // Limitations and TODO items:
73 //
74 // 1) We only considers n-ary adds for now. This should be extended and
75 // generalized.
76 //
77 //===----------------------------------------------------------------------===//
78 
84 #include "llvm/IR/Dominators.h"
85 #include "llvm/IR/Module.h"
86 #include "llvm/IR/PatternMatch.h"
87 #include "llvm/Support/Debug.h"
89 #include "llvm/Transforms/Scalar.h"
91 using namespace llvm;
92 using namespace PatternMatch;
93 
94 #define DEBUG_TYPE "nary-reassociate"
95 
96 namespace {
97 class NaryReassociate : public FunctionPass {
98 public:
99  static char ID;
100 
101  NaryReassociate(): FunctionPass(ID) {
103  }
104 
105  bool doInitialization(Module &M) override {
106  DL = &M.getDataLayout();
107  return false;
108  }
109  bool runOnFunction(Function &F) override;
110 
111  void getAnalysisUsage(AnalysisUsage &AU) const override {
120  AU.setPreservesCFG();
121  }
122 
123 private:
124  // Runs only one iteration of the dominator-based algorithm. See the header
125  // comments for why we need multiple iterations.
126  bool doOneIteration(Function &F);
127 
128  // Reassociates I for better CSE.
129  Instruction *tryReassociate(Instruction *I);
130 
131  // Reassociate GEP for better CSE.
132  Instruction *tryReassociateGEP(GetElementPtrInst *GEP);
133  // Try splitting GEP at the I-th index and see whether either part can be
134  // CSE'ed. This is a helper function for tryReassociateGEP.
135  //
136  // \p IndexedType The element type indexed by GEP's I-th index. This is
137  // equivalent to
138  // GEP->getIndexedType(GEP->getPointerOperand(), 0-th index,
139  // ..., i-th index).
140  GetElementPtrInst *tryReassociateGEPAtIndex(GetElementPtrInst *GEP,
141  unsigned I, Type *IndexedType);
142  // Given GEP's I-th index = LHS + RHS, see whether &Base[..][LHS][..] or
143  // &Base[..][RHS][..] can be CSE'ed and rewrite GEP accordingly.
144  GetElementPtrInst *tryReassociateGEPAtIndex(GetElementPtrInst *GEP,
145  unsigned I, Value *LHS,
146  Value *RHS, Type *IndexedType);
147 
148  // Reassociate Add for better CSE.
149  Instruction *tryReassociateAdd(BinaryOperator *I);
150  // A helper function for tryReassociateAdd. LHS and RHS are explicitly passed.
151  Instruction *tryReassociateAdd(Value *LHS, Value *RHS, Instruction *I);
152  // Rewrites I to LHS + RHS if LHS is computed already.
153  Instruction *tryReassociatedAdd(const SCEV *LHS, Value *RHS, Instruction *I);
154 
155  // Returns the closest dominator of \c Dominatee that computes
156  // \c CandidateExpr. Returns null if not found.
157  Instruction *findClosestMatchingDominator(const SCEV *CandidateExpr,
158  Instruction *Dominatee);
159  // GetElementPtrInst implicitly sign-extends an index if the index is shorter
160  // than the pointer size. This function returns whether Index is shorter than
161  // GEP's pointer size, i.e., whether Index needs to be sign-extended in order
162  // to be an index of GEP.
163  bool requiresSignExtension(Value *Index, GetElementPtrInst *GEP);
164  // Returns whether V is known to be non-negative at context \c Ctxt.
165  bool isKnownNonNegative(Value *V, Instruction *Ctxt);
166  // Returns whether AO may sign overflow at context \c Ctxt. It computes a
167  // conservative result -- it answers true when not sure.
168  bool maySignOverflow(AddOperator *AO, Instruction *Ctxt);
169 
170  AssumptionCache *AC;
171  const DataLayout *DL;
172  DominatorTree *DT;
173  ScalarEvolution *SE;
174  TargetLibraryInfo *TLI;
175  TargetTransformInfo *TTI;
176  // A lookup table quickly telling which instructions compute the given SCEV.
177  // Note that there can be multiple instructions at different locations
178  // computing to the same SCEV, so we map a SCEV to an instruction list. For
179  // example,
180  //
181  // if (p1)
182  // foo(a + b);
183  // if (p2)
184  // bar(a + b);
186 };
187 } // anonymous namespace
188 
189 char NaryReassociate::ID = 0;
190 INITIALIZE_PASS_BEGIN(NaryReassociate, "nary-reassociate", "Nary reassociation",
191  false, false)
197 INITIALIZE_PASS_END(NaryReassociate, "nary-reassociate", "Nary reassociation",
198  false, false)
199 
201  return new NaryReassociate();
202 }
203 
204 bool NaryReassociate::runOnFunction(Function &F) {
205  if (skipOptnoneFunction(F))
206  return false;
207 
208  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
209  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
210  SE = &getAnalysis<ScalarEvolution>();
211  TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
212  TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
213 
214  bool Changed = false, ChangedInThisIteration;
215  do {
216  ChangedInThisIteration = doOneIteration(F);
217  Changed |= ChangedInThisIteration;
218  } while (ChangedInThisIteration);
219  return Changed;
220 }
221 
222 // Whitelist the instruction types NaryReassociate handles for now.
224  switch (I->getOpcode()) {
225  case Instruction::Add:
226  case Instruction::GetElementPtr:
227  return true;
228  default:
229  return false;
230  }
231 }
232 
233 bool NaryReassociate::doOneIteration(Function &F) {
234  bool Changed = false;
235  SeenExprs.clear();
236  // Process the basic blocks in pre-order of the dominator tree. This order
237  // ensures that all bases of a candidate are in Candidates when we process it.
238  for (auto Node = GraphTraits<DominatorTree *>::nodes_begin(DT);
239  Node != GraphTraits<DominatorTree *>::nodes_end(DT); ++Node) {
240  BasicBlock *BB = Node->getBlock();
241  for (auto I = BB->begin(); I != BB->end(); ++I) {
242  if (SE->isSCEVable(I->getType()) && isPotentiallyNaryReassociable(I)) {
243  const SCEV *OldSCEV = SE->getSCEV(I);
244  if (Instruction *NewI = tryReassociate(I)) {
245  Changed = true;
246  SE->forgetValue(I);
247  I->replaceAllUsesWith(NewI);
249  I = NewI;
250  }
251  // Add the rewritten instruction to SeenExprs; the original instruction
252  // is deleted.
253  const SCEV *NewSCEV = SE->getSCEV(I);
254  SeenExprs[NewSCEV].push_back(I);
255  // Ideally, NewSCEV should equal OldSCEV because tryReassociate(I)
256  // is equivalent to I. However, ScalarEvolution::getSCEV may
257  // weaken nsw causing NewSCEV not to equal OldSCEV. For example, suppose
258  // we reassociate
259  // I = &a[sext(i +nsw j)] // assuming sizeof(a[0]) = 4
260  // to
261  // NewI = &a[sext(i)] + sext(j).
262  //
263  // ScalarEvolution computes
264  // getSCEV(I) = a + 4 * sext(i + j)
265  // getSCEV(newI) = a + 4 * sext(i) + 4 * sext(j)
266  // which are different SCEVs.
267  //
268  // To alleviate this issue of ScalarEvolution not always capturing
269  // equivalence, we add I to SeenExprs[OldSCEV] as well so that we can
270  // map both SCEV before and after tryReassociate(I) to I.
271  //
272  // This improvement is exercised in @reassociate_gep_nsw in nary-gep.ll.
273  if (NewSCEV != OldSCEV)
274  SeenExprs[OldSCEV].push_back(I);
275  }
276  }
277  }
278  return Changed;
279 }
280 
281 Instruction *NaryReassociate::tryReassociate(Instruction *I) {
282  switch (I->getOpcode()) {
283  case Instruction::Add:
284  return tryReassociateAdd(cast<BinaryOperator>(I));
285  case Instruction::GetElementPtr:
286  return tryReassociateGEP(cast<GetElementPtrInst>(I));
287  default:
288  llvm_unreachable("should be filtered out by isPotentiallyNaryReassociable");
289  }
290 }
291 
292 // FIXME: extract this method into TTI->getGEPCost.
294  const TargetTransformInfo *TTI,
295  const DataLayout *DL) {
296  GlobalVariable *BaseGV = nullptr;
297  int64_t BaseOffset = 0;
298  bool HasBaseReg = false;
299  int64_t Scale = 0;
300 
301  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getPointerOperand()))
302  BaseGV = GV;
303  else
304  HasBaseReg = true;
305 
307  for (auto I = GEP->idx_begin(); I != GEP->idx_end(); ++I, ++GTI) {
308  if (isa<SequentialType>(*GTI)) {
309  int64_t ElementSize = DL->getTypeAllocSize(GTI.getIndexedType());
310  if (ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I)) {
311  BaseOffset += ConstIdx->getSExtValue() * ElementSize;
312  } else {
313  // Needs scale register.
314  if (Scale != 0) {
315  // No addressing mode takes two scale registers.
316  return false;
317  }
318  Scale = ElementSize;
319  }
320  } else {
321  StructType *STy = cast<StructType>(*GTI);
322  uint64_t Field = cast<ConstantInt>(*I)->getZExtValue();
323  BaseOffset += DL->getStructLayout(STy)->getElementOffset(Field);
324  }
325  }
326 
327  unsigned AddrSpace = GEP->getPointerAddressSpace();
328  return TTI->isLegalAddressingMode(GEP->getType()->getElementType(), BaseGV,
329  BaseOffset, HasBaseReg, Scale, AddrSpace);
330 }
331 
332 Instruction *NaryReassociate::tryReassociateGEP(GetElementPtrInst *GEP) {
333  // Not worth reassociating GEP if it is foldable.
334  if (isGEPFoldable(GEP, TTI, DL))
335  return nullptr;
336 
337  gep_type_iterator GTI = gep_type_begin(*GEP);
338  for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I) {
339  if (isa<SequentialType>(*GTI++)) {
340  if (auto *NewGEP = tryReassociateGEPAtIndex(GEP, I - 1, *GTI)) {
341  return NewGEP;
342  }
343  }
344  }
345  return nullptr;
346 }
347 
348 bool NaryReassociate::requiresSignExtension(Value *Index,
349  GetElementPtrInst *GEP) {
350  unsigned PointerSizeInBits =
351  DL->getPointerSizeInBits(GEP->getType()->getPointerAddressSpace());
352  return cast<IntegerType>(Index->getType())->getBitWidth() < PointerSizeInBits;
353 }
354 
355 bool NaryReassociate::isKnownNonNegative(Value *V, Instruction *Ctxt) {
356  bool NonNegative, Negative;
357  // TODO: ComputeSignBits is expensive. Consider caching the results.
358  ComputeSignBit(V, NonNegative, Negative, *DL, 0, AC, Ctxt, DT);
359  return NonNegative;
360 }
361 
362 bool NaryReassociate::maySignOverflow(AddOperator *AO, Instruction *Ctxt) {
363  if (AO->hasNoSignedWrap())
364  return false;
365 
366  Value *LHS = AO->getOperand(0), *RHS = AO->getOperand(1);
367  // If LHS or RHS has the same sign as the sum, AO doesn't sign overflow.
368  // TODO: handle the negative case as well.
369  if (isKnownNonNegative(AO, Ctxt) &&
370  (isKnownNonNegative(LHS, Ctxt) || isKnownNonNegative(RHS, Ctxt)))
371  return false;
372 
373  return true;
374 }
375 
377 NaryReassociate::tryReassociateGEPAtIndex(GetElementPtrInst *GEP, unsigned I,
378  Type *IndexedType) {
379  Value *IndexToSplit = GEP->getOperand(I + 1);
380  if (SExtInst *SExt = dyn_cast<SExtInst>(IndexToSplit)) {
381  IndexToSplit = SExt->getOperand(0);
382  } else if (ZExtInst *ZExt = dyn_cast<ZExtInst>(IndexToSplit)) {
383  // zext can be treated as sext if the source is non-negative.
384  if (isKnownNonNegative(ZExt->getOperand(0), GEP))
385  IndexToSplit = ZExt->getOperand(0);
386  }
387 
388  if (AddOperator *AO = dyn_cast<AddOperator>(IndexToSplit)) {
389  // If the I-th index needs sext and the underlying add is not equipped with
390  // nsw, we cannot split the add because
391  // sext(LHS + RHS) != sext(LHS) + sext(RHS).
392  if (requiresSignExtension(IndexToSplit, GEP) && maySignOverflow(AO, GEP))
393  return nullptr;
394  Value *LHS = AO->getOperand(0), *RHS = AO->getOperand(1);
395  // IndexToSplit = LHS + RHS.
396  if (auto *NewGEP = tryReassociateGEPAtIndex(GEP, I, LHS, RHS, IndexedType))
397  return NewGEP;
398  // Symmetrically, try IndexToSplit = RHS + LHS.
399  if (LHS != RHS) {
400  if (auto *NewGEP =
401  tryReassociateGEPAtIndex(GEP, I, RHS, LHS, IndexedType))
402  return NewGEP;
403  }
404  }
405  return nullptr;
406 }
407 
408 GetElementPtrInst *NaryReassociate::tryReassociateGEPAtIndex(
409  GetElementPtrInst *GEP, unsigned I, Value *LHS, Value *RHS,
410  Type *IndexedType) {
411  // Look for GEP's closest dominator that has the same SCEV as GEP except that
412  // the I-th index is replaced with LHS.
413  SmallVector<const SCEV *, 4> IndexExprs;
414  for (auto Index = GEP->idx_begin(); Index != GEP->idx_end(); ++Index)
415  IndexExprs.push_back(SE->getSCEV(*Index));
416  // Replace the I-th index with LHS.
417  IndexExprs[I] = SE->getSCEV(LHS);
418  if (isKnownNonNegative(LHS, GEP) &&
419  DL->getTypeSizeInBits(LHS->getType()) <
420  DL->getTypeSizeInBits(GEP->getOperand(I)->getType())) {
421  // Zero-extend LHS if it is non-negative. InstCombine canonicalizes sext to
422  // zext if the source operand is proved non-negative. We should do that
423  // consistently so that CandidateExpr more likely appears before. See
424  // @reassociate_gep_assume for an example of this canonicalization.
425  IndexExprs[I] =
426  SE->getZeroExtendExpr(IndexExprs[I], GEP->getOperand(I)->getType());
427  }
428  const SCEV *CandidateExpr = SE->getGEPExpr(
429  GEP->getSourceElementType(), SE->getSCEV(GEP->getPointerOperand()),
430  IndexExprs, GEP->isInBounds());
431 
432  auto *Candidate = findClosestMatchingDominator(CandidateExpr, GEP);
433  if (Candidate == nullptr)
434  return nullptr;
435 
436  PointerType *TypeOfCandidate = dyn_cast<PointerType>(Candidate->getType());
437  // Pretty rare but theoretically possible when a numeric value happens to
438  // share CandidateExpr.
439  if (TypeOfCandidate == nullptr)
440  return nullptr;
441 
442  // NewGEP = (char *)Candidate + RHS * sizeof(IndexedType)
443  uint64_t IndexedSize = DL->getTypeAllocSize(IndexedType);
444  Type *ElementType = TypeOfCandidate->getElementType();
445  uint64_t ElementSize = DL->getTypeAllocSize(ElementType);
446  // Another less rare case: because I is not necessarily the last index of the
447  // GEP, the size of the type at the I-th index (IndexedSize) is not
448  // necessarily divisible by ElementSize. For example,
449  //
450  // #pragma pack(1)
451  // struct S {
452  // int a[3];
453  // int64 b[8];
454  // };
455  // #pragma pack()
456  //
457  // sizeof(S) = 100 is indivisible by sizeof(int64) = 8.
458  //
459  // TODO: bail out on this case for now. We could emit uglygep.
460  if (IndexedSize % ElementSize != 0)
461  return nullptr;
462 
463  // NewGEP = &Candidate[RHS * (sizeof(IndexedType) / sizeof(Candidate[0])));
464  IRBuilder<> Builder(GEP);
465  Type *IntPtrTy = DL->getIntPtrType(TypeOfCandidate);
466  if (RHS->getType() != IntPtrTy)
467  RHS = Builder.CreateSExtOrTrunc(RHS, IntPtrTy);
468  if (IndexedSize != ElementSize) {
469  RHS = Builder.CreateMul(
470  RHS, ConstantInt::get(IntPtrTy, IndexedSize / ElementSize));
471  }
472  GetElementPtrInst *NewGEP =
473  cast<GetElementPtrInst>(Builder.CreateGEP(Candidate, RHS));
474  NewGEP->setIsInBounds(GEP->isInBounds());
475  NewGEP->takeName(GEP);
476  return NewGEP;
477 }
478 
479 Instruction *NaryReassociate::tryReassociateAdd(BinaryOperator *I) {
480  Value *LHS = I->getOperand(0), *RHS = I->getOperand(1);
481  if (auto *NewI = tryReassociateAdd(LHS, RHS, I))
482  return NewI;
483  if (auto *NewI = tryReassociateAdd(RHS, LHS, I))
484  return NewI;
485  return nullptr;
486 }
487 
488 Instruction *NaryReassociate::tryReassociateAdd(Value *LHS, Value *RHS,
489  Instruction *I) {
490  Value *A = nullptr, *B = nullptr;
491  // To be conservative, we reassociate I only when it is the only user of A+B.
492  if (LHS->hasOneUse() && match(LHS, m_Add(m_Value(A), m_Value(B)))) {
493  // I = (A + B) + RHS
494  // = (A + RHS) + B or (B + RHS) + A
495  const SCEV *AExpr = SE->getSCEV(A), *BExpr = SE->getSCEV(B);
496  const SCEV *RHSExpr = SE->getSCEV(RHS);
497  if (BExpr != RHSExpr) {
498  if (auto *NewI = tryReassociatedAdd(SE->getAddExpr(AExpr, RHSExpr), B, I))
499  return NewI;
500  }
501  if (AExpr != RHSExpr) {
502  if (auto *NewI = tryReassociatedAdd(SE->getAddExpr(BExpr, RHSExpr), A, I))
503  return NewI;
504  }
505  }
506  return nullptr;
507 }
508 
509 Instruction *NaryReassociate::tryReassociatedAdd(const SCEV *LHSExpr,
510  Value *RHS, Instruction *I) {
511  auto Pos = SeenExprs.find(LHSExpr);
512  // Bail out if LHSExpr is not previously seen.
513  if (Pos == SeenExprs.end())
514  return nullptr;
515 
516  // Look for the closest dominator LHS of I that computes LHSExpr, and replace
517  // I with LHS + RHS.
518  auto *LHS = findClosestMatchingDominator(LHSExpr, I);
519  if (LHS == nullptr)
520  return nullptr;
521 
522  Instruction *NewI = BinaryOperator::CreateAdd(LHS, RHS, "", I);
523  NewI->takeName(I);
524  return NewI;
525 }
526 
527 Instruction *
528 NaryReassociate::findClosestMatchingDominator(const SCEV *CandidateExpr,
529  Instruction *Dominatee) {
530  auto Pos = SeenExprs.find(CandidateExpr);
531  if (Pos == SeenExprs.end())
532  return nullptr;
533 
534  auto &Candidates = Pos->second;
535  // Because we process the basic blocks in pre-order of the dominator tree, a
536  // candidate that doesn't dominate the current instruction won't dominate any
537  // future instruction either. Therefore, we pop it out of the stack. This
538  // optimization makes the algorithm O(n).
539  while (!Candidates.empty()) {
540  Instruction *Candidate = Candidates.back();
541  if (DT->dominates(Candidate, Dominatee))
542  return Candidate;
543  Candidates.pop_back();
544  }
545  return nullptr;
546 }
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Type * getSourceElementType() const
Definition: Instructions.h:926
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: GraphTraits.h:27
void initializeNaryReassociatePass(PassRegistry &)
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:138
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property...
Definition: Operator.h:102
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
Definition: Instructions.h:976
ScalarEvolution - This class is the main scalar evolution driver.
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of .assume calls within a function.
nary reassociate
F(f)
This class represents a sign extension of integer types.
Hexagon Common GEP
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: Type.cpp:216
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:551
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
void setIsInBounds(bool b=true)
setIsInBounds - Set or clear the inbounds flag on this GEP instruction.
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:517
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:434
op_iterator idx_begin()
Definition: Instructions.h:954
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:256
static bool isGEPFoldable(GetElementPtrInst *GEP, const TargetTransformInfo *TTI, const DataLayout *DL)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
Type * getElementType() const
Definition: DerivedTypes.h:323
static BinaryOperator * CreateAdd(Value *S1, Value *S2, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
bool isInBounds() const
isInBounds - Determine whether the GEP has the inbounds flag.
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:491
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace=0) const
Return true if the addressing mode represented by AM is legal for this target, for a load/store of th...
Wrapper pass for TargetTransformInfo.
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Value * getOperand(unsigned i) const
Definition: User.h:118
void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeSignBit - Determine whether the sign bit is known to be zero or one.
INITIALIZE_PASS_BEGIN(NaryReassociate,"nary-reassociate","Nary reassociation", false, false) INITIALIZE_PASS_END(NaryReassociate
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr)
RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a trivially dead instruction...
Definition: Local.cpp:340
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
iterator end()
Definition: BasicBlock.h:233
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
SequentialType * getType() const
Definition: Instructions.h:922
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:582
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:263
LLVM_ATTRIBUTE_UNUSED_RESULT 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:285
nary Nary false
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
SCEV - This class represents an analyzed expression in the program.
#define I(x, y, z)
Definition: MD5.cpp:54
nary Nary reassociation
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:311
LLVM Value Representation.
Definition: Value.h:69
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
static bool isPotentiallyNaryReassociable(Instruction *I)
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
This pass exposes codegen information to IR-level passes.
FunctionPass * createNaryReassociatePass()
gep_type_iterator gep_type_begin(const User *GEP)