This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH] Fix PR36826
- From: Richard Guenther <rguenther at suse dot de>
- To: gcc-patches at gcc dot gnu dot org
- Cc: Daniel Berlin <dberlin at dberlin dot org>, Diego Novillo <dnovillo at google dot com>
- Date: Mon, 21 Jul 2008 13:14:52 +0200 (CEST)
- Subject: Re: [PATCH] Fix PR36826
- References: <alpine.LNX.1.10.0807151440320.4328@zhemvz.fhfr.qr>
On Tue, 15 Jul 2008, Richard Guenther wrote:
>
> This fixes PR36826 where we ICE in fold_convert trying to convert
> a float to a bool. This happens because we replace a_1 < 0.0 with
> a_1 which happens because the LHS of a_1 < 0.0 has no uses and thus
> we don't value-number it, but still initially the VN_INFO for that
> SSA_NAME got the value_id 0. Unsurprisingly we just use another
> available (unused) SSA_NAME with value_id 0 during replacement.
>
> After trying to get value-numbering even unused SSA_NAMEs right
> (and failing miserably due to dead SSA_NAMEs and dead stmts in
> the list of ssa_name()s) I just decided to never eliminate on
> dead statements. (Thus, I didn't try to do something clever
> with value_id 0 either)
>
> Eventually avail computation is broken by the same fact, so Danny,
> any help appreciated with this value_id 0 thing ;)
>
> Bootstrap & regtest running on x86_64-unknown-linux-gnu.
It turns out that this also breaks Ada on the tuples branch, so
I installed the patch there.
Richard.
>
> Richard.
>
> 2008-07-15 Richard Guenther <rguenther@suse.de>
>
> PR tree-optimization/36826
> * tree-ssa-pre.c (eliminate): Do not eliminate in unused
> statements.
>
> * g++.dg/torture/pr36826.C: New testcase.
>
> Index: tree-ssa-pre.c
> ===================================================================
> *** tree-ssa-pre.c (revision 137835)
> --- tree-ssa-pre.c (working copy)
> *************** eliminate (void)
> *** 3808,3814 ****
> && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME
> && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) != SSA_NAME
> && !is_gimple_min_invariant (GIMPLE_STMT_OPERAND (stmt, 1))
> ! && !stmt_ann (stmt)->has_volatile_ops)
> {
> tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
> tree *rhs_p = &GIMPLE_STMT_OPERAND (stmt, 1);
> --- 3808,3815 ----
> && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME
> && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) != SSA_NAME
> && !is_gimple_min_invariant (GIMPLE_STMT_OPERAND (stmt, 1))
> ! && !stmt_ann (stmt)->has_volatile_ops
> ! && !has_zero_uses (GIMPLE_STMT_OPERAND (stmt, 0)))
> {
> tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
> tree *rhs_p = &GIMPLE_STMT_OPERAND (stmt, 1);
> Index: testsuite/g++.dg/torture/pr36826.C
> ===================================================================
> *** testsuite/g++.dg/torture/pr36826.C (revision 0)
> --- testsuite/g++.dg/torture/pr36826.C (revision 0)
> ***************
> *** 0 ****
> --- 1,166 ----
> + template <class T> T CoinMax(register const T x1, register const T x2);
> + template <class T> T CoinMin(register const T x1, register const T x2);
> + class CoinIndexedVector;
> + class ClpModel {
> + protected:
> + double objectiveScale_;
> + double rhsScale_;
> + int numberRows_;
> + int numberColumns_;
> + double * rowActivity_;
> + double * columnActivity_;
> + double * dual_;
> + double * reducedCost_;
> + double* rowLower_;
> + double* rowUpper_;
> + double * rowObjective_;
> + double * columnLower_;
> + double * columnUpper_;
> + double * rowScale_;
> + double * columnScale_;
> + double * inverseRowScale_;
> + double * inverseColumnScale_;
> + int problemStatus_;
> + int secondaryStatus_;
> + };
> + class ClpSimplex : public ClpModel {
> + void deleteRim(int getRidOfFactorizationData=2);
> + double upperOut_;
> + double dualTolerance_;
> + double primalTolerance_;
> + double * rowLowerWork_;
> + double * columnLowerWork_;
> + double * rowUpperWork_;
> + double * columnUpperWork_;
> + double * rowObjectiveWork_;
> + CoinIndexedVector * columnArray_[6];
> + double * reducedCostWork_;
> + double * rowActivityWork_;
> + double * columnActivityWork_;
> + ClpSimplex * auxiliaryModel_;
> + };
> + class CoinIndexedVector {
> + public:
> + void clear();
> + };
> + void ClpSimplex::deleteRim(int getRidOfFactorizationData)
> + {
> + int numberRows=numberRows_;
> + int numberColumns=numberColumns_;
> + int i;
> + int numberPrimalScaled=0;
> + int numberPrimalUnscaled=0;
> + int numberDualScaled=0;
> + int numberDualUnscaled=0;
> + double scaleC = 1.0/objectiveScale_;
> + double scaleR = 1.0/rhsScale_;
> + if (!inverseColumnScale_) {
> + for (i=0; i<numberColumns; i++)
> + {
> + double scaleFactor = columnScale_[i];
> + double valueScaled = columnActivityWork_[i];
> + double lowerScaled = columnLowerWork_[i];
> + double upperScaled = columnUpperWork_[i];
> + if (lowerScaled>-1.0e20||upperScaled<1.0e20) {
> + if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_)
> + numberPrimalScaled++;
> + else
> + upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));
> + }
> + columnActivity_[i] = valueScaled*scaleFactor*scaleR;
> + double value = columnActivity_[i];
> + if (value<columnLower_[i]-primalTolerance_)
> + numberPrimalUnscaled++;
> + else if (value>columnUpper_[i]+primalTolerance_)
> + numberPrimalUnscaled++;
> + double valueScaledDual = reducedCostWork_[i];
> + if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)
> + numberDualScaled++;
> + if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)
> + numberDualScaled++;
> + reducedCost_[i] = (valueScaledDual*scaleC)/scaleFactor;
> + double valueDual = reducedCost_[i];
> + if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_)
> + numberDualUnscaled++;
> + if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)
> + numberDualUnscaled++;
> + }
> + for (i=0; i<numberRows; i++)
> + {
> + double scaleFactor = rowScale_[i];
> + double valueScaled = rowActivityWork_[i];
> + double lowerScaled = rowLowerWork_[i];
> + double upperScaled = rowUpperWork_[i];
> + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
> + rowActivity_[i] = (valueScaled*scaleR)/scaleFactor;
> + double value = rowActivity_[i];
> + if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++;
> + else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
> + double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
> + ;
> + if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
> + if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
> + dual_[i] *= scaleFactor*scaleC;
> + double valueDual = dual_[i];
> + if (rowObjective_) valueDual += rowObjective_[i];
> + if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
> + if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
> + }
> + }
> + const double * inverseScale = inverseColumnScale_;
> + for (i=0; i<numberColumns; i++)
> + {
> + double scaleFactor = columnScale_[i];
> + double valueScaled = columnActivityWork_[i];
> + double lowerScaled = columnLowerWork_[i];
> + double upperScaled = columnUpperWork_[i];
> + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
> + columnActivity_[i] = valueScaled*scaleFactor*scaleR;
> + double value = columnActivity_[i];
> + if (value<columnLower_[i]-primalTolerance_) numberPrimalUnscaled++;
> + else if (value>columnUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
> + double valueScaledDual = reducedCostWork_[i];
> + if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
> + if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
> + reducedCost_[i] = (valueScaledDual*scaleC)*inverseScale[i];
> + double valueDual = reducedCost_[i];
> + if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
> + if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
> + }
> + inverseScale = inverseRowScale_;
> + for (i=0; i<numberRows; i++)
> + {
> + double scaleFactor = rowScale_[i];
> + double valueScaled = rowActivityWork_[i];
> + double lowerScaled = rowLowerWork_[i];
> + double upperScaled = rowUpperWork_[i];
> + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
> + rowActivity_[i] = (valueScaled*scaleR)*inverseScale[i];
> + double value = rowActivity_[i];
> + if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++;
> + else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
> + double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
> + ;
> + if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
> + if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
> + dual_[i] *= scaleFactor*scaleC;
> + double valueDual = dual_[i];
> + if (rowObjective_) valueDual += rowObjective_[i];
> + if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
> + if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
> + }
> + if (numberPrimalUnscaled) {
> + if (numberDualUnscaled)
> + secondaryStatus_=4;
> + else
> + secondaryStatus_=2;
> + }
> + if (numberDualUnscaled)
> + secondaryStatus_=3;
> + int iRow,iColumn;
> + for (iRow=0; iRow<4; iRow++)
> + ;
> + for (iColumn=0; iColumn<2; iColumn++)
> + if (columnArray_[iColumn])
> + columnArray_[iColumn]->clear();
> + }
>
--
Richard Guenther <rguenther@suse.de>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex