Skip to content

R
riscv-gcc-1
Commit 125e025e by Richard Guenther Committed by Richard Biener
Options

re PR tree-optimization/34651 (ICE in set_value_range, at tree-vrp.c:321) 

2008-01-10  Richard Guenther  <rguenther@suse.de>

	PR tree-optimization/34651
	* tree-sra.c (sra_build_assignment): Sanitize.  Use the correct
	types and ordering for masking and converting.

	* g++.dg/torture/pr34651.C: New testcase.

From-SVN: r131442
parent 5817ff8e
Showing with 96 additions and 78 deletions
gcc/ChangeLog
2008-01-10 Richard Guenther <rguenther@suse.de>
PR tree-optimization/34651
* tree-sra.c (sra_build_assignment): Sanitize. Use the correct
types and ordering for masking and converting.
2008-01-09 Sebastian Pop <sebastian.pop@amd.com>
PR tree-optimization/34017
gcc/testsuite/ChangeLog
2008-01-10 Richard Guenther <rguenther@suse.de>
PR tree-optimization/34651
* g++.dg/torture/pr34651.C: New testcase.
2008-01-09 Sebastian Pop <sebastian.pop@amd.com>
PR tree-optimization/34017
gcc/testsuite/g++.dg/torture/pr34651.C 0 → 100644
/* { dg-do compile } */
typedef bool Bool;
struct CString {
CString (const char * =__null);
CString & operator += (const CString &);
};
struct THotKey {
short Key;
Bool Control;
Bool Shift;
Bool Alt;
};
THotKey m_HotKey;
THotKey GetHotKey () { return m_HotKey; }
void Serialize ()
{
THotKey inHotKey (GetHotKey());
CString outCombinaison (inHotKey.Control
? ((inHotKey.Alt || inHotKey.Shift)
? "ctrl+" : "ctrl")
: __null);
outCombinaison += inHotKey.Alt ? inHotKey.Shift ? "alt+" : "alt" : "";
outCombinaison += inHotKey.Shift ? "shift" : "";
}
gcc/tree-sra.c
......@@ -2127,30 +2127,37 @@ static tree
sra_build_assignment (tree dst, tree src)
{
/* Turning BIT_FIELD_REFs into bit operations enables other passes
to do a much better job at optimizing the code. */
to do a much better job at optimizing the code.
From dst = BIT_FIELD_REF <var, sz, off> we produce
SR.1 = (scalar type) var;
SR.2 = SR.1 >> off;
SR.3 = SR.2 & ((1 << sz) - 1);
... possible sign extension of SR.3 ...
dst = (destination type) SR.3;
*/
if (scalar_bitfield_p (src))
{
tree cst, cst2, mask, minshift, maxshift;
tree tmp, var, utype, stype;
tree var, shift, width;
tree utype, stype, stmp, utmp;
tree list, stmt;
bool unsignedp = BIT_FIELD_REF_UNSIGNED (src);
var = TREE_OPERAND (src, 0);
cst = TREE_OPERAND (src, 2);
cst2 = size_binop (PLUS_EXPR, TREE_OPERAND (src, 1),
TREE_OPERAND (src, 2));
width = TREE_OPERAND (src, 1);
/* The offset needs to be adjusted to a right shift quantity
depending on the endianess. */
if (BYTES_BIG_ENDIAN)
{
maxshift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), cst);
minshift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), cst2);
tree tmp = size_binop (PLUS_EXPR, width, TREE_OPERAND (src, 2));
shift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), tmp);
}
else
{
maxshift = cst2;
minshift = cst;
}
shift = TREE_OPERAND (src, 2);
/* In weird cases we have non-integral types for the source or
destination object.
??? For unknown reasons we also want an unsigned scalar type. */
stype = TREE_TYPE (var);
if (!INTEGRAL_TYPE_P (stype))
stype = lang_hooks.types.type_for_size (TREE_INT_CST_LOW
......@@ -2166,117 +2173,92 @@ sra_build_assignment (tree dst, tree src)
utype = unsigned_type_for (utype);
list = NULL;
stmp = make_rename_temp (stype, "SR");
cst2 = size_binop (MINUS_EXPR, maxshift, minshift);
if (TREE_INT_CST_LOW (cst2) == TYPE_PRECISION (utype))
{
unsignedp = true;
mask = NULL_TREE;
}
else
{
mask = build_int_cst_wide (utype, 1, 0);
cst = int_const_binop (LSHIFT_EXPR, mask, cst2, true);
mask = int_const_binop (MINUS_EXPR, cst, mask, true);
}
tmp = make_rename_temp (stype, "SR");
if (TYPE_MAIN_VARIANT (TREE_TYPE (var)) != TYPE_MAIN_VARIANT (stype))
/* Convert the base var of the BIT_FIELD_REF to the scalar type
we use for computation if we cannot use it directly. */
if (!useless_type_conversion_p (stype, TREE_TYPE (var)))
{
if (INTEGRAL_TYPE_P (TREE_TYPE (var)))
stmt = build_gimple_modify_stmt (tmp,
stmt = build_gimple_modify_stmt (stmp,
fold_convert (stype, var));
else
stmt = build_gimple_modify_stmt (tmp,
stmt = build_gimple_modify_stmt (stmp,
fold_build1 (VIEW_CONVERT_EXPR,
stype, var));
append_to_statement_list (stmt, &list);
var = tmp;
var = stmp;
}
if (!integer_zerop (minshift))
if (!integer_zerop (shift))
{
tmp = make_rename_temp (stype, "SR");
stmt = build_gimple_modify_stmt (tmp,
stmt = build_gimple_modify_stmt (stmp,
fold_build2 (RSHIFT_EXPR, stype,
var, minshift));
var, shift));
append_to_statement_list (stmt, &list);
var = tmp;
var = stmp;
}
if (TYPE_MAIN_VARIANT (utype) != TYPE_MAIN_VARIANT (stype))
/* If we need a masking operation, produce one. */
if (TREE_INT_CST_LOW (width) == TYPE_PRECISION (stype))
unsignedp = true;
else
{
if (!mask && unsignedp
&& (TYPE_MAIN_VARIANT (utype)
== TYPE_MAIN_VARIANT (TREE_TYPE (dst))))
tmp = dst;
else
tmp = make_rename_temp (utype, "SR");
tree one = build_int_cst_wide (stype, 1, 0);
tree mask = int_const_binop (LSHIFT_EXPR, one, width, 0);
mask = int_const_binop (MINUS_EXPR, mask, one, 0);
stmt = build_gimple_modify_stmt (tmp, fold_convert (utype, var));
stmt = build_gimple_modify_stmt (stmp,
fold_build2 (BIT_AND_EXPR, stype,
var, mask));
append_to_statement_list (stmt, &list);
var = tmp;
var = stmp;
}
if (mask)
/* After shifting and masking, convert to the target type. */
utmp = stmp;
if (!useless_type_conversion_p (utype, stype))
{
if (!unsignedp
|| (TYPE_MAIN_VARIANT (TREE_TYPE (dst))
!= TYPE_MAIN_VARIANT (utype)))
tmp = make_rename_temp (utype, "SR");
else
tmp = dst;
utmp = make_rename_temp (utype, "SR");
stmt = build_gimple_modify_stmt (tmp,
fold_build2 (BIT_AND_EXPR, utype,
var, mask));
stmt = build_gimple_modify_stmt (utmp, fold_convert (utype, var));
append_to_statement_list (stmt, &list);
var = tmp;
var = utmp;
}
/* Perform sign extension, if required.
??? This should never be necessary. */
if (!unsignedp)
{
tree signbit = int_const_binop (LSHIFT_EXPR,
build_int_cst_wide (utype, 1, 0),
size_binop (MINUS_EXPR, cst2,
bitsize_int (1)),
true);
size_binop (MINUS_EXPR, width,
bitsize_int (1)), 0);
tmp = make_rename_temp (utype, "SR");
stmt = build_gimple_modify_stmt (tmp,
stmt = build_gimple_modify_stmt (utmp,
fold_build2 (BIT_XOR_EXPR, utype,
var, signbit));
append_to_statement_list (stmt, &list);
var = tmp;
if (TYPE_MAIN_VARIANT (TREE_TYPE (dst)) != TYPE_MAIN_VARIANT (utype))
tmp = make_rename_temp (utype, "SR");
else
tmp = dst;
stmt = build_gimple_modify_stmt (tmp,
stmt = build_gimple_modify_stmt (utmp,
fold_build2 (MINUS_EXPR, utype,
var, signbit));
utmp, signbit));
append_to_statement_list (stmt, &list);
var = tmp;
var = utmp;
}
if (var != dst)
/* Finally, move and convert to the destination. */
if (!useless_type_conversion_p (TREE_TYPE (dst), TREE_TYPE (var)))
{
if (INTEGRAL_TYPE_P (TREE_TYPE (dst)))
var = fold_convert (TREE_TYPE (dst), var);
else
var = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (dst), var);
stmt = build_gimple_modify_stmt (dst, var);
append_to_statement_list (stmt, &list);
}
stmt = build_gimple_modify_stmt (dst, var);
append_to_statement_list (stmt, &list);
return list;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment