maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

dependence analysis 

Patch from Preston Briggs <preston.briggs@gmail.com>.

This is an updated version of the dependence-analysis patch, including an MIV
test based on Banerjee's inequalities.

It's a fairly complete implementation of the paper

    Practical Dependence Testing
    Gina Goff, Ken Kennedy, and Chau-Wen Tseng
    PLDI 1991

It cannot yet propagate constraints between coupled RDIV subscripts (discussed
in Section 5.3.2 of the paper).

It's organized as a FunctionPass with a single entry point that supports testing
for dependence between two instructions in a function. If there's no dependence,
it returns null. If there's a dependence, it returns a pointer to a Dependence
which can be queried about details (what kind of dependence, is it loop
independent, direction and distance vector entries, etc). I haven't included
every imaginable feature, but there's a good selection that should be adequate
for supporting many loop transformations. Of course, it can be extended as
necessary.

Included in the patch file are many test cases, commented with C code showing
the loops and array references.

llvm-svn: 165708
This commit is contained in:
Sebastian Pop 2012-10-11 07:32:34 +00:00
parent 6b49c2f69c
commit 59b61b9e2c
23 changed files with 10207 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

891
llvm/include/llvm/Analysis/DependenceAnalysis.h Normal file
View File

@ -0,0 +1,891 @@
//===-- llvm/Analysis/DependenceAnalysis.h -------------------- -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// DependenceAnalysis is an LLVM pass that analyses dependences between memory
// accesses. Currently, it is an implementation of the approach described in
//
// Practical Dependence Testing
// Goff, Kennedy, Tseng
// PLDI 1991
//
// There's a single entry point that analyzes the dependence between a pair
// of memory references in a function, returning either NULL, for no dependence,
// or a more-or-less detailed description of the dependence between them.
//
// Please note that this is work in progress and the interface is subject to
// change.
//
// Plausible changes:
// Return a set of more precise dependences instead of just one dependence
// summarizing all.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_DEPENDENCEANALYSIS_H
#define LLVM_ANALYSIS_DEPENDENCEANALYSIS_H
#include "llvm/BasicBlock.h"
#include "llvm/Function.h"
#include "llvm/Instruction.h"
#include "llvm/Pass.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/raw_ostream.h"
namespace llvm {
class AliasAnalysis;
class ScalarEvolution;
class SCEV;
class Value;
class raw_ostream;
/// Dependence - This class represents a dependence between two memory
/// memory references in a function. It contains minimal information and
/// is used in the very common situation where the compiler is unable to
/// determine anything beyond the existence of a dependence; that is, it
/// represents a confused dependence (see also FullDependence). In most
/// cases (for output, flow, and anti dependences), the dependence implies
/// an ordering, where the source must preceed the destination; in contrast,
/// input dependences are unordered.
class Dependence {
public:
Dependence(const Instruction *Source,
const Instruction *Destination) :
Src(Source), Dst(Destination) {}
virtual ~Dependence() {}
/// Dependence::DVEntry - Each level in the distance/direction vector
/// has a direction (or perhaps a union of several directions), and
/// perhaps a distance.
struct DVEntry {
enum { NONE = 0,
LT = 1,
EQ = 2,
LE = 3,
GT = 4,
NE = 5,
GE = 6,
ALL = 7 };
unsigned char Direction : 3; // Init to ALL, then refine.
bool Scalar : 1; // Init to true.
bool PeelFirst : 1; // Peeling the first iteration will break dependence.
bool PeelLast : 1; // Peeling the last iteration will break the dependence.
bool Splitable : 1; // Splitting the loop will break dependence.
const SCEV *Distance; // NULL implies no distance available.
DVEntry() : Direction(ALL), Scalar(true), PeelFirst(false),
PeelLast(false), Splitable(false), Distance(NULL) { }
};
/// getSrc - Returns the source instruction for this dependence.
///
const Instruction *getSrc() const { return Src; }
/// getDst - Returns the destination instruction for this dependence.
///
const Instruction *getDst() const { return Dst; }
/// isInput - Returns true if this is an input dependence.
///
bool isInput() const;
/// isOutput - Returns true if this is an output dependence.
///
bool isOutput() const;
/// isFlow - Returns true if this is a flow (aka true) dependence.
///
bool isFlow() const;
/// isAnti - Returns true if this is an anti dependence.
///
bool isAnti() const;
/// isOrdered - Returns true if dependence is Output, Flow, or Anti
///
bool isOrdered() const { return isOutput() || isFlow() || isAnti(); }
/// isUnordered - Returns true if dependence is Input
///
bool isUnordered() const { return isInput(); }
/// isLoopIndependent - Returns true if this is a loop-independent
/// dependence.
virtual bool isLoopIndependent() const { return true; }
/// isConfused - Returns true if this dependence is confused
/// (the compiler understands nothing and makes worst-case
/// assumptions).
virtual bool isConfused() const { return true; }
/// isConsistent - Returns true if this dependence is consistent
/// (occurs every time the source and destination are executed).
virtual bool isConsistent() const { return false; }
/// getLevels - Returns the number of common loops surrounding the
/// souce and destination of the dependence.
virtual unsigned getLevels() const { return 0; }
/// getDirection - Returns the direction associated with a particular
/// level.
virtual unsigned getDirection(unsigned Level) const { return DVEntry::ALL; }
/// getDistance - Returns the distance (or NULL) associated with a
/// particular level.
virtual const SCEV *getDistance(unsigned Level) const { return NULL; }
/// isPeelFirst - Returns true if peeling the first iteration from
/// this loop will break this dependence.
virtual bool isPeelFirst(unsigned Level) const { return false; }
/// isPeelLast - Returns true if peeling the last iteration from
/// this loop will break this dependence.
virtual bool isPeelLast(unsigned Level) const { return false; }
/// isSplitable - Returns true if splitting this loop will break
/// the dependence.
virtual bool isSplitable(unsigned Level) const { return false; }
/// isScalar - Returns true if a particular level is scalar; that is,
/// if no subscript in the source or destination mention the induction
/// variable associated with the loop at this level.
virtual bool isScalar(unsigned Level) const;
/// dump - For debugging purposes, dumps a dependence to OS.
///
void dump(raw_ostream &OS) const;
private:
const Instruction *Src, *Dst;
friend class DependenceAnalysis;
};
/// FullDependence - This class represents a dependence between two memory
/// references in a function. It contains detailed information about the
/// dependence (direction vectors, etc) and is used when the compiler is
/// able to accurately analyze the interaction of the references; that is,
/// it is not a confused dependence (see Dependence). In most cases
/// (for output, flow, and anti dependences), the dependence implies an
/// ordering, where the source must preceed the destination; in contrast,
/// input dependences are unordered.
class FullDependence : public Dependence {
public:
FullDependence(const Instruction *Src,
const Instruction *Dst,
bool LoopIndependent,
unsigned Levels);
~FullDependence() {
delete DV;
}
/// isLoopIndependent - Returns true if this is a loop-independent
/// dependence.
bool isLoopIndependent() const { return LoopIndependent; }
/// isConfused - Returns true if this dependence is confused
/// (the compiler understands nothing and makes worst-case
/// assumptions).
bool isConfused() const { return false; }
/// isConsistent - Returns true if this dependence is consistent
/// (occurs every time the source and destination are executed).
bool isConsistent() const { return Consistent; }
/// getLevels - Returns the number of common loops surrounding the
/// souce and destination of the dependence.
unsigned getLevels() const { return Levels; }
/// getDirection - Returns the direction associated with a particular
/// level.
unsigned getDirection(unsigned Level) const;
/// getDistance - Returns the distance (or NULL) associated with a
/// particular level.
const SCEV *getDistance(unsigned Level) const;
/// isPeelFirst - Returns true if peeling the first iteration from
/// this loop will break this dependence.
bool isPeelFirst(unsigned Level) const;
/// isPeelLast - Returns true if peeling the last iteration from
/// this loop will break this dependence.
bool isPeelLast(unsigned Level) const;
/// isSplitable - Returns true if splitting the loop will break
/// the dependence.
bool isSplitable(unsigned Level) const;
/// isScalar - Returns true if a particular level is scalar; that is,
/// if no subscript in the source or destination mention the induction
/// variable associated with the loop at this level.
bool isScalar(unsigned Level) const;
private:
unsigned short Levels;
bool LoopIndependent;
bool Consistent; // Init to true, then refine.
DVEntry *DV;
friend class DependenceAnalysis;
};
/// DependenceAnalysis - This class is the main dependence-analysis driver.
///
class DependenceAnalysis : public FunctionPass {
void operator=(const DependenceAnalysis &); // do not implement
DependenceAnalysis(const DependenceAnalysis &); // do not implement
public:
/// depends - Tests for a dependence between the Src and Dst instructions.
/// Returns NULL if no dependence; otherwise, returns a Dependence (or a
/// FullDependence) with as much information as can be gleaned.
/// The flag PossiblyLoopIndependent should be set by the caller
/// if it appears that control flow can reach from Src to Dst
/// without traversing a loop back edge.
Dependence *depends(const Instruction *Src,
const Instruction *Dst,
bool PossiblyLoopIndependent);
/// getSplitIteration - Give a dependence that's splitable at some
/// particular level, return the iteration that should be used to split
/// the loop.
///
/// Generally, the dependence analyzer will be used to build
/// a dependence graph for a function (basically a map from instructions
/// to dependences). Looking for cycles in the graph shows us loops
/// that cannot be trivially vectorized/parallelized.
///
/// We can try to improve the situation by examining all the dependences
/// that make up the cycle, looking for ones we can break.
/// Sometimes, peeling the first or last iteration of a loop will break
/// dependences, and there are flags for those possibilities.
/// Sometimes, splitting a loop at some other iteration will do the trick,
/// and we've got a flag for that case. Rather than waste the space to
/// record the exact iteration (since we rarely know), we provide
/// a method that calculates the iteration. It's a drag that it must work
/// from scratch, but wonderful in that it's possible.
///
/// Here's an example:
///
/// for (i = 0; i < 10; i++)
/// A[i] = ...
/// ... = A[11 - i]
///
/// There's a loop-carried flow dependence from the store to the load,
/// found by the weak-crossing SIV test. The dependence will have a flag,
/// indicating that the dependence can be broken by splitting the loop.
/// Calling getSplitIteration will return 5.
/// Splitting the loop breaks the dependence, like so:
///
/// for (i = 0; i <= 5; i++)
/// A[i] = ...
/// ... = A[11 - i]
/// for (i = 6; i < 10; i++)
/// A[i] = ...
/// ... = A[11 - i]
///
/// breaks the dependence and allows us to vectorize/parallelize
/// both loops.
const SCEV *getSplitIteration(const Dependence *Dep, unsigned Level);
private:
AliasAnalysis *AA;
ScalarEvolution *SE;
LoopInfo *LI;
Function *F;
/// Subscript - This private struct represents a pair of subscripts from
/// a pair of potentially multi-dimensional array references. We use a
/// vector of them to guide subscript partitioning.
struct Subscript {
const SCEV *Src;
const SCEV *Dst;
enum ClassificationKind { ZIV, SIV, RDIV, MIV, NonLinear } Classification;
SmallBitVector Loops;
SmallBitVector GroupLoops;
SmallBitVector Group;
};
struct CoefficientInfo {
const SCEV *Coeff;
const SCEV *PosPart;
const SCEV *NegPart;
const SCEV *Iterations;
};
struct BoundInfo {
const SCEV *Iterations;
const SCEV *Upper[8];
const SCEV *Lower[8];
unsigned char Direction;
unsigned char DirSet;
};
/// Constraint - This private class represents a constraint, as defined
/// in the paper
///
/// Practical Dependence Testing
/// Goff, Kennedy, Tseng
/// PLDI 1991
///
/// There are 5 kinds of constraint, in a hierarchy.
/// 1) Any - indicates no constraint, any dependence is possible.
/// 2) Line - A line ax + by = c, where a, b, and c are parameters,
/// representing the dependence equation.
/// 3) Distance - The value d of the dependence distance;
/// 4) Point - A point <x, y> representing the dependence from
/// iteration x to iteration y.
/// 5) Empty - No dependence is possible.
class Constraint {
private:
enum ConstraintKind { Empty, Point, Distance, Line, Any } Kind;
ScalarEvolution *SE;
const SCEV *A;
const SCEV *B;
const SCEV *C;
const Loop *AssociatedLoop;
public:
/// isEmpty - Return true if the constraint is of kind Empty.
bool isEmpty() const { return Kind == Empty; }
/// isPoint - Return true if the constraint is of kind Point.
bool isPoint() const { return Kind == Point; }
/// isDistance - Return true if the constraint is of kind Distance.
bool isDistance() const { return Kind == Distance; }
/// isLine - Return true if the constraint is of kind Line.
/// Since Distance's can also be represented as Lines, we also return
/// true if the constraint is of kind Distance.
bool isLine() const { return Kind == Line || Kind == Distance; }
/// isAny - Return true if the constraint is of kind Any;
bool isAny() const { return Kind == Any; }
/// getX - If constraint is a point <X, Y>, returns X.
/// Otherwise assert.
const SCEV *getX() const;
/// getY - If constraint is a point <X, Y>, returns Y.
/// Otherwise assert.
const SCEV *getY() const;
/// getA - If constraint is a line AX + BY = C, returns A.
/// Otherwise assert.
const SCEV *getA() const;
/// getB - If constraint is a line AX + BY = C, returns B.
/// Otherwise assert.
const SCEV *getB() const;
/// getC - If constraint is a line AX + BY = C, returns C.
/// Otherwise assert.
const SCEV *getC() const;
/// getD - If constraint is a distance, returns D.
/// Otherwise assert.
const SCEV *getD() const;
/// getAssociatedLoop - Returns the loop associated with this constraint.
const Loop *getAssociatedLoop() const;
/// setPoint - Change a constraint to Point.
void setPoint(const SCEV *X, const SCEV *Y, const Loop *CurrentLoop);
/// setLine - Change a constraint to Line.
void setLine(const SCEV *A, const SCEV *B,
const SCEV *C, const Loop *CurrentLoop);
/// setDistance - Change a constraint to Distance.
void setDistance(const SCEV *D, const Loop *CurrentLoop);
/// setEmpty - Change a constraint to Empty.
void setEmpty();
/// setAny - Change a constraint to Any.
void setAny(ScalarEvolution *SE);
/// dump - For debugging purposes. Dumps the constraint
/// out to OS.
void dump(raw_ostream &OS) const;
};
/// establishNestingLevels - Examines the loop nesting of the Src and Dst
/// instructions and establishes their shared loops. Sets the variables
/// CommonLevels, SrcLevels, and MaxLevels.
/// The source and destination instructions needn't be contained in the same
/// loop. The routine establishNestingLevels finds the level of most deeply
/// nested loop that contains them both, CommonLevels. An instruction that's
/// not contained in a loop is at level = 0. MaxLevels is equal to the level
/// of the source plus the level of the destination, minus CommonLevels.
/// This lets us allocate vectors MaxLevels in length, with room for every
/// distinct loop referenced in both the source and destination subscripts.
/// The variable SrcLevels is the nesting depth of the source instruction.
/// It's used to help calculate distinct loops referenced by the destination.
/// Here's the map from loops to levels:
/// 0 - unused
/// 1 - outermost common loop
/// ... - other common loops
/// CommonLevels - innermost common loop
/// ... - loops containing Src but not Dst
/// SrcLevels - innermost loop containing Src but not Dst
/// ... - loops containing Dst but not Src
/// MaxLevels - innermost loop containing Dst but not Src
/// Consider the follow code fragment:
/// for (a = ...) {
/// for (b = ...) {
/// for (c = ...) {
/// for (d = ...) {
/// A[] = ...;
/// }
/// }
/// for (e = ...) {
/// for (f = ...) {
/// for (g = ...) {
/// ... = A[];
/// }
/// }
/// }
/// }
/// }
/// If we're looking at the possibility of a dependence between the store
/// to A (the Src) and the load from A (the Dst), we'll note that they
/// have 2 loops in common, so CommonLevels will equal 2 and the direction
/// vector for Result will have 2 entries. SrcLevels = 4 and MaxLevels = 7.
/// A map from loop names to level indices would look like
/// a - 1
/// b - 2 = CommonLevels
/// c - 3
/// d - 4 = SrcLevels
/// e - 5
/// f - 6
/// g - 7 = MaxLevels
void establishNestingLevels(const Instruction *Src,
const Instruction *Dst);
unsigned CommonLevels, SrcLevels, MaxLevels;
/// mapSrcLoop - Given one of the loops containing the source, return
/// its level index in our numbering scheme.
unsigned mapSrcLoop(const Loop *SrcLoop) const;
/// mapDstLoop - Given one of the loops containing the destination,
/// return its level index in our numbering scheme.
unsigned mapDstLoop(const Loop *DstLoop) const;
/// isLoopInvariant - Returns true if Expression is loop invariant
/// in LoopNest.
bool isLoopInvariant(const SCEV *Expression, const Loop *LoopNest) const;
/// removeMatchingExtensions - Examines a subscript pair.
/// If the source and destination are identically sign (or zero)
/// extended, it strips off the extension in an effort to
/// simplify the actual analysis.
void removeMatchingExtensions(Subscript *Pair);
/// collectCommonLoops - Finds the set of loops from the LoopNest that
/// have a level <= CommonLevels and are referred to by the SCEV Expression.
void collectCommonLoops(const SCEV *Expression,
const Loop *LoopNest,
SmallBitVector &Loops) const;
/// checkSrcSubscript - Examines the SCEV Src, returning true iff it's
/// linear. Collect the set of loops mentioned by Src.
bool checkSrcSubscript(const SCEV *Src,
const Loop *LoopNest,
SmallBitVector &Loops);
/// checkDstSubscript - Examines the SCEV Dst, returning true iff it's
/// linear. Collect the set of loops mentioned by Dst.
bool checkDstSubscript(const SCEV *Dst,
const Loop *LoopNest,
SmallBitVector &Loops);
/// isKnownPredicate - Compare X and Y using the predicate Pred.
/// Basically a wrapper for SCEV::isKnownPredicate,
/// but tries harder, especially in the presense of sign and zero
/// extensions and symbolics.
bool isKnownPredicate(ICmpInst::Predicate Pred,
const SCEV *X,
const SCEV *Y) const;
/// collectUpperBound - All subscripts are the same type (on my machine,
/// an i64). The loop bound may be a smaller type. collectUpperBound
/// find the bound, if available, and zero extends it to the Type T.
/// (I zero extend since the bound should always be >= 0.)
/// If no upper bound is available, return NULL.
const SCEV *collectUpperBound(const Loop *l, Type *T) const;
/// collectConstantUpperBound - Calls collectUpperBound(), then
/// attempts to cast it to SCEVConstant. If the cast fails,
/// returns NULL.
const SCEVConstant *collectConstantUpperBound(const Loop *l, Type *T) const;
/// classifyPair - Examines the subscript pair (the Src and Dst SCEVs)
/// and classifies it as either ZIV, SIV, RDIV, MIV, or Nonlinear.
/// Collects the associated loops in a set.
Subscript::ClassificationKind classifyPair(const SCEV *Src,
const Loop *SrcLoopNest,
const SCEV *Dst,
const Loop *DstLoopNest,
SmallBitVector &Loops);
/// testZIV - Tests the ZIV subscript pair (Src and Dst) for dependence.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// If the dependence isn't proven to exist,
/// marks the Result as inconsistent.
bool testZIV(const SCEV *Src,
const SCEV *Dst,
FullDependence &Result) const;
/// testSIV - Tests the SIV subscript pair (Src and Dst) for dependence.
/// Things of the form [c1 + a1*i] and [c2 + a2*j], where
/// i and j are induction variables, c1 and c2 are loop invariant,
/// and a1 and a2 are constant.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction vector entry and, when possible,
/// the distance vector entry.
/// If the dependence isn't proven to exist,
/// marks the Result as inconsistent.
bool testSIV(const SCEV *Src,
const SCEV *Dst,
unsigned &Level,
FullDependence &Result,
Constraint &NewConstraint,
const SCEV *&SplitIter) const;
/// testRDIV - Tests the RDIV subscript pair (Src and Dst) for dependence.
/// Things of the form [c1 + a1*i] and [c2 + a2*j]
/// where i and j are induction variables, c1 and c2 are loop invariant,
/// and a1 and a2 are constant.
/// With minor algebra, this test can also be used for things like
/// [c1 + a1*i + a2*j][c2].
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Marks the Result as inconsistent.
bool testRDIV(const SCEV *Src,
const SCEV *Dst,
FullDependence &Result) const;
/// testMIV - Tests the MIV subscript pair (Src and Dst) for dependence.
/// Returns true if dependence disproved.
/// Can sometimes refine direction vectors.
bool testMIV(const SCEV *Src,
const SCEV *Dst,
const SmallBitVector &Loops,
FullDependence &Result) const;
/// strongSIVtest - Tests the strong SIV subscript pair (Src and Dst)
/// for dependence.
/// Things of the form [c1 + a*i] and [c2 + a*i],
/// where i is an induction variable, c1 and c2 are loop invariant,
/// and a is a constant
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction and distance.
bool strongSIVtest(const SCEV *Coeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *CurrentLoop,
unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
/// weakCrossingSIVtest - Tests the weak-crossing SIV subscript pair
/// (Src and Dst) for dependence.
/// Things of the form [c1 + a*i] and [c2 - a*i],
/// where i is an induction variable, c1 and c2 are loop invariant,
/// and a is a constant.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction entry.
/// Set consistent to false.
/// Marks the dependence as splitable.
bool weakCrossingSIVtest(const SCEV *SrcCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *CurrentLoop,
unsigned Level,
FullDependence &Result,
Constraint &NewConstraint,
const SCEV *&SplitIter) const;
/// ExactSIVtest - Tests the SIV subscript pair
/// (Src and Dst) for dependence.
/// Things of the form [c1 + a1*i] and [c2 + a2*i],
/// where i is an induction variable, c1 and c2 are loop invariant,
/// and a1 and a2 are constant.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction entry.
/// Set consistent to false.
bool exactSIVtest(const SCEV *SrcCoeff,
const SCEV *DstCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *CurrentLoop,
unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
/// weakZeroSrcSIVtest - Tests the weak-zero SIV subscript pair
/// (Src and Dst) for dependence.
/// Things of the form [c1] and [c2 + a*i],
/// where i is an induction variable, c1 and c2 are loop invariant,
/// and a is a constant. See also weakZeroDstSIVtest.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction entry.
/// Set consistent to false.
/// If loop peeling will break the dependence, mark appropriately.
bool weakZeroSrcSIVtest(const SCEV *DstCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *CurrentLoop,
unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
/// weakZeroDstSIVtest - Tests the weak-zero SIV subscript pair
/// (Src and Dst) for dependence.
/// Things of the form [c1 + a*i] and [c2],
/// where i is an induction variable, c1 and c2 are loop invariant,
/// and a is a constant. See also weakZeroSrcSIVtest.
/// Returns true if any possible dependence is disproved.
/// If there might be a dependence, returns false.
/// Sets appropriate direction entry.
/// Set consistent to false.
/// If loop peeling will break the dependence, mark appropriately.
bool weakZeroDstSIVtest(const SCEV *SrcCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *CurrentLoop,
unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const;
/// exactRDIVtest - Tests the RDIV subscript pair for dependence.
/// Things of the form [c1 + a*i] and [c2 + b*j],
/// where i and j are induction variable, c1 and c2 are loop invariant,
/// and a and b are constants.
/// Returns true if any possible dependence is disproved.
/// Marks the result as inconsistant.
/// Works in some cases that symbolicRDIVtest doesn't,
/// and vice versa.
bool exactRDIVtest(const SCEV *SrcCoeff,
const SCEV *DstCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *SrcLoop,
const Loop *DstLoop,
FullDependence &Result) const;
/// symbolicRDIVtest - Tests the RDIV subscript pair for dependence.
/// Things of the form [c1 + a*i] and [c2 + b*j],
/// where i and j are induction variable, c1 and c2 are loop invariant,
/// and a and b are constants.
/// Returns true if any possible dependence is disproved.
/// Marks the result as inconsistant.
/// Works in some cases that exactRDIVtest doesn't,
/// and vice versa. Can also be used as a backup for
/// ordinary SIV tests.
bool symbolicRDIVtest(const SCEV *SrcCoeff,
const SCEV *DstCoeff,
const SCEV *SrcConst,
const SCEV *DstConst,
const Loop *SrcLoop,
const Loop *DstLoop) const;
/// gcdMIVtest - Tests an MIV subscript pair for dependence.
/// Returns true if any possible dependence is disproved.
/// Marks the result as inconsistant.
/// Can sometimes disprove the equal direction for 1 or more loops.
// Can handle some symbolics that even the SIV tests don't get,
/// so we use it as a backup for everything.
bool gcdMIVtest(const SCEV *Src,
const SCEV *Dst,
FullDependence &Result) const;
/// banerjeeMIVtest - Tests an MIV subscript pair for dependence.
/// Returns true if any possible dependence is disproved.
/// Marks the result as inconsistant.
/// Computes directions.
bool banerjeeMIVtest(const SCEV *Src,
const SCEV *Dst,
const SmallBitVector &Loops,
FullDependence &Result) const;
/// collectCoefficientInfo - Walks through the subscript,
/// collecting each coefficient, the associated loop bounds,
/// and recording its positive and negative parts for later use.
CoefficientInfo *collectCoeffInfo(const SCEV *Subscript,
bool SrcFlag,
const SCEV *&Constant) const;
/// getPositivePart - X^+ = max(X, 0).
///
const SCEV *getPositivePart(const SCEV *X) const;
/// getNegativePart - X^- = min(X, 0).
///
const SCEV *getNegativePart(const SCEV *X) const;
/// getLowerBound - Looks through all the bounds info and
/// computes the lower bound given the current direction settings
/// at each level.
const SCEV *getLowerBound(BoundInfo *Bound) const;
/// getUpperBound - Looks through all the bounds info and
/// computes the upper bound given the current direction settings
/// at each level.
const SCEV *getUpperBound(BoundInfo *Bound) const;
/// exploreDirections - Hierarchically expands the direction vector
/// search space, combining the directions of discovered dependences
/// in the DirSet field of Bound. Returns the number of distinct
/// dependences discovered. If the dependence is disproved,
/// it will return 0.
unsigned exploreDirections(unsigned Level,
CoefficientInfo *A,
CoefficientInfo *B,
BoundInfo *Bound,
const SmallBitVector &Loops,
unsigned &DepthExpanded,
const SCEV *Delta) const;
/// testBounds - Returns true iff the current bounds are plausible.
///
bool testBounds(unsigned char DirKind,
unsigned Level,
BoundInfo *Bound,
const SCEV *Delta) const;
/// findBoundsALL - Computes the upper and lower bounds for level K
/// using the * direction. Records them in Bound.
void findBoundsALL(CoefficientInfo *A,
CoefficientInfo *B,
BoundInfo *Bound,
unsigned K) const;
/// findBoundsLT - Computes the upper and lower bounds for level K
/// using the < direction. Records them in Bound.
void findBoundsLT(CoefficientInfo *A,
CoefficientInfo *B,
BoundInfo *Bound,
unsigned K) const;
/// findBoundsGT - Computes the upper and lower bounds for level K
/// using the > direction. Records them in Bound.
void findBoundsGT(CoefficientInfo *A,
CoefficientInfo *B,
BoundInfo *Bound,
unsigned K) const;
/// findBoundsEQ - Computes the upper and lower bounds for level K
/// using the = direction. Records them in Bound.
void findBoundsEQ(CoefficientInfo *A,
CoefficientInfo *B,
BoundInfo *Bound,
unsigned K) const;
/// intersectConstraints - Updates X with the intersection
/// of the Constraints X and Y. Returns true if X has changed.
bool intersectConstraints(Constraint *X,
const Constraint *Y);
/// propagate - Review the constraints, looking for opportunities
/// to simplify a subscript pair (Src and Dst).
/// Return true if some simplification occurs.
/// If the simplification isn't exact (that is, if it is conservative
/// in terms of dependence), set consistent to false.
bool propagate(const SCEV *&Src,
const SCEV *&Dst,
SmallBitVector &Loops,
SmallVector<Constraint, 4> &Constraints,
bool &Consistent);
/// propagateDistance - Attempt to propagate a distance
/// constraint into a subscript pair (Src and Dst).
/// Return true if some simplification occurs.
/// If the simplification isn't exact (that is, if it is conservative
/// in terms of dependence), set consistent to false.
bool propagateDistance(const SCEV *&Src,
const SCEV *&Dst,
Constraint &CurConstraint,
bool &Consistent);
/// propagatePoint - Attempt to propagate a point
/// constraint into a subscript pair (Src and Dst).
/// Return true if some simplification occurs.
bool propagatePoint(const SCEV *&Src,
const SCEV *&Dst,
Constraint &CurConstraint);
/// propagateLine - Attempt to propagate a line
/// constraint into a subscript pair (Src and Dst).
/// Return true if some simplification occurs.
/// If the simplification isn't exact (that is, if it is conservative
/// in terms of dependence), set consistent to false.
bool propagateLine(const SCEV *&Src,
const SCEV *&Dst,
Constraint &CurConstraint,
bool &Consistent);
/// findCoefficient - Given a linear SCEV,
/// return the coefficient corresponding to specified loop.
/// If there isn't one, return the SCEV constant 0.
/// For example, given a*i + b*j + c*k, returning the coefficient
/// corresponding to the j loop would yield b.
const SCEV *findCoefficient(const SCEV *Expr,
const Loop *TargetLoop) const;
/// zeroCoefficient - Given a linear SCEV,
/// return the SCEV given by zeroing out the coefficient
/// corresponding to the specified loop.
/// For example, given a*i + b*j + c*k, zeroing the coefficient
/// corresponding to the j loop would yield a*i + c*k.
const SCEV *zeroCoefficient(const SCEV *Expr,
const Loop *TargetLoop) const;
/// addToCoefficient - Given a linear SCEV Expr,
/// return the SCEV given by adding some Value to the
/// coefficient corresponding to the specified TargetLoop.
/// For example, given a*i + b*j + c*k, adding 1 to the coefficient
/// corresponding to the j loop would yield a*i + (b+1)*j + c*k.
const SCEV *addToCoefficient(const SCEV *Expr,
const Loop *TargetLoop,
const SCEV *Value) const;
/// updateDirection - Update direction vector entry
/// based on the current constraint.
void updateDirection(Dependence::DVEntry &Level,
const Constraint &CurConstraint) const;
public:
static char ID; // Class identification, replacement for typeinfo
DependenceAnalysis() : FunctionPass(ID) {
initializeDependenceAnalysisPass(*PassRegistry::getPassRegistry());
};
bool runOnFunction(Function &F);
void releaseMemory();
void getAnalysisUsage(AnalysisUsage &) const;
void print(raw_ostream &, const Module * = 0) const;
}; // class DependenceAnalysis
/// createDependenceAnalysisPass - This creates an instance of the
/// DependenceAnalysis pass.
FunctionPass *createDependenceAnalysisPass();
} // namespace llvm
#endif

9
llvm/include/llvm/Analysis/Passes.h
View File

@ -178,6 +178,13 @@ namespace llvm {
/// pass.
FunctionPass *createLazyValueInfoPass();
//===--------------------------------------------------------------------===//
//
// createLoopDependenceAnalysisPass - This creates an instance of the
// LoopDependenceAnalysis pass.
//
LoopPass *createDependenceAnalysisPass();
//===--------------------------------------------------------------------===//
//
// createLoopDependenceAnalysisPass - This creates an instance of the
@ -185,6 +192,8 @@ namespace llvm {
//
LoopPass *createLoopDependenceAnalysisPass();
//===--------------------------------------------------------------------===//
//
// Minor pass prototypes, allowing us to expose them through bugpoint and
// analyze.
FunctionPass *createInstCountPass();

1
llvm/include/llvm/InitializePasses.h
View File

@ -94,6 +94,7 @@ void initializeDCEPass(PassRegistry&);
void initializeDSEPass(PassRegistry&);
void initializeDeadInstEliminationPass(PassRegistry&);
void initializeDeadMachineInstructionElimPass(PassRegistry&);
void initializeDependenceAnalysisPass(PassRegistry&);
void initializeDomOnlyPrinterPass(PassRegistry&);
void initializeDomOnlyViewerPass(PassRegistry&);
void initializeDomPrinterPass(PassRegistry&);

1
llvm/include/llvm/LinkAllPasses.h
View File

@ -64,6 +64,7 @@ namespace {
(void) llvm::createDeadCodeEliminationPass();
(void) llvm::createDeadInstEliminationPass();
(void) llvm::createDeadStoreEliminationPass();
(void) llvm::createDependenceAnalysisPass();
(void) llvm::createDomOnlyPrinterPass();
(void) llvm::createDomPrinterPass();
(void) llvm::createDomOnlyViewerPass();

1
llvm/lib/Analysis/Analysis.cpp
View File

@ -31,6 +31,7 @@ void llvm::initializeAnalysis(PassRegistry &Registry) {
initializeCFGOnlyViewerPass(Registry);
initializeCFGOnlyPrinterPass(Registry);
initializePrintDbgInfoPass(Registry);
initializeDependenceAnalysisPass(Registry);
initializeDominanceFrontierPass(Registry);
initializeDomViewerPass(Registry);
initializeDomPrinterPass(Registry);

1
llvm/lib/Analysis/CMakeLists.txt
View File

@ -13,6 +13,7 @@ add_llvm_library(LLVMAnalysis
CodeMetrics.cpp
ConstantFolding.cpp
DbgInfoPrinter.cpp
DependenceAnalysis.cpp
DomPrinter.cpp
DominanceFrontier.cpp
IVUsers.cpp

3781
llvm/lib/Analysis/DependenceAnalysis.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

595
llvm/test/Analysis/DependenceAnalysis/Banerjee.ll Normal file
View File

@ -0,0 +1,595 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'Banerjee.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 1; i <= 10; i++)
;; for (long int j = 1; j <= 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j - 1];
define void @banerjee0(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 1, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 1, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%sub = add nsw i64 %add5, -1
%arrayidx6 = getelementptr inbounds i64* %A, i64 %sub
%0 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [<= <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 11
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 11
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; for (long int i = 1; i <= n; i++)
;; for (long int j = 1; j <= m; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j - 1];
define void @banerjee1(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
%cmp4 = icmp sgt i64 %n, 0
br i1 %cmp4, label %for.cond1.preheader.preheader, label %for.end9
for.cond1.preheader.preheader: ; preds = %entry
%0 = add i64 %n, 1
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.cond1.preheader.preheader, %for.inc7
%B.addr.06 = phi i64* [ %B.addr.1.lcssa, %for.inc7 ], [ %B, %for.cond1.preheader.preheader ]
%i.05 = phi i64 [ %inc8, %for.inc7 ], [ 1, %for.cond1.preheader.preheader ]
%1 = add i64 %m, 1
%cmp21 = icmp sgt i64 %m, 0
br i1 %cmp21, label %for.body3.preheader, label %for.inc7
for.body3.preheader: ; preds = %for.cond1.preheader
br label %for.body3
for.body3: ; preds = %for.body3.preheader, %for.body3
%j.03 = phi i64 [ %inc, %for.body3 ], [ 1, %for.body3.preheader ]
%B.addr.12 = phi i64* [ %incdec.ptr, %for.body3 ], [ %B.addr.06, %for.body3.preheader ]
%mul = mul nsw i64 %i.05, 10
%add = add nsw i64 %mul, %j.03
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.05, 10
%add5 = add nsw i64 %mul4, %j.03
%sub = add nsw i64 %add5, -1
%arrayidx6 = getelementptr inbounds i64* %A, i64 %sub
%2 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [* <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.12, i64 1
store i64 %2, i64* %B.addr.12, align 8
%inc = add nsw i64 %j.03, 1
%exitcond = icmp eq i64 %inc, %1
br i1 %exitcond, label %for.inc7.loopexit, label %for.body3
for.inc7.loopexit: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.06, i64 %m
br label %for.inc7
for.inc7: ; preds = %for.inc7.loopexit, %for.cond1.preheader
%B.addr.1.lcssa = phi i64* [ %B.addr.06, %for.cond1.preheader ], [ %scevgep, %for.inc7.loopexit ]
%inc8 = add nsw i64 %i.05, 1
%exitcond7 = icmp eq i64 %inc8, %0
br i1 %exitcond7, label %for.end9.loopexit, label %for.cond1.preheader
for.end9.loopexit: ; preds = %for.inc7
br label %for.end9
for.end9: ; preds = %for.end9.loopexit, %entry
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = 0;
;; *B++ = A[10*i + j + 100];
define void @banerjee2(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%add6 = add nsw i64 %add5, 100
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%0 = load i64* %arrayidx7, align 8
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j + 99];
define void @banerjee3(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%add6 = add nsw i64 %add5, 99
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%0 = load i64* %arrayidx7, align 8
; CHECK: da analyze - flow [> >]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j - 100];
define void @banerjee4(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%sub = add nsw i64 %add5, -100
%arrayidx6 = getelementptr inbounds i64* %A, i64 %sub
%0 = load i64* %arrayidx6, align 8
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j - 99];
define void @banerjee5(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%sub = add nsw i64 %add5, -99
%arrayidx6 = getelementptr inbounds i64* %A, i64 %sub
%0 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [< <]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j + 9];
define void @banerjee6(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%add6 = add nsw i64 %add5, 9
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%0 = load i64* %arrayidx7, align 8
; CHECK: da analyze - flow [=> <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j + 10];
define void @banerjee7(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%add6 = add nsw i64 %add5, 10
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%0 = load i64* %arrayidx7, align 8
; CHECK: da analyze - flow [> <=]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 10; i++)
;; for (long int j = 0; j < 10; j++) {
;; A[10*i + j] = ...
;; ... = A[10*i + j + 11];
define void @banerjee8(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 10
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 10
%add5 = add nsw i64 %mul4, %j.02
%add6 = add nsw i64 %add5, 11
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%0 = load i64* %arrayidx7, align 8
; CHECK: da analyze - flow [> <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 10
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 10
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 10
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 20; i++)
;; for (long int j = 0; j < 20; j++) {
;; A[30*i + 500*j] = ...
;; ... = A[i - 500*j + 11];
define void @banerjee9(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 30
%mul4 = mul nsw i64 %j.02, 500
%add = add nsw i64 %mul, %mul4
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%0 = mul i64 %j.02, -500
%sub = add i64 %i.03, %0
%add6 = add nsw i64 %sub, 11
%arrayidx7 = getelementptr inbounds i64* %A, i64 %add6
%1 = load i64* %arrayidx7, align 8
; CHECK: da analyze - flow [<= =|<]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %1, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 20
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 20
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 20
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 20; i++)
;; for (long int j = 0; j < 20; j++) {
;; A[i + 500*j] = ...
;; ... = A[i - 500*j + 11];
define void @banerjee10(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %j.02, 500
%add = add nsw i64 %i.03, %mul
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%0 = mul i64 %j.02, -500
%sub = add i64 %i.03, %0
%add5 = add nsw i64 %sub, 11
%arrayidx6 = getelementptr inbounds i64* %A, i64 %add5
%1 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [<> =]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %1, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 20
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 20
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 20
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; for (long int i = 0; i < 20; i++)
;; for (long int j = 0; j < 20; j++) {
;; A[300*i + j] = ...
;; ... = A[250*i - j + 11];
define void @banerjee11(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 300
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 250
%sub = sub nsw i64 %mul4, %j.02
%add5 = add nsw i64 %sub, 11
%arrayidx6 = getelementptr inbounds i64* %A, i64 %add5
%0 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [<= <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 20
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 20
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 20
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; for (long int i = 0; i < 20; i++)
;; for (long int j = 0; j < 20; j++) {
;; A[100*i + j] = ...
;; ... = A[100*i - j + 11];
define void @banerjee12(i64* %A, i64* %B, i64 %m, i64 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i64* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i64* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%mul = mul nsw i64 %i.03, 100
%add = add nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i64* %A, i64 %add
store i64 0, i64* %arrayidx, align 8
%mul4 = mul nsw i64 %i.03, 100
%sub = sub nsw i64 %mul4, %j.02
%add5 = add nsw i64 %sub, 11
%arrayidx6 = getelementptr inbounds i64* %A, i64 %add5
%0 = load i64* %arrayidx6, align 8
; CHECK: da analyze - flow [= <>]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.11, i64 1
store i64 %0, i64* %B.addr.11, align 8
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 20
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i64* %B.addr.04, i64 20
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 20
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}

509
llvm/test/Analysis/DependenceAnalysis/Coupled.ll Normal file
View File

@ -0,0 +1,509 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'Coupled.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < 50; i++)
;; A[i][i] = ...
;; ... = A[i + 10][i + 9]
define void @couple0([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx1 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
store i32 %conv, i32* %arrayidx1, align 4
%add = add nsw i64 %i.02, 9
%add2 = add nsw i64 %i.02, 10
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %add2, i64 %add
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[i][i] = ...
;; ... = A[i + 9][i + 9]
define void @couple1([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx1 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
store i32 %conv, i32* %arrayidx1, align 4
%add = add nsw i64 %i.02, 9
%add2 = add nsw i64 %i.02, 9
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %add2, i64 %add
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - consistent flow [-9]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[3*i - 6][3*i - 6] = ...
;; ... = A[i][i]
define void @couple2([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%sub = add nsw i64 %mul, -6
%mul1 = mul nsw i64 %i.02, 3
%sub2 = add nsw i64 %mul1, -6
%arrayidx3 = getelementptr inbounds [100 x i32]* %A, i64 %sub2, i64 %sub
store i32 %conv, i32* %arrayidx3, align 4
%arrayidx5 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[3*i - 6][3*i - 5] = ...
;; ... = A[i][i]
define void @couple3([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%sub = add nsw i64 %mul, -5
%mul1 = mul nsw i64 %i.02, 3
%sub2 = add nsw i64 %mul1, -6
%arrayidx3 = getelementptr inbounds [100 x i32]* %A, i64 %sub2, i64 %sub
store i32 %conv, i32* %arrayidx3, align 4
%arrayidx5 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[3*i - 6][3*i - n] = ...
;; ... = A[i][i]
define void @couple4([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%conv1 = sext i32 %n to i64
%sub = sub nsw i64 %mul, %conv1
%mul2 = mul nsw i64 %i.02, 3
%sub3 = add nsw i64 %mul2, -6
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %sub3, i64 %sub
store i32 %conv, i32* %arrayidx4, align 4
%arrayidx6 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx6, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[3*i - n + 1][3*i - n] = ...
;; ... = A[i][i]
define void @couple5([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%conv1 = sext i32 %n to i64
%sub = sub nsw i64 %mul, %conv1
%mul2 = mul nsw i64 %i.02, 3
%conv3 = sext i32 %n to i64
%sub4 = sub nsw i64 %mul2, %conv3
%add = add nsw i64 %sub4, 1
%arrayidx5 = getelementptr inbounds [100 x i32]* %A, i64 %add, i64 %sub
store i32 %conv, i32* %arrayidx5, align 4
%arrayidx7 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[i][3*i - 6] = ...
;; ... = A[i][i]
define void @couple6([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%sub = add nsw i64 %mul, -6
%arrayidx1 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %sub
store i32 %conv, i32* %arrayidx1, align 4
%arrayidx3 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - flow [=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 50; i++)
;; A[i][3*i - 5] = ...
;; ... = A[i][i]
define void @couple7([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul nsw i64 %i.02, 3
%sub = add nsw i64 %mul, -5
%arrayidx1 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %sub
store i32 %conv, i32* %arrayidx1, align 4
%arrayidx3 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 50
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i <= 15; i++)
;; A[3*i - 18][3 - i] = ...
;; ... = A[i][i]
define void @couple8([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 3, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 16
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i <= 15; i++)
;; A[3*i - 18][2 - i] = ...
;; ... = A[i][i]
define void @couple9([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 2, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 16
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i <= 15; i++)
;; A[3*i - 18][6 - i] = ...
;; ... = A[i][i]
define void @couple10([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 6, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - flow [>] splitable!
; CHECK: da analyze - split level = 1, iteration = 3!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 16
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i <= 15; i++)
;; A[3*i - 18][18 - i] = ...
;; ... = A[i][i]
define void @couple11([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 18, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - flow [=|<] splitable!
; CHECK: da analyze - split level = 1, iteration = 9!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 16
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i <= 12; i++)
;; A[3*i - 18][22 - i] = ...
;; ... = A[i][i]
define void @couple12([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - flow [<] splitable!
; CHECK: da analyze - split level = 1, iteration = 11!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 13
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 12; i++)
;; A[3*i - 18][22 - i] = ...
;; ... = A[i][i]
define void @couple13([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx2 = getelementptr inbounds [100 x i32]* %A, i64 %sub1, i64 %sub
store i32 %conv, i32* %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 12
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 100; i++)
;; A[3*i - 18][18 - i][i] = ...
;; ... = A[i][i][i]
define void @couple14([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 18, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx3 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %sub1, i64 %sub, i64 %i.02
store i32 %conv, i32* %arrayidx3, align 4
%arrayidx6 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %i.02, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx6, align 4
; CHECK: da analyze - flow [=|<] splitable!
; CHECK: da analyze - split level = 1, iteration = 9!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 100
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long int i = 0; i < 100; i++)
;; A[3*i - 18][22 - i][i] = ...
;; ... = A[i][i][i]
define void @couple15([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
%sub1 = add nsw i64 %mul, -18
%arrayidx3 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %sub1, i64 %sub, i64 %i.02
store i32 %conv, i32* %arrayidx3, align 4
%arrayidx6 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %i.02, i64 %i.02, i64 %i.02
%0 = load i32* %arrayidx6, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add nsw i64 %i.02, 1
%cmp = icmp slt i64 %inc, 100
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}

508
llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll Normal file
View File

@ -0,0 +1,508 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'ExactRDIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < 10; i++)
;; A[4*i + 10] = ...
;; for (long int j = 0; j < 10; j++)
;; ... = A[2*j + 1];
define void @rdiv0(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 2
%add = add nsw i64 %mul, 10
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 10
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc9, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%mul5 = shl nsw i64 %j.02, 1
%add64 = or i64 %mul5, 1
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add64
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc9 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc9, 10
br i1 %cmp2, label %for.body4, label %for.end10
for.end10: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i < 5; i++)
;; A[11*i - 45] = ...
;; for (long int j = 0; j < 10; j++)
;; ... = A[j];
define void @rdiv1(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = add nsw i64 %mul, -45
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 5
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%arrayidx5 = getelementptr inbounds i32* %A, i64 %j.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 10
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i <= 5; i++)
;; A[11*i - 45] = ...
;; for (long int j = 0; j < 10; j++)
;; ... = A[j];
define void @rdiv2(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = add nsw i64 %mul, -45
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 6
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%arrayidx5 = getelementptr inbounds i32* %A, i64 %j.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 10
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i < 5; i++)
;; A[11*i - 45] = ...
;; for (long int j = 0; j <= 10; j++)
;; ... = A[j];
define void @rdiv3(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = add nsw i64 %mul, -45
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 5
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%arrayidx5 = getelementptr inbounds i32* %A, i64 %j.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 11
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i <= 5; i++)
;; A[11*i - 45] = ...
;; for (long int j = 0; j <= 10; j++)
;; ... = A[j];
define void @rdiv4(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = add nsw i64 %mul, -45
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 6
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%arrayidx5 = getelementptr inbounds i32* %A, i64 %j.02
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - flow!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 11
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i < 5; i++)
;; A[-11*i + 45] = ...
;; for (long int j = 0; j < 10; j++)
;; ... = A[-j];
define void @rdiv5(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -11
%add = add nsw i64 %mul, 45
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 5
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%sub = sub nsw i64 0, %j.02
%arrayidx5 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 10
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i <= 5; i++)
;; A[-11*i + 45] = ...
;; for (long int j = 0; j < 10; j++)
;; ... = A[-j];
define void @rdiv6(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -11
%add = add nsw i64 %mul, 45
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 6
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%sub = sub nsw i64 0, %j.02
%arrayidx5 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 10
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i < 5; i++)
;; A[-11*i + 45] = ...
;; for (long int j = 0; j <= 10; j++)
;; ... = A[-j];
define void @rdiv7(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -11
%add = add nsw i64 %mul, 45
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 5
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%sub = sub nsw i64 0, %j.02
%arrayidx5 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 11
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i <= 5; i++)
;; A[-11*i + 45] = ...
;; for (long int j = 0; j <= 10; j++)
;; ... = A[-j];
define void @rdiv8(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -11
%add = add nsw i64 %mul, 45
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, 6
br i1 %cmp, label %for.body, label %for.body4
for.body4: ; preds = %for.body4, %for.body
%j.02 = phi i64 [ %inc7, %for.body4 ], [ 0, %for.body ]
%B.addr.01 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.body ]
%sub = sub nsw i64 0, %j.02
%arrayidx5 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - flow!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc7 = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc7, 11
br i1 %cmp2, label %for.body4, label %for.end8
for.end8: ; preds = %for.body4
ret void
}
;; for (long int i = 0; i < 5; i++)
;; for (long int j = 0; j < 10; j++)
;; A[11*i - j] = ...
;; ... = A[45];
define void @rdiv9(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc5, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc5 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc6, %for.inc5 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = sub nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%arrayidx4 = getelementptr inbounds i32* %A, i64 45
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 10
br i1 %cmp2, label %for.body3, label %for.inc5
for.inc5: ; preds = %for.body3
%inc6 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc6, 5
br i1 %cmp, label %for.cond1.preheader, label %for.end7
for.end7: ; preds = %for.inc5
ret void
}
;; for (long int i = 0; i < 5; i++)
;; for (long int j = 0; j <= 10; j++)
;; A[11*i - j] = ...
;; ... = A[45];
define void @rdiv10(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc5, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc5 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc6, %for.inc5 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = sub nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%arrayidx4 = getelementptr inbounds i32* %A, i64 45
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 10
br i1 %cmp2, label %for.body3, label %for.inc5
for.inc5: ; preds = %for.body3
%inc6 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc6, 6
br i1 %cmp, label %for.cond1.preheader, label %for.end7
for.end7: ; preds = %for.inc5
ret void
}
;; for (long int i = 0; i <= 5; i++)
;; for (long int j = 0; j <= 10; j++)
;; A[11*i - j] = ...
;; ... = A[45];
define void @rdiv11(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc5, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc5 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc6, %for.inc5 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = sub nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%arrayidx4 = getelementptr inbounds i32* %A, i64 45
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 11
br i1 %cmp2, label %for.body3, label %for.inc5
for.inc5: ; preds = %for.body3
%inc6 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc6, 5
br i1 %cmp, label %for.cond1.preheader, label %for.end7
for.end7: ; preds = %for.inc5
ret void
}
;; for (long int i = 0; i < 5; i++)
;; for (long int j = 0; j < 10; j++)
;; A[11*i - j] = ...
;; ... = A[45];
define void @rdiv12(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc5, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc5 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc6, %for.inc5 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 11
%sub = sub nsw i64 %mul, %j.02
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%arrayidx4 = getelementptr inbounds i32* %A, i64 45
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - flow [* *|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 11
br i1 %cmp2, label %for.body3, label %for.inc5
for.inc5: ; preds = %for.body3
%inc6 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc6, 6
br i1 %cmp, label %for.cond1.preheader, label %for.end7
for.end7: ; preds = %for.inc5
ret void
}

428
llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll Normal file
View File

@ -0,0 +1,428 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'ExactSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long unsigned i = 0; i < 10; i++) {
;; A[i + 10] = ...
;; ... = A[2*i + 1];
define void @exact0(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%add = add i64 %i.02, 10
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%add13 = or i64 %mul, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %add13
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [<=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 10
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 10; i++) {
;; A[4*i + 10] = ...
;; ... = A[2*i + 1];
define void @exact1(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 2
%add = add i64 %mul, 10
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul1 = shl i64 %i.02, 1
%add23 = or i64 %mul1, 1
%arrayidx3 = getelementptr inbounds i32* %A, i64 %add23
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 10
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 10; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact2(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 10
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 10; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact3(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [>]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 11
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 12; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact4(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [>]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 12
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 12; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact5(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [=>|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 13
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 18; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact6(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [=>|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 18
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 18; i++) {
;; A[6*i] = ...
;; ... = A[i + 60];
define void @exact7(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%add = add i64 %i.02, 60
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 19
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 10; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact8(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 10
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 10; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact9(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [>]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 11
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 12; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact10(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [>]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 12
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 12; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact11(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [=>|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 13
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 18; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact12(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [=>|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 18
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i <= 18; i++) {
;; A[-6*i] = ...
;; ... = A[-i - 60];
define void @exact13(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, -6
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%sub1 = sub i64 -60, %i.02
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 19
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}

597
llvm/test/Analysis/DependenceAnalysis/GCD.ll Normal file
View File

@ -0,0 +1,597 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'GCD.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[2*i - 4*j] = ...
;; ... = A[6*i + 8*j];
define void @gcd0(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc8
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%mul4 = shl nsw i64 %j.02, 2
%sub = sub nsw i64 %mul, %mul4
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%mul5 = mul nsw i64 %i.03, 6
%mul6 = shl nsw i64 %j.02, 3
%add = add nsw i64 %mul5, %mul6
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - flow [=> *|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc9 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc9, 100
br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[2*i - 4*j] = ...
;; ... = A[6*i + 8*j + 1];
define void @gcd1(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc9
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc9 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%mul4 = shl nsw i64 %j.02, 2
%sub = sub nsw i64 %mul, %mul4
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%mul5 = mul nsw i64 %i.03, 6
%mul6 = shl nsw i64 %j.02, 3
%add = add nsw i64 %mul5, %mul6
%add7 = or i64 %add, 1
%arrayidx8 = getelementptr inbounds i32* %A, i64 %add7
%0 = load i32* %arrayidx8, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc9
for.inc9: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc10 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc10, 100
br i1 %exitcond5, label %for.cond1.preheader, label %for.end11
for.end11: ; preds = %for.inc9
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[2*i - 4*j + 1] = ...
;; ... = A[6*i + 8*j];
define void @gcd2(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc9
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc9 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%mul4 = shl nsw i64 %j.02, 2
%sub = sub nsw i64 %mul, %mul4
%add5 = or i64 %sub, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %add5
store i32 %conv, i32* %arrayidx, align 4
%mul5 = mul nsw i64 %i.03, 6
%mul6 = shl nsw i64 %j.02, 3
%add7 = add nsw i64 %mul5, %mul6
%arrayidx8 = getelementptr inbounds i32* %A, i64 %add7
%0 = load i32* %arrayidx8, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc9
for.inc9: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc10 = add nsw i64 %i.03, 1
%exitcond6 = icmp ne i64 %inc10, 100
br i1 %exitcond6, label %for.cond1.preheader, label %for.end11
for.end11: ; preds = %for.inc9
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i + 2*j] = ...
;; ... = A[i + 2*j - 1];
define void @gcd3(i32* %A, i32* %B) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc7
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc7 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc8, %for.inc7 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %j.02, 1
%add = add nsw i64 %i.03, %mul
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul4 = shl nsw i64 %j.02, 1
%add5 = add nsw i64 %i.03, %mul4
%sub = add nsw i64 %add5, -1
%arrayidx6 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx6, align 4
; CHECK: da analyze - flow [<> *]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc7
for.inc7: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc8 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc8, 100
br i1 %exitcond5, label %for.cond1.preheader, label %for.end9
for.end9: ; preds = %for.inc7
ret void
}
;; void gcd4(int *A, int *B, long int M, long int N) {
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++) {
;; A[5*i + 10*j*M + 9*M*N] = i;
;; *B++ = A[15*i + 20*j*M - 21*N*M + 4];
define void @gcd4(i32* %A, i32* %B, i64 %M, i64 %N) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc17
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc17 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc18, %for.inc17 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 5
%mul4 = mul nsw i64 %j.02, 10
%mul5 = mul nsw i64 %mul4, %M
%add = add nsw i64 %mul, %mul5
%mul6 = mul nsw i64 %M, 9
%mul7 = mul nsw i64 %mul6, %N
%add8 = add nsw i64 %add, %mul7
%arrayidx = getelementptr inbounds i32* %A, i64 %add8
store i32 %conv, i32* %arrayidx, align 4
%mul9 = mul nsw i64 %i.03, 15
%mul10 = mul nsw i64 %j.02, 20
%mul11 = mul nsw i64 %mul10, %M
%add12 = add nsw i64 %mul9, %mul11
%mul13 = mul nsw i64 %N, 21
%mul14 = mul nsw i64 %mul13, %M
%sub = sub nsw i64 %add12, %mul14
%add15 = add nsw i64 %sub, 4
%arrayidx16 = getelementptr inbounds i32* %A, i64 %add15
%0 = load i32* %arrayidx16, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc17
for.inc17: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc18 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc18, 100
br i1 %exitcond5, label %for.cond1.preheader, label %for.end19
for.end19: ; preds = %for.inc17
ret void
}
;; void gcd5(int *A, int *B, long int M, long int N) {
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++) {
;; A[5*i + 10*j*M + 9*M*N] = i;
;; *B++ = A[15*i + 20*j*M - 21*N*M + 5];
define void @gcd5(i32* %A, i32* %B, i64 %M, i64 %N) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc17
%B.addr.04 = phi i32* [ %B, %entry ], [ %scevgep, %for.inc17 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc18, %for.inc17 ]
br label %for.body3
for.body3: ; preds = %for.cond1.preheader, %for.body3
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 5
%mul4 = mul nsw i64 %j.02, 10
%mul5 = mul nsw i64 %mul4, %M
%add = add nsw i64 %mul, %mul5
%mul6 = mul nsw i64 %M, 9
%mul7 = mul nsw i64 %mul6, %N
%add8 = add nsw i64 %add, %mul7
%arrayidx = getelementptr inbounds i32* %A, i64 %add8
store i32 %conv, i32* %arrayidx, align 4
%mul9 = mul nsw i64 %i.03, 15
%mul10 = mul nsw i64 %j.02, 20
%mul11 = mul nsw i64 %mul10, %M
%add12 = add nsw i64 %mul9, %mul11
%mul13 = mul nsw i64 %N, 21
%mul14 = mul nsw i64 %mul13, %M
%sub = sub nsw i64 %add12, %mul14
%add15 = add nsw i64 %sub, 5
%arrayidx16 = getelementptr inbounds i32* %A, i64 %add15
%0 = load i32* %arrayidx16, align 4
; CHECK: da analyze - flow [<> *]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%exitcond = icmp ne i64 %inc, 100
br i1 %exitcond, label %for.body3, label %for.inc17
for.inc17: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.04, i64 100
%inc18 = add nsw i64 %i.03, 1
%exitcond5 = icmp ne i64 %inc18, 100
br i1 %exitcond5, label %for.cond1.preheader, label %for.end19
for.end19: ; preds = %for.inc17
ret void
}
;; void gcd6(long int n, int A[][n], int *B) {
;; for (long int i = 0; i < n; i++)
;; for (long int j = 0; j < n; j++) {
;; A[2*i][4*j] = i;
;; *B++ = A[8*i][6*j + 1];
define void @gcd6(i64 %n, i32* %A, i32* %B) nounwind uwtable ssp {
entry:
%cmp4 = icmp sgt i64 %n, 0
br i1 %cmp4, label %for.cond1.preheader.preheader, label %for.end12
for.cond1.preheader.preheader: ; preds = %entry
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.cond1.preheader.preheader, %for.inc10
%i.06 = phi i64 [ %inc11, %for.inc10 ], [ 0, %for.cond1.preheader.preheader ]
%B.addr.05 = phi i32* [ %B.addr.1.lcssa, %for.inc10 ], [ %B, %for.cond1.preheader.preheader ]
%cmp21 = icmp sgt i64 %n, 0
br i1 %cmp21, label %for.body3.preheader, label %for.inc10
for.body3.preheader: ; preds = %for.cond1.preheader
br label %for.body3
for.body3: ; preds = %for.body3.preheader, %for.body3
%j.03 = phi i64 [ %inc, %for.body3 ], [ 0, %for.body3.preheader ]
%B.addr.12 = phi i32* [ %incdec.ptr, %for.body3 ], [ %B.addr.05, %for.body3.preheader ]
%conv = trunc i64 %i.06 to i32
%mul = shl nsw i64 %j.03, 2
%mul4 = shl nsw i64 %i.06, 1
%0 = mul nsw i64 %mul4, %n
%arrayidx.sum = add i64 %0, %mul
%arrayidx5 = getelementptr inbounds i32* %A, i64 %arrayidx.sum
store i32 %conv, i32* %arrayidx5, align 4
%mul6 = mul nsw i64 %j.03, 6
%add7 = or i64 %mul6, 1
%mul7 = shl nsw i64 %i.06, 3
%1 = mul nsw i64 %mul7, %n
%arrayidx8.sum = add i64 %1, %add7
%arrayidx9 = getelementptr inbounds i32* %A, i64 %arrayidx8.sum
%2 = load i32* %arrayidx9, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.12, i64 1
store i32 %2, i32* %B.addr.12, align 4
%inc = add nsw i64 %j.03, 1
%exitcond = icmp ne i64 %inc, %n
br i1 %exitcond, label %for.body3, label %for.inc10.loopexit
for.inc10.loopexit: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.05, i64 %n
br label %for.inc10
for.inc10: ; preds = %for.inc10.loopexit, %for.cond1.preheader
%B.addr.1.lcssa = phi i32* [ %B.addr.05, %for.cond1.preheader ], [ %scevgep, %for.inc10.loopexit ]
%inc11 = add nsw i64 %i.06, 1
%exitcond8 = icmp ne i64 %inc11, %n
br i1 %exitcond8, label %for.cond1.preheader, label %for.end12.loopexit
for.end12.loopexit: ; preds = %for.inc10
br label %for.end12
for.end12: ; preds = %for.end12.loopexit, %entry
ret void
}
;; void gcd7(int n, int A[][n], int *B) {
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < n; j++) {
;; A[2*i][4*j] = i;
;; *B++ = A[8*i][6*j + 1];
define void @gcd7(i32 %n, i32* %A, i32* %B) nounwind uwtable ssp {
entry:
%0 = zext i32 %n to i64
%cmp4 = icmp sgt i32 %n, 0
br i1 %cmp4, label %for.cond1.preheader.preheader, label %for.end15
for.cond1.preheader.preheader: ; preds = %entry
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.cond1.preheader.preheader, %for.inc13
%indvars.iv8 = phi i64 [ 0, %for.cond1.preheader.preheader ], [ %indvars.iv.next9, %for.inc13 ]
%B.addr.05 = phi i32* [ %B.addr.1.lcssa, %for.inc13 ], [ %B, %for.cond1.preheader.preheader ]
%1 = add i32 %n, -1
%2 = zext i32 %1 to i64
%3 = add i64 %2, 1
%cmp21 = icmp sgt i32 %n, 0
br i1 %cmp21, label %for.body3.preheader, label %for.inc13
for.body3.preheader: ; preds = %for.cond1.preheader
br label %for.body3
for.body3: ; preds = %for.body3.preheader, %for.body3
%indvars.iv = phi i64 [ 0, %for.body3.preheader ], [ %indvars.iv.next, %for.body3 ]
%B.addr.12 = phi i32* [ %incdec.ptr, %for.body3 ], [ %B.addr.05, %for.body3.preheader ]
%4 = trunc i64 %indvars.iv to i32
%mul = shl nsw i32 %4, 2
%idxprom = sext i32 %mul to i64
%5 = trunc i64 %indvars.iv8 to i32
%mul4 = shl nsw i32 %5, 1
%idxprom5 = sext i32 %mul4 to i64
%6 = mul nsw i64 %idxprom5, %0
%arrayidx.sum = add i64 %6, %idxprom
%arrayidx6 = getelementptr inbounds i32* %A, i64 %arrayidx.sum
%7 = trunc i64 %indvars.iv8 to i32
store i32 %7, i32* %arrayidx6, align 4
%8 = trunc i64 %indvars.iv to i32
%mul7 = mul nsw i32 %8, 6
%add7 = or i32 %mul7, 1
%idxprom8 = sext i32 %add7 to i64
%9 = trunc i64 %indvars.iv8 to i32
%mul9 = shl nsw i32 %9, 3
%idxprom10 = sext i32 %mul9 to i64
%10 = mul nsw i64 %idxprom10, %0
%arrayidx11.sum = add i64 %10, %idxprom8
%arrayidx12 = getelementptr inbounds i32* %A, i64 %arrayidx11.sum
%11 = load i32* %arrayidx12, align 4
; CHECK: da analyze - flow [* *|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.12, i64 1
store i32 %11, i32* %B.addr.12, align 4
%indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, %n
br i1 %exitcond, label %for.body3, label %for.inc13.loopexit
for.inc13.loopexit: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.05, i64 %3
br label %for.inc13
for.inc13: ; preds = %for.inc13.loopexit, %for.cond1.preheader
%B.addr.1.lcssa = phi i32* [ %B.addr.05, %for.cond1.preheader ], [ %scevgep, %for.inc13.loopexit ]
%indvars.iv.next9 = add i64 %indvars.iv8, 1
%lftr.wideiv10 = trunc i64 %indvars.iv.next9 to i32
%exitcond11 = icmp ne i32 %lftr.wideiv10, %n
br i1 %exitcond11, label %for.cond1.preheader, label %for.end15.loopexit
for.end15.loopexit: ; preds = %for.inc13
br label %for.end15
for.end15: ; preds = %for.end15.loopexit, %entry
ret void
}
;; void gcd8(int n, int *A, int *B) {
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < n; j++) {
;; A[n*2*i + 4*j] = i;
;; *B++ = A[n*8*i + 6*j + 1];
define void @gcd8(i32 %n, i32* %A, i32* %B) nounwind uwtable ssp {
entry:
%cmp4 = icmp sgt i32 %n, 0
br i1 %cmp4, label %for.cond1.preheader.preheader, label %for.end15
for.cond1.preheader.preheader: ; preds = %entry
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.cond1.preheader.preheader, %for.inc13
%i.06 = phi i32 [ %inc14, %for.inc13 ], [ 0, %for.cond1.preheader.preheader ]
%B.addr.05 = phi i32* [ %B.addr.1.lcssa, %for.inc13 ], [ %B, %for.cond1.preheader.preheader ]
%0 = add i32 %n, -1
%1 = zext i32 %0 to i64
%2 = add i64 %1, 1
%cmp21 = icmp sgt i32 %n, 0
br i1 %cmp21, label %for.body3.preheader, label %for.inc13
for.body3.preheader: ; preds = %for.cond1.preheader
br label %for.body3
for.body3: ; preds = %for.body3.preheader, %for.body3
%indvars.iv = phi i64 [ 0, %for.body3.preheader ], [ %indvars.iv.next, %for.body3 ]
%B.addr.12 = phi i32* [ %incdec.ptr, %for.body3 ], [ %B.addr.05, %for.body3.preheader ]
%mul = shl nsw i32 %n, 1
%mul4 = mul nsw i32 %mul, %i.06
%3 = trunc i64 %indvars.iv to i32
%mul5 = shl nsw i32 %3, 2
%add = add nsw i32 %mul4, %mul5
%idxprom = sext i32 %add to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 %i.06, i32* %arrayidx, align 4
%mul6 = shl nsw i32 %n, 3
%mul7 = mul nsw i32 %mul6, %i.06
%4 = trunc i64 %indvars.iv to i32
%mul8 = mul nsw i32 %4, 6
%add9 = add nsw i32 %mul7, %mul8
%add10 = or i32 %add9, 1
%idxprom11 = sext i32 %add10 to i64
%arrayidx12 = getelementptr inbounds i32* %A, i64 %idxprom11
%5 = load i32* %arrayidx12, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.12, i64 1
store i32 %5, i32* %B.addr.12, align 4
%indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, %n
br i1 %exitcond, label %for.body3, label %for.inc13.loopexit
for.inc13.loopexit: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.05, i64 %2
br label %for.inc13
for.inc13: ; preds = %for.inc13.loopexit, %for.cond1.preheader
%B.addr.1.lcssa = phi i32* [ %B.addr.05, %for.cond1.preheader ], [ %scevgep, %for.inc13.loopexit ]
%inc14 = add nsw i32 %i.06, 1
%exitcond7 = icmp ne i32 %inc14, %n
br i1 %exitcond7, label %for.cond1.preheader, label %for.end15.loopexit
for.end15.loopexit: ; preds = %for.inc13
br label %for.end15
for.end15: ; preds = %for.end15.loopexit, %entry
ret void
}
;; void gcd9(unsigned n, int A[][n], int *B) {
;; for (unsigned i = 0; i < n; i++)
;; for (unsigned j = 0; j < n; j++) {
;; A[2*i][4*j] = i;
;; *B++ = A[8*i][6*j + 1];
define void @gcd9(i32 %n, i32* %A, i32* %B) nounwind uwtable ssp {
entry:
%0 = zext i32 %n to i64
%cmp4 = icmp eq i32 %n, 0
br i1 %cmp4, label %for.end15, label %for.cond1.preheader.preheader
for.cond1.preheader.preheader: ; preds = %entry
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.cond1.preheader.preheader, %for.inc13
%indvars.iv8 = phi i64 [ 0, %for.cond1.preheader.preheader ], [ %indvars.iv.next9, %for.inc13 ]
%B.addr.05 = phi i32* [ %B.addr.1.lcssa, %for.inc13 ], [ %B, %for.cond1.preheader.preheader ]
%1 = add i32 %n, -1
%2 = zext i32 %1 to i64
%3 = add i64 %2, 1
%cmp21 = icmp eq i32 %n, 0
br i1 %cmp21, label %for.inc13, label %for.body3.preheader
for.body3.preheader: ; preds = %for.cond1.preheader
br label %for.body3
for.body3: ; preds = %for.body3.preheader, %for.body3
%indvars.iv = phi i64 [ 0, %for.body3.preheader ], [ %indvars.iv.next, %for.body3 ]
%B.addr.12 = phi i32* [ %incdec.ptr, %for.body3 ], [ %B.addr.05, %for.body3.preheader ]
%4 = trunc i64 %indvars.iv to i32
%mul = shl i32 %4, 2
%idxprom = zext i32 %mul to i64
%5 = trunc i64 %indvars.iv8 to i32
%mul4 = shl i32 %5, 1
%idxprom5 = zext i32 %mul4 to i64
%6 = mul nsw i64 %idxprom5, %0
%arrayidx.sum = add i64 %6, %idxprom
%arrayidx6 = getelementptr inbounds i32* %A, i64 %arrayidx.sum
%7 = trunc i64 %indvars.iv8 to i32
store i32 %7, i32* %arrayidx6, align 4
%8 = trunc i64 %indvars.iv to i32
%mul7 = mul i32 %8, 6
%add7 = or i32 %mul7, 1
%idxprom8 = zext i32 %add7 to i64
%9 = trunc i64 %indvars.iv8 to i32
%mul9 = shl i32 %9, 3
%idxprom10 = zext i32 %mul9 to i64
%10 = mul nsw i64 %idxprom10, %0
%arrayidx11.sum = add i64 %10, %idxprom8
%arrayidx12 = getelementptr inbounds i32* %A, i64 %arrayidx11.sum
%11 = load i32* %arrayidx12, align 4
; CHECK: da analyze - flow [* *|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.12, i64 1
store i32 %11, i32* %B.addr.12, align 4
%indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, %n
br i1 %exitcond, label %for.body3, label %for.inc13.loopexit
for.inc13.loopexit: ; preds = %for.body3
%scevgep = getelementptr i32* %B.addr.05, i64 %3
br label %for.inc13
for.inc13: ; preds = %for.inc13.loopexit, %for.cond1.preheader
%B.addr.1.lcssa = phi i32* [ %B.addr.05, %for.cond1.preheader ], [ %scevgep, %for.inc13.loopexit ]
%indvars.iv.next9 = add i64 %indvars.iv8, 1
%lftr.wideiv10 = trunc i64 %indvars.iv.next9 to i32
%exitcond11 = icmp ne i32 %lftr.wideiv10, %n
br i1 %exitcond11, label %for.cond1.preheader, label %for.end15.loopexit
for.end15.loopexit: ; preds = %for.inc13
br label %for.end15
for.end15: ; preds = %for.end15.loopexit, %entry
ret void
}

469
llvm/test/Analysis/DependenceAnalysis/Preliminary.ll Normal file
View File

@ -0,0 +1,469 @@
; RUN: opt < %s -analyze -basicaa -indvars -da | FileCheck %s
; This series of tests is more interesting when debugging is enabled.
; ModuleID = 'Preliminary.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; may alias
;; int p0(int n, int *A, int *B) {
;; A[0] = n;
;; return B[1];
define i32 @p0(i32 %n, i32* %A, i32* %B) nounwind uwtable ssp {
entry:
store i32 %n, i32* %A, align 4
%arrayidx1 = getelementptr inbounds i32* %B, i64 1
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - confused!
ret i32 %0
}
;; no alias
;; int p1(int n, int *restrict A, int *restrict B) {
;; A[0] = n;
;; return B[1];
define i32 @p1(i32 %n, i32* noalias %A, i32* noalias %B) nounwind uwtable ssp {
entry:
store i32 %n, i32* %A, align 4
%arrayidx1 = getelementptr inbounds i32* %B, i64 1
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
ret i32 %0
}
;; check loop nesting levels
;; for (long int i = 0; i < n; i++)
;; for (long int j = 0; j < n; j++)
;; for (long int k = 0; k < n; k++)
;; A[i][j][k] = ...
;; for (long int k = 0; k < n; k++)
;; ... = A[i + 3][j + 2][k + 1];
define void @p2(i64 %n, [100 x [100 x i64]]* %A, i64* %B) nounwind uwtable ssp {
entry:
%cmp10 = icmp sgt i64 %n, 0
br i1 %cmp10, label %for.cond1.preheader, label %for.end26
for.cond1.preheader: ; preds = %for.inc24, %entry
%B.addr.012 = phi i64* [ %B.addr.1.lcssa, %for.inc24 ], [ %B, %entry ]
%i.011 = phi i64 [ %inc25, %for.inc24 ], [ 0, %entry ]
%cmp26 = icmp sgt i64 %n, 0
br i1 %cmp26, label %for.cond4.preheader, label %for.inc24
for.cond4.preheader: ; preds = %for.inc21, %for.cond1.preheader
%B.addr.18 = phi i64* [ %B.addr.2.lcssa, %for.inc21 ], [ %B.addr.012, %for.cond1.preheader ]
%j.07 = phi i64 [ %inc22, %for.inc21 ], [ 0, %for.cond1.preheader ]
%cmp51 = icmp sgt i64 %n, 0
br i1 %cmp51, label %for.body6, label %for.cond10.loopexit
for.body6: ; preds = %for.body6, %for.cond4.preheader
%k.02 = phi i64 [ %inc, %for.body6 ], [ 0, %for.cond4.preheader ]
%arrayidx8 = getelementptr inbounds [100 x [100 x i64]]* %A, i64 %i.011, i64 %j.07, i64 %k.02
store i64 %i.011, i64* %arrayidx8, align 8
%inc = add nsw i64 %k.02, 1
%cmp5 = icmp slt i64 %inc, %n
br i1 %cmp5, label %for.body6, label %for.cond10.loopexit
for.cond10.loopexit: ; preds = %for.body6, %for.cond4.preheader
%cmp113 = icmp sgt i64 %n, 0
br i1 %cmp113, label %for.body12, label %for.inc21
for.body12: ; preds = %for.body12, %for.cond10.loopexit
%k9.05 = phi i64 [ %inc19, %for.body12 ], [ 0, %for.cond10.loopexit ]
%B.addr.24 = phi i64* [ %incdec.ptr, %for.body12 ], [ %B.addr.18, %for.cond10.loopexit ]
%add = add nsw i64 %k9.05, 1
%add13 = add nsw i64 %j.07, 2
%add14 = add nsw i64 %i.011, 3
%arrayidx17 = getelementptr inbounds [100 x [100 x i64]]* %A, i64 %add14, i64 %add13, i64 %add
%0 = load i64* %arrayidx17, align 8
; CHECK: da analyze - flow [-3 -2]!
%incdec.ptr = getelementptr inbounds i64* %B.addr.24, i64 1
store i64 %0, i64* %B.addr.24, align 8
%inc19 = add nsw i64 %k9.05, 1
%cmp11 = icmp slt i64 %inc19, %n
br i1 %cmp11, label %for.body12, label %for.inc21
for.inc21: ; preds = %for.body12, %for.cond10.loopexit
%B.addr.2.lcssa = phi i64* [ %B.addr.18, %for.cond10.loopexit ], [ %incdec.ptr, %for.body12 ]
%inc22 = add nsw i64 %j.07, 1
%cmp2 = icmp slt i64 %inc22, %n
br i1 %cmp2, label %for.cond4.preheader, label %for.inc24
for.inc24: ; preds = %for.inc21, %for.cond1.preheader
%B.addr.1.lcssa = phi i64* [ %B.addr.012, %for.cond1.preheader ], [ %B.addr.2.lcssa, %for.inc21 ]
%inc25 = add nsw i64 %i.011, 1
%cmp = icmp slt i64 %inc25, %n
br i1 %cmp, label %for.cond1.preheader, label %for.end26
for.end26: ; preds = %for.inc24, %entry
ret void
}
;; classify subscripts
;; for (long int i = 0; i < n; i++)
;; for (long int j = 0; j < n; j++)
;; for (long int k = 0; k < n; k++)
;; for (long int l = 0; l < n; l++)
;; for (long int m = 0; m < n; m++)
;; for (long int o = 0; o < n; o++)
;; for (long int p = 0; p < n; p++)
;; for (long int q = 0; q < n; q++)
;; for (long int r = 0; r < n; r++)
;; for (long int s = 0; s < n; s++)
;; for (long int u = 0; u < n; u++)
;; for (long int t = 0; t < n; t++) {
;; A[i - 3] [j] [2] [k-1] [2*l + 1] [m] [p + q] [r + s] = ...
;; ... = A[i + 3] [2] [u] [1-k] [3*l - 1] [o] [1 + n] [t + 2];
define void @p3(i64 %n, [100 x [100 x [100 x [100 x [100 x [100 x [100 x i64]]]]]]]* %A, i64* %B) nounwind uwtable ssp {
entry:
%cmp44 = icmp sgt i64 %n, 0
br i1 %cmp44, label %for.cond1.preheader, label %for.end90
for.cond1.preheader: ; preds = %for.inc88, %entry
%B.addr.046 = phi i64* [ %B.addr.1.lcssa, %for.inc88 ], [ %B, %entry ]
%i.045 = phi i64 [ %inc89, %for.inc88 ], [ 0, %entry ]
%cmp240 = icmp sgt i64 %n, 0
br i1 %cmp240, label %for.cond4.preheader, label %for.inc88
for.cond4.preheader: ; preds = %for.inc85, %for.cond1.preheader
%B.addr.142 = phi i64* [ %B.addr.2.lcssa, %for.inc85 ], [ %B.addr.046, %for.cond1.preheader ]
%j.041 = phi i64 [ %inc86, %for.inc85 ], [ 0, %for.cond1.preheader ]
%cmp536 = icmp sgt i64 %n, 0
br i1 %cmp536, label %for.cond7.preheader, label %for.inc85
for.cond7.preheader: ; preds = %for.inc82, %for.cond4.preheader
%B.addr.238 = phi i64* [ %B.addr.3.lcssa, %for.inc82 ], [ %B.addr.142, %for.cond4.preheader ]
%k.037 = phi i64 [ %inc83, %for.inc82 ], [ 0, %for.cond4.preheader ]
%cmp832 = icmp sgt i64 %n, 0
br i1 %cmp832, label %for.cond10.preheader, label %for.inc82
for.cond10.preheader: ; preds = %for.inc79, %for.cond7.preheader
%B.addr.334 = phi i64* [ %B.addr.4.lcssa, %for.inc79 ], [ %B.addr.238, %for.cond7.preheader ]
%l.033 = phi i64 [ %inc80, %for.inc79 ], [ 0, %for.cond7.preheader ]
%cmp1128 = icmp sgt i64 %n, 0
br i1 %cmp1128, label %for.cond13.preheader, label %for.inc79
for.cond13.preheader: ; preds = %for.inc76, %for.cond10.preheader
%B.addr.430 = phi i64* [ %B.addr.5.lcssa, %for.inc76 ], [ %B.addr.334, %for.cond10.preheader ]
%m.029 = phi i64 [ %inc77, %for.inc76 ], [ 0, %for.cond10.preheader ]
%cmp1424 = icmp sgt i64 %n, 0
br i1 %cmp1424, label %for.cond16.preheader, label %for.inc76
for.cond16.preheader: ; preds = %for.inc73, %for.cond13.preheader
%B.addr.526 = phi i64* [ %B.addr.6.lcssa, %for.inc73 ], [ %B.addr.430, %for.cond13.preheader ]
%o.025 = phi i64 [ %inc74, %for.inc73 ], [ 0, %for.cond13.preheader ]
%cmp1720 = icmp sgt i64 %n, 0
br i1 %cmp1720, label %for.cond19.preheader, label %for.inc73
for.cond19.preheader: ; preds = %for.inc70, %for.cond16.preheader
%B.addr.622 = phi i64* [ %B.addr.7.lcssa, %for.inc70 ], [ %B.addr.526, %for.cond16.preheader ]
%p.021 = phi i64 [ %inc71, %for.inc70 ], [ 0, %for.cond16.preheader ]
%cmp2016 = icmp sgt i64 %n, 0
br i1 %cmp2016, label %for.cond22.preheader, label %for.inc70
for.cond22.preheader: ; preds = %for.inc67, %for.cond19.preheader
%B.addr.718 = phi i64* [ %B.addr.8.lcssa, %for.inc67 ], [ %B.addr.622, %for.cond19.preheader ]
%q.017 = phi i64 [ %inc68, %for.inc67 ], [ 0, %for.cond19.preheader ]
%cmp2312 = icmp sgt i64 %n, 0
br i1 %cmp2312, label %for.cond25.preheader, label %for.inc67
for.cond25.preheader: ; preds = %for.inc64, %for.cond22.preheader
%B.addr.814 = phi i64* [ %B.addr.9.lcssa, %for.inc64 ], [ %B.addr.718, %for.cond22.preheader ]
%r.013 = phi i64 [ %inc65, %for.inc64 ], [ 0, %for.cond22.preheader ]
%cmp268 = icmp sgt i64 %n, 0
br i1 %cmp268, label %for.cond28.preheader, label %for.inc64
for.cond28.preheader: ; preds = %for.inc61, %for.cond25.preheader
%B.addr.910 = phi i64* [ %B.addr.10.lcssa, %for.inc61 ], [ %B.addr.814, %for.cond25.preheader ]
%s.09 = phi i64 [ %inc62, %for.inc61 ], [ 0, %for.cond25.preheader ]
%cmp294 = icmp sgt i64 %n, 0
br i1 %cmp294, label %for.cond31.preheader, label %for.inc61
for.cond31.preheader: ; preds = %for.inc58, %for.cond28.preheader
%u.06 = phi i64 [ %inc59, %for.inc58 ], [ 0, %for.cond28.preheader ]
%B.addr.105 = phi i64* [ %B.addr.11.lcssa, %for.inc58 ], [ %B.addr.910, %for.cond28.preheader ]
%cmp321 = icmp sgt i64 %n, 0
br i1 %cmp321, label %for.body33, label %for.inc58
for.body33: ; preds = %for.body33, %for.cond31.preheader
%t.03 = phi i64 [ %inc, %for.body33 ], [ 0, %for.cond31.preheader ]
%B.addr.112 = phi i64* [ %incdec.ptr, %for.body33 ], [ %B.addr.105, %for.cond31.preheader ]
%add = add nsw i64 %r.013, %s.09
%add34 = add nsw i64 %p.021, %q.017
%mul = shl nsw i64 %l.033, 1
%add3547 = or i64 %mul, 1
%sub = add nsw i64 %k.037, -1
%sub36 = add nsw i64 %i.045, -3
%arrayidx43 = getelementptr inbounds [100 x [100 x [100 x [100 x [100 x [100 x [100 x i64]]]]]]]* %A, i64 %sub36, i64 %j.041, i64 2, i64 %sub, i64 %add3547, i64 %m.029, i64 %add34, i64 %add
store i64 %i.045, i64* %arrayidx43, align 8
%add44 = add nsw i64 %t.03, 2
%add45 = add nsw i64 %n, 1
%mul46 = mul nsw i64 %l.033, 3
%sub47 = add nsw i64 %mul46, -1
%sub48 = sub nsw i64 1, %k.037
%add49 = add nsw i64 %i.045, 3
%arrayidx57 = getelementptr inbounds [100 x [100 x [100 x [100 x [100 x [100 x [100 x i64]]]]]]]* %A, i64 %add49, i64 2, i64 %u.06, i64 %sub48, i64 %sub47, i64 %o.025, i64 %add45, i64 %add44
%0 = load i64* %arrayidx57, align 8
; CHECK: da analyze - flow [-6 * * => * * * * * * * *] splitable!
; CHECK: da analyze - split level = 3, iteration = 1!
%incdec.ptr = getelementptr inbounds i64* %B.addr.112, i64 1
store i64 %0, i64* %B.addr.112, align 8
%inc = add nsw i64 %t.03, 1
%cmp32 = icmp slt i64 %inc, %n
br i1 %cmp32, label %for.body33, label %for.inc58
for.inc58: ; preds = %for.body33, %for.cond31.preheader
%B.addr.11.lcssa = phi i64* [ %B.addr.105, %for.cond31.preheader ], [ %incdec.ptr, %for.body33 ]
%inc59 = add nsw i64 %u.06, 1
%cmp29 = icmp slt i64 %inc59, %n
br i1 %cmp29, label %for.cond31.preheader, label %for.inc61
for.inc61: ; preds = %for.inc58, %for.cond28.preheader
%B.addr.10.lcssa = phi i64* [ %B.addr.910, %for.cond28.preheader ], [ %B.addr.11.lcssa, %for.inc58 ]
%inc62 = add nsw i64 %s.09, 1
%cmp26 = icmp slt i64 %inc62, %n
br i1 %cmp26, label %for.cond28.preheader, label %for.inc64
for.inc64: ; preds = %for.inc61, %for.cond25.preheader
%B.addr.9.lcssa = phi i64* [ %B.addr.814, %for.cond25.preheader ], [ %B.addr.10.lcssa, %for.inc61 ]
%inc65 = add nsw i64 %r.013, 1
%cmp23 = icmp slt i64 %inc65, %n
br i1 %cmp23, label %for.cond25.preheader, label %for.inc67
for.inc67: ; preds = %for.inc64, %for.cond22.preheader
%B.addr.8.lcssa = phi i64* [ %B.addr.718, %for.cond22.preheader ], [ %B.addr.9.lcssa, %for.inc64 ]
%inc68 = add nsw i64 %q.017, 1
%cmp20 = icmp slt i64 %inc68, %n
br i1 %cmp20, label %for.cond22.preheader, label %for.inc70
for.inc70: ; preds = %for.inc67, %for.cond19.preheader
%B.addr.7.lcssa = phi i64* [ %B.addr.622, %for.cond19.preheader ], [ %B.addr.8.lcssa, %for.inc67 ]
%inc71 = add nsw i64 %p.021, 1
%cmp17 = icmp slt i64 %inc71, %n
br i1 %cmp17, label %for.cond19.preheader, label %for.inc73
for.inc73: ; preds = %for.inc70, %for.cond16.preheader
%B.addr.6.lcssa = phi i64* [ %B.addr.526, %for.cond16.preheader ], [ %B.addr.7.lcssa, %for.inc70 ]
%inc74 = add nsw i64 %o.025, 1
%cmp14 = icmp slt i64 %inc74, %n
br i1 %cmp14, label %for.cond16.preheader, label %for.inc76
for.inc76: ; preds = %for.inc73, %for.cond13.preheader
%B.addr.5.lcssa = phi i64* [ %B.addr.430, %for.cond13.preheader ], [ %B.addr.6.lcssa, %for.inc73 ]
%inc77 = add nsw i64 %m.029, 1
%cmp11 = icmp slt i64 %inc77, %n
br i1 %cmp11, label %for.cond13.preheader, label %for.inc79
for.inc79: ; preds = %for.inc76, %for.cond10.preheader
%B.addr.4.lcssa = phi i64* [ %B.addr.334, %for.cond10.preheader ], [ %B.addr.5.lcssa, %for.inc76 ]
%inc80 = add nsw i64 %l.033, 1
%cmp8 = icmp slt i64 %inc80, %n
br i1 %cmp8, label %for.cond10.preheader, label %for.inc82
for.inc82: ; preds = %for.inc79, %for.cond7.preheader
%B.addr.3.lcssa = phi i64* [ %B.addr.238, %for.cond7.preheader ], [ %B.addr.4.lcssa, %for.inc79 ]
%inc83 = add nsw i64 %k.037, 1
%cmp5 = icmp slt i64 %inc83, %n
br i1 %cmp5, label %for.cond7.preheader, label %for.inc85
for.inc85: ; preds = %for.inc82, %for.cond4.preheader
%B.addr.2.lcssa = phi i64* [ %B.addr.142, %for.cond4.preheader ], [ %B.addr.3.lcssa, %for.inc82 ]
%inc86 = add nsw i64 %j.041, 1
%cmp2 = icmp slt i64 %inc86, %n
br i1 %cmp2, label %for.cond4.preheader, label %for.inc88
for.inc88: ; preds = %for.inc85, %for.cond1.preheader
%B.addr.1.lcssa = phi i64* [ %B.addr.046, %for.cond1.preheader ], [ %B.addr.2.lcssa, %for.inc85 ]
%inc89 = add nsw i64 %i.045, 1
%cmp = icmp slt i64 %inc89, %n
br i1 %cmp, label %for.cond1.preheader, label %for.end90
for.end90: ; preds = %for.inc88, %entry
ret void
}
;; cleanup around chars, shorts, ints
;;void p4(int *A, int *B, long int n)
;; for (char i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @p4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp sgt i64 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i8 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv2 = sext i8 %i.03 to i32
%conv3 = sext i8 %i.03 to i64
%add = add i64 %conv3, 2
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv2, i32* %arrayidx, align 4
%idxprom4 = sext i8 %i.03 to i64
%arrayidx5 = getelementptr inbounds i32* %A, i64 %idxprom4
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i8 %i.03, 1
%conv = sext i8 %inc to i64
%cmp = icmp slt i64 %conv, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;;void p5(int *A, int *B, long int n)
;; for (short i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @p5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp sgt i64 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i16 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv2 = sext i16 %i.03 to i32
%conv3 = sext i16 %i.03 to i64
%add = add i64 %conv3, 2
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv2, i32* %arrayidx, align 4
%idxprom4 = sext i16 %i.03 to i64
%arrayidx5 = getelementptr inbounds i32* %A, i64 %idxprom4
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i16 %i.03, 1
%conv = sext i16 %inc to i64
%cmp = icmp slt i64 %conv, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;;void p6(int *A, int *B, long int n)
;; for (int i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @p6(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp sgt i64 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%add = add nsw i32 %i.03, 2
%idxprom = sext i32 %add to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 %i.03, i32* %arrayidx, align 4
%idxprom2 = sext i32 %i.03 to i64
%arrayidx3 = getelementptr inbounds i32* %A, i64 %idxprom2
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - consistent flow [2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i32 %i.03, 1
%conv = sext i32 %inc to i64
%cmp = icmp slt i64 %conv, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;;void p7(unsigned *A, unsigned *B, char n)
;; A[n] = ...
;; ... = A[n + 1];
define void @p7(i32* %A, i32* %B, i8 signext %n) nounwind uwtable ssp {
entry:
%idxprom = sext i8 %n to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 0, i32* %arrayidx, align 4
%conv = sext i8 %n to i64
%add = add i64 %conv, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
store i32 %0, i32* %B, align 4
ret void
}
;;void p8(unsigned *A, unsigned *B, short n)
;; A[n] = ...
;; ... = A[n + 1];
define void @p8(i32* %A, i32* %B, i16 signext %n) nounwind uwtable ssp {
entry:
%idxprom = sext i16 %n to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 0, i32* %arrayidx, align 4
%conv = sext i16 %n to i64
%add = add i64 %conv, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
store i32 %0, i32* %B, align 4
ret void
}
;;void p9(unsigned *A, unsigned *B, int n)
;; A[n] = ...
;; ... = A[n + 1];
define void @p9(i32* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
%idxprom = sext i32 %n to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 0, i32* %arrayidx, align 4
%add = add nsw i32 %n, 1
%idxprom1 = sext i32 %add to i64
%arrayidx2 = getelementptr inbounds i32* %A, i64 %idxprom1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
store i32 %0, i32* %B, align 4
ret void
}
;;void p10(unsigned *A, unsigned *B, unsigned n)
;; A[n] = ...
;; ... = A[n + 1];
define void @p10(i32* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
%idxprom = zext i32 %n to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 0, i32* %arrayidx, align 4
%add = add i32 %n, 1
%idxprom1 = zext i32 %add to i64
%arrayidx2 = getelementptr inbounds i32* %A, i64 %idxprom1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
store i32 %0, i32* %B, align 4
ret void
}

467
llvm/test/Analysis/DependenceAnalysis/Propagating.ll Normal file
View File

@ -0,0 +1,467 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'Propagating.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i + 1][i + j] = i;
;; *B++ = A[i][i + j];
define void @prop0([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc9, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc9 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%add = add nsw i64 %i.03, %j.02
%add4 = add nsw i64 %i.03, 1
%arrayidx5 = getelementptr inbounds [100 x i32]* %A, i64 %add4, i64 %add
store i32 %conv, i32* %arrayidx5, align 4
%add6 = add nsw i64 %i.03, %j.02
%arrayidx8 = getelementptr inbounds [100 x i32]* %A, i64 %i.03, i64 %add6
%0 = load i32* %arrayidx8, align 4
; CHECK: da analyze - consistent flow [1 -1]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc9
for.inc9: ; preds = %for.body3
%inc10 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc10, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end11
for.end11: ; preds = %for.inc9
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; for (long int k = 0; k < 100; k++)
;; A[j - i][i + 1][j + k] = ...
;; ... = A[j - i][i][j + k];
define void @prop1([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc18, %entry
%B.addr.06 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc18 ]
%i.05 = phi i64 [ 0, %entry ], [ %inc19, %for.inc18 ]
br label %for.cond4.preheader
for.cond4.preheader: ; preds = %for.inc15, %for.cond1.preheader
%B.addr.14 = phi i32* [ %B.addr.06, %for.cond1.preheader ], [ %incdec.ptr, %for.inc15 ]
%j.03 = phi i64 [ 0, %for.cond1.preheader ], [ %inc16, %for.inc15 ]
br label %for.body6
for.body6: ; preds = %for.body6, %for.cond4.preheader
%k.02 = phi i64 [ 0, %for.cond4.preheader ], [ %inc, %for.body6 ]
%B.addr.21 = phi i32* [ %B.addr.14, %for.cond4.preheader ], [ %incdec.ptr, %for.body6 ]
%conv = trunc i64 %i.05 to i32
%add = add nsw i64 %j.03, %k.02
%add7 = add nsw i64 %i.05, 1
%sub = sub nsw i64 %j.03, %i.05
%arrayidx9 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %sub, i64 %add7, i64 %add
store i32 %conv, i32* %arrayidx9, align 4
%add10 = add nsw i64 %j.03, %k.02
%sub11 = sub nsw i64 %j.03, %i.05
%arrayidx14 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %sub11, i64 %i.05, i64 %add10
%0 = load i32* %arrayidx14, align 4
; CHECK: da analyze - consistent flow [1 1 -1]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.21, i64 1
store i32 %0, i32* %B.addr.21, align 4
%inc = add nsw i64 %k.02, 1
%cmp5 = icmp slt i64 %inc, 100
br i1 %cmp5, label %for.body6, label %for.inc15
for.inc15: ; preds = %for.body6
%inc16 = add nsw i64 %j.03, 1
%cmp2 = icmp slt i64 %inc16, 100
br i1 %cmp2, label %for.cond4.preheader, label %for.inc18
for.inc18: ; preds = %for.inc15
%inc19 = add nsw i64 %i.05, 1
%cmp = icmp slt i64 %inc19, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end20
for.end20: ; preds = %for.inc18
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i - 1][2*i] = ...
;; ... = A[i][i + j + 110];
define void @prop2([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc8, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc8 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%sub = add nsw i64 %i.03, -1
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %sub, i64 %mul
store i32 %conv, i32* %arrayidx4, align 4
%add = add nsw i64 %i.03, %j.02
%add5 = add nsw i64 %add, 110
%arrayidx7 = getelementptr inbounds [100 x i32]* %A, i64 %i.03, i64 %add5
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc8
for.inc8: ; preds = %for.body3
%inc9 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc9, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end10
for.end10: ; preds = %for.inc8
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i][2*j + i] = ...
;; ... = A[i][2*j - i + 5];
define void @prop3([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc9, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc9 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %j.02, 1
%add = add nsw i64 %mul, %i.03
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 %i.03, i64 %add
store i32 %conv, i32* %arrayidx4, align 4
%mul5 = shl nsw i64 %j.02, 1
%sub = sub nsw i64 %mul5, %i.03
%add6 = add nsw i64 %sub, 5
%arrayidx8 = getelementptr inbounds [100 x i32]* %A, i64 %i.03, i64 %add6
%0 = load i32* %arrayidx8, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc9
for.inc9: ; preds = %for.body3
%inc10 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc10, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end11
for.end11: ; preds = %for.inc9
ret void
}
;; propagate Distance
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i + 2][2*i + j + 1] = ...
;; ... = A[i][2*i + j];
define void @prop4([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc11, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc11 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc12, %for.inc11 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%add = add nsw i64 %mul, %j.02
%add4 = add nsw i64 %add, 1
%add5 = add nsw i64 %i.03, 2
%arrayidx6 = getelementptr inbounds [100 x i32]* %A, i64 %add5, i64 %add4
store i32 %conv, i32* %arrayidx6, align 4
%mul7 = shl nsw i64 %i.03, 1
%add8 = add nsw i64 %mul7, %j.02
%arrayidx10 = getelementptr inbounds [100 x i32]* %A, i64 %i.03, i64 %add8
%0 = load i32* %arrayidx10, align 4
; CHECK: da analyze - consistent flow [2 -3]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc11
for.inc11: ; preds = %for.body3
%inc12 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc12, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end13
for.end13: ; preds = %for.inc11
ret void
}
;; propagate Point
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[3*i - 18][22 - i][2*i + j] = ...
;; ... = A[i][i][3*i + j];
define void @prop5([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc13, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc13 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc14, %for.inc13 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%add = add nsw i64 %mul, %j.02
%sub = sub nsw i64 22, %i.03
%mul4 = mul nsw i64 %i.03, 3
%sub5 = add nsw i64 %mul4, -18
%arrayidx7 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %sub5, i64 %sub, i64 %add
store i32 %conv, i32* %arrayidx7, align 4
%mul8 = mul nsw i64 %i.03, 3
%add9 = add nsw i64 %mul8, %j.02
%arrayidx12 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %i.03, i64 %i.03, i64 %add9
%0 = load i32* %arrayidx12, align 4
; CHECK: da analyze - flow [< -16] splitable!
; CHECK: da analyze - split level = 1, iteration = 11!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc13
for.inc13: ; preds = %for.body3
%inc14 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc14, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end15
for.end15: ; preds = %for.inc13
ret void
}
;; propagate Line
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[i + 1][4*i + j + 2] = ...
;; ... = A[2*i][8*i + j];
define void @prop6([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc12, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc12 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc13, %for.inc12 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 2
%add = add nsw i64 %mul, %j.02
%add4 = add nsw i64 %add, 2
%add5 = add nsw i64 %i.03, 1
%arrayidx6 = getelementptr inbounds [100 x i32]* %A, i64 %add5, i64 %add4
store i32 %conv, i32* %arrayidx6, align 4
%mul7 = shl nsw i64 %i.03, 3
%add8 = add nsw i64 %mul7, %j.02
%mul9 = shl nsw i64 %i.03, 1
%arrayidx11 = getelementptr inbounds [100 x i32]* %A, i64 %mul9, i64 %add8
%0 = load i32* %arrayidx11, align 4
; CHECK: da analyze - flow [=> -2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc12
for.inc12: ; preds = %for.body3
%inc13 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc13, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end14
for.end14: ; preds = %for.inc12
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[2*i + 4][-5*i + j + 2] = ...
;; ... = A[-2*i + 20][5*i + j];
define void @prop7([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc14, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc14 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc15, %for.inc14 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -5
%add = add nsw i64 %mul, %j.02
%add4 = add nsw i64 %add, 2
%mul5 = shl nsw i64 %i.03, 1
%add6 = add nsw i64 %mul5, 4
%arrayidx7 = getelementptr inbounds [100 x i32]* %A, i64 %add6, i64 %add4
store i32 %conv, i32* %arrayidx7, align 4
%mul8 = mul nsw i64 %i.03, 5
%add9 = add nsw i64 %mul8, %j.02
%mul10 = mul nsw i64 %i.03, -2
%add11 = add nsw i64 %mul10, 20
%arrayidx13 = getelementptr inbounds [100 x i32]* %A, i64 %add11, i64 %add9
%0 = load i32* %arrayidx13, align 4
; CHECK: da analyze - flow [* -38] splitable!
; CHECK: da analyze - split level = 1, iteration = 4!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc14
for.inc14: ; preds = %for.body3
%inc15 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc15, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end16
for.end16: ; preds = %for.inc14
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[4][j + 2] = ...
;; ... = A[-2*i + 4][5*i + j];
define void @prop8([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc10, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc10 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc11, %for.inc10 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%add = add nsw i64 %j.02, 2
%arrayidx4 = getelementptr inbounds [100 x i32]* %A, i64 4, i64 %add
store i32 %conv, i32* %arrayidx4, align 4
%mul = mul nsw i64 %i.03, 5
%add5 = add nsw i64 %mul, %j.02
%mul6 = mul nsw i64 %i.03, -2
%add7 = add nsw i64 %mul6, 4
%arrayidx9 = getelementptr inbounds [100 x i32]* %A, i64 %add7, i64 %add5
%0 = load i32* %arrayidx9, align 4
; CHECK: da analyze - flow [p<= 2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc10
for.inc10: ; preds = %for.body3
%inc11 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc11, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end12
for.end12: ; preds = %for.inc10
ret void
}
;; for (long int i = 0; i < 100; i++)
;; for (long int j = 0; j < 100; j++)
;; A[2*i + 4][5*i + j + 2] = ...
;; ... = A[4][j];
define void @prop9([100 x i32]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc10, %entry
%B.addr.04 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc10 ]
%i.03 = phi i64 [ 0, %entry ], [ %inc11, %for.inc10 ]
br label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
%B.addr.11 = phi i32* [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, 5
%add = add nsw i64 %mul, %j.02
%add4 = add nsw i64 %add, 2
%mul5 = shl nsw i64 %i.03, 1
%add6 = add nsw i64 %mul5, 4
%arrayidx7 = getelementptr inbounds [100 x i32]* %A, i64 %add6, i64 %add4
store i32 %conv, i32* %arrayidx7, align 4
%arrayidx9 = getelementptr inbounds [100 x i32]* %A, i64 4, i64 %j.02
%0 = load i32* %arrayidx9, align 4
; CHECK: da analyze - flow [p<= 2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.11, i64 1
store i32 %0, i32* %B.addr.11, align 4
%inc = add nsw i64 %j.02, 1
%cmp2 = icmp slt i64 %inc, 100
br i1 %cmp2, label %for.body3, label %for.inc10
for.inc10: ; preds = %for.body3
%inc11 = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc11, 100
br i1 %cmp, label %for.cond1.preheader, label %for.end12
for.end12: ; preds = %for.inc10
ret void
}

267
llvm/test/Analysis/DependenceAnalysis/Separability.ll Normal file
View File

@ -0,0 +1,267 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'Separability.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < 50; i++)
;; for (long int j = 0; j < 50; j++)
;; for (long int k = 0; k < 50; k++)
;; for (long int l = 0; l < 50; l++)
;; A[n][i][j + k] = ...
;; ... = A[10][i + 10][2*j - l];
define void @sep0([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc22, %entry
%B.addr.08 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc22 ]
%i.07 = phi i64 [ 0, %entry ], [ %inc23, %for.inc22 ]
br label %for.cond4.preheader
for.cond4.preheader: ; preds = %for.inc19, %for.cond1.preheader
%B.addr.16 = phi i32* [ %B.addr.08, %for.cond1.preheader ], [ %incdec.ptr, %for.inc19 ]
%j.05 = phi i64 [ 0, %for.cond1.preheader ], [ %inc20, %for.inc19 ]
br label %for.cond7.preheader
for.cond7.preheader: ; preds = %for.inc16, %for.cond4.preheader
%B.addr.24 = phi i32* [ %B.addr.16, %for.cond4.preheader ], [ %incdec.ptr, %for.inc16 ]
%k.03 = phi i64 [ 0, %for.cond4.preheader ], [ %inc17, %for.inc16 ]
br label %for.body9
for.body9: ; preds = %for.body9, %for.cond7.preheader
%l.02 = phi i64 [ 0, %for.cond7.preheader ], [ %inc, %for.body9 ]
%B.addr.31 = phi i32* [ %B.addr.24, %for.cond7.preheader ], [ %incdec.ptr, %for.body9 ]
%conv = trunc i64 %i.07 to i32
%add = add nsw i64 %j.05, %k.03
%idxprom = sext i32 %n to i64
%arrayidx11 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %idxprom, i64 %i.07, i64 %add
store i32 %conv, i32* %arrayidx11, align 4
%mul = shl nsw i64 %j.05, 1
%sub = sub nsw i64 %mul, %l.02
%add12 = add nsw i64 %i.07, 10
%arrayidx15 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 10, i64 %add12, i64 %sub
%0 = load i32* %arrayidx15, align 4
; CHECK: da analyze - flow [-10 * * *]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.31, i64 1
store i32 %0, i32* %B.addr.31, align 4
%inc = add nsw i64 %l.02, 1
%cmp8 = icmp slt i64 %inc, 50
br i1 %cmp8, label %for.body9, label %for.inc16
for.inc16: ; preds = %for.body9
%inc17 = add nsw i64 %k.03, 1
%cmp5 = icmp slt i64 %inc17, 50
br i1 %cmp5, label %for.cond7.preheader, label %for.inc19
for.inc19: ; preds = %for.inc16
%inc20 = add nsw i64 %j.05, 1
%cmp2 = icmp slt i64 %inc20, 50
br i1 %cmp2, label %for.cond4.preheader, label %for.inc22
for.inc22: ; preds = %for.inc19
%inc23 = add nsw i64 %i.07, 1
%cmp = icmp slt i64 %inc23, 50
br i1 %cmp, label %for.cond1.preheader, label %for.end24
for.end24: ; preds = %for.inc22
ret void
}
;; for (long int i = 0; i < 50; i++)
;; for (long int j = 0; j < 50; j++)
;; for (long int k = 0; k < 50; k++)
;; for (long int l = 0; l < 50; l++)
;; A[i][i][j + k] = ...
;; ... = A[10][i + 10][2*j - l];
define void @sep1([100 x [100 x i32]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc22, %entry
%B.addr.08 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc22 ]
%i.07 = phi i64 [ 0, %entry ], [ %inc23, %for.inc22 ]
br label %for.cond4.preheader
for.cond4.preheader: ; preds = %for.inc19, %for.cond1.preheader
%B.addr.16 = phi i32* [ %B.addr.08, %for.cond1.preheader ], [ %incdec.ptr, %for.inc19 ]
%j.05 = phi i64 [ 0, %for.cond1.preheader ], [ %inc20, %for.inc19 ]
br label %for.cond7.preheader
for.cond7.preheader: ; preds = %for.inc16, %for.cond4.preheader
%B.addr.24 = phi i32* [ %B.addr.16, %for.cond4.preheader ], [ %incdec.ptr, %for.inc16 ]
%k.03 = phi i64 [ 0, %for.cond4.preheader ], [ %inc17, %for.inc16 ]
br label %for.body9
for.body9: ; preds = %for.body9, %for.cond7.preheader
%l.02 = phi i64 [ 0, %for.cond7.preheader ], [ %inc, %for.body9 ]
%B.addr.31 = phi i32* [ %B.addr.24, %for.cond7.preheader ], [ %incdec.ptr, %for.body9 ]
%conv = trunc i64 %i.07 to i32
%add = add nsw i64 %j.05, %k.03
%arrayidx11 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 %i.07, i64 %i.07, i64 %add
store i32 %conv, i32* %arrayidx11, align 4
%mul = shl nsw i64 %j.05, 1
%sub = sub nsw i64 %mul, %l.02
%add12 = add nsw i64 %i.07, 10
%arrayidx15 = getelementptr inbounds [100 x [100 x i32]]* %A, i64 10, i64 %add12, i64 %sub
%0 = load i32* %arrayidx15, align 4
; CHECK: da analyze - flow [> * * *]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.31, i64 1
store i32 %0, i32* %B.addr.31, align 4
%inc = add nsw i64 %l.02, 1
%cmp8 = icmp slt i64 %inc, 50
br i1 %cmp8, label %for.body9, label %for.inc16
for.inc16: ; preds = %for.body9
%inc17 = add nsw i64 %k.03, 1
%cmp5 = icmp slt i64 %inc17, 50
br i1 %cmp5, label %for.cond7.preheader, label %for.inc19
for.inc19: ; preds = %for.inc16
%inc20 = add nsw i64 %j.05, 1
%cmp2 = icmp slt i64 %inc20, 50
br i1 %cmp2, label %for.cond4.preheader, label %for.inc22
for.inc22: ; preds = %for.inc19
%inc23 = add nsw i64 %i.07, 1
%cmp = icmp slt i64 %inc23, 50
br i1 %cmp, label %for.cond1.preheader, label %for.end24
for.end24: ; preds = %for.inc22
ret void
}
;; for (long int i = 0; i < 50; i++)
;; for (long int j = 0; j < 50; j++)
;; for (long int k = 0; k < 50; k++)
;; for (long int l = 0; l < 50; l++)
;; A[i][i][i + k][l] = ...
;; ... = A[10][i + 10][j + k][l + 10];
define void @sep2([100 x [100 x [100 x i32]]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc26, %entry
%B.addr.08 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc26 ]
%i.07 = phi i64 [ 0, %entry ], [ %inc27, %for.inc26 ]
br label %for.cond4.preheader
for.cond4.preheader: ; preds = %for.inc23, %for.cond1.preheader
%B.addr.16 = phi i32* [ %B.addr.08, %for.cond1.preheader ], [ %incdec.ptr, %for.inc23 ]
%j.05 = phi i64 [ 0, %for.cond1.preheader ], [ %inc24, %for.inc23 ]
br label %for.cond7.preheader
for.cond7.preheader: ; preds = %for.inc20, %for.cond4.preheader
%B.addr.24 = phi i32* [ %B.addr.16, %for.cond4.preheader ], [ %incdec.ptr, %for.inc20 ]
%k.03 = phi i64 [ 0, %for.cond4.preheader ], [ %inc21, %for.inc20 ]
br label %for.body9
for.body9: ; preds = %for.body9, %for.cond7.preheader
%l.02 = phi i64 [ 0, %for.cond7.preheader ], [ %inc, %for.body9 ]
%B.addr.31 = phi i32* [ %B.addr.24, %for.cond7.preheader ], [ %incdec.ptr, %for.body9 ]
%conv = trunc i64 %i.07 to i32
%add = add nsw i64 %i.07, %k.03
%arrayidx12 = getelementptr inbounds [100 x [100 x [100 x i32]]]* %A, i64 %i.07, i64 %i.07, i64 %add, i64 %l.02
store i32 %conv, i32* %arrayidx12, align 4
%add13 = add nsw i64 %l.02, 10
%add14 = add nsw i64 %j.05, %k.03
%add15 = add nsw i64 %i.07, 10
%arrayidx19 = getelementptr inbounds [100 x [100 x [100 x i32]]]* %A, i64 10, i64 %add15, i64 %add14, i64 %add13
%0 = load i32* %arrayidx19, align 4
; CHECK: da analyze - flow [> * * -10]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.31, i64 1
store i32 %0, i32* %B.addr.31, align 4
%inc = add nsw i64 %l.02, 1
%cmp8 = icmp slt i64 %inc, 50
br i1 %cmp8, label %for.body9, label %for.inc20
for.inc20: ; preds = %for.body9
%inc21 = add nsw i64 %k.03, 1
%cmp5 = icmp slt i64 %inc21, 50
br i1 %cmp5, label %for.cond7.preheader, label %for.inc23
for.inc23: ; preds = %for.inc20
%inc24 = add nsw i64 %j.05, 1
%cmp2 = icmp slt i64 %inc24, 50
br i1 %cmp2, label %for.cond4.preheader, label %for.inc26
for.inc26: ; preds = %for.inc23
%inc27 = add nsw i64 %i.07, 1
%cmp = icmp slt i64 %inc27, 50
br i1 %cmp, label %for.cond1.preheader, label %for.end28
for.end28: ; preds = %for.inc26
ret void
}
;; for (long int i = 0; i < 50; i++)
;; for (long int j = 0; j < 50; j++)
;; for (long int k = 0; k < 50; k++)
;; for (long int l = 0; l < 50; l++)
;; A[i][i][i + k][l + k] = ...
;; ... = A[10][i + 10][j + k][l + 10];
define void @sep3([100 x [100 x [100 x i32]]]* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc27, %entry
%B.addr.08 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.inc27 ]
%i.07 = phi i64 [ 0, %entry ], [ %inc28, %for.inc27 ]
br label %for.cond4.preheader
for.cond4.preheader: ; preds = %for.inc24, %for.cond1.preheader
%B.addr.16 = phi i32* [ %B.addr.08, %for.cond1.preheader ], [ %incdec.ptr, %for.inc24 ]
%j.05 = phi i64 [ 0, %for.cond1.preheader ], [ %inc25, %for.inc24 ]
br label %for.cond7.preheader
for.cond7.preheader: ; preds = %for.inc21, %for.cond4.preheader
%B.addr.24 = phi i32* [ %B.addr.16, %for.cond4.preheader ], [ %incdec.ptr, %for.inc21 ]
%k.03 = phi i64 [ 0, %for.cond4.preheader ], [ %inc22, %for.inc21 ]
br label %for.body9
for.body9: ; preds = %for.body9, %for.cond7.preheader
%l.02 = phi i64 [ 0, %for.cond7.preheader ], [ %inc, %for.body9 ]
%B.addr.31 = phi i32* [ %B.addr.24, %for.cond7.preheader ], [ %incdec.ptr, %for.body9 ]
%conv = trunc i64 %i.07 to i32
%add = add nsw i64 %l.02, %k.03
%add10 = add nsw i64 %i.07, %k.03
%arrayidx13 = getelementptr inbounds [100 x [100 x [100 x i32]]]* %A, i64 %i.07, i64 %i.07, i64 %add10, i64 %add
store i32 %conv, i32* %arrayidx13, align 4
%add14 = add nsw i64 %l.02, 10
%add15 = add nsw i64 %j.05, %k.03
%add16 = add nsw i64 %i.07, 10
%arrayidx20 = getelementptr inbounds [100 x [100 x [100 x i32]]]* %A, i64 10, i64 %add16, i64 %add15, i64 %add14
%0 = load i32* %arrayidx20, align 4
; CHECK: da analyze - flow [> * * *]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.31, i64 1
store i32 %0, i32* %B.addr.31, align 4
%inc = add nsw i64 %l.02, 1
%cmp8 = icmp slt i64 %inc, 50
br i1 %cmp8, label %for.body9, label %for.inc21
for.inc21: ; preds = %for.body9
%inc22 = add nsw i64 %k.03, 1
%cmp5 = icmp slt i64 %inc22, 50
br i1 %cmp5, label %for.cond7.preheader, label %for.inc24
for.inc24: ; preds = %for.inc21
%inc25 = add nsw i64 %j.05, 1
%cmp2 = icmp slt i64 %inc25, 50
br i1 %cmp2, label %for.cond4.preheader, label %for.inc27
for.inc27: ; preds = %for.inc24
%inc28 = add nsw i64 %i.07, 1
%cmp = icmp slt i64 %inc28, 50
br i1 %cmp, label %for.cond1.preheader, label %for.end29
for.end29: ; preds = %for.inc27
ret void
}

342
llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll Normal file
View File

@ -0,0 +1,342 @@
; RUN: opt < %s -analyze -basicaa -indvars -da | FileCheck %s
; ModuleID = 'StrongSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (int i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @strong0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp sgt i64 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%add = add nsw i32 %i.03, 2
%idxprom = sext i32 %add to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 %i.03, i32* %arrayidx, align 4
%idxprom2 = sext i32 %i.03 to i64
%arrayidx3 = getelementptr inbounds i32* %A, i64 %idxprom2
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - consistent flow [2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i32 %i.03, 1
%conv = sext i32 %inc to i64
%cmp = icmp slt i64 %conv, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @strong1(i32* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
%conv = sext i32 %n to i64
%cmp1 = icmp sgt i32 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv2 = trunc i64 %i.03 to i32
%add = add nsw i64 %i.03, 2
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv2, i32* %arrayidx, align 4
%arrayidx3 = getelementptr inbounds i32* %A, i64 %i.03
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - consistent flow [2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp slt i64 %inc, %conv
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @strong2(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%add = add i64 %i.03, 2
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 %i.03
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - consistent flow [2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (int i = 0; i < n; i++)
;; A[i + 2] = ...
;; ... = A[i];
define void @strong3(i32* %A, i32* %B, i32 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp sgt i32 %n, 0
br i1 %cmp1, label %for.body, label %for.end
for.body: ; preds = %for.body, %entry
%i.03 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%add = add nsw i32 %i.03, 2
%idxprom = sext i32 %add to i64
%arrayidx = getelementptr inbounds i32* %A, i64 %idxprom
store i32 %i.03, i32* %arrayidx, align 4
%idxprom1 = sext i32 %i.03 to i64
%arrayidx2 = getelementptr inbounds i32* %A, i64 %idxprom1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - consistent flow [2]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i32 %i.03, 1
%cmp = icmp slt i32 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 19; i++)
;; A[i + 19] = ...
;; ... = A[i];
define void @strong4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%add = add i64 %i.02, 19
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 %i.02
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 19
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 20; i++)
;; A[i + 19] = ...
;; ... = A[i];
define void @strong5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%add = add i64 %i.02, 19
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 %i.02
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - consistent flow [19]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 20
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 20; i++)
;; A[2*i + 6] = ...
;; ... = A[2*i];
define void @strong6(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%add = add i64 %mul, 6
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul1 = shl i64 %i.02, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %mul1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - consistent flow [3]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 20
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 20; i++)
;; A[2*i + 7] = ...
;; ... = A[2*i];
define void @strong7(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%add = add i64 %mul, 7
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul1 = shl i64 %i.02, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %mul1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 20
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 20; i++)
;; A[i + n] = ...
;; ... = A[i];
define void @strong8(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%add = add i64 %i.02, %n
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 %i.02
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - consistent flow [%n|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 20
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[i + n] = ...
;; ... = A[i + 2*n];
define void @strong9(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%add = add i64 %i.03, %n
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %n, 1
%add1 = add i64 %i.03, %mul
%arrayidx2 = getelementptr inbounds i32* %A, i64 %add1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 1000; i++)
;; A[n*i + 5] = ...
;; ... = A[n*i + 5];
define void @strong10(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = mul i64 %i.02, %n
%add = add i64 %mul, 5
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul1 = mul i64 %i.02, %n
%add2 = add i64 %mul1, 5
%arrayidx3 = getelementptr inbounds i32* %A, i64 %add2
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - consistent flow [0|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 1000
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}

312
llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll Normal file
View File

@ -0,0 +1,312 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'SymbolicRDIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < n1; i++)
;; A[2*i + n1] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[3*j + 3*n1];
define void @symbolicrdiv0(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond1.preheader, label %for.body
for.cond1.preheader: ; preds = %for.body, %entry
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.end11, label %for.body4
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%mul = shl nsw i64 %i.05, 1
%add = add i64 %mul, %n1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond1.preheader
for.body4: ; preds = %for.body4, %for.cond1.preheader
%j.03 = phi i64 [ %inc10, %for.body4 ], [ 0, %for.cond1.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.cond1.preheader ]
%mul56 = add i64 %j.03, %n1
%add7 = mul i64 %mul56, 3
%arrayidx8 = getelementptr inbounds i32* %A, i64 %add7
%0 = load i32* %arrayidx8, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc10 = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc10, %n2
br i1 %cmp2, label %for.body4, label %for.end11
for.end11: ; preds = %for.body4, %for.cond1.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; A[2*i + 5*n2] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[3*j + 2*n2];
define void @symbolicrdiv1(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond2.preheader, label %for.body
for.cond2.preheader: ; preds = %for.body, %entry
%cmp31 = icmp eq i64 %n2, 0
br i1 %cmp31, label %for.end12, label %for.body5
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%mul = shl nsw i64 %i.05, 1
%mul1 = mul i64 %n2, 5
%add = add i64 %mul, %mul1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond2.preheader
for.body5: ; preds = %for.body5, %for.cond2.preheader
%j.03 = phi i64 [ %inc11, %for.body5 ], [ 0, %for.cond2.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body5 ], [ %B, %for.cond2.preheader ]
%mul6 = mul nsw i64 %j.03, 3
%mul7 = shl i64 %n2, 1
%add8 = add i64 %mul6, %mul7
%arrayidx9 = getelementptr inbounds i32* %A, i64 %add8
%0 = load i32* %arrayidx9, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc11 = add nsw i64 %j.03, 1
%cmp3 = icmp ult i64 %inc11, %n2
br i1 %cmp3, label %for.body5, label %for.end12
for.end12: ; preds = %for.body5, %for.cond2.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; A[2*i - n2] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[-j + 2*n1];
define void @symbolicrdiv2(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond1.preheader, label %for.body
for.cond1.preheader: ; preds = %for.body, %entry
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.end10, label %for.body4
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%mul = shl nsw i64 %i.05, 1
%sub = sub i64 %mul, %n2
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond1.preheader
for.body4: ; preds = %for.body4, %for.cond1.preheader
%j.03 = phi i64 [ %inc9, %for.body4 ], [ 0, %for.cond1.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.cond1.preheader ]
%mul6 = shl i64 %n1, 1
%add = sub i64 %mul6, %j.03
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc9 = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc9, %n2
br i1 %cmp2, label %for.body4, label %for.end10
for.end10: ; preds = %for.body4, %for.cond1.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; A[-i + n2] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[j - n1];
define void @symbolicrdiv3(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond1.preheader, label %for.body
for.cond1.preheader: ; preds = %for.body, %entry
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.end9, label %for.body4
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%add = sub i64 %n2, %i.05
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond1.preheader
for.body4: ; preds = %for.body4, %for.cond1.preheader
%j.03 = phi i64 [ %inc8, %for.body4 ], [ 0, %for.cond1.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.cond1.preheader ]
%sub5 = sub i64 %j.03, %n1
%arrayidx6 = getelementptr inbounds i32* %A, i64 %sub5
%0 = load i32* %arrayidx6, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc8 = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc8, %n2
br i1 %cmp2, label %for.body4, label %for.end9
for.end9: ; preds = %for.body4, %for.cond1.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; A[-i + 2*n1] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[-j + n1];
define void @symbolicrdiv4(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond1.preheader, label %for.body
for.cond1.preheader: ; preds = %for.body, %entry
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.end10, label %for.body4
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%mul = shl i64 %n1, 1
%add = sub i64 %mul, %i.05
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond1.preheader
for.body4: ; preds = %for.body4, %for.cond1.preheader
%j.03 = phi i64 [ %inc9, %for.body4 ], [ 0, %for.cond1.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.cond1.preheader ]
%add6 = sub i64 %n1, %j.03
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add6
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc9 = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc9, %n2
br i1 %cmp2, label %for.body4, label %for.end10
for.end10: ; preds = %for.body4, %for.cond1.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; A[-i + n2] = ...
;; for (long int j = 0; j < n2; j++)
;; ... = A[-j + 2*n2];
define void @symbolicrdiv5(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.cond1.preheader, label %for.body
for.cond1.preheader: ; preds = %for.body, %entry
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.end10, label %for.body4
for.body: ; preds = %for.body, %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%conv = trunc i64 %i.05 to i32
%add = sub i64 %n2, %i.05
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%inc = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc, %n1
br i1 %cmp, label %for.body, label %for.cond1.preheader
for.body4: ; preds = %for.body4, %for.cond1.preheader
%j.03 = phi i64 [ %inc9, %for.body4 ], [ 0, %for.cond1.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body4 ], [ %B, %for.cond1.preheader ]
%mul = shl i64 %n2, 1
%add6 = sub i64 %mul, %j.03
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add6
%0 = load i32* %arrayidx7, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc9 = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc9, %n2
br i1 %cmp2, label %for.body4, label %for.end10
for.end10: ; preds = %for.body4, %for.cond1.preheader
ret void
}
;; for (long int i = 0; i < n1; i++)
;; for (long int j = 0; j < n2; j++)
;; A[j -i + n2] = ...
;; ... = A[2*n2];
define void @symbolicrdiv6(i32* %A, i32* %B, i64 %n1, i64 %n2) nounwind uwtable ssp {
entry:
%cmp4 = icmp eq i64 %n1, 0
br i1 %cmp4, label %for.end7, label %for.cond1.preheader
for.cond1.preheader: ; preds = %for.inc5, %entry
%B.addr.06 = phi i32* [ %B.addr.1.lcssa, %for.inc5 ], [ %B, %entry ]
%i.05 = phi i64 [ %inc6, %for.inc5 ], [ 0, %entry ]
%cmp21 = icmp eq i64 %n2, 0
br i1 %cmp21, label %for.inc5, label %for.body3
for.body3: ; preds = %for.body3, %for.cond1.preheader
%j.03 = phi i64 [ %inc, %for.body3 ], [ 0, %for.cond1.preheader ]
%B.addr.12 = phi i32* [ %incdec.ptr, %for.body3 ], [ %B.addr.06, %for.cond1.preheader ]
%conv = trunc i64 %i.05 to i32
%sub = sub nsw i64 %j.03, %i.05
%add = add i64 %sub, %n2
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %n2, 1
%arrayidx4 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.12, i64 1
store i32 %0, i32* %B.addr.12, align 4
%inc = add nsw i64 %j.03, 1
%cmp2 = icmp ult i64 %inc, %n2
br i1 %cmp2, label %for.body3, label %for.inc5
for.inc5: ; preds = %for.body3, %for.cond1.preheader
%B.addr.1.lcssa = phi i32* [ %B.addr.06, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
%inc6 = add nsw i64 %i.05, 1
%cmp = icmp ult i64 %inc6, %n1
br i1 %cmp, label %for.cond1.preheader, label %for.end7
for.end7: ; preds = %for.inc5, %entry
ret void
}

330
llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll Normal file
View File

@ -0,0 +1,330 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'SymbolicSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long int i = 0; i < n; i++)
;; A[2*i + n] = ...
;; ... = A[3*i + 3*n];
define void @symbolicsiv0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%add = add i64 %mul, %n
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul14 = add i64 %i.03, %n
%add3 = mul i64 %mul14, 3
%arrayidx4 = getelementptr inbounds i32* %A, i64 %add3
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[2*i + 5*n] = ...
;; ... = A[3*i + 2*n];
define void @symbolicsiv1(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%mul1 = mul i64 %n, 5
%add = add i64 %mul, %mul1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul2 = mul nsw i64 %i.03, 3
%mul3 = shl i64 %n, 1
%add4 = add i64 %mul2, %mul3
%arrayidx5 = getelementptr inbounds i32* %A, i64 %add4
%0 = load i32* %arrayidx5, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[2*i - n] = ...
;; ... = A[-i + 2*n];
define void @symbolicsiv2(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = shl nsw i64 %i.03, 1
%sub = sub i64 %mul, %n
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%mul2 = shl i64 %n, 1
%add = sub i64 %mul2, %i.03
%arrayidx3 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[-2*i + n + 1] = ...
;; ... = A[i - 2*n];
define void @symbolicsiv3(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -2
%add = add i64 %mul, %n
%add1 = add i64 %add, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %add1
store i32 %conv, i32* %arrayidx, align 4
%mul2 = shl i64 %n, 1
%sub = sub i64 %i.03, %mul2
%arrayidx3 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[-2*i + 3*n] = ...
;; ... = A[-i + n];
define void @symbolicsiv4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -2
%mul1 = mul i64 %n, 3
%add = add i64 %mul, %mul1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%add2 = sub i64 %n, %i.03
%arrayidx3 = getelementptr inbounds i32* %A, i64 %add2
%0 = load i32* %arrayidx3, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long int i = 0; i < n; i++)
;; A[-2*i - 2*n] = ...
;; ... = A[-i - n];
define void @symbolicsiv5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul nsw i64 %i.03, -2
%mul1 = shl i64 %n, 1
%sub = sub i64 %mul, %mul1
%arrayidx = getelementptr inbounds i32* %A, i64 %sub
store i32 %conv, i32* %arrayidx, align 4
%sub2 = sub nsw i64 0, %i.03
%sub3 = sub i64 %sub2, %n
%arrayidx4 = getelementptr inbounds i32* %A, i64 %sub3
%0 = load i32* %arrayidx4, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; why doesn't SCEV package understand that n >= 0?
;;void weaktest(int *A, int *B, long unsigned n)
;; for (long unsigned i = 0; i < n; i++)
;; A[i + n + 1] = ...
;; ... = A[-i];
define void @weaktest(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%add = add i64 %i.03, %n
%add1 = add i64 %add, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %add1
store i32 %conv, i32* %arrayidx, align 4
%sub = sub i64 0, %i.03
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [*|<] splitable!
; CHECK: da analyze - split level = 1, iteration = ((0 smax (-1 + (-1 * %n))) /u 2)!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; void symbolicsiv6(int *A, int *B, long unsigned n, long unsigned N, long unsigned M) {
;; for (long int i = 0; i < n; i++) {
;; A[4*N*i + M] = i;
;; *B++ = A[4*N*i + 3*M + 1];
define void @symbolicsiv6(i32* %A, i32* %B, i64 %n, i64 %N, i64 %M) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body.preheader
for.body.preheader: ; preds = %entry
br label %for.body
for.body: ; preds = %for.body.preheader, %for.body
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %for.body.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %for.body.preheader ]
%conv = trunc i64 %i.03 to i32
%mul = shl i64 %N, 2
%mul1 = mul i64 %mul, %i.03
%add = add i64 %mul1, %M
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul2 = shl i64 %N, 2
%mul3 = mul i64 %mul2, %i.03
%mul4 = mul i64 %M, 3
%add5 = add i64 %mul3, %mul4
%add6 = add i64 %add5, 1
%arrayidx7 = getelementptr inbounds i32* %A, i64 %add6
%0 = load i32* %arrayidx7, align 4
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
; CHECK: da analyze - none!
store i32 %0, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%exitcond = icmp ne i64 %inc, %n
br i1 %exitcond, label %for.body, label %for.end.loopexit
for.end.loopexit: ; preds = %for.body
br label %for.end
for.end: ; preds = %for.end.loopexit, %entry
ret void
}
;; void symbolicsiv7(int *A, int *B, long unsigned n, long unsigned N, long unsigned M) {
;; for (long int i = 0; i < n; i++) {
;; A[2*N*i + M] = i;
;; *B++ = A[2*N*i - 3*M + 2];
define void @symbolicsiv7(i32* %A, i32* %B, i64 %n, i64 %N, i64 %M) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body.preheader
for.body.preheader: ; preds = %entry
br label %for.body
for.body: ; preds = %for.body.preheader, %for.body
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %for.body.preheader ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %for.body.preheader ]
%conv = trunc i64 %i.03 to i32
%mul = shl i64 %N, 1
%mul1 = mul i64 %mul, %i.03
%add = add i64 %mul1, %M
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul2 = shl i64 %N, 1
%mul3 = mul i64 %mul2, %i.03
%0 = mul i64 %M, -3
%sub = add i64 %mul3, %0
%add5 = add i64 %sub, 2
%arrayidx6 = getelementptr inbounds i32* %A, i64 %add5
%1 = load i32* %arrayidx6, align 4
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
; CHECK: da analyze - flow [<>]!
store i32 %1, i32* %B.addr.02, align 4
%inc = add nsw i64 %i.03, 1
%exitcond = icmp ne i64 %inc, %n
br i1 %exitcond, label %for.body, label %for.end.loopexit
for.end.loopexit: ; preds = %for.body
br label %for.end
for.end: ; preds = %for.end.loopexit, %entry
ret void
}

220
llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll Normal file
View File

@ -0,0 +1,220 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'WeakCrossingSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long unsigned i = 0; i < n; i++)
;; A[1 + n*i] = ...
;; ... = A[1 - n*i];
define void @weakcrossing0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul i64 %i.03, %n
%add = add i64 %mul, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%mul1 = mul i64 %i.03, %n
%sub = sub i64 1, %mul1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [0|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[n + i] = ...
;; ... = A[1 + n - i];
define void @weakcrossing1(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%add = add i64 %i.03, %n
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%add1 = add i64 %n, 1
%sub = sub i64 %add1, %i.03
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - flow [<>] splitable!
; CHECK: da analyze - split level = 1, iteration = 0!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 3; i++)
;; A[i] = ...
;; ... = A[6 - i];
define void @weakcrossing2(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 %i.02
store i32 %conv, i32* %arrayidx, align 4
%sub = sub i64 6, %i.02
%arrayidx1 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 3
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 4; i++)
;; A[i] = ...
;; ... = A[6 - i];
define void @weakcrossing3(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 %i.02
store i32 %conv, i32* %arrayidx, align 4
%sub = sub i64 6, %i.02
%arrayidx1 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [0|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 4
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 10; i++)
;; A[i] = ...
;; ... = A[-6 - i];
define void @weakcrossing4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 %i.02
store i32 %conv, i32* %arrayidx, align 4
%sub = sub i64 -6, %i.02
%arrayidx1 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 10
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[3*i] = ...
;; ... = A[5 - 3*i];
define void @weakcrossing5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul i64 %i.03, 3
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%0 = mul i64 %i.03, -3
%sub = add i64 %0, 5
%arrayidx2 = getelementptr inbounds i32* %A, i64 %sub
%1 = load i32* %arrayidx2, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %1, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 4; i++)
;; A[i] = ...
;; ... = A[5 - i];
define void @weakcrossing6(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 %i.02
store i32 %conv, i32* %arrayidx, align 4
%sub = sub i64 5, %i.02
%arrayidx1 = getelementptr inbounds i32* %A, i64 %sub
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [<>] splitable!
; CHECK: da analyze - split level = 1, iteration = 2!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 4
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}

212
llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll Normal file
View File

@ -0,0 +1,212 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'WeakZeroDstSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long unsigned i = 0; i < 30; i++)
;; A[2*i + 10] = ...
;; ... = A[10];
define void @weakzerodst0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%add = add i64 %mul, 10
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [p<=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 30
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[n*i + 10] = ...
;; ... = A[10];
define void @weakzerodst1(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul i64 %i.03, %n
%add = add i64 %mul, 10
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [p<=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 5; i++)
;; A[2*i] = ...
;; ... = A[10];
define void @weakzerodst2(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 5
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 6; i++)
;; A[2*i] = ...
;; ... = A[10];
define void @weakzerodst3(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [=>p|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 6
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 7; i++)
;; A[2*i] = ...
;; ... = A[10];
define void @weakzerodst4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 7
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 7; i++)
;; A[2*i] = ...
;; ... = A[-10];
define void @weakzerodst5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%mul = shl i64 %i.02, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 -10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 7
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[3*i] = ...
;; ... = A[10];
define void @weakzerodst6(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%mul = mul i64 %i.03, 3
%arrayidx = getelementptr inbounds i32* %A, i64 %mul
store i32 %conv, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 10
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}

212
llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll Normal file
View File

@ -0,0 +1,212 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'WeakZeroSrcSIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; for (long unsigned i = 0; i < 30; i++)
;; A[10] = ...
;; ... = A[2*i + 10];
define void @weakzerosrc0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%add = add i64 %mul, 10
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [p<=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 30
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[10] = ...
;; ... = A[n*i + 10];
define void @weakzerosrc1(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = mul i64 %i.03, %n
%add = add i64 %mul, 10
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [p<=|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}
;; for (long unsigned i = 0; i < 5; i++)
;; A[10] = ...
;; ... = A[2*i];
define void @weakzerosrc2(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%arrayidx1 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 5
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 6; i++)
;; A[10] = ...
;; ... = A[2*i];
define void @weakzerosrc3(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%arrayidx1 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [=>p|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 6
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 7; i++)
;; A[10] = ...
;; ... = A[2*i];
define void @weakzerosrc4(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%arrayidx1 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow [*|<]!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 7
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < 7; i++)
;; A[-10] = ...
;; ... = A[2*i];
define void @weakzerosrc5(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
br label %for.body
for.body: ; preds = %for.body, %entry
%i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
%B.addr.01 = phi i32* [ %B, %entry ], [ %incdec.ptr, %for.body ]
%conv = trunc i64 %i.02 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 -10
store i32 %conv, i32* %arrayidx, align 4
%mul = shl i64 %i.02, 1
%arrayidx1 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.01, i64 1
store i32 %0, i32* %B.addr.01, align 4
%inc = add i64 %i.02, 1
%cmp = icmp ult i64 %inc, 7
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body
ret void
}
;; for (long unsigned i = 0; i < n; i++)
;; A[10] = ...
;; ... = A[3*i];
define void @weakzerosrc6(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%cmp1 = icmp eq i64 %n, 0
br i1 %cmp1, label %for.end, label %for.body
for.body: ; preds = %for.body, %entry
%i.03 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
%B.addr.02 = phi i32* [ %incdec.ptr, %for.body ], [ %B, %entry ]
%conv = trunc i64 %i.03 to i32
%arrayidx = getelementptr inbounds i32* %A, i64 10
store i32 %conv, i32* %arrayidx, align 4
%mul = mul i64 %i.03, 3
%arrayidx1 = getelementptr inbounds i32* %A, i64 %mul
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
%incdec.ptr = getelementptr inbounds i32* %B.addr.02, i64 1
store i32 %0, i32* %B.addr.02, align 4
%inc = add i64 %i.03, 1
%cmp = icmp ult i64 %inc, %n
br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry
ret void
}

53
llvm/test/Analysis/DependenceAnalysis/ZIV.ll Normal file
View File

@ -0,0 +1,53 @@
; RUN: opt < %s -analyze -basicaa -da | FileCheck %s
; ModuleID = 'ZIV.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
;; A[n + 1] = ...
;; ... = A[1 + n];
define void @z0(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%add = add i64 %n, 1
%arrayidx = getelementptr inbounds i32* %A, i64 %add
store i32 0, i32* %arrayidx, align 4
%add1 = add i64 %n, 1
%arrayidx2 = getelementptr inbounds i32* %A, i64 %add1
%0 = load i32* %arrayidx2, align 4
; CHECK: da analyze - consistent flow!
store i32 %0, i32* %B, align 4
ret void
}
;; A[n] = ...
;; ... = A[n + 1];
define void @z1(i32* %A, i32* %B, i64 %n) nounwind uwtable ssp {
entry:
%arrayidx = getelementptr inbounds i32* %A, i64 %n
store i32 0, i32* %arrayidx, align 4
%add = add i64 %n, 1
%arrayidx1 = getelementptr inbounds i32* %A, i64 %add
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - none!
store i32 %0, i32* %B, align 4
ret void
}
;; A[n] = ...
;; ... = A[m];
define void @z2(i32* %A, i32* %B, i64 %n, i64 %m) nounwind uwtable ssp {
entry:
%arrayidx = getelementptr inbounds i32* %A, i64 %n
store i32 0, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds i32* %A, i64 %m
%0 = load i32* %arrayidx1, align 4
; CHECK: da analyze - flow!
store i32 %0, i32* %B, align 4
ret void
}

1
llvm/test/Analysis/DependenceAnalysis/lit.local.cfg Normal file
View File

@ -0,0 +1 @@
config.suffixes = ['.ll']