[llvm-commits] [polly] r143958 - /polly/trunk/lib/Analysis/ScopDetection.cpp
Sebastian Pop
spop at codeaurora.org
Tue Nov 15 21:04:59 PST 2011
On Mon, Nov 7, 2011 at 6:58 AM, Tobias Grosser
<grosser at fim.uni-passau.de> wrote:
> Author: grosser
> Date: Mon Nov 7 06:58:41 2011
> New Revision: 143958
>
> URL: http://llvm.org/viewvc/llvm-project?rev=143958&view=rev
> Log:
> ScopDetection: Add ValidatorResult class
>
> Modified:
> polly/trunk/lib/Analysis/ScopDetection.cpp
>
> Modified: polly/trunk/lib/Analysis/ScopDetection.cpp
> URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopDetection.cpp?rev=143958&r1=143957&r2=143958&view=diff
> ==============================================================================
> --- polly/trunk/lib/Analysis/ScopDetection.cpp (original)
> +++ polly/trunk/lib/Analysis/ScopDetection.cpp Mon Nov 7 06:58:41 2011
> @@ -113,8 +113,22 @@
> enum TYPE {INT, PARAM, IV, INVALID};
> }
>
> +struct ValidatorResult {
> + SCEVType::TYPE type;
> +
> + ValidatorResult() : type(SCEVType::INVALID) {};
> +
> + ValidatorResult(const ValidatorResult &vres) {
> + type = vres.type;
> + };
> +
> + ValidatorResult(SCEVType::TYPE type) : type(type) {};
> +
> +};
> +
> /// Check if a SCEV is valid in a SCoP.
> -struct SCEVValidator : public SCEVVisitor<SCEVValidator, SCEVType::TYPE> {
> +struct SCEVValidator
> + : public SCEVVisitor<SCEVValidator, struct ValidatorResult> {
> private:
> const Region *R;
> ScalarEvolution &SE;
> @@ -131,42 +145,44 @@
> *BaseAddress = NULL;
>
> SCEVValidator Validator(R, SE, BaseAddress);
> - return Validator.visit(Scev) != SCEVType::INVALID;
> + ValidatorResult Result = Validator.visit(Scev);
> +
> + return Result.type != SCEVType::INVALID;
> }
>
> SCEVValidator(const Region *R, ScalarEvolution &SE,
> Value **BaseAddress) : R(R), SE(SE),
> BaseAddress(BaseAddress) {};
>
> - SCEVType::TYPE visitConstant(const SCEVConstant *Constant) {
> - return SCEVType::INT;
> + struct ValidatorResult visitConstant(const SCEVConstant *Constant) {
> + return ValidatorResult(SCEVType::INT);
> }
>
> - SCEVType::TYPE visitTruncateExpr(const SCEVTruncateExpr* Expr) {
> - SCEVType::TYPE Op = visit(Expr->getOperand());
> + struct ValidatorResult visitTruncateExpr(const SCEVTruncateExpr* Expr) {
> + ValidatorResult Op = visit(Expr->getOperand());
>
> // We currently do not represent a truncate expression as an affine
> // expression. If it is constant during Scop execution, we treat it as a
> // parameter, otherwise we bail out.
> - if (Op == SCEVType::INT || Op == SCEVType::PARAM)
> - return SCEVType::PARAM;
> + if (Op.type == SCEVType::INT || Op.type == SCEVType::PARAM)
> + return ValidatorResult(SCEVType::PARAM);
>
> - return SCEVType::INVALID;
> + return ValidatorResult (SCEVType::INVALID);
> }
>
> - SCEVType::TYPE visitZeroExtendExpr(const SCEVZeroExtendExpr * Expr) {
> - SCEVType::TYPE Op = visit(Expr->getOperand());
> + struct ValidatorResult visitZeroExtendExpr(const SCEVZeroExtendExpr * Expr) {
> + ValidatorResult Op = visit(Expr->getOperand());
>
> // We currently do not represent a zero extend expression as an affine
> // expression. If it is constant during Scop execution, we treat it as a
> // parameter, otherwise we bail out.
> - if (Op == SCEVType::INT || Op == SCEVType::PARAM)
> - return SCEVType::PARAM;
> + if (Op.type == SCEVType::INT || Op.type == SCEVType::PARAM)
> + return ValidatorResult (SCEVType::PARAM);
>
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
> }
>
> - SCEVType::TYPE visitSignExtendExpr(const SCEVSignExtendExpr* Expr) {
> + struct ValidatorResult visitSignExtendExpr(const SCEVSignExtendExpr* Expr) {
> // We currently allow only signed SCEV expressions. In the case of a
> // signed value, a sign extend is a noop.
> //
> @@ -174,126 +190,130 @@
> return visit(Expr->getOperand());
> }
>
> - SCEVType::TYPE visitAddExpr(const SCEVAddExpr* Expr) {
> - SCEVType::TYPE Return = SCEVType::INT;
> + struct ValidatorResult visitAddExpr(const SCEVAddExpr* Expr) {
> + ValidatorResult Return(SCEVType::INT);
>
> for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
> - SCEVType::TYPE OpType = visit(Expr->getOperand(i));
> + ValidatorResult Op = visit(Expr->getOperand(i));
>
> - if (OpType == SCEVType::INVALID)
> - return SCEVType::INVALID;
> + if (Op.type == SCEVType::INVALID)
> + return ValidatorResult(SCEVType::INVALID);
>
> - Return = std::max(Return, OpType);
> + Return.type = std::max(Return.type, Op.type);
> }
>
> // TODO: Check for NSW and NUW.
> return Return;
> }
>
> - SCEVType::TYPE visitMulExpr(const SCEVMulExpr* Expr) {
> - SCEVType::TYPE Return = SCEVType::INT;
> + struct ValidatorResult visitMulExpr(const SCEVMulExpr* Expr) {
> + ValidatorResult Return(SCEVType::INT);
>
> for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
> - SCEVType::TYPE OpType = visit(Expr->getOperand(i));
> + ValidatorResult Op = visit(Expr->getOperand(i));
>
> - if (OpType == SCEVType::INT)
> + if (Op.type == SCEVType::INT)
> continue;
>
> - if (OpType == SCEVType::INVALID || Return != SCEVType::INT)
> - return SCEVType::INVALID;
> + if (Op.type == SCEVType::INVALID || Return.type != SCEVType::INT)
> + return ValidatorResult(SCEVType::INVALID);
>
> - Return = OpType;
> + Return.type = Op.type;
> }
>
> // TODO: Check for NSW and NUW.
> return Return;
> }
>
> - SCEVType::TYPE visitUDivExpr(const SCEVUDivExpr* Expr) {
> - SCEVType::TYPE LHS = visit(Expr->getLHS());
> - SCEVType::TYPE RHS = visit(Expr->getRHS());
> + struct ValidatorResult visitUDivExpr(const SCEVUDivExpr* Expr) {
> + ValidatorResult LHS = visit(Expr->getLHS());
> + ValidatorResult RHS = visit(Expr->getRHS());
>
> // We currently do not represent a unsigned devision as an affine
> // expression. If the division is constant during Scop execution we treat it
> // as a parameter, otherwise we bail out.
> - if (LHS == SCEVType::INT || LHS == SCEVType::PARAM ||
> - RHS == SCEVType::INT || RHS == SCEVType::PARAM)
> - return SCEVType::PARAM;
> + if (LHS.type == SCEVType::INT || LHS.type == SCEVType::PARAM ||
> + RHS.type == SCEVType::INT || RHS.type == SCEVType::PARAM)
> + return ValidatorResult(SCEVType::PARAM);
>
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
> }
>
> - SCEVType::TYPE visitAddRecExpr(const SCEVAddRecExpr* Expr) {
> + struct ValidatorResult visitAddRecExpr(const SCEVAddRecExpr* Expr) {
> if (!Expr->isAffine())
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
>
> - SCEVType::TYPE Start = visit(Expr->getStart());
> - SCEVType::TYPE Recurrence = visit(Expr->getStepRecurrence(SE));
> + ValidatorResult Start = visit(Expr->getStart());
> + ValidatorResult Recurrence = visit(Expr->getStepRecurrence(SE));
> +
> + if (Start.type == SCEVType::INVALID ||
> + Recurrence.type == SCEVType::INVALID ||
> + Recurrence.type == SCEVType::IV)
> + return ValidatorResult(SCEVType::INVALID);
>
> - if (Start == SCEVType::INVALID ||
> - Recurrence == SCEVType::INVALID ||
> - Recurrence == SCEVType::IV)
> - return SCEVType::INVALID;
>
> if (!R->contains(Expr->getLoop())) {
> - if (Start == SCEVType::IV)
> - return SCEVType::INVALID;
> + if (Start.type == SCEVType::IV)
> + return ValidatorResult(SCEVType::INVALID);
> else
> - return SCEVType::PARAM;
> + return ValidatorResult(SCEVType::PARAM);
> }
>
> - if (Recurrence != SCEVType::INT)
> - return SCEVType::INVALID;
> + if (Recurrence.type != SCEVType::INT)
> + return ValidatorResult(SCEVType::INVALID);
>
> - return SCEVType::IV;
> + return ValidatorResult(SCEVType::IV);
> }
>
> - SCEVType::TYPE visitSMaxExpr(const SCEVSMaxExpr* Expr) {
> - SCEVType::TYPE Return = SCEVType::INT;
> + struct ValidatorResult visitSMaxExpr(const SCEVSMaxExpr* Expr) {
> + ValidatorResult Return(SCEVType::INT);
>
> for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
> - SCEVType::TYPE OpType = visit(Expr->getOperand(i));
> + ValidatorResult Op = visit(Expr->getOperand(i));
>
> - if (OpType == SCEVType::INVALID)
> - return SCEVType::INVALID;
> + if (Op.type == SCEVType::INVALID)
> + return ValidatorResult(SCEVType::INVALID);
>
> - Return = std::max(Return, OpType);
> + Return.type = std::max(Return.type, Op.type);
> }
>
> return Return;
> }
>
> - SCEVType::TYPE visitUMaxExpr(const SCEVUMaxExpr* Expr) {
> + struct ValidatorResult visitUMaxExpr(const SCEVUMaxExpr* Expr) {
> // We do not support unsigned operations. If 'Expr' is constant during Scop
> // execution we treat this as a parameter, otherwise we bail out.
> for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
> - SCEVType::TYPE OpType = visit(Expr->getOperand(i));
> + ValidatorResult Op = visit(Expr->getOperand(i));
>
> - if (OpType != SCEVType::INT && OpType != SCEVType::PARAM)
> - return SCEVType::INVALID;
> + if (Op.type != SCEVType::INT && Op.type != SCEVType::PARAM)
> + return ValidatorResult(SCEVType::INVALID);
> }
>
> - return SCEVType::PARAM;
> + return ValidatorResult(SCEVType::PARAM);
> }
>
> - SCEVType::TYPE visitUnknown(const SCEVUnknown* Expr) {
> + ValidatorResult visitUnknown(const SCEVUnknown* Expr) {
> Value *V = Expr->getValue();
>
> if (isa<UndefValue>(V))
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
>
> if (BaseAddress) {
> if (*BaseAddress)
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
> else
> *BaseAddress = V;
> }
>
> if (Instruction *I = dyn_cast<Instruction>(Expr->getValue()))
> if (R->contains(I))
> - return SCEVType::INVALID;
> + return ValidatorResult(SCEVType::INVALID);
>
> - return SCEVType::PARAM;
> + if (BaseAddress)
> + return ValidatorResult(SCEVType::PARAM);
> + else
> + return ValidatorResult(SCEVType::PARAM);
This change looks strange: why are you returning the same thing in
both branches?
> }
> };
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
--
Sebastian Pop
--
Qualcomm Innovation Center, Inc is a member of Code Aurora Forum
More information about the llvm-commits
mailing list