llvm/polly/lib/Support/SCEVValidator.cpp

#include "polly/Support/SCEVValidator.h"
#include "polly/ScopDetection.h"
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Support/Debug.h"

usingnamespacellvm;
usingnamespacepolly;

#include "polly/Support/PollyDebug.h"
#define DEBUG_TYPE …

namespace SCEVType {
/// The type of a SCEV
///
/// To check for the validity of a SCEV we assign to each SCEV a type. The
/// possible types are INT, PARAM, IV and INVALID. The order of the types is
/// important. The subexpressions of SCEV with a type X can only have a type
/// that is smaller or equal than X.
enum TYPE { … };
} // namespace SCEVType

/// The result the validator returns for a SCEV expression.
class ValidatorResult final { … };

raw_ostream &operator<<(raw_ostream &OS, ValidatorResult &VR) { … }

/// Check if a SCEV is valid in a SCoP.
class SCEVValidator : public SCEVVisitor<SCEVValidator, ValidatorResult> { … };

/// Check whether a SCEV refers to an SSA name defined inside a region.
class SCEVInRegionDependences final { … };

/// Find all loops referenced in SCEVAddRecExprs.
class SCEVFindLoops final { … };

void polly::findLoops(const SCEV *Expr, SetVector<const Loop *> &Loops) { … }

/// Find all values referenced in SCEVUnknowns.
class SCEVFindValues final { … };

void polly::findValues(const SCEV *Expr, ScalarEvolution &SE,
                       SetVector<Value *> &Values) { … }

bool polly::hasScalarDepsInsideRegion(const SCEV *Expr, const Region *R,
                                      llvm::Loop *Scope, bool AllowLoops,
                                      const InvariantLoadsSetTy &ILS) { … }

bool polly::isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
                         ScalarEvolution &SE, InvariantLoadsSetTy *ILS) { … }

static bool isAffineExpr(Value *V, const Region *R, Loop *Scope,
                         ScalarEvolution &SE, ParameterSetTy &Params) { … }

bool polly::isAffineConstraint(Value *V, const Region *R, Loop *Scope,
                               ScalarEvolution &SE, ParameterSetTy &Params,
                               bool OrExpr) { … }

ParameterSetTy polly::getParamsInAffineExpr(const Region *R, Loop *Scope,
                                            const SCEV *Expr,
                                            ScalarEvolution &SE) { … }

std::pair<const SCEVConstant *, const SCEV *>
polly::extractConstantFactor(const SCEV *S, ScalarEvolution &SE) { … }

const SCEV *polly::tryForwardThroughPHI(const SCEV *Expr, Region &R,
                                        ScalarEvolution &SE,
                                        ScopDetection *SD) { … }

Value *polly::getUniqueNonErrorValue(PHINode *PHI, Region *R,
                                     ScopDetection *SD) { … }