Attachment #12035 for bug #28632

View | Details | Return to bug 28632 | Differences between
Collapse All | Expand All




   are not using wrapping arithmetic, then adjust the result to be
   -INF or +INF depending on CODE, VAL1 and VAL2.  */

static tree
vrp_int_const_binop (enum tree_code code, tree val1, tree val2)
{
  tree res;

}


/* Example: let's say operand has:
max = 01010010101001010010
min = 01010010100000010010
We can infer that these bits will be set
in any possible value of the operand:
      01010010100000000000
*/
static tree
find_bits1 (tree min, tree max)
{
  tree xored, shift, always1;
  int xor_hi;

  always1 = vrp_int_const_binop(BIT_AND_EXPR, min, max);
  xored = vrp_int_const_binop(BIT_XOR_EXPR, min, max);
  xor_hi = tree_floor_log2(xored);
  if(xor_hi >= 0) /* if min!=max */
    {
      shift = build_int_cst (NULL_TREE, xor_hi+1);
      always1 = vrp_int_const_binop(RSHIFT_EXPR, always1, shift);
      always1 = vrp_int_const_binop(LSHIFT_EXPR, always1, shift);
    }
  return always1;
}
/* Example: let's say operand has:
max = 01010010101001010010
min = 01010010100000010010
We can infer that these bits will be unset
in any possible value of the operand:
      01010010101111111111
*/
static tree
find_bits0 (tree min, tree max)
{
  tree xored, always0, tmp;
  int xor_hi;

  always0 = vrp_int_const_binop(BIT_IOR_EXPR, min, max);
  xored = vrp_int_const_binop(BIT_XOR_EXPR, min, max);
  xor_hi = tree_floor_log2(xored);
  if(xor_hi > 0) /* if min!=max and difference is not in lowest bit only */
    {
      tmp = build_int_cst (NULL_TREE, xor_hi);
      always0 = vrp_int_const_binop(RSHIFT_EXPR, always0, tmp);
      /* Too ugly for words */
      tmp = build_int_cst (NULL_TREE, 1);
      do
        {
          always0 = vrp_int_const_binop(LSHIFT_EXPR, always0, tmp);
          always0 = vrp_int_const_binop(PLUS_EXPR, always0, tmp);
          xor_hi--;
        }
      while(xor_hi);
    }
  return always0;
}

