[Bug c/19976] New: integer division by zero in subexpression should be overflow

[Bug c/19976] New: integer division by zero in subexpression should be overflow

[jsm28 at gcc dot gnu dot org]

The test

enum e { E = 0 * (1 / 0) };

should yield an error with -pedantic-errors.  Not a regression.

-- 
           Summary: integer division by zero in subexpression should be
                    overflow
           Product: gcc
           Version: 4.0.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: c
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: jsm28 at gcc dot gnu dot org
                CC: gcc-bugs at gcc dot gnu dot org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2005-02-15 21:18 -------
Confirmed.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever Confirmed|                            |1
           Keywords|                            |accepts-invalid, diagnostic
      Known to fail|                            |3.3.3 3.2.3 3.4.0 4.0.0
                   |                            |3.0.4 2.95.3
   Last reconfirmed|0000-00-00 00:00:00         |2005-02-15 21:18:33
               date|                            |


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[jsm28 at gcc dot gnu dot org]

------- Comment #14 from jsm28 at gcc dot gnu dot org  2009-03-29 18:19 -------
Fixed for 4.5.


-- 

jsm28 at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|                            |FIXED
   Target Milestone|---                         |4.5.0


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[jsm28 at gcc dot gnu dot org]

------- Comment #13 from jsm28 at gcc dot gnu dot org  2009-03-29 18:14 -------
Subject: Bug 19976

Author: jsm28
Date: Sun Mar 29 18:13:43 2009
New Revision: 145254

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=145254
Log:
        PR c/456
        PR c/5675
        PR c/19976
        PR c/29116
        PR c/31871
        PR c/35198

fixincludes:
        * inclhack.def (glibc_tgmath): New fix.
        * fixincl.x: Regenerate.
        * tests/base/tgmath.h: New.

gcc:
        * builtins.c (fold_builtin_sincos): Build COMPOUND_EXPR in
        void_type_node.
        (fold_call_expr): Return a NOP_EXPR from folding rather than the
        contained expression.
        * c-common.c (c_fully_fold, c_fully_fold_internal, c_save_expr):
        New.
        (c_common_truthvalue_conversion): Use c_save_expr.  Do not fold
        conditional expressions for C.
        (decl_constant_value_for_optimization): Move from
        decl_constant_value_for_broken_optimization in c-typeck.c.  Check
        whether optimizing and that the expression is a VAR_DECL not of
        array type instead of doing such checks in the caller.  Do not
        check pedantic.  Call gcc_unreachable for C++.
        * c-common.def (C_MAYBE_CONST_EXPR): New.
        * c-common.h (c_fully_fold, c_save_expr,
        decl_constant_value_for_optimization): New prototypes.
        (C_MAYBE_CONST_EXPR_PRE, C_MAYBE_CONST_EXPR_EXPR,
        C_MAYBE_CONST_EXPR_INT_OPERANDS, C_MAYBE_CONST_EXPR_NON_CONST,
        EXPR_INT_CONST_OPERANDS): Define.
        * c-convert.c (convert): Strip nops from expression.
        * c-decl.c (groktypename): Take extra parameters expr and
        expr_const_operands.  Update call to grokdeclarator.
        (start_decl): Update call to grokdeclarator.  Add statement for
        expressions used in type of decl.
        (grokparm): Update call to grokdeclarator.
        (push_parm_decl): Update call to grokdeclarator.
        (build_compound_literal): Add parameter non_const and build a
        C_MAYBE_COSNT_EXPR if applicable.
        (grokdeclarator): Take extra parameters expr and
        expr_const_operands.  Track expressions used in declaration
        specifiers and declarators.  Fold array sizes and track whether
        they are constant expressions and whether they are integer
        constant expressions.
        (parser_xref_tag): Set expr and expr_const_operands fields in
        return value.
        (grokfield): Update call to grokdeclarator.
        (start_function): Update call to grokdeclarator.
        (build_null_declspecs): Set expr and expr_const_operands fields in
        return value.
        (declspecs_add_type): Handle expressions in typeof specifiers.
        * c-parser.c (c_parser_declspecs): Set expr and
        expr_const_operands fields for declaration specifiers.
        (c_parser_enum_specifier): Likewise.
        (c_parser_struct_or_union_specifier): Likewise.
        (c_parser_typeof_specifier): Likewise.  Update call to
        groktypename.  Fold expression as needed.  Return expressions with
        type instead of adding statements.
        (c_parser_attributes): Update calls to c_parser_expr_list.
        (c_parser_statement_after_labels): Fold expression before passing
        to objc_build_throw_stmt.
        (c_parser_condition): Fold expression.
        (c_parser_asm_operands): Fold expression.
        (c_parser_conditional_expression): Use c_save_expr.  Update call
        to build_conditional_expr.
        (c_parser_alignof_expression): Update call to groktypename.
        (c_parser_postfix_expression): Preserve C_MAYBE_CONST_EXPR as
        original_code.  Fold expression argument of va_arg.  Create
        C_MAYBE_CONST_EXPR to preserve side effects of expressions in type
        argument to va_arg.  Update calls to groktypename.  Fold array
        index for offsetof.  Verify that first argument to
        __builtin_choose_expr has integer type.
        (c_parser_postfix_expression_after_paren_type): Update calls to
        groktypename and build_compound_literal.  Handle expressions with
        side effects in type name.
        (c_parser_postfix_expression_after_primary): Update call to
        c_parser_expr_list.  Set original_code for calls to
        __builtin_constant_p.
        (c_parser_expr_list): Take extra parameter fold_p.  Fold
        expressions if requested.
        (c_parser_objc_type_name): Update call to groktypename.
        (c_parser_objc_synchronized_statement): Fold expression.
        (c_parser_objc_receiver): Fold expression.
        (c_parser_objc_keywordexpr): Update call to c_parser_expr_list.
        (c_parser_omp_clause_num_threads, c_parser_omp_clause_schedule,
        c_parser_omp_atomic, c_parser_omp_for_loop): Fold expressions.
        * c-tree.h (CONSTRUCTOR_NON_CONST): Define.
        (struct c_typespec): Add elements expr and expr_const_operands.
        (struct c_declspecs): Add elements expr and expr_const_operands.
        (groktypename, build_conditional_expr, build_compound_literal):
        Update prototypes.
        (in_late_binary_op): Declare.
        * c-typeck.c (note_integer_operands): New function.
        (in_late_binary_op): New variable.
        (decl_constant_value_for_broken_optimization): Move to c-common.c
        and rename to decl_constant_value_for_optimization.
        (default_function_array_conversion): Do not strip nops.
        (default_conversion): Do not call
        decl_constant_value_for_broken_optimization.
        (build_array_ref): Do not fold result.
        (c_expr_sizeof_expr): Fold operand.  Use C_MAYBE_CONST_EXPR for
        result when operand is a VLA.
        (c_expr_sizeof_type): Update call to groktypename.  Handle
        expressions included in type name.  Use C_MAYBE_CONST_EXPR for
        result when operand names a VLA type.
        (build_function_call): Update call to build_compound_literal.
        Only fold result for calls to __builtin_* functions.  Strip
        NOP_EXPR from INTEGER_CST returned from such functions.  Fold
        the function designator.
        (convert_arguments): Fold arguments.  Update call to
        convert_for_assignment.
        (build_unary_op): Handle increment and decrement of
        C_MAYBE_CONST_EXPR.  Move lvalue checks for increment and
        decrement earlier.  Fold operand of increment and decrement.
        Handle address of C_MAYBE_CONST_EXPR.  Only fold expression being
        built for integer operand.  Wrap returns that are INTEGER_CSTs
        without being integer constant expressions or that have integer
        constant operands without being INTEGER_CSTs.
        (lvalue_p): Handle C_MAYBE_CONST_EXPR.
        (build_conditional_expr): Add operand ifexp_bcp.  Track whether
        result is an integer constant expression or can be used in
        unevaluated parts of one and avoid folding and wrap as
        appropriate.  Fold operands before possibly doing -Wsign-compare
        warnings.
        (build_compound_expr): Wrap result for C99 if operands can be used
        in integer constant expressions.
        (build_c_cast): Update call to digest_init.  Do not ignore
        overflow from casting floating-point constants to integers.  Wrap
        results that could be confused with integer constant expressions,
        null pointer constants or floating-point constants.
        (c_cast_expr): Update call to groktypename.  Handle expressions
        included in type name.
        (build_modify_expr): Handle modifying a C_MAYBE_CONST_EXPR.  Fold
        lhs inside possible SAVE_EXPR.  Fold RHS before assignment.
        Update calls to convert_for_assignment.
        (convert_for_assignment): Take new parameter
        null_pointer_constant.  Do not strip nops or call
        decl_constant_value_for_broken_optimization.  Set
        in_late_binary_op for conversions to boolean.
        (store_init_value): Update call to digest_init.
        (digest_init): Take new parameter null_pointer_constant.  Do not
        call decl_constant_value_for_broken_optimization.  pedwarn for
        initializers not constant expressions.  Update calls to
        convert_for_assignment.
        (constructor_nonconst): New.
        (struct constructor_stack): Add nonconst element.
        (really_start_incremental_init, push_init_level, pop_init_level):
        Handle constructor_nonconst and nonconst element.
        (set_init_index): Call constant_expression_warning for array
        designators.
        (output_init_element): Fold value.  Set constructor_nonconst as
        applicable.  pedwarn for initializers not constant expressions.
        Update call to digest_init.  Call constant_expression_warning
        where constant initializers are required.
        (process_init_element): Use c_save_expr.
        (c_finish_goto_ptr): Fold expression.
        (c_finish_return): Fold return value.  Update call to
        convert_for_assignment.
        (c_start_case): Fold switch expression.
        (c_process_expr_stmt): Fold expression.
        (c_finish_stmt_expr): Create C_MAYBE_CONST_EXPR as needed to
        ensure statement expression is not evaluated in constant
        expression.
        (build_binary_op): Track whether results are integer constant
        expressions or may occur in such, disable folding and wrap results
        as applicable.  Fold operands for -Wsign-compare warnings unless
        in_late_binary_op.
        (c_objc_common_truthvalue_conversion): Handle results folded to
        integer constants that are not integer constant expressions.
        * doc/extend.texi: Document when typeof operands are evaluated,
        that condition of __builtin_choose_expr is an integer constant
        expression, and more about use of __builtin_constant_p in
        initializers.

gcc/objc:
        * objc-act.c (objc_finish_try_stmt): Set in_late_binary_op.

gcc/testsuite:
        * gcc.c-torture/compile/20081108-1.c,
        gcc.c-torture/compile/20081108-2.c,
        gcc.c-torture/compile/20081108-3.c, gcc.dg/bconstp-2.c,
        gcc.dg/bconstp-3.c, gcc.dg/bconstp-4.c, gcc.dg/c90-const-expr-6.c,
        gcc.dg/c90-const-expr-7.c, gcc.dg/c90-const-expr-8.c,
        gcc.dg/c90-const-expr-9.c, gcc.dg/c90-const-expr-10.c,
        gcc.dg/c90-const-expr-11.c, gcc.dg/c99-const-expr-6.c,
        gcc.dg/c99-const-expr-7.c, gcc.dg/c99-const-expr-8.c,
        gcc.dg/c99-const-expr-9.c, gcc.dg/c99-const-expr-10.c,
        gcc.dg/c99-const-expr-11.c, gcc.dg/c99-const-expr-12.c,
        gcc.dg/c99-const-expr-13.c, gcc.dg/compare10.c,
        gcc.dg/gnu89-const-expr-1.c, gcc.dg/gnu89-const-expr-2.c,
        gcc.dg/gnu99-const-expr-1.c, gcc.dg/gnu99-const-expr-2.c,
        gcc.dg/gnu99-const-expr-3.c, gcc.dg/vla-12.c, gcc.dg/vla-13.c,
        gcc.dg/vla-14.c, gcc.dg/vla-15.c, gcc.dg/vla-16.c: New tests.
        * gcc.dg/c90-const-expr-1.c, gcc.dg/c90-const-expr-2.c,
        gcc.dg/c90-const-expr-3.c, gcc.dg/c99-const-expr-2.c,
        gcc.dg/c99-const-expr-3.c, gcc.dg/c99-static-1.c: Remove XFAILs.
        * gcc.dg/c90-const-expr-2.c: Use ZERO in place of 0 in another
        case.
        * gcc.dg/overflow-warn-1.c, gcc.dg/overflow-warn-2.c,
        gcc.dg/overflow-warn-3.c, gcc.dg/overflow-warn-4.c: Remove
        XFAILs.  Update expected messages.
        * gcc.dg/pr14649-1.c, gcc.dg/pr19984.c, gcc.dg/pr25682.c: Update
        expected messages.
        * gcc.dg/real-const-1.c: Replace with test from original PR.
        * gcc.dg/vect/pr32230.c: Use intermediate cast to __PTRDIFF_TYPE__
        when casting from non-constant integer to pointer.

Added:
    trunk/fixincludes/tests/base/tgmath.h
    trunk/gcc/testsuite/gcc.c-torture/compile/20081108-1.c
    trunk/gcc/testsuite/gcc.c-torture/compile/20081108-2.c
    trunk/gcc/testsuite/gcc.c-torture/compile/20081108-3.c
    trunk/gcc/testsuite/gcc.dg/bconstp-2.c
    trunk/gcc/testsuite/gcc.dg/bconstp-3.c
    trunk/gcc/testsuite/gcc.dg/bconstp-4.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-10.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-11.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-6.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-7.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-8.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-9.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-10.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-11.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-12.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-13.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-6.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-7.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-8.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-9.c
    trunk/gcc/testsuite/gcc.dg/compare10.c
    trunk/gcc/testsuite/gcc.dg/gnu89-const-expr-1.c
    trunk/gcc/testsuite/gcc.dg/gnu89-const-expr-2.c
    trunk/gcc/testsuite/gcc.dg/gnu99-const-expr-1.c
    trunk/gcc/testsuite/gcc.dg/gnu99-const-expr-2.c
    trunk/gcc/testsuite/gcc.dg/gnu99-const-expr-3.c
    trunk/gcc/testsuite/gcc.dg/vla-12.c
    trunk/gcc/testsuite/gcc.dg/vla-13.c
    trunk/gcc/testsuite/gcc.dg/vla-14.c
    trunk/gcc/testsuite/gcc.dg/vla-15.c
    trunk/gcc/testsuite/gcc.dg/vla-16.c
Modified:
    trunk/fixincludes/ChangeLog
    trunk/fixincludes/fixincl.x
    trunk/fixincludes/inclhack.def
    trunk/gcc/ChangeLog
    trunk/gcc/builtins.c
    trunk/gcc/c-common.c
    trunk/gcc/c-common.def
    trunk/gcc/c-common.h
    trunk/gcc/c-convert.c
    trunk/gcc/c-decl.c
    trunk/gcc/c-parser.c
    trunk/gcc/c-tree.h
    trunk/gcc/c-typeck.c
    trunk/gcc/doc/extend.texi
    trunk/gcc/objc/ChangeLog
    trunk/gcc/objc/objc-act.c
    trunk/gcc/testsuite/ChangeLog
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-1.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-2.c
    trunk/gcc/testsuite/gcc.dg/c90-const-expr-3.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-2.c
    trunk/gcc/testsuite/gcc.dg/c99-const-expr-3.c
    trunk/gcc/testsuite/gcc.dg/c99-static-1.c
    trunk/gcc/testsuite/gcc.dg/overflow-warn-1.c
    trunk/gcc/testsuite/gcc.dg/overflow-warn-2.c
    trunk/gcc/testsuite/gcc.dg/overflow-warn-3.c
    trunk/gcc/testsuite/gcc.dg/overflow-warn-4.c
    trunk/gcc/testsuite/gcc.dg/pr14649-1.c
    trunk/gcc/testsuite/gcc.dg/pr19984.c
    trunk/gcc/testsuite/gcc.dg/pr25682.c
    trunk/gcc/testsuite/gcc.dg/real-const-1.c
    trunk/gcc/testsuite/gcc.dg/vect/pr32230.c


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[jsm28 at gcc dot gnu dot org]

------- Comment #12 from jsm28 at gcc dot gnu dot org  2008-10-24 19:36 -------
Subject: Bug 19976

Author: jsm28
Date: Fri Oct 24 19:34:52 2008
New Revision: 141349

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=141349
Log:
        PR c/456
        PR c/5675
        PR c/19976
        PR c/29116
        PR c/31871
        PR c/35198

fixincludes:
        * inclhack.def (glibc_tgmath): New fix.
        * fixincl.x: Regenerate.
        * tests/base/tgmath.h: New.

gcc:
        * builtins.c (fold_call_expr): Return a NOP_EXPR from folding
        rather than the contained expression.
        * c-common.c (c_save_expr): New.
        (c_common_truthvalue_conversion): Use c_save_expr.  Do not fold
        conditional expressions for C.
        * c-common.def (C_MAYBE_CONST_EXPR): New.
        * c-common.h (c_fully_fold, c_save_expr): New prototypes.
        (C_MAYBE_CONST_EXPR_PRE, C_MAYBE_CONST_EXPR_EXPR,
        C_MAYBE_CONST_EXPR_INT_OPERANDS, C_MAYBE_CONST_EXPR_NON_CONST,
        EXPR_INT_CONST_OPERANDS): Define.
        * c-convert.c (convert): Strip nops from expression.
        * c-decl.c (groktypename): Take extra parameters expr and
        expr_const_operands.  Update call to grokdeclarator.
        (start_decl): Update call to grokdeclarator.  Add statement for
        expressions used in type of decl.
        (grokparm): Update call to grokdeclarator.
        (push_parm_decl): Update call to grokdeclarator.
        (build_compound_literal): Add parameter non_const and build a
        C_MAYBE_COSNT_EXPR if applicable.
        (grokdeclarator): Take extra parameters expr and
        expr_const_operands.  Track expressions used in declaration
        specifiers and declarators.  Fold array sizes and track whether
        they are constant expressions and whether they are integer
        constant expressions.
        (parser_xref_tag): Set expr and expr_const_operands fields in
        return value.
        (grokfield): Update call to grokdeclarator.
        (start_function): Update call to grokdeclarator.
        (build_null_declspecs): Set expr and expr_const_operands fields in
        return value.
        (declspecs_add_type): Handle expressions in typeof specifiers.
        * c-parser.c (c_parser_declspecs): Set expr and
        expr_const_operands fields for declaration specifiers.
        (c_parser_enum_specifier): Likewise.
        (c_parser_struct_or_union_specifier): Likewise.
        (c_parser_typeof_specifier): Likewise.  Update call to
        groktypename.  Fold expression as needed.  Return expressions with
        type instead of adding statements.
        (c_parser_attributes): Update calls to c_parser_expr_list.
        (c_parser_statement_after_labels): Fold expression before passing
        to objc_build_throw_stmt.
        (c_parser_condition): Fold expression.
        (c_parser_asm_operands): Fold expression.
        (c_parser_conditional_expression): Use c_save_expr.  Update call
        to build_conditional_expr.
        (c_parser_alignof_expression): Update call to groktypename.
        (c_parser_postfix_expression): Preserve C_MAYBE_CONST_EXPR as
        original_code.  Fold expression argument of va_arg.  Create
        C_MAYBE_CONST_EXPR to preserve side effects of expressions in type
        argument to va_arg.  Update calls to groktypename.  Fold array
        index for offsetof.  Verify that first argument to
        __builtin_choose_expr has integer type.
        (c_parser_postfix_expression_after_paren_type): Update calls to
        groktypename and build_compound_literal.  Handle expressions with
        side effects in type name.
        (c_parser_postfix_expression_after_primary): Update call to
        c_parser_expr_list.  Set original_code for calls to
        __builtin_constant_p.
        (c_parser_expr_list): Take extra parameter fold_p.  Fold
        expressions if requested.
        (c_parser_objc_type_name): Update call to groktypename.
        (c_parser_objc_synchronized_statement): Fold expression.
        (c_parser_objc_receiver): Fold expression.
        (c_parser_objc_keywordexpr): Update call to c_parser_expr_list.
        (c_parser_omp_clause_num_threads, c_parser_omp_clause_schedule,
        c_parser_omp_atomic, c_parser_omp_for_loop): Fold expressions.
        * c-tree.h (CONSTRUCTOR_NON_CONST): Define.
        (struct c_typespec): Add elements expr and expr_const_operands.
        (struct c_declspecs): Add elements expr and expr_const_operands.
        (groktypename, build_conditional_expr, build_compound_literal):
        Update prototypes.
        * c-typeck.c (c_fully_fold, c_fully_fold_internal,
        note_integer_operands): New functions.
        (decl_constant_value_for_broken_optimization): Rename to
        decl_constant_value_for_optimization:  Check whether optimizing
        and that the expression is a VAR_DECL not of array type instead of
        doing such checks in the caller.  Do not check pedantic.
        (default_function_array_conversion): Do not strip nops.
        (default_conversion): Do not call
        decl_constant_value_for_broken_optimization.
        (build_array_ref): Do not fold result.
        (c_expr_sizeof_expr): Fold operand.  Use C_MAYBE_CONST_EXPR for
        result when operand is a VLA.
        (c_expr_sizeof_type): Update call to groktypename.  Handle
        expressions included in type name.  Use C_MAYBE_CONST_EXPR for
        result when operand names a VLA type.
        (build_function_call): Update call to build_compound_literal.
        Only fold result for calls to __builtin_* functions.  Strip
        NOP_EXPR from INTEGER_CST returned from such functions.
        (convert_arguments): Fold arguments.  Update call to
        convert_for_assignment.
        (build_unary_op): Handle increment and decrement of
        C_MAYBE_CONST_EXPR.  Move lvalue checks for increment and
        decrement earlier.  Fold operand of increment and decrement.
        Handle address of C_MAYBE_CONST_EXPR.  Only fold expression being
        built for integer operand.  Wrap returns that are INTEGER_CSTs
        without being integer constant expressions or that have integer
        constant operands without being INTEGER_CSTs.
        (lvalue_p): Handle C_MAYBE_CONST_EXPR.
        (build_conditional_expr): Add operand ifexp_bcp.  Track whether
        result is an integer constant expression or can be used in
        unevaluated parts of one and avoid folding and wrap as
        appropriate.
        (build_compound_expr): Wrap result for C99 if operands can be used
        in integer constant expressions.
        (build_c_cast): Update call to digest_init.  Do not ignore
        overflow from casting floating-point constants to integers.  Wrap
        results that could be confused with integer constant expressions,
        null pointer constants or floating-point constants.
        (c_cast_expr): Update call to groktypename.  Handle expressions
        included in type name.
        (build_modify_expr): Handle modifying a C_MAYBE_CONST_EXPR.  Fold
        lhs inside possible SAVE_EXPR.  Fold RHS before assignment.
        Update calls to convert_for_assignment.
        (convert_for_assignment): Take new parameter
        null_pointer_constant.  Do not strip nops or call
        decl_constant_value_for_broken_optimization.
        (store_init_value): Update call to digest_init.
        (digest_init): Take new parameter null_pointer_constant.  Do not
        call decl_constant_value_for_broken_optimization.  pedwarn for
        initializers not constant expressions.  Update calls to
        convert_for_assignment.
        (constructor_nonconst): New.
        (struct constructor_stack): Add nonconst element.
        (really_start_incremental_init, push_init_level, pop_init_level):
        Handle constructor_nonconst and nonconst element.
        (set_init_index): Call constant_expression_warning for array
        designators.
        (output_init_element): Fold value.  Set constructor_nonconst as
        applicable.  pedwarn for initializers not constant expressions.
        Update call to digest_init.  Call constant_expression_warning
        where constant initializers are required.
        (process_init_element): Use c_save_expr.
        (c_finish_goto_ptr): Fold expression.
        (c_finish_return): Fold return value.  Update call to
        convert_for_assignment.
        (c_start_case): Fold switch expression.
        (c_process_expr_stmt): Fold expression.
        (c_finish_stmt_expr): Create C_MAYBE_CONST_EXPR as needed to
        ensure statement expression is not evaluated in constant
        expression.
        (build_binary_op): Track whether results are integer constant
        expressions or may occur in such, disable folding and wrap results
        as applicable.
        (c_objc_common_truthvalue_conversion): Handle results folded to
        integer constants that are not integer constant expressions.
        * doc/extend.texi: Document when typeof operands are evaluated,
        that condition of __builtin_choose_expr is an integer constant
        expression, and more about use of __builtin_constant_p in
        initializers.

