* fold-const.c (fold_unary, fold_binary): Take decomposed
arguments, code, type, op0, and op1 in case of fold_binary.
(fold): Update calls to fold_unary and fold_binary.
From-SVN: r96202
* fold-const.c (fold_unary, fold_binary, fold_ternary): Return
NULL_TREE when a given tree is not simplified.
(fold): Return the original tree when any of the functions
mentioned above NULL_TREE.
From-SVN: r96201
* fold-const.c (fold_binary_op_with_conditional_arg): Take
decomposed arguments code, type, op0, and op1 instead of t.
(fold_binary): Update a call to fold_range_test.
From-SVN: r95978
* fold-const.c (fold_range_test): Take decomposed arguments
code, type, op0, and op1 instead of t.
(fold_binary): Update a call to fold_range_test.
From-SVN: r95977
* fold-const.c (optimize_minmax_comparison): Take decomposed
arguments code, type, op0, and op1 instead of t.
(fold_binary): Update a call to optimize_minmax_comparison.
From-SVN: r95971
2005-03-04 Andrew Pinski <pinskia@physics.uc.edu>
Revert for now:
2005-03-03 James A. Morrison <phython@gcc.gnu.org>
PR tree-optimization/15784
* fold-const.c (fold): Fold ~A + 1 to -1. Fold -A - 1
and -1 - A to ~A.
From-SVN: r95880
2005-03-03 James A. Morrison <phython@gcc.gnu.org>
PR tree-optimization/15784
* fold-const.c (fold): Fold ~A + 1 to -1. Fold -A - 1
and -1 - A to ~A.
From-SVN: r95870
2005-02-18 Andrew Pinski <pinskia@physics.uc.edu>
PR middle-end/20030
* fold-const.c (fold_indirect_ref_1): Use the correct index for zero access,
the lower bound of the array type if it exists.
From-SVN: r95226
2005-02-15 James A. Morrison <phython@gcc.gnu.org>
* fold-const.c (fold): Fold -(~A) to A + 1. Fold ~(-A) to A - 1.
Fold ~(A - 1) and ~(A + -1) to -A.
From-SVN: r95074
2005-02-13 James A. Morrison <phython@gcc.gnu.org>
PR tree-optimization/14303
PR tree-optimization/15784
* fold-const.c (fold): Fold ABS_EXPR<x> >= 0 to true, when possible.
Fold ABS_EXPR<x> < 0 to false. Fold ABS_EXPR<x> == 0 to x == 0 and
ABS_EXPR<x> != 0 to x != 0.
From-SVN: r94977
PR middle-end/19858
* fold-const.c (make_bit_field_ref): If bitpos == 0 and bitsize
is number of inner's bits, avoid creating a BIT_FIELD_REF.
* gcc.c-torture/compile/20050210-1.c: New test.
From-SVN: r94892
* fold-const.c (fold_strip_sign_ops): New function to simplify a
floating point expression ignoring the sign of the result.
(fold) <ABS_EXPR>: Use it to simplify fabs(x).
(fold) <MULT_EXPR>: Use it to simplify x*x.
* tree.h (fold_strip_sign_ops): Prototype here.
* builtins.c (fold_builtin_copysign): Take an additional FNDECL
argument. Use fold_strip_sign_ops to simplify the first argument.
(fold_builtin_pow): Use fold_strip_sign_ops to simplify the
first argument when the second argument is an even integer
constant, but only with -funsafe_math_optimizations.
(fold_builtin_1): Update call to fold_builtin_copysign.
* gcc.dg/builtins-48.c: New test case.
* gcc.dg/builtins-49.c: New test case.
* gcc.dg/builtins-50.c: New test case.
* gcc.dg/builtins-51.c: New test case.
From-SVN: r94779
2005-02-09 Richard Guenther <rguenth@gcc.gnu.org>
* fold-const.c (try_move_mult_to_index): Remove redundant
type argument. Create ADDR_EXPR with correct type.
(fold): Update callers of try_move_mult_to_index. Convert
result to the appropriate type.
* g++.dg/tree-ssa/tmmti.C: New testcase.
From-SVN: r94767
* fold-const.c (fold, case CEIL_MOD_EXPR): Do not lose side
effects when optimizing 0 % X. Do not try to optimize X % 0.
* gcc.c-torture/execute/20050131-1.c: New test.
* gcc.dg/wcaselabel.c: New test.
From-SVN: r94516
2005-01-31 Roger Sayle <roger@eyesopen.com>
Dale Johannesen <dalej@apple.com>
PR middle-end/19650
* fold-const.c (fold_binary_op_with_conditional_arg):
Make types match original operands, before STRIP_NOPS.
From-SVN: r94485
PR rtl-optimization/576
* real.c (real_arithmetic): Change return type from void to bool
to return an indication that the result may be inexact.
* real.h (real_arithmeric): Update prototype.
* fold-const.c (const_binop): Don't constant fold floating
point expressions when the user specifies -frounding-math and
the result may depend upon the run-time rounding mode.
(fold_convert_const_real_from_real): Clean-up.
(fold_initializer): Ignore flag_rounding_math for initializers.
* simplify-rtx.c (simplify_binary_operation): Likewise, don't
constant fold FP operations with flag_rounding_math if the
result may depend upon the run-time rounding mode.
From-SVN: r94020
PR tree-optimization/19283
* fold-const.c (fold_widened_comparison): Return NULL if shorter_type
is not shorter than the original type.
* gcc.c-torture/execute/20050106-1.c: New test.
From-SVN: r93043
* fold-const.c (fold_single_bit_test): Delete unreachable handling
of TRUTH_NOT_EXPR.
(fold): Don't call fold_single_bit_test with a TRUTH_NOT_EXPR, as
all the cases handled by it are inverted by invert_truthvalue.
From-SVN: r92909
2004-12-28 Andrew Pinski <pinskia@physics.uc.edu>
* fold-const.c (fold_build_cleanup_point_expr): For a RETURN_EXPR,
we only need a cleanup point expression when the expression on the
left hand side of the MODIFIY_EXPR inside the return has side
effects.
From-SVN: r92672
* fold-const.c (fold_single_bit_test): If flag_syntax_only, pretend
LOAD_EXTEND_OP is not defined.
(fold): Likewise. If flag_syntax_only, don't depend on BITS_PER_WORD.
From-SVN: r92150
PR middle-end/18921
* fold-const.c (fold_unwidened_comparison): Use omit_one_operand
instead of constant_boolean_node as arg0 may have side-effects.
* gcc.dg/pr18921-1.c: New test case.
From-SVN: r92030
gcc/
* c-common.c, expr.c, fold-const.c, print-tree.c,
tree-gimple.c, tree-inline.c, tree-pretty-print.c,
tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c: Replace uses of
first_rtl_op with TREE_CODE_LENGTH.
* tree.c (first_rtl_op): Remove.
Replace uses of first_rtl_op with TREE_CODE_LENGTH.
* tree.h: Remove the prototype for first_rtl_op.
gcc/cp/
* pt.c: Replace a use of first_rtl_op with TREE_CODE_LENGTH.
From-SVN: r91818
2004-11-30 Eric Christopher <echristo@redhat.com>
* fold-const.c (fold_widened_comparison): Make sure that we're
passing an INTEGER_TYPE to int_fits_type_p.
(fold): Clean up comment.
From-SVN: r91539
* fold-const.c (extract_muldiv_1) <case ABS_EXPR>: If ctype is
unsigned and type signed, build ABS_EXPR with signed_type (ctype)
and only afterwards convert to ctype.
* gcc.c-torture/execute/20041126-1.c: New test.
From-SVN: r91373
* fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and
ARG1 to be null; instead define OP_SAME and OP_SAME_NULL and use them.
From-SVN: r91170
PR tree-optimization/18529
* fold-const.c (fold_to_nonsharp_ineq_using_bound): New function.
(simple_operand_p): Use STRIP_NOPS. Consider SSA names simple.
(fold): Call fold_to_nonsharp_ineq_using_bound.
* tree-ssa-loop-niter.c (simplify_replace_tree): New function.
(number_of_iterations_cond): Fold the expressions before futher
processing.
(tree_simplify_using_condition): Handle case when cond or expr is
an EQ_EXPR specially.
From-SVN: r91031
PR tree-optimization/18431
* fold-const.c (associate_trees): Do not produce x + 0.
(fold_widened_comparison, fold_sign_changed_comparison): New functions.
(fold): Use them.
* tree-ssa-loop-niter.c (upper_bound_in_type, lower_bound_in_type):
Moved ...
* tree.c (upper_bound_in_type, lower_bound_in_type): Here.
* tree.h (upper_bound_in_type, lower_bound_in_type): Declare.
* testsuite/gcc.c-torture/execute/20041114-1.c: New test.
From-SVN: r90646
* tree-ssa-loop-ivopts.c (get_address_cost): Add address elements in
right order.
(force_var_cost): Determine cost of addition and multiplication more
precisely.
(get_computation_cost_at): Add cost for computing address elements to
the final cost.
* fold-const.c (fold): Attempt to use ptr_difference_const whenever
one of the arguments of MINUS_EXPR is an address.
(split_address_to_core_and_offset): New function.
(ptr_difference_const): Handle case when one of the operands is a
pointer.
* tree-ssa-loop-ivopts.c (determine_base_object): Fold &*addr.
(ptr_difference_cost): Pass addresses instead of objects to
ptr_difference_const.
From-SVN: r90451
* fold-const.c (fold): Reassociate also (x - mult) + mult and
(mult - x) + mult. Cast operands of expression after applying
distributive law to the correct types. Apply distributive law
to a * c - b * c for all non-float types.
From-SVN: r90000
PR tree-optimization/18048
* fold-const.c (try_move_mult_to_index): New function.
(fold): Use try_move_mult_to_index.
* tree-ssa-loop-ivopts.c (try_add_cand_for): Prefer common candidates.
* tree-ssa-loop-niter.c (number_of_iterations_cond): Produce
an all-ones unsigned constant without extra bits.
* tree.c (build_low_bits_mask): New function.
* tree.h (build_low_bits_mask): Declare.
From-SVN: r89708
PR middle-end/17894
* fold-const.c (fold_div_compare): When optimizing X/C1 op C2, the
relational comparison operator op needs to be swapped/reversed when
C1 is negative. i.e. X/-10 < 1 becomes X >= -9, not X < -9.
* gcc.c-torture/execute/divcmp-4.c: New test case.
From-SVN: r88818
* fold-const.c (fold) [EQ_EXPR]: When seeing if D & ~C != 0 to
fold (A & C) == D into 0, fold ~C. Similarly, for the case
where | is used instead of &.
* testsuite/gcc.dg/tree-ssa/20041002-1.c: New.
From-SVN: r88449
* fold-const.c (fold): Avoid non INTEGER_TYPEs when widening
operands in an integer comparison.
* tree-cfg.c (find_taken_edge): Call fold() to determine
whether the predicate is known.
From-SVN: r87855
* fold-const.c (fold): Fold difference of addresses.
(ptr_difference_const): Moved from tree-ssa-loop-ivopts, based on
get_inner_reference.
* tree-ssa-loop-ivopts.c (peel_address): Removed.
(ptr_difference_const): Moved to fold-const.c.
(split_address_cost): Use get_inner_reference instead of peel_address.
(ptr_difference_cost): Change type of diff to HOST_WIDE_INT.
* tree.h (ptr_difference_const): Export.
* tree-ssa-loop-ivopts.c (dump_iv, dump_use, dump_cand): Add induction
variable type to the dump. Fix indentation.
(idx_find_step): Handle nonconstant array_ref_element_size and
array_ref_low_bound.
(idx_record_use): Handle array_ref_element_size and
array_ref_low_bound.
(find_interesting_uses_stmt): Handle memory = nontrivial_expression
statements correctly.
(get_computation_at, iv_value): Do not unshare expressions here.
(rewrite_use_outer): Unshare the expression before it is emitted
to code.
* tree-ssa-loop-niter.c (unsigned_type_for, signed_type_for):
Moved to tree.c.
* tree.c (unsigned_type_for, signed_type_for): Moved from
tree-ssa-loop-niter.c. Use langhooks.
* tree.h (signed_type_for): Export.
From-SVN: r87601
PR c++/17412
* fold-const.c (fold): Do not try to fold the operand of a
CLEANUP_POINT_EXPR if that operand does itself not have any
operands.
testsuite/
* g++.dg/parse/break-in-for.C: New test.
PR middle-end/17417
* langhooks.c (lhd_decl_printable_name): Make sure that this
function is called with is a decl node that has an identifier.
* tree-pretty-print.c (dump_function_name): New function to
wrap PRINT_FUNCTION_NAME and dump_decl_name.
(print_call_name): Use it.
From-SVN: r87363
PR middle-end/17055
* fold-const.c (build_zero_vector): New function to construct a
vector (either floating point or integer) of zeros.
(fold_convert): Internally, enable conversions of integer zero
to arbitrary vector types, using the new build_zero_vector.
* gcc.dg/pr17055-1.c: New test case.
From-SVN: r87272
* fold-const.c (operand_equal_p): Remove code to allow null ARG0/1.
Define locals macros OP_SAME and OP_SAME_WITH_NULL and use throughout.
From-SVN: r87082
* fold-const.c (operand_equal_p): Require equal sign also for
FIX_{CEIL,TRUNC,FLOOR,ROUND}_EXPR.
* gcc.c-torture/execute/20040831-1.c: New test.
From-SVN: r86906
* fold-const.c (tree_expr_nonzero_p): Use get_base_address before
assuming an ADDR_EXPR is non-null.
cp/
* class.c (fixed_type_or_null): Use get_base_address before
assuming an ADDR_EXPR is non-null.
From-SVN: r86788
* stor-layout.c (round_up, round_down): Move ...
* fold-const.c (round_up, round_down): ... here. Use
multiple_of_p to avoid any arithmetic at all.
From-SVN: r85848
PR middle-end/16790
* fold-const.c (extract_muldiv_1) <NOP_EXPR>: Disallow local
truncations, not just global truncations.
* gcc.c-torture/execute/pr16790-1.c: New test case.
From-SVN: r85506
PR c/7284
* fold-const.c (extract_muldiv_1): Do not treat signed left shift
as multiplication.
testsuite:
* gcc.c-torture/execute/pr7284-1.c: New test.
From-SVN: r85059
2004-07-21 Paolo Bonzini <bonzini@gnu.org>
* c-common.c (vector_types_convertible_p): Use vector types'
TYPE_SIZE and TREE_TYPE instead of their mode.
* convert.c (convert_to_integer): Likewise.
(convert_to_vector): Likewise.
* fold-const.c (fold_convert): Likewise.
* varasm.c (output_constant): Likewise.
* expr.c (store_constructor): Split ARRAY_TYPE and VECTOR_TYPE.
Allow a VECTOR_TYPE initializer to be made of several vectors.
For ARRAY_TYPEs and VECTOR_TYPES, simplify a bit the handling
of cleared and need_to_clear, and use fold_convert.
* c-typeck.c (build_binary_op): Do not use RDIV_EXPR for
integer vectors.
cp/ChangeLog:
2004-07-21 Paolo Bonzini <bonzini@gnu.org>
* c-typeck.c (build_binary_op): Do not use RDIV_EXPR for
integer vectors.
From-SVN: r85002
* fold-const.c (operand_equal_p): Temporarily support NULL args.
(operand_equal_p, case ARRAY_REF): Compare args 2 and 3.
(operand_equal_p, case COMPONENT_REF): Likewise, for arg 2.
From-SVN: r84990
* fold-const.c (tree_expr_nonzero_p): Add function prototype.
(fold) <EQ_EXPR>: Move tree_expr_nonzero_p optimization from
fold_relational_const to here, i.e. "(x | 5) == 0" -> false.
(fold) (UNEQ_EXPR>: Add optimizations for unordered comparisons
of the form "x op x" where op is UNLE, UNGE, UNEQ or LTGT.
(fold_relational_const): Tidy up handling of floating point
comparisons by calling real_compare. Remove tree_expr_nonzero_p
transformation; fold_relational_const assumes constant operands.
From-SVN: r84916
* fold-const.c (fold) <PLUS_EXPR>: Canonicalize X + -C as X - C for
floating point additions, to keep real immediate constant positive.
<MINUS_EXPR>: For floating point subtractions, only transform X - -C
into X + C, and leave positive real constants as X - C.
From-SVN: r84535
* builtins.c (fold_builtin_fputs): Don't bother converting the
return type to integer_type_node, as we've already checked that
the result will be ignored.
* tree-eh.c (tree_could_trap_p): Add support for -ftrapv such
that signed addition, subtraction, multiplication, division,
remainder, negation and absolute value may potentially trap.
* fold-const.c (fold_ignored_result): New function to strip
non-side-effecting tree nodes from an expression whose result
is ignored.
(fold_convert): Call fold_ignored_result when casting a value
to VOID_TYPE.
(omit_one_operand): Call fold_ignored_result on the "omitted"
operand when building a COMPOUND_EXPR.
(pedantic_omit_one_operand): Likewise.
* tree.h (fold_ignored_result): Prototype here.
* tree-ssa-ccp.c (ccp_fold_builtin): Call fold_ignored_result
when we're going to ignore the result.
From-SVN: r84525
PR tree-optimization/16437
* c-common.c (shorten_compare): Don't mark result of conversion to
narrower signed type as overflowing.
* fold-const.c (decode_field_reference): Determine whether
signedness comes from outer type using precision rather than size.
testsuite:
* gcc.c-torture/execute/bitfld-4.c: New test.
From-SVN: r84498
* builtins.c (fold_builtin_strcpy): Merge functionality from
simplify_builtin_strcpy. Add additional len argument. No longer
static. Remove function prototype.
(fold_builtin_strncpy): Likewise integrate functionality from
simplify_builtin_strncpy. Add additional slen argument. No
longer static. Remove function prototype.
(simplify_builtin_strcy, simplify_builtin_strncpy): Delete.
(simplify_builtin_fputs): Rename to fold_builtin_fputs. Change
types of "ignore" and "unlocked" parameters to bool.
(fold_builtin_1): Add additional ignore argument. Call renamed
fold_builtin_fputs to simplify GCC "fputs" and "fputs_unlocked"
builtins. Update arguments to fold_builtin_strncpy and
fold_builtin_strcpy. Add function prototype.
(fold_builtin): Add additional Boolean ignore argument to pass
to fold_builtin_1.
(simplify_builtin): Call fold_builtin_fputs, fold_builtin_strcpy
and fold_builtin_strncpy instead of simplify_builtin_fputs,
simplify_builtin_strcpy and simplify_builtin_strncpy respectively.
* expr.h (simplify_builtin_fputs, simplify_builtin_strcpy,
simplify_builtin_strncpy): Delete function prototypes.
* tree.h (fold_builtin_fputs, fold_builtin_strcpy,
fold_builtin_strncpy): Add function prototypes here.
(fold_builtin): Update function prototype with new "bool ignore".
* tree-ssa-ccp.c (ccp_fold): Update call to fold_builtin.
(ccp_fold_builtin): Update call to fold_builtin. Call
fold_builtin_fputs, fold_builtin_strcpy and fold_builtin_strncpy
instead of simplify_builtin_fputs, simplify_builtin_strcpy and
simplify_builtin_strncpy respectively.
* fold-const.c (fold): Update call to fold_builtin.
From-SVN: r84302
* fold-const.c (fold) <TRUNC_MOD_EXPR>: Optimize unsigned modulus
by a power of two into a bit-wise AND, i.e. "X % C" as "X & (C-1)".
Normalize "X % C" as "X % -C" for signed modulus and negative C.
Optimize "X % -Y" as "X % Y" for signed modulus.
<EQ_EXPR>: Recursively call "fold" when transforming "(X % Y) == 0"
into "((unsigned) X % Y) == 0".
From-SVN: r84122
2004-06-28 Paolo Bonzini <bonzini@gnu.org>
* fold-const.c (fold_cond_expr_with_comparison): Add ARG1
parameter. Use it instead of ARG00 to produce the result.
From-SVN: r83768
* fold-const.c (fold) <BIT_IOR_EXPR>: Optimize ~X|X and X|~X as -1.
<BIT_XOR_EXPR>: Optimize ~X|X and X|~X as -1.
<BIT_AND_EXPR>: Optimize ~X&X and X&~X as 0.
<TRUTH_AND_EXPR, TRUTH_ANDIF_EXPR>: Optimize !X&&X and X&&!X as false.
<TRUTH_OR_EXPR, TRUTH_ORIF_EXPR>: Optimize !X||X and !X||X as true.
<TRUTH_XOR_EXPR>: Optimize !X^X and X^X! as true. Now that
TRUTH_XOR_EXPR is a commutative tree code, don't test whether arg0
is a constant.
* gcc.dg/20040527-1.c: New test case.
From-SVN: r83733
2004-06-23 Andrew Pinski <apinski@apple.com>
PR middle-end/15988
* fold-const.c (fold_convert): Types which are compatible
can be converted with only a NOP_EXPR.
2004-06-23 Andrew Pinski <apinski@apple.com>
PR middle-end/15988
* g++.dg/opt/ptrmem4.C: New test.
From-SVN: r83585
2004-06-23 Eric Christopher <echristo@redhat.com>
* fold-const.c (make_range): Cleanup type checking through function.
Remove orig_type. Replace with checks to exp_type and arg0_type.
Clarify comment when converting from unsigned to signed.
From-SVN: r83576
* alias.c (adjust_offset_for_component_ref): Use
component_ref_field_offset.
* c-decl.c (build_array_declarator): Add news args for ARRAY_REF.
* c-gimplify.c (gimplify_expr_stmt): Use alloc_stmt_list.
(gimplify_decl_stmt): Call gimplify_type_sizes for type.
For decl, call gimplify_one_sizepos and use statement list.
(gimplify_compound_literal_expr): New arg PRE_P.
Add statement to PRE_P list and return DECL.
(c_gimplify_expr, case COMPOUND_LITERAL_EXPR): Add arg to
gimplify_compound_literal_expr.
* c-tree.h (getdecls): Deleted.
* c-typeck.c (build_component_ref): Add operand for COMPONENT_REF.
(build_array_ref): Add two operands for ARRAY_REF.
(build_unary_op): Set TREE_INVARIANT and TREE_CONSTANT for
COMPOUND_LITERAL_EXPR.
* coverage.c (tree_coverage_counter_ref): Add new operands
for ARRAY_REF.
* emit-rtl.c (component_ref_for_mem_expr): Add new operand
for COMPONENT_REF.
(set_mem_attributes_minus_bitpos): Use array_ref_low_bound
and array_ref_element_size.
(widen_memory_access):Use component_ref_field_offset.
* explow.c (update_nonlocal_goto_save_area): Add two operands
for ARRAY_REF.
* expr.c (array_ref_element_size, array_ref_low_bound): New functions.
(component_ref_field_offset): Likewise.
(get_inner_reference): Use them.
(expand_expr_real_1, case ARRAY_REF): Use array_ref_low_bound.
* fold-const.c (fold, case EQ_EXPR): Properly handle DECL_SIZE.
(fold_read_from_constant_string): Use array_ref_low_bound.
Verify that result is a character type.
(build_fold_indirect_ref): Add two operands for ARRAY_REF.
* function.c (expand_function_start): Likewise.
* gimple-low.c (expand_var_p): Delete duplicated line.
* gimplify.c: Add static decls for local functions.
(cgraph.h): Now included.
(create_tmp_var): Remove check for ARRAY_TYPE.
(copy_if_shared_r): Look at bounds and sizes of types.
(build_and_jump): Return alloc_stmt_list instead of build_empty_stmt.
(gimplify_exit_expr, shortcut_cond_expr): Likewise.
(gimplify_save_expr, gimple_push_cleanup): Likewise.
(gimplify_init_constructor): Likewise.
WANT_VALUE now bool.
If empty list with no result wanted, return GS_UNHANDLED.
Add additional operands for ARRAY_REF and COMPONENT_REF.
(canonicalize_component_ref): Convert to &array[L].
(gimplify_array_ref_to_plus): Use array_ref_element_size and
array_ref_lower_bound.
(build_addr_expr_with_type, build_addr_expr): New functions.
(gimplify_compound_lval): WANT_LVALUE now bool.
Major rework to allow handle_component_p and initialize and
gimplify new operands for ARRAY_REF, ARRAY_RANGE_REF, and
COMPONENT_REF.
(gimplify_array_ref): Deleted.
(gimplify_self_mod_expr): WANT_VALUE now bool.
(gimplify_modify_expr): Gimplify to_p and from_p later.
Factor out code into gimplify_modify_expr_rhs and call twice.
Move variable-size code earlier and handle PLACEHOLDER_EXPR.
(gimplify_modify_expr_rhs, gimplify_variable_sized_compare): New fns.
(gimplify_addr_expr, case VIEW_CONVERT_EXPR): New case.
(gimplify_expr, case ARRAY_REF): Delete special case.
Instead handle like COMPONENT_REF; also do ARRAY_RANGE_REF,
IMAGPART, and REALPART the same way.
(gimplify_expr, case VIEW_CONVERT_EXPR): New case.
(gimplify_expr): Call gimplify_variable_sized_compare if applicable.
Call alloc_stmt_list instead of build_empty_stmt.
Deal with _REF that's volatile.
(gimplify_type_sizes, gimplify_one_sizepos): New functions.
(unshare_body, unvisit_body): New functions.
(gimplify_body): Call them.
* stmt.c (expand_stack_alloc): Don't expand TYPE_MAX_VALUE.
* stor-layout.c (get_pending_sizes): Don't change SAVE_EXPR_CONTEXT.
* tree-alias-common.c (get_alias_var): Also skip ARRAY_RANGE_REF.
* tree-cfg.c (tree_node_can_be_shared): Treat ARRAY_RANGE_REF
like ARRAY_REF.
(verify_expr, case ADDR_EXPR): Use handled_component_p.
* tree-dfa.c (get_virtual_var): Likewise.
* tree-dump.c (dequeue_and_dump, case COMPONENT_REF, ARRAY_REF):
New cases to dump new operands; likewise for ARRAY_RANGE_REF.
* tree-eh.c (tree_could_trap, case ARRAY_RANGE_REF): Like ARRAY_REF.
* tree-gimple.c (is_gimple_addr_expr_arg): Add ARRAY_RANGE_REF
and INDIRECT_REF.
(get_base_address): Use handled_component_p.
* tree-gimple.h (gimplify_type_sizes, gimplify_one_sizepos): New.
* tree-line.c (walk_tree): Walk more things for types and decls.
* tree-mudflap.c (mf_build_check_statement_for): Add new operands
for ARRAY_REF and COMPONENT_REF.
(mx_xform_derefs_1): Clean up usage of decl sizes.
* tree-nested.c (build_addr): Use handled_component_p.
(walk_stmts, case CATCH_EXPR): Add missing "break".
(get_static_chain, get_frame_field): Add new operand for COMPONENT_REF.
(finalize_nesting_tree_1): Likewise.
(convert_nonlocal_reference, case ARRAY_RANGE_REF): Like ARRAY_REF
and process additional operands.
(convert_local_reference): Likewise.
* tree-outof-ssa.c (discover_nonconstant_array_refs_r): Treat
ARRAY_RANGE_REF similarly to ARRAY_REF.
* tree-pretty-print.c (dump_generic_node, case QUAL_UNION_TYPE): Handle
like RECORD_TYPE.
(dump_generic_node, case COMPONENT_REF): Print offset operand.
(dump_generic_node, case ARRAY_RANGE_REF): Treat like ARRAY_REF
and print lower bound and element size for both.
(op_prio, case ARRAY_RANGE_REF): Like ARRAY_REF.
* tree-sra.c (csc_build_component_ref): Add new operand.
(scalarize_call_expr): Use get_base_address.
* tree-ssa-ccp.c (widen_bitfield): Clean up size handling.
(maybe_fold_offset_to_array_ref): Rework to handle input having an
ARRAY_REF, refine handling of lower bound, and add new operands
for ARRAY_REF.
(maybe_fold_to_component_ref): Add new operand for COMPONENT_REF.
(maybe_fold_stmt_indirect): Only fold *&B to B if types match.
(maybe_fold_stmt_addition): Only handle constant lower bound.
* tree-ssa-operands.c (get_expr_operands): Minor rearrangements.
Treat ARRAY_REF and ARRAY_RANGE_REF the same; look at extra operands.
Look at new offset operand of COMPONENT_REF.
* tree-ssa.c (set_is_used): Use handled_component_p.
* tree.c (substitute_in_expr, case COMPONENT_REF): Add new operand.
(stabilize_reference, case COMPONENT_REF): Likewise.
(stabilize_reference, case ARRAY_RANGE_REF, ARRAY_REF): Similarly.
(recompute_tree_invariant_for_addr_expr): Completely rework to
be more precise. Also set TREE_SIDE_EFFECTS.
(build1_stat, case ARRAY_EXPR): Don't handle TREE_SIDE_EFFECTS here.
(build2_stat, build3_stat, build4_stat): For references,
propagate TREE_THIS_VOLATILE.
(get_unwidened): Add new operand for COMPONENT_REF.
(get_narrower): Likewise; use host_integerp for DECL_SIZE.
* tree.def (COMPONENT_REF): Add new operand.
(ARRAY_REF, ARRAY_RANGE_REF): Add two new operands.
* tree.h (array_ref_element_size, array_ref_low_bound): New decls.
(component_ref_field_offset): Likewise.
* config/alpha/alpha.c (alpha_va_start): Add new op for COMPONENT_REF.
(alpha_gimplify_va_arg): Likewise.
* config/i386/i386.c (ix86_va_start, ix86_gimplify_va_arg): Likewise.
* config/i860/i860.c (i860_va_start, i860_va_arg): Likewise.
* config/iq2000/iq2000.c (iq2000_va_arg): Likewise.
* config/mips/mips.c (mips_va_start, mips_va_arg): Likewise.
* config/rs6000/rs6000.c (rs6000_va_start, rs6000_gimplify_va_arg):
Likewise.
* config/s390/s390.c (s390_va_start, s390_gimplify_va_arg): Likewise.
* config/sh/sh.c (sh_va_start, sh_va_arg): Likewise.
* config/stormy16/stormy16.c (xstormy1_expand_builin_va_start):
Likewise.
(xstormy16_expand_builtin_va_arg): Likewise.
* config/xtensa/xtensa.c (xtensa_va_start, xtensa_va_arg): Likewise.
* cp/call.c (build_vfield_ref): Add new operand for COMPONENT_REF.
(build_new_method_call): Likewise.
* cp/decl.c (local_variable_p_walkfn): Don't walk into types.
* cp/decl2.c (grok_array_decl): Add new operands for ARRAY_REF.
(build_anon_union_vars): Add new operand for COMPONENT_REF.
* cp/init.c (buld_new): Add new operand for ARRAY_REF.
* cp/method.c (do_build_copy_constructor): New op for COMPONENT_REF.
(do_build_assign_ref): Likewise.
* cp/parser.c (cp_parser_direct_new_declarator): Add new operands
for ARRAY_REF.
(cp_parser_direct_declarator): Likewise.
* cp/pt.c (tsubst): Likewise.
(tsubst_copy, tsubst_copy_and_build): Likewise; also add new operand
for COMPONENT_REF.
* cp/semantics.c (finish_non_static_data_member): Add new operand
for COMPONENT_REF.
* cp/typeck.c (build_class_member_access_expr): Likewise.
(build_class_member_access_expr, finish_class_member_access_expr):
Likewise.
(build_ptrmemfunc_access_expr): Likewise.
(build_array_ref): Add new operands for ARRAY_REF.
* cp/typeck2.c (split_nonconstant_init_1): Likewise; COMPONENT_REF too.
* cp/tree.c (count_trees_r, no_linkage_helper): Don't walk in types.
* fortran/f95-lang.c (LANG_HOOKS_GIMPLE_BEFORE_INLINING): Deleted.
* fortran/trans-array.c (gfc_conv_descriptor_data): Add operand
for COMPONENT_REF.
(gfc_conv_descriptor_offset, gfc_conv_descriptor_dtype): Likewise.
(gfc_conv_descriptor_dimension, gfc_conv_descriptor_stride): Likewise.
(gfc_conv_descriptor_lbound, gfc_conv_descriptor_ubound): Likewise.
* fortran/trans-common.c (create_common): Likewise.
* fortran/trans-expr.c (gfc_conv_component_ref): Likewise.
* fortran/trans-io.c (set_parameter_value): Likewise.
(set_parameter_ref, set_string, set_flag, io_result): Likewise.
(transfer_expr): Likewise.
* fortran/trans-decl.c (gfc_trans_auto_character_variable):
Set up to get DECL_SIZE and DECL_SIZE_UNIT gimplified.
(gfc_simplify_function): New function.
(gfc_generate_function-code): Properly handle nested functions.
* fortran/trans.c (gfc_build_array_ref): Add two new operands
for ARRAY_REF.
* java/class.c (build_class_ref): Add new operand for COMPONENT_REF.
(build_static_field_ref): Likewise and add new operands for ARRAY_REF.
* java/constants.c (build_ref_from_constant_pool): Likewise.
* java/expr.c (build_java_array_length_access): Likewise.
(build_get_class, build_field_ref, build_known_method_ref): Likewise.
(invoke_build_dtable, build_invokevirtual): Likewise.
(build_invokeinterface, java_expand_expr): Likewise.
(emit_init_test_initialization): Likewise.
* java/java-gimplify.c (java_gimplify_new_array_init): Likewise.
* java/parse.y (make_qualifed_name, build_array_ref): Likewise.
* objc/ojbc-act.c (generate_static_references): Add additional
operands to ARRAY_REF.
(generate_strings, build_method_prototype_list_template): Likewise.
(generate_protocol_list): Likewise.
From-SVN: r83474
* fold-const.c (operand_equal_p): Pass flags in recursive calls for
binary and relational operations. Add support for TRUTH_ANDIF_EXPR,
TRUTH_ORIF_EXPR, TRUTH_AND_EXPR, TRUTH_OR_EXPR and TRUTH_XOR_EXPR.
* tree.c (commutative_tree_code): Also list UNORDERED_EXPR,
ORDERED_EXPR, UNEQ_EXPR, LTGT_EXPR, TRUTH_AND_EXPR, TRUTH_OR_EXPR
and TRUTH_XOR_EXPR.
From-SVN: r83433
2004-06-21 Paolo Bonzini <bonzini@gnu.org>
* fold-const.c (fold_cond_expr_with_comparison):
New function, extracted from fold.
(fold): Extract code to fold A op B ? A : C, use
it to fold A op B ? C : A. Really optimize
A & N ? N : 0 where N is a power of two. Avoid
relying on canonicalization and recursion for
foldings of COND_EXPR to happen.
From-SVN: r83428
* fold-const.c (fold) <UNORDERED_EXPR, ORDERED_EXPR, UNLT_EXPR,
UNLE_EXPR, UNGT_EXPR, UNGE_EXPR, UNEQ_EXPR, LTGT_EXPR>: Add
constant folding for unordered comparison tree nodes. If both
operands are real constants, call fold_relational_const. If either
operand is a NaN, evaluate the other for side-effects and return a
constant. Optimize (double)float1 CMP (double)float2 into the
equivalent float1 CMP float2.
(nondestructive_fold_binary_to_constant) <UNORDERED_EXPR,
ORDERED_EXPR, UNLT_EXPR, UNLE_EXPR, UNGT_EXPR, UNGE_EXPR, UNEQ_EXPR,
LTGT_EXPR>: Call fold_relational_const for constant operands.
(fold_relational_const): Add support for unordered comparison tree
nodes. Don't constant fold "ordered" floating point comparisons
against NaN if when flag_trapping_math is set.
* gcc.dg/unordered-2.c: New test case.
* gcc.dg/unordered-3.c: New test case.
From-SVN: r83379
* fold-const.c (build_range_check): If !in_p and recursive call
fails, exit immediately. If high - low overflows and etype is
a signed type, retry with unsigned etype.
(merge_ranges): If !in0_p and !in1_p, handle even range2 adjacent
to range1 at TYPE_MAX_VALUE and TYPE_MIN_VALUE.
* gcc.dg/range-test-1.c: New test.
* g++.dg/opt/range-test-1.C: New test.
From-SVN: r83369
* fold-const.c (swap_tree_comparison): No longer static.
(tree_swap_operands_p): Similarly. Return true if both operands
are SSA_NAMEs and the first operand has a higher version number than
the second operand.
* tree.h (swap_tree_comparison): Prototype.
(tree_swap_operands_p): Prototype.
* tree-ssa-operands.c (get_expr_operands): For commutative
operators and relational comparisons, canonicalize the
order of the operands.
* gcc.dg/tree-ssa/20040615-1.c: New test.
* gcc.dg/tree-ssa/20030824-1.c: Update expected output to
be less sensitive to operand ordering.
* gcc.dg/tree-ssa/20030824-2.c: Likewise.
From-SVN: r83224
2004-06-13 Andrew Pinski <pinskia@physics.uc.edu>
* fold-const.c (fold_checksum_tree <case 't'>): Only
look at TREE_VALUES if the EXPR is an ENUMERAL_TYPE.
Only look at TYPE_MIN_VALUE and TYPE_MAX_VALUE if
EXPR is an INTEGERAL_TYPE or a scalar float type.
From-SVN: r83068
* fold-const.c (omit_two_operands): New function.
* tree.h (omit_two_operands): Prototype here.
* builtins.c (fold_builtin_unordered_cmp): New function to lower
C99 unordered comparison builtins to the appropriate tree nodes.
(fold_builtin_1): Use fold_builtin_unordered_cmp to lower
BUILT_IN_ISGREATER, BUILT_IN_ISGREATEREQUAL, BUILT_IN_ISLESS,
BUILT_IN_ISLESSEQUAL and BUILT_IN_ISLESSGREATER. Manually lower
BUILT_IN_ISUNORDERED comparisons to an UNORDERED_EXPR tree node.
(simplify_builtin_memcmp, simplify_builtin_strncmp,
simplify_builtin_strncat, simplify_builtin_strspn): Use the new
omit_two_operands function to build the required COMPOUND_EXPRs.
From-SVN: r83040
* fold-const.c (fold_inf_compare): Avoid creating non-gimple
code when we are in gimple form.
* gcc.c-torture/compile/20040610-1.c: New test.
From-SVN: r82958
* fold-const.c (fold_abs_const): Make extern.
* tree.h (fold_abs_const): Prototype here.
* builtins.c (fold_builtin_fabs): New function to transform
fabs, fabsf and fabsl builtins into ABS_EXPR tree nodes.
(fold_builtin_abs): New function to transform abs, labs, llabs
and imaxabs builtins into ABS_EXPR tree nodes.
(expand_builtin): Fall back to a function call for abs, labs,
llabs and imaxabs builtins that survive constant folding.
(fold_builtin_1): Call fold_builtin_fabs for FABS, FABSF and
FABSL, and fold_builtin_abs for ABS, LABS, LLABS and IMAXABS.
From-SVN: r82916
* target.h: Add gimplify_va_arg_expr hook.
* target-def.h: Add TARGET_GIMPLIFY_VA_ARG_EXPR.
* fold-const.c (build_fold_addr_expr)
(build_fold_addr_expr_with_type): Move from gimplify.c.
* tree.h: Declare them.
* gimplify.c (gimplify_and_add): New fn.
(build_addr_expr, build_addr_expr_with_type): Move to fold-const.c.
(gimplify_array_ref_to_plus, gimplify_modify_expr)
(gimplify_expr): Use build_fold_*.
(copy_if_shared_r): Only mark VA_ARG_EXPR volatile if we
don't know how to gimplify it.
* builtins.c (std_gimplify_va_arg_expr): New fn.
(dummy_object): New static fn.
(gimplify_va_arg_expr): New fn.
(stabilize_va_list): Use build_fold_*.
* tree-gimple.h: Declare new fns.
* config/i386/i386.c (TARGET_GIMPLIFY_VA_ARG_EXPR): Define.
(ix86_gimplify_va_arg): New fn.
* config/i386/ia64.c (TARGET_GIMPLIFY_VA_ARG_EXPR): Define.
(ia64_gimplify_va_arg): New fn.
* config/i386/rs6000.c (rs6000_gimplify_va_arg): New fn.
(TARGET_GIMPLIFY_VA_ARG_EXPR): Define.
* config/i386/sparc.c (sparc_gimplify_va_arg): New fn.
* alias.c (get_varargs_alias_set): Just return 0 for now.
* c-objc-common.c (c_tree_printer): Improve handling of %T.
From-SVN: r82838
2004-06-08 Andrew Pinski <pinskia@physics.uc.edu>
* fold-const.c (fold_convert): Treat OFFSET_TYPE like
POINTER_TYPE and INTEGER_TYPE.
From-SVN: r82792
* real.c (real_copysign): New function to implement libm's copysign.
* real.h (real_copysign): Prototype here.
* fold-const.c (tree_expr_nonnegative_p): The result of sqrt, sqrtf
and sqrtl can be negative, as sqrt(-0.0) = -0.0. Correct whitespace.
* builtins.c (fold_builtin_isascii, fold_builtin_toascii,
fold_builtin_isdigit): Add function prototypes.
(fold_builtin_copysign): New function to fold copysign, copysignf
and copysignl. Optimize copysign(x,x) as x. Evaluate copysign of
constant arguments at compile-time using real_copysign. Fold
copysign(X,Y) as fabs(X) if Y is always non-negative.
(fold_builtin_1): Correct minor whitespace/style issues. Call
fold_builtin_copysign for BUILT_IN_COPYSIGN{,F,L}.
* gcc.dg/builtins-41.c: New test case.
* gcc.dg/builtins-42.c: New test case.
From-SVN: r82721
PR middle-end/15069
* fold-const.c (fold_single_bit_test): Only perform "(X & C) != 0"
into "X < 0" (where C is the signbit) if X's type is a full mode.
* g++.dg/opt/fold3.C: New test case.
From-SVN: r82490
* fold-const.c (combine_comparisons, optimize_bit_field_compare,
range_binop, fold_truthop, fold_binary_op_with_conditional_arg,
fold_mathfn_compare, fold_inf_compare, fold,
fold_relational_hi_lo, nondestructive_fold_binary_to_constant):
Use constant_boolean_node where appropriate. Don't bother using
fold_convert on the second argument to omit_one_operand.
From-SVN: r82468
gcc/ChangeLog:
2004-05-27 Paolo Bonzini <bonzini@gnu.org>
Roger Sayle <roger@eyesopen.com>
PR rtl-optimization/15649
Add LTGT_EXPR and improve pretty-printing of unordered
comparisons.
* c-common.c (c_common_truthvalue_conversion):
Handle LTGT_EXPR.
* c-typeck.c (build_binary_op): Likewise.
* dojump.c (do_jump): Likewise.
* expr.c (expand_expr_real_1, do_store_flag): Likewise.
* predict.c (tree_predict_by_opcode): Likewise.
* real.c (real_compare): Likewise.
* tree-cfg.c (verify_expr): Likewise.
* tree-inline.c (estimate_num_insns_1): Likewise.
* tree-pretty-print.c (dump_generic_node): Likewise.
Handle ORDERED_EXPR, UNORDERED_EXPR.
(op_symbol): Print unordered comparisons differently
than ordered ones.
* tree.def (LTGT_EXPR): New '<' tree code.
* doc/c-tree.texi (Expressions): Document floating-point
comparison nodes.
Fold comparisons between floating point values.
* fold-const.c (enum comparison_code): New, from
#define'd constants. Define compcodes for unordered
comparisons and for invalid transformations.
(invert_tree_comparison): Add "honor_nans" parameter.
(fold_truthop): Revamp to work on floating-point types too.
(comparison_to_compcode): Support unordered comparisons.
Use new enum comparison_code.
(compcode_to_comparison): Likewise.
(combine_compcodes): New function.
(invert_truthvalue): Let invert_tree_comparison decide
whether it is valid to fold the comparison. Fold ORDERED
and UNORDERED even if flag_unsafe_math_optimizations is off,
and the remaining even if flag_unsafe_math_optimizations
is off but we are under -fno-trapping-math.
(fold_relational_const): Integer modes do not honor NaNs.
gcc/testsuite/ChangeLog:
2004-05-27 Paolo Bonzini <bonzini@gnu.org>
* gcc.c-torture/compare-fp-1.c, gcc.c-torture/compare-fp-2.c,
gcc.c-torture/compare-fp-3.c, gcc.c-torture/compare-fp-4.c,
gcc.c-torture/compare-fp-3.x, gcc.c-torture/compare-fp-4.x,
gcc.c-torture/pr15649-1.c: New.
Co-Authored-By: Roger Sayle <roger@eyesopen.com>
From-SVN: r82365
PR middle-end/3074
* fold-const.c (strip_compound_expr): Delete function.
(count_cond): Delete function.
(fold_binary_op_with_conditional_arg): Only perform transformations
"a + (b?c:d) -> b ? a+c : a+d" and "(b?c:d) + a -> b ? c+a : d+a"
when a is constant. This greatly simplifies this routine.
* tree.c (saved_expr_p): Delete function.
* tree.h (saved_expr_p): Delete function prototype.
* gcc.dg/pr3074-1.c: New test case.
* gcc.dg/sequence-pt-1.c: Remove an XFAIL.
From-SVN: r82071
* fold-const.c (fold_div_compare): New function to optimize X/C1 op C2
where op is a comparison operator and C1 and C2 are integer constants
into a range check.
(fold): Call fold_div_compare.
* gcc.c-torture/execute/divcmp-1.c: New test case.
* gcc.c-torture/execute/divcmp-2.c: New test case.
* gcc.c-torture/execute/divcmp-3.c: New test case.
From-SVN: r81645
* fold-const.c (fold): Prefer fold_convert (negate_expr (...)) to
fold (build1 (NEGATE_EXPR, ...)). Optimize X / -1 as -X and
X % -1 as 0.
From-SVN: r81177
* fold-const.c (fold_binary_op_with_conditional_arg): Tweak
calling convention to allow a NULL_TREE to be returned. Factor
sanity checks from callers, return NULL_TREE when appropriate.
(fold): Handle COMPOUND_EXPR operands of binary expressions
before COND_EXPR operands. Use reorder_operands_p(a,b) to check
whether a op (b,c) can be rewritten as (b, a op c). Simplify
calls to fold_binary_op_with_conditional_arg.
From-SVN: r80609
* expr.c (get_inner_reference): Use DECL_UNSIGNED, not TREE_UNSIGNED.
* stor-layout.c (layout_decl): Likewise.
* tree.c (get_narrower): Likewise and also use BIT_FIELD_REF_UNSIGNED.
* fold-const.c (make_bit_field_ref): Use BIT_FIELD_REF_UNSIGNED.
* print-tree.c (print_node): Handle various used of unsigned_flag.
* tree.def (BIT_FIELD_REF): Update comment.
* tree.h (TREE_UNSIGNED): Deleted.
(DECL_UNSIGNED, BIT_FIELD_REF_UNSIGNED): New macros.
* cp/class.c (VTT_TOP_LEVEL_P): Use unsigned_flag directly.
* f/com.c (ffe_truthvalue_conversion, case COMPONENT_REF):
Use DECL_UNSIGNED and integer_onep.
From-SVN: r80293
* fold-const.c (tree_expr_nonnegative_p): Handle BIT_XOR_EXPR like
BIT_IOR_EXPR; A^B is nonnegative when A and B are nonnegative.
* gcc.dg/compare8.c: Add an additional test for XOR.
From-SVN: r79979
* fold-const.c (tree_expr_nonnegative_p): A&B is nonnegative when
A is nonnegative or B is nonnegative. Similarly A|B is nonnegative
when both A and B are nonnegative.
(tree_expr_nonzero_p): A|B is nonzero when A is nonzero or B is
nonzero.
From-SVN: r79870
2004-03-23 Kazu Hirata <kazu@cs.umass.edu>
PR optimization/14669
* fold-const.c (fold): Only unwiden integer comparisons for equality
or inequality operators, or when the signedness is the same.
* g++.dg/opt/fold2.C: New test case.
From-SVN: r79859
* fold-const.c (fold): Remove variable "invert".
Move the handling of relational expressions that can be folded
to a constant ...
(fold_relational_const): ... here.
(tree_expr_nonzero_p): New.
From-SVN: r79745
* fold-const.c (negate_expr_p) <RSHIFT_EXPR>: We can optimize
-((int)X>>C) where C is an integer constant one bit less than the
size of X into (unsigned)X>>C. Similarly for unsigned->signed.
(negate_expr) <RSHIFT_EXPR>: Implement the above transformations.
* simplify-rtx.c (simplify_unary_operation): Also implement the
above transformations at the RTL level.
* gcc.c-torture/execute/20040311-1.c: New test case.
From-SVN: r79334
* fold-const.c (fold): An equality comparison of a non-weak object
against zero has a known result. Similarly an equality comparison
of the address of two non-weak, unaliased symbols has a known result.
* ggc-page.c (struct page_entry): New field PREV.
(ggc_alloc): Update PREV field appropriately.
(sweep_pages): Likewise.
(ggc_free): Likewise. Use PREV field rather than loop to
improve ggc_free performance.
cp/
* init.c (build_vec_delete_1): Convert 2nd argument to NE_EXPR to
the proper type.
From-SVN: r78713
* fold-const.c (fold): Revert 2004-02-25 change. Use the original
operands to build a tree with swapped operands.
* expr.c (expand_expr_real) <MAX_EXPR>: Consistently use the
'unsignedp' predicate to specify the signedness.
Co-Authored-By: Roger Sayle <roger@eyesopen.com>
From-SVN: r78558
PR c/14092
* gcc.dg/pr14092-1.c: New testcase.
* fold-const.c (fold) <NEGATE_EXPR>: Convert result of
negate_expr back to the original type.
From-SVN: r77602
* fold-const.c (fold) <NOP_EXPR>: Use the original type conversion
tree code rather than call fold_convert, which doesn't specify a
default floating point to integer conversion.
* gcc.c-torture/compile/20040209-1.c: New test case.
From-SVN: r77535
PR middle-end/13696
* fold-const.c (fold_convert): New function to provide type
conversion to the middle-end without using convert.
(negate_expr, associate_trees, size_diffop, omit_one_operand,
operand_equal_for_comparison_p, pedantic_omit_one_operand,
invert_truthvalue, optimize_bit_field_compare, range_binop,
decode_field_reference, make_range, build_range_check, unextend,
fold_truthop, extract_muldiv_1, fold_mathfn_compare,
fold_binary_op_with_conditional_arg, fold_inf_compare,
fold_single_bit_test, fold, multiple_of_p): Replace all calls to
convert with calls to fold_convert.
* g++.dg/opt/fold1.C: New test case.
From-SVN: r77464
* fold-const.c (negate_expr_p, negate_expr): Optimize -(A+B) into
either (-A)-B or (-B)-A, if A or B is easily negated respectively.
(fold) <MINUS_EXPR>: Optimize (A*C) - (B*C) -> (A-B)*C for both
integer types and floating point with unsafe_math_optimizations.
Add similar optimization for (A*C1) - (A*C2) -> A*(C1-C2).
Optimize A - B as A + (-B), if B is easily negated.
From-SVN: r77453
* tree.c (commutative_tree_code, associative_tree_code): New
functions.
(iterative_hash_expr): Use commutative_tree_code.
* tree.h (commutative_tree_code, associative_tree_code): Declare.
* fold-const.c (operand_equal_p): Use commutative_tree_code
rather than inlining the commutativity check.
(fold): Likewise.
Co-Authored-By: Roger Sayle <roger@eyesopen.com>
From-SVN: r77152
* fold-const.c (fold_binary_op_with_conditional_arg): Only
build a COMPOUND_EXPR if 'arg' is really a SAVE_EXPR.
Co-Authored-By: Olivier Hainque <hainque@act-europe.fr>
From-SVN: r76434
* fold-const.c (fold_convert): Rename to fold_convert_const.
(fold_convert_const): Change arguments to take a tree_code,
a type and the operand/expression to be converted. Return
NULL_TREE if no simplification is possible. Add support for
FIX_CEIL_EXPR and FIX_FLOOR_EXPR in addition to FIX_TRUNC_EXPR.
(fold): Handle FIX_CEIL_EXPR and FIX_FLOOR_EXPR.
Adjust call to fold_convert to match new fold_convert_const.
Avoid modifying the tree passed to fold in-place.
From-SVN: r76237
* fold-const.c (fold) <COND_EXPR>: Don't require strict type
equality, instead just prevent replacing a COND_EXPR of non-void
type by one of its operands of void type.
From-SVN: r75239
PR fortran/12632
* fold-const.c (fold) <COND_EXPR>: Don't fold a constant condition,
if the type of the selected branch doesn't match its' parent.
* com.c (ffecom_subscript_check_): Take as an extra argument the
(possibly NULL) decl of the array. Don't create unnecessary tree
nodes if the array index is known to be safe at compile-time.
If the array index is unsafe, force the array decl into memory to
avoid RTL expansion problems.
(ffecom_array_ref_): Update calls to ffecom_subscript_check_.
(ffecom_char_args_x_): Likewise.
* g77.dg/12632.f: New test case.
From-SVN: r75203
* fold-const.c (negate_mathfn_p): New function to determine whether
a built-in mathematical function is sign preserving, f(-x) == -f(x).
Add support for BUILT_IN_ASIN, BUILT_IN_ASINF and BUILT_IN_ASINL.
(tree_swap_operands_p): Change API to take an additional argument
indicating that the swapped operands evaluate in reverse order.
Canonicalize VAR_DECLs and PARM_DECLs last if we can, i.e. neither
operand side-effects or we don't care about flag_evaluation_order.
(reorder_operands_p): New function to check whether its safe to
evaluate the given operands in reverse order.
(negate_expr_p): We can always negate integer constants unless
we honor -ftrapv and the signed type would overflow. Only allow
-(A-B) into B-A if reorder_operands_p says that its OK. Allow
negation of COMPLEX_CST if both real and imaginary parts can be
negated. Allow negation through floating point extensions and
sign-preserving built-in functions.
(negate_expr): Move the code to negate integers from "fold" to
here. Always negate integer constants unless we honor -ftrapv
and the signed type would overflow. Always negate real constants
unless we honor -ftrapping-math. Only convert -(A-B) into B-A
if allowed by reorder_operands_p. Add support for COMPLEX_CST.
Optimize negation through floating point extensions and
sign-preserving built-in functions (as defined by negate_mathfn_p).
(fold): Adjust calls to tree_swap_operands_p.
(fold <NEGATE_EXPR>): Move the remaining negation optimizations
to negate_expr_p/negate_expr.
(fold <MINUS_EXPR>): Use reorder_operands_p to check whether we're
allowed to convert (-A) - B into (-B) - A.
From-SVN: r72381
PR optimization/9325, PR java/6391
* fold-const.c (fold_convert): For floating point to integer
conversions, return the maximum/minimum representable integer
value if the real constant overflows the destination type.
* tree.c (real_value_from_int_cst): Allow the type to be NULL,
meaning don't truncate the result to a floating point mode.
Simplify the logic by calling real_from_integer directly.
* simplify-rtx.c (simplify_unary_operation): Implement the
same semantics for folding floating point to integer conversions
in RTL.
* gcc.c-torture/execute/20031003-1.c: New test case.
From-SVN: r72079
* fold-const.c (tree_swap_operands_p): New function to determine
the prefered ordering of operands.
(fold): Numerous clean-ups. Use tree_swap_operands_p when swapping
operands to commutative, comparison or ternary operators. Replace
uses of TREE_SET_CODE with recursive call to fold. Remove duplicate
transformation of A ? B : C into !A ? C : B.
From-SVN: r71438
* builtins.c (real_dconstp, fold_builtin_logarithm,
fold_builtin_exponent): New, split out from fold_builtin. Also
generalize to add log2, log10, exp2 and exp10/pow10 equivalents.
* emit-rtl.c (dconst3, dconst10, dconstthird): New.
(init_emit_once): Initialize new dconsts, use ARRAY_SIZE in lieu
of hardcoded array size.
* fold-const.c (fold): Add cases for exp2, exp10 and pow10.
(tree_expr_nonnegative_p): Likewise.
* real.h (dconst3, dconst10, dconstthird): New.
testsuite:
* gcc.dg/torture/builtin-explog-1.c: New testcase.
From-SVN: r71252
PR middle-end/12002
* tree.h (SCALAR_FLOAT_TYPE_P, COMPLEX_FLOAT_TYPE_P): New macros.
(FLOAT_TYPE_P): Define in terms of these two new macros.
* fold-const.c (fold <PLUS_EXPR>): Don't convert x+x into x*2.0
for complex floating point types.
* g77.f-torture/compile/12002.f: New test case.
From-SVN: r70821
* fold-const.c (fold <MULT_EXPR>): Optimize (C1/X)*C2 into
(C1*C2)/X when unsafe math optimizations are allowed.
(fold <RDIV_EXPR>): Optimize C1/(X*C2) into (C1/C2)/X with unsafe
math optimizations. Minor code clean-ups. Recursively call
fold when constructing sub-expressions.
* gcc.dg/20030826-1.c: New test case.
From-SVN: r70807
PR middle-end/11984
* fold-const.c (fold <PLUS_EXPR>): Check for integer constant
operands before calling tree_int_cst_lt when performing associative
transformations.
* gcc.dg/20030820-1.c: New test case.
From-SVN: r70618
* fold-const.c (negate_expr_p): MULT_EXPRs and RDIV_EXPRs are easy
to negate if either operand is easy to negate, if we don't care
about sign-dependent rounding.
(negate_expr): Make the logic to negate a REAL_CST explicit.
Attempt to negate a MULT_EXPR or RDIV_EXPR by negating an operand
that's easy to negate, if we don't honor sign-dependent rounding.
(fold <MULT_EXPR>): Optimize -A * B as A * -B if B is easy to
negate, and the symmetric A * -B as -A * B if A is easy to negate.
(fold <RDIV_EXPR>): Likewise, optimize -A/B and C/-D as A/-B and
-C/D if B and C are cheap to negate. Add an explicit rule to
optimize X/-1.0 as -X when we don't care about signaling NaNs.
From-SVN: r70455