/* Extract range information from a binary expression EXPR based on
   the ranges of each of its operands and the expression code.  */


      && code != ROUND_DIV_EXPR
      && code != MIN_EXPR
      && code != MAX_EXPR
      && code != BIT_AND_EXPR
      && code != BIT_IOR_EXPR
      && code != TRUTH_ANDIF_EXPR
      && code != TRUTH_ORIF_EXPR
      && code != TRUTH_AND_EXPR

  else
    set_value_range_to_varying (&vr1);

  /* Bitwise ops */
  if (code == BIT_AND_EXPR)
    {
      if (vr0.type == VR_RANGE || vr1.type == VR_RANGE)
        {
          if(vr0.type == VR_RANGE)
            {
              if(vr1.type == VR_RANGE)
                {
                  tree always1_0, always1_1;
                  always1_0 = find_bits1(vr0.min, vr0.max);
                  always1_1 = find_bits1(vr1.min, vr1.max);
                  min = vrp_int_const_binop(BIT_AND_EXPR, always1_0, always1_1);
                  max = vrp_int_const_binop(MIN_EXPR, vr0.max, vr1.max);
                }
              else
                {
                  min = build_int_cst(TREE_TYPE(vr0.min), 0);
                  max = vr0.max;
                }
              set_value_range (vr, vr0.type, min, max, NULL);
            }
          else
            {
              min = build_int_cst(TREE_TYPE(vr1.min), 0);
              max = vr1.max;
              set_value_range (vr, vr1.type, min, max, NULL);
            }
          return;
        }
      set_value_range_to_varying (vr);
      return;
    }
  if (code == BIT_IOR_EXPR)
    {
      if (vr0.type == VR_RANGE || vr1.type == VR_RANGE)
        {
          if(vr0.type == VR_RANGE)
            {
              if(vr1.type == VR_RANGE)
                {
                  tree always0_0, always0_1;
                  always0_0 = find_bits0(vr0.min, vr0.max);
                  always0_1 = find_bits0(vr1.min, vr1.max);
                  min = vrp_int_const_binop(MAX_EXPR, vr0.min, vr1.min);
                  max = vrp_int_const_binop(BIT_IOR_EXPR, always0_0, always0_1);
                }
              else
                {
                  min = vr0.min;
                  max = TYPE_MAX_VALUE(TREE_TYPE(vr0.max));
                }
              set_value_range (vr, vr0.type, min, max, NULL);
            }
          else
            {
              min = vr1.min;
              max = TYPE_MAX_VALUE(TREE_TYPE(vr1.max));
              set_value_range (vr, vr1.type, min, max, NULL);
            }
          return;
        }
      set_value_range_to_varying (vr);
      return;
    }

  /* If either range is UNDEFINED, so is the result.  */
  if (vr0.type == VR_UNDEFINED || vr1.type == VR_UNDEFINED)
    {

  /* Refuse to operate on VARYING ranges, ranges of different kinds
     and symbolic ranges.  TODO, we may be able to derive anti-ranges
     in some cases.  */
  if (vr0.type != vr1.type
      || vr0.type == VR_VARYING
      || vr0.type != vr1.type
      || symbolic_range_p (&vr0)
      || symbolic_range_p (&vr1))
    {

Return to bug 28632

Lines 1086-1092 extract_range_from_ssa_name (value_range Link Here

(-)gcc-4.1.1/gcc/tree-vrp.c.orig (-4 / +128 lines)
1086	are not using wrapping arithmetic, then adjust the result to be	1086	are not using wrapping arithmetic, then adjust the result to be
1087	-INF or +INF depending on CODE, VAL1 and VAL2. */	1087	-INF or +INF depending on CODE, VAL1 and VAL2. */
1088		1088
1089	static inline tree	1089	static tree
1090	vrp_int_const_binop (enum tree_code code, tree val1, tree val2)	1090	vrp_int_const_binop (enum tree_code code, tree val1, tree val2)
1091	{	1091	{
1092	tree res;	1092	tree res;
Lines 1182-1187 vrp_int_const_binop (enum tree_code code Link Here
1182	}	1182	}
1183		1183
1184		1184
		1185	/* Example: let's say operand has:
		1186	max = 01010010101001010010
		1187	min = 01010010100000010010
		1188	We can infer that these bits will be set
		1189	in any possible value of the operand:
		1190	01010010100000000000
		1191	*/
		1192	static tree
		1193	find_bits1 (tree min, tree max)
		1194	{
		1195	tree xored, shift, always1;
		1196	int xor_hi;
		1197
		1198	always1 = vrp_int_const_binop(BIT_AND_EXPR, min, max);
		1199	xored = vrp_int_const_binop(BIT_XOR_EXPR, min, max);
		1200	xor_hi = tree_floor_log2(xored);
		1201	if(xor_hi >= 0) /* if min!=max */
		1202	{
		1203	shift = build_int_cst (NULL_TREE, xor_hi+1);
		1204	always1 = vrp_int_const_binop(RSHIFT_EXPR, always1, shift);
		1205	always1 = vrp_int_const_binop(LSHIFT_EXPR, always1, shift);
		1206	}
		1207	return always1;
		1208	}
		1209	/* Example: let's say operand has:
		1210	max = 01010010101001010010
		1211	min = 01010010100000010010
		1212	We can infer that these bits will be unset
		1213	in any possible value of the operand:
		1214	01010010101111111111
		1215	*/
		1216	static tree
		1217	find_bits0 (tree min, tree max)
		1218	{
		1219	tree xored, always0, tmp;
		1220	int xor_hi;
		1221
		1222	always0 = vrp_int_const_binop(BIT_IOR_EXPR, min, max);
		1223	xored = vrp_int_const_binop(BIT_XOR_EXPR, min, max);
		1224	xor_hi = tree_floor_log2(xored);
		1225	if(xor_hi > 0) /* if min!=max and difference is not in lowest bit only */
		1226	{
		1227	tmp = build_int_cst (NULL_TREE, xor_hi);
		1228	always0 = vrp_int_const_binop(RSHIFT_EXPR, always0, tmp);
		1229	/* Too ugly for words */
		1230	tmp = build_int_cst (NULL_TREE, 1);
		1231	do
		1232	{
		1233	always0 = vrp_int_const_binop(LSHIFT_EXPR, always0, tmp);
		1234	always0 = vrp_int_const_binop(PLUS_EXPR, always0, tmp);
		1235	xor_hi--;
		1236	}
		1237	while(xor_hi);
		1238	}
		1239	return always0;
		1240	}
		1241
1185	/* Extract range information from a binary expression EXPR based on	1242	/* Extract range information from a binary expression EXPR based on
1186	the ranges of each of its operands and the expression code. */	1243	the ranges of each of its operands and the expression code. */
1187		1244
Lines 1206-1211 extract_range_from_binary_expr (value_ra Link Here
1206	&& code != ROUND_DIV_EXPR	1263	&& code != ROUND_DIV_EXPR
1207	&& code != MIN_EXPR	1264	&& code != MIN_EXPR
1208	&& code != MAX_EXPR	1265	&& code != MAX_EXPR
		1266	&& code != BIT_AND_EXPR
		1267	&& code != BIT_IOR_EXPR
1209	&& code != TRUTH_ANDIF_EXPR	1268	&& code != TRUTH_ANDIF_EXPR
1210	&& code != TRUTH_ORIF_EXPR	1269	&& code != TRUTH_ORIF_EXPR
1211	&& code != TRUTH_AND_EXPR	1270	&& code != TRUTH_AND_EXPR
Lines 1234-1239 extract_range_from_binary_expr (value_ra Link Here
1234	else	1293	else
1235	set_value_range_to_varying (&vr1);	1294	set_value_range_to_varying (&vr1);
1236		1295
		1296	/* Bitwise ops */
		1297	if (code == BIT_AND_EXPR)
		1298	{
		1299	if (vr0.type == VR_RANGE \|\| vr1.type == VR_RANGE)
		1300	{
		1301	if(vr0.type == VR_RANGE)
		1302	{
		1303	if(vr1.type == VR_RANGE)
		1304	{
		1305	tree always1_0, always1_1;
		1306	always1_0 = find_bits1(vr0.min, vr0.max);
		1307	always1_1 = find_bits1(vr1.min, vr1.max);
		1308	min = vrp_int_const_binop(BIT_AND_EXPR, always1_0, always1_1);
		1309	max = vrp_int_const_binop(MIN_EXPR, vr0.max, vr1.max);
		1310	}
		1311	else
		1312	{
		1313	min = build_int_cst(TREE_TYPE(vr0.min), 0);
		1314	max = vr0.max;
		1315	}
		1316	set_value_range (vr, vr0.type, min, max, NULL);
		1317	}
		1318	else
		1319	{
		1320	min = build_int_cst(TREE_TYPE(vr1.min), 0);
		1321	max = vr1.max;
		1322	set_value_range (vr, vr1.type, min, max, NULL);
		1323	}
		1324	return;
		1325	}
		1326	set_value_range_to_varying (vr);
		1327	return;
		1328	}
		1329	if (code == BIT_IOR_EXPR)
		1330	{
		1331	if (vr0.type == VR_RANGE \|\| vr1.type == VR_RANGE)
		1332	{
		1333	if(vr0.type == VR_RANGE)
		1334	{
		1335	if(vr1.type == VR_RANGE)
		1336	{
		1337	tree always0_0, always0_1;
		1338	always0_0 = find_bits0(vr0.min, vr0.max);
		1339	always0_1 = find_bits0(vr1.min, vr1.max);
		1340	min = vrp_int_const_binop(MAX_EXPR, vr0.min, vr1.min);
		1341	max = vrp_int_const_binop(BIT_IOR_EXPR, always0_0, always0_1);
		1342	}
		1343	else
		1344	{
		1345	min = vr0.min;
		1346	max = TYPE_MAX_VALUE(TREE_TYPE(vr0.max));
		1347	}
		1348	set_value_range (vr, vr0.type, min, max, NULL);
		1349	}
		1350	else
		1351	{
		1352	min = vr1.min;
		1353	max = TYPE_MAX_VALUE(TREE_TYPE(vr1.max));
		1354	set_value_range (vr, vr1.type, min, max, NULL);
		1355	}
		1356	return;
		1357	}
		1358	set_value_range_to_varying (vr);
		1359	return;
1360	}
1361
1237	/* If either range is UNDEFINED, so is the result. */	1362	/* If either range is UNDEFINED, so is the result. */
1238	if (vr0.type == VR_UNDEFINED \|\| vr1.type == VR_UNDEFINED)	1363	if (vr0.type == VR_UNDEFINED \|\| vr1.type == VR_UNDEFINED)
1239	{	1364	{
Lines 1244-1252 extract_range_from_binary_expr (value_ra Link Here
1244	/* Refuse to operate on VARYING ranges, ranges of different kinds	1369	/* Refuse to operate on VARYING ranges, ranges of different kinds
1245	and symbolic ranges. TODO, we may be able to derive anti-ranges	1370	and symbolic ranges. TODO, we may be able to derive anti-ranges
1246	in some cases. */	1371	in some cases. */
1247	if (vr0.type == VR_VARYING	1372	if (vr0.type != vr1.type
1248	\|\| vr1.type == VR_VARYING	1373	\|\| vr0.type == VR_VARYING
1249	\|\| vr0.type != vr1.type
1250	\|\| symbolic_range_p (&vr0)	1374	\|\| symbolic_range_p (&vr0)
1251	\|\| symbolic_range_p (&vr1))	1375	\|\| symbolic_range_p (&vr1))
1252	{	1376	{