gcc/cp:
        * typeck.c (c_fully_fold): New.

gcc/testsuite:
        * gcc.dg/bconstp-2.c, gcc.dg/c90-const-expr-6.c,
        gcc.dg/c90-const-expr-7.c, gcc.dg/c90-const-expr-8.c,
        gcc.dg/c90-const-expr-9.c, gcc.dg/c90-const-expr-10.c,
        gcc.dg/c90-const-expr-11.c, gcc.dg/c99-const-expr-6.c,
        gcc.dg/c99-const-expr-7.c, gcc.dg/c99-const-expr-8.c,
        gcc.dg/c99-const-expr-9.c, gcc.dg/c99-const-expr-10.c,
        gcc.dg/c99-const-expr-11.c, gcc.dg/c99-const-expr-12.c,
        gcc.dg/c99-const-expr-13.c, gcc.dg/gnu89-const-expr-1.c,
        gcc.dg/gnu89-const-expr-2.c, gcc.dg/gnu99-const-expr-1.c,
        gcc.dg/gnu99-const-expr-2.c, gcc.dg/gnu99-const-expr-3.c,
        gcc.dg/vla-11.c, gcc.dg/vla-12.c, gcc.dg/vla-13.c,
        gcc.dg/vla-14.c, gcc.dg/vla-15.c: New tests.
        * gcc.dg/c90-const-expr-1.c, gcc.dg/c90-const-expr-2.c,
        gcc.dg/c90-const-expr-3.c, gcc.dg/c99-const-expr-2.c,
        gcc.dg/c99-const-expr-3.c, gcc.dg/c99-static-1.c: Remove XFAILs.
        * gcc.dg/overflow-warn-1.c, gcc.dg/overflow-warn-2.c,
        gcc.dg/overflow-warn-3.c, gcc.dg/overflow-warn-4.c: Remove
        XFAILs.  Update expected messages.
        * gcc.dg/pr14649-1.c, gcc.dg/pr19984.c, gcc.dg/pr25682.c: Update
        expected messages.
        * gcc.dg/real-const-1.c: Replace with test from original PR.

Added:
    branches/c-4_5-branch/fixincludes/ChangeLog.c45
    branches/c-4_5-branch/fixincludes/tests/base/tgmath.h
    branches/c-4_5-branch/gcc/ChangeLog.c45
    branches/c-4_5-branch/gcc/cp/ChangeLog.c45
    branches/c-4_5-branch/gcc/testsuite/ChangeLog.c45
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/bconstp-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-10.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-11.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-6.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-7.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-8.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-9.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-10.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-11.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-12.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-13.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-6.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-7.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-8.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-9.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/gnu89-const-expr-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/gnu89-const-expr-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/gnu99-const-expr-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/gnu99-const-expr-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/gnu99-const-expr-3.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/vla-11.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/vla-12.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/vla-13.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/vla-14.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/vla-15.c
Modified:
    branches/c-4_5-branch/fixincludes/fixincl.x
    branches/c-4_5-branch/fixincludes/inclhack.def
    branches/c-4_5-branch/gcc/builtins.c
    branches/c-4_5-branch/gcc/c-common.c
    branches/c-4_5-branch/gcc/c-common.def
    branches/c-4_5-branch/gcc/c-common.h
    branches/c-4_5-branch/gcc/c-convert.c
    branches/c-4_5-branch/gcc/c-decl.c
    branches/c-4_5-branch/gcc/c-parser.c
    branches/c-4_5-branch/gcc/c-tree.h
    branches/c-4_5-branch/gcc/c-typeck.c
    branches/c-4_5-branch/gcc/cp/typeck.c
    branches/c-4_5-branch/gcc/doc/extend.texi
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c90-const-expr-3.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-const-expr-3.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/c99-static-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/overflow-warn-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/overflow-warn-2.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/overflow-warn-3.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/overflow-warn-4.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/pr14649-1.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/pr19984.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/pr25682.c
    branches/c-4_5-branch/gcc/testsuite/gcc.dg/real-const-1.c


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[jsm28 at gcc dot gnu dot org]

