X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fconvert.c;h=471d93db5628296b6ee31e75c5f190553de90fde;hb=0933bd90096fc0db5d4ee6bd89749be8985c96ba;hp=9517c50bf3a975f7845ef1f9943a518e69c7ff53;hpb=7c446c951a941facd5f225bba9916ff669420c34;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/convert.c b/gcc/convert.c index 9517c50bf3a..471d93db562 100644 --- a/gcc/convert.c +++ b/gcc/convert.c @@ -1,6 +1,6 @@ /* Utility routines for data type conversion for GCC. Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998, - 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GCC. @@ -16,8 +16,8 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ /* These routines are somewhat language-independent utility function @@ -42,10 +42,7 @@ tree convert_to_pointer (tree type, tree expr) { if (integer_zerop (expr)) - { - expr = build_int_cst (type, 0, 0); - return expr; - } + return build_int_cst (type, 0); switch (TREE_CODE (TREE_TYPE (expr))) { @@ -57,13 +54,12 @@ convert_to_pointer (tree type, tree expr) case ENUMERAL_TYPE: case BOOLEAN_TYPE: case CHAR_TYPE: - if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE) - return build1 (CONVERT_EXPR, type, expr); + if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE) + expr = fold_build1 (NOP_EXPR, + lang_hooks.types.type_for_size (POINTER_SIZE, 0), + expr); + return fold_build1 (CONVERT_EXPR, type, expr); - return - convert_to_pointer (type, - convert (lang_hooks.types.type_for_size - (POINTER_SIZE, 0), expr)); default: error ("cannot convert to a pointer type"); @@ -204,35 +200,9 @@ convert_to_real (tree type, tree expr) break; } } - if (optimize - && (((fcode == BUILT_IN_FLOORL - || fcode == BUILT_IN_CEILL - || fcode == BUILT_IN_ROUNDL - || fcode == BUILT_IN_RINTL - || fcode == BUILT_IN_TRUNCL - || fcode == BUILT_IN_NEARBYINTL) - && (TYPE_MODE (type) == TYPE_MODE (double_type_node) - || TYPE_MODE (type) == TYPE_MODE (float_type_node))) - || ((fcode == BUILT_IN_FLOOR - || fcode == BUILT_IN_CEIL - || fcode == BUILT_IN_ROUND - || fcode == BUILT_IN_RINT - || fcode == BUILT_IN_TRUNC - || fcode == BUILT_IN_NEARBYINT) - && (TYPE_MODE (type) == TYPE_MODE (float_type_node))))) - { - tree fn = mathfn_built_in (type, fcode); - - if (fn) - { - tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, - 1))); - tree arglist = build_tree_list (NULL_TREE, - fold (convert_to_real (type, arg0))); - - return build_function_call_expr (fn, arglist); - } - } + /* This code formerly changed (float)floor(double d) to + floorf((float)d). This is incorrect, because (float)d uses + round-to-nearest and can round up to the next integer. */ /* Propagate the cast into the operation. */ if (itype != type && FLOAT_TYPE_P (type)) @@ -294,8 +264,8 @@ convert_to_real (tree type, tree expr) case COMPLEX_TYPE: return convert (type, - fold (build1 (REALPART_EXPR, - TREE_TYPE (TREE_TYPE (expr)), expr))); + fold_build1 (REALPART_EXPR, + TREE_TYPE (TREE_TYPE (expr)), expr)); case POINTER_TYPE: case REFERENCE_TYPE: @@ -349,6 +319,26 @@ convert_to_integer (tree type, tree expr) switch (fcode) { + case BUILT_IN_CEIL: case BUILT_IN_CEILF: case BUILT_IN_CEILL: + /* Only convert in ISO C99 mode. */ + if (!TARGET_C99_FUNCTIONS) + break; + if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node)) + fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL); + else + fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL); + break; + + case BUILT_IN_FLOOR: case BUILT_IN_FLOORF: case BUILT_IN_FLOORL: + /* Only convert in ISO C99 mode. */ + if (!TARGET_C99_FUNCTIONS) + break; + if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node)) + fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR); + else + fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR); + break; + case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL: if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node)) fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND); @@ -367,6 +357,13 @@ convert_to_integer (tree type, tree expr) else fn = mathfn_built_in (s_intype, BUILT_IN_LRINT); break; + + case BUILT_IN_TRUNC: case BUILT_IN_TRUNCF: case BUILT_IN_TRUNCL: + { + tree arglist = TREE_OPERAND (s_expr, 1); + return convert_to_integer (type, TREE_VALUE (arglist)); + } + default: break; } @@ -384,49 +381,29 @@ convert_to_integer (tree type, tree expr) case POINTER_TYPE: case REFERENCE_TYPE: if (integer_zerop (expr)) - expr = integer_zero_node; - else - expr = fold (build1 (CONVERT_EXPR, - lang_hooks.types.type_for_size (POINTER_SIZE, 0), - expr)); + return build_int_cst (type, 0); - return convert_to_integer (type, expr); + /* Convert to an unsigned integer of the correct width first, + and from there widen/truncate to the required type. */ + expr = fold_build1 (CONVERT_EXPR, + lang_hooks.types.type_for_size (POINTER_SIZE, 0), + expr); + return fold_build1 (NOP_EXPR, type, expr); case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: case CHAR_TYPE: /* If this is a logical operation, which just returns 0 or 1, we can - change the type of the expression. For some logical operations, - we must also change the types of the operands to maintain type - correctness. */ + change the type of the expression. */ - if (TREE_CODE_CLASS (ex_form) == '<') + if (TREE_CODE_CLASS (ex_form) == tcc_comparison) { expr = copy_node (expr); TREE_TYPE (expr) = type; return expr; } - else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR - || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR - || ex_form == TRUTH_XOR_EXPR) - { - expr = copy_node (expr); - TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0)); - TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1)); - TREE_TYPE (expr) = type; - return expr; - } - - else if (ex_form == TRUTH_NOT_EXPR) - { - expr = copy_node (expr); - TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0)); - TREE_TYPE (expr) = type; - return expr; - } - /* If we are widening the type, put in an explicit conversion. Similarly if we are not changing the width. After this, we know we are truncating EXPR. */ @@ -451,7 +428,7 @@ convert_to_integer (tree type, tree expr) else code = NOP_EXPR; - return build1 (code, type, expr); + return fold_build1 (code, type, expr); } /* If TYPE is an enumeral type or a type with a precision less @@ -604,9 +581,9 @@ convert_to_integer (tree type, tree expr) else typex = lang_hooks.types.signed_type (typex); return convert (type, - fold (build2 (ex_form, typex, - convert (typex, arg0), - convert (typex, arg1)))); + fold_build2 (ex_form, typex, + convert (typex, arg0), + convert (typex, arg1))); } } } @@ -617,30 +594,18 @@ convert_to_integer (tree type, tree expr) /* This is not correct for ABS_EXPR, since we must test the sign before truncation. */ { - tree typex = type; - - /* Can't do arithmetic in enumeral types - so use an integer type that will hold the values. */ - if (TREE_CODE (typex) == ENUMERAL_TYPE) - typex = lang_hooks.types.type_for_size - (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex)); - - /* But now perhaps TYPEX is as wide as INPREC. - In that case, do nothing special here. - (Otherwise would recurse infinitely in convert. */ - if (TYPE_PRECISION (typex) != inprec) - { - /* Don't do unsigned arithmetic where signed was wanted, - or vice versa. */ - if (TYPE_UNSIGNED (TREE_TYPE (expr))) - typex = lang_hooks.types.unsigned_type (typex); - else - typex = lang_hooks.types.signed_type (typex); - return convert (type, - fold (build1 (ex_form, typex, - convert (typex, - TREE_OPERAND (expr, 0))))); - } + tree typex; + + /* Don't do unsigned arithmetic where signed was wanted, + or vice versa. */ + if (TYPE_UNSIGNED (TREE_TYPE (expr))) + typex = lang_hooks.types.unsigned_type (type); + else + typex = lang_hooks.types.signed_type (type); + return convert (type, + fold_build1 (ex_form, typex, + convert (typex, + TREE_OPERAND (expr, 0)))); } case NOP_EXPR: @@ -657,9 +622,9 @@ convert_to_integer (tree type, tree expr) case COND_EXPR: /* It is sometimes worthwhile to push the narrowing down through the conditional and never loses. */ - return fold (build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), - convert (type, TREE_OPERAND (expr, 1)), - convert (type, TREE_OPERAND (expr, 2)))); + return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), + convert (type, TREE_OPERAND (expr, 1)), + convert (type, TREE_OPERAND (expr, 2))); default: break; @@ -672,8 +637,8 @@ convert_to_integer (tree type, tree expr) case COMPLEX_TYPE: return convert (type, - fold (build1 (REALPART_EXPR, - TREE_TYPE (TREE_TYPE (expr)), expr))); + fold_build1 (REALPART_EXPR, + TREE_TYPE (TREE_TYPE (expr)), expr)); case VECTOR_TYPE: if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr)))) @@ -681,7 +646,7 @@ convert_to_integer (tree type, tree expr) error ("can't convert between vector values of different size"); return error_mark_node; } - return build1 (NOP_EXPR, type, expr); + return build1 (VIEW_CONVERT_EXPR, type, expr); default: error ("aggregate value used where an integer was expected"); @@ -713,22 +678,22 @@ convert_to_complex (tree type, tree expr) if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype)) return expr; else if (TREE_CODE (expr) == COMPLEX_EXPR) - return fold (build2 (COMPLEX_EXPR, type, - convert (subtype, TREE_OPERAND (expr, 0)), - convert (subtype, TREE_OPERAND (expr, 1)))); + return fold_build2 (COMPLEX_EXPR, type, + convert (subtype, TREE_OPERAND (expr, 0)), + convert (subtype, TREE_OPERAND (expr, 1))); else { expr = save_expr (expr); return - fold (build2 (COMPLEX_EXPR, type, - convert (subtype, - fold (build1 (REALPART_EXPR, - TREE_TYPE (TREE_TYPE (expr)), - expr))), - convert (subtype, - fold (build1 (IMAGPART_EXPR, - TREE_TYPE (TREE_TYPE (expr)), - expr))))); + fold_build2 (COMPLEX_EXPR, type, + convert (subtype, + fold_build1 (REALPART_EXPR, + TREE_TYPE (TREE_TYPE (expr)), + expr)), + convert (subtype, + fold_build1 (IMAGPART_EXPR, + TREE_TYPE (TREE_TYPE (expr)), + expr))); } } @@ -757,10 +722,10 @@ convert_to_vector (tree type, tree expr) error ("can't convert between vector values of different size"); return error_mark_node; } - return build1 (NOP_EXPR, type, expr); + return build1 (VIEW_CONVERT_EXPR, type, expr); default: error ("can't convert value to a vector"); - return convert_to_vector (type, integer_zero_node); + return error_mark_node; } }