------- Comment #11 from jsm28 at gcc dot gnu dot org  2008-10-24 00:07 -------
Testing a patch for 4.5.


-- 

jsm28 at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot gnu   |jsm28 at gcc dot gnu dot org
                   |dot org                     |
             Status|NEW                         |ASSIGNED
   Last reconfirmed|2005-12-18 01:39:17         |2008-10-24 00:07:24
               date|                            |


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[pinskia at gcc dot gnu dot org]

------- Comment #10 from pinskia at gcc dot gnu dot org  2007-07-06 09:52 -------
I think for the 0*x case, we need the infrastructure provided by PR 32643 and
then set folding_initializer when we are inside an enum.


-- 

pinskia at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |pinskia at gcc dot gnu dot
                   |                            |org
  BugsThisDependsOn|                            |32643


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[manu at gcc dot gnu dot org]

------- Comment #9 from manu at gcc dot gnu dot org  2007-03-11 00:31 -------
I tried setting TREE_OVERFLOW on a new node created from the zero of the
division by zero and then replacing the zero in 1/0 by this new node. It didn't
work, it seems that somehow the node that represents the result of 1/0 is built
in some way that ignores TREE_OVERFLOW.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[manu at gcc dot gnu dot org]

------- Comment #8 from manu at gcc dot gnu dot org  2006-12-11 20:52 -------
(In reply to comment #5)
> int x;
> 
> enum e { E = 0 * x };
> 
> 
> which currently compiles without even a warning using -pedantic-errors.
> This is exactly the sort of thing that Joseph's struct c_expr were intended
> to handle.  I don't think is unreasonable for fold to convert "0 * x" into
> 0, the issue is that a front-end can't really look at a folded tree and
> determine anything much about the original source code.

Should it warn? 

But back to the original case, we detect enum e { E = 0 * (INT_MAX + 1) }; by
setting TREE_OVERFLOW. We could do the same for 1/0 and we just don't emit an
overflow warning but a division by zero one. But this could be tricky.

However, an alternative would be to prevent the folding for this specific case,
so the resulting tree is not constant. We could try to detect this when folding
0*x (not sure how), or we could build something from 1/0 that will prevent
folding 0*x (if such thing exists). 

Am I missing any other alternatives?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[joseph at codesourcery dot com]

------- Comment #7 from joseph at codesourcery dot com  2006-12-03 21:05 -------
Subject: Re:  integer division by zero in subexpression should
 be overflow

On Sun, 3 Dec 2006, manu at gcc dot gnu dot org wrote:

> > The real issue is that OPT_Wdiv_by_zero needs to be enabled by -pedantic
> > in order to generate an error for -pedantic-errors, as requested by
> > Joseph in comment #1.
> 
> So, we just have to replace warning by pedwarn, don't we?

No, because except in evaluated parts of constant expressions this is only 
runtime undefined and so must be accepted.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[manu at gcc dot gnu dot org]

------- Comment #6 from manu at gcc dot gnu dot org  2006-12-03 21:02 -------
(In reply to comment #3)
> Hi Manual,

Manuel (or Manu) http://en.wikipedia.org/wiki/Manuel

not manual: http://en.wikipedia.org/wiki/Manual

:-)

> The real issue is that OPT_Wdiv_by_zero needs to be enabled by -pedantic
> in order to generate an error for -pedantic-errors, as requested by
> Joseph in comment #1.

So, we just have to replace warning by pedwarn, don't we?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[roger at eyesopen dot com]

------- Comment #5 from roger at eyesopen dot com  2006-12-01 04:04 -------
>> This needs to be handled in the front-ends...
>       ^^^^^ should
              ^^^^^^ can only be

I was thinking of a slightly weaker form of need/must.
But there are two issues here.  The division by zero is one, but its also
a red herring, we really shouldn't be accepting the code:

int x;

enum e { E = 0 * x };


which currently compiles without even a warning using -pedantic-errors.
This is exactly the sort of thing that Joseph's struct c_expr were intended
to handle.  I don't think is unreasonable for fold to convert "0 * x" into
0, the issue is that a front-end can't really look at a folded tree and
determine anything much about the original source code.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

Re: [Bug c/19976] integer division by zero in subexpression should be overflow

[Andrew Pinski]

> Hi Manual,
> 
> This needs to be handled in the front-ends, and in fact is already handled
       ^^^^^
       should
> by the front-ends.  In c-typeck.c:build_binary_op, I see:
> 
>     case TRUNC_DIV_EXPR:
>     case CEIL_DIV_EXPR:
>     case FLOOR_DIV_EXPR:
>     case ROUND_DIV_EXPR:
>     case EXACT_DIV_EXPR:
>       /* Floating point division by zero is a legitimate way to obtain
>          infinities and NaNs.  */
>       if (skip_evaluation == 0 && integer_zerop (op1))
>         warning (OPT_Wdiv_by_zero, "division by zero");
> 
> Likewise, there are several references to OPT_Wdiv_by_zero in cp/typeck.c.
> The real issue is that OPT_Wdiv_by_zero needs to be enabled by -pedantic
> in order to generate an error for -pedantic-errors, as requested by
> Joseph in comment #1.

Actually it is only a diagnostic problem if we are in a constant expression.

Thanks,
Andrew Pinski

[Bug c/19976] integer division by zero in subexpression should be overflow

[pinskia at physics dot uc dot edu]

------- Comment #4 from pinskia at physics dot uc dot edu  2006-12-01 03:32 -------
Subject: Re:  integer division by zero in subexpression should be overflow

> Hi Manual,
> 
> This needs to be handled in the front-ends, and in fact is already handled
       ^^^^^
       should
> by the front-ends.  In c-typeck.c:build_binary_op, I see:
> 
>     case TRUNC_DIV_EXPR:
>     case CEIL_DIV_EXPR:
>     case FLOOR_DIV_EXPR:
>     case ROUND_DIV_EXPR:
>     case EXACT_DIV_EXPR:
>       /* Floating point division by zero is a legitimate way to obtain
>          infinities and NaNs.  */
>       if (skip_evaluation == 0 && integer_zerop (op1))
>         warning (OPT_Wdiv_by_zero, "division by zero");
> 
> Likewise, there are several references to OPT_Wdiv_by_zero in cp/typeck.c.
> The real issue is that OPT_Wdiv_by_zero needs to be enabled by -pedantic
> in order to generate an error for -pedantic-errors, as requested by
> Joseph in comment #1.

Actually it is only a diagnostic problem if we are in a constant expression.

Thanks,
Andrew Pinski


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[roger at eyesopen dot com]

------- Comment #3 from roger at eyesopen dot com  2006-12-01 03:25 -------
Hi Manual,

This needs to be handled in the front-ends, and in fact is already handled
by the front-ends.  In c-typeck.c:build_binary_op, I see:

    case TRUNC_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case EXACT_DIV_EXPR:
      /* Floating point division by zero is a legitimate way to obtain
         infinities and NaNs.  */
      if (skip_evaluation == 0 && integer_zerop (op1))
        warning (OPT_Wdiv_by_zero, "division by zero");

Likewise, there are several references to OPT_Wdiv_by_zero in cp/typeck.c.
The real issue is that OPT_Wdiv_by_zero needs to be enabled by -pedantic
in order to generate an error for -pedantic-errors, as requested by
Joseph in comment #1.

I hope this helps.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976

[Bug c/19976] integer division by zero in subexpression should be overflow

[manu at gcc dot gnu dot org]

------- Comment #2 from manu at gcc dot gnu dot org  2006-12-01 02:37 -------
Hi Roger,

I am not sure how we are going to handle this. 

First, the 1/0 is detected at int_const_binop at line 1509 
--------------------------------------
   case ROUND_DIV_EXPR:
      if (int2h == 0 && int2l == 0)
        return NULL_TREE;
--------------------------------------
I don't think we can return something different from NULL_TREE here. But we
cannot set TREE_OVERFLOW on a NULL_TREE.

Second, when int_const_binop returns to fold_binary we have another opportunity
to detect this at line 10026, but again we return NULL_TREE
----------------------------
    case ROUND_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case EXACT_DIV_EXPR:
      if (integer_onep (arg1))
        return non_lvalue (fold_convert (type, arg0));
      if (integer_zerop (arg1))
        return NULL_TREE;
----------------------------

Next, fold_build2_stat uses build2_stat to construct a valid tree node
(code=TRUNC_DIV_EXPR) but I don't see anything that can be used to detect that
there was a division by zero. 

Finally, that tree node is simply omitted when folding 0*expr . 

I really don't see how TREE_OVERFLOW could help here.

Unless we change 1/0 to be the same as INT_MAX+1, that is, a constant overflow.
However, then we will need something else to not warn about constant overflow
but only for division by zero. 

Another option could be to build a TRUNC_DIV_EXPR node with TREE_OVERFLOW set
instead of returning NULL_TREE. But how and when?

I am running out of ideas...


-- 

manu at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |manu at gcc dot gnu dot org,
                   |                            |roger at eyesopen dot com


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19976