[Bug c/45831] New: 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[Bug c/45831] New: 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

           Summary: 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10
                    expected)
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: MichieldeB@aim.com


gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

#include <stdio.h>

main () {
  int ten = 10;
  printf ("%d = %d\n", 10 << -32, ten << -32);
  return 0;
}

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[schwab@linux-m68k.org]

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

Andreas Schwab <schwab@linux-m68k.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |INVALID

--- Comment #1 from Andreas Schwab <schwab@linux-m68k.org> 2010-09-29 13:38:32 UTC ---
Negative shift counts are undefined.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #2 from Michiel <MichieldeB at aim dot com> 2010-09-29 14:20:29 UTC ---
That does not mean that it is a very bad idea to use another library for
precomputation.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #3 from Michiel <MichieldeB at aim dot com> 2010-09-29 14:22:39 UTC ---
Still it is a very bad idea to use another library for precomputation.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #4 from Michiel <MichieldeB at aim dot com> 2010-09-29 14:29:54 UTC ---
In case you are missing the point, most non-bug posters compile on their target
machine.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[pinskia at gcc dot gnu.org]

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

--- Comment #5 from Andrew Pinski <pinskia at gcc dot gnu.org> 2010-09-29 14:59:22 UTC ---
(In reply to comment #4)
> In case you are missing the point, most non-bug posters compile on their target
> machine.

In C/C++, shifting by a negative number is undefined.  So what that means is
that it could produce a different values on different targets and at different
times (including at different optimization level).  I think we warn with either
-Wextra or -Wall when we see a negative shifting count.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[manu at gcc dot gnu.org]

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

Manuel López-Ibáñez <manu at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |manu at gcc dot gnu.org

--- Comment #7 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2010-09-29 15:25:11 UTC ---
Andrew, I really admire your patience explaining the details, but I think we
should just point people to good references from the start

http://c-faq.com/ansi/undef.html

I think that provides far more info that we can give here, save us time, and
avoids the frustration of users having to ask for more and more details until
they understand the issue.

And we warn by default.

warning: left shift count is negative

I think the warning should mention "undefined"

warning: negative left shift count is undefined

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #6 from Michiel <MichieldeB at aim dot com> 2010-09-29 15:19:11 UTC ---
If undefined behavior only depends on the machine (most times compiling machine
and target machine are the same), then there will be less bias here.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[manu at gcc dot gnu.org]

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

--- Comment #8 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2010-09-29 15:28:11 UTC ---
Why don't we just not compile programs with evident undefined behaviour? I
think the standard allows us to do so.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[joseph at codesourcery dot com]

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

--- Comment #9 from joseph at codesourcery dot com <joseph at codesourcery dot com> 2010-09-29 15:43:02 UTC ---
On Wed, 29 Sep 2010, manu at gcc dot gnu.org wrote:

> Why don't we just not compile programs with evident undefined behaviour? I
> think the standard allows us to do so.

http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_109.html

   A conforming implementation must not fail to translate a strictly
   conforming program simply because some possible execution of that
   program would result in undefined behavior. Because foo might never be
   called, the example given must be successfully translated by a
   conforming implementation.

The standard never says explicitly whether particular undefined behavior 
is compile-time undefined (a property of the program) or run-time 
undefined (a property of a particular path of execution through the 
program), so you have to read it carefully to figure this out in each 
case, but when it is run-time undefined (as here) the program must be 
accepted unless all executions must involve the undefined behavior.  I 
don't think the cases where the undefined behavior is in main and can be 
shown always to occur are sufficiently common (in real code rather than 
artificial testcases) to make it worthwhile to give errors specially for 
them.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #10 from Michiel <MichieldeB at aim dot com> 2010-09-30 11:23:58 UTC ---
To get to know what a formula does, I usually compute some examples. When doing
so, I was warned, but ignored them and that was stupid.

There are however also warnings that are stupid. I now think of setting an
integer to -2147483648. 2147483648 is too large for an integer and it is good
that the compiler warns you. Unfortunately, the compiler ignores the context of
2147483648 and thus warns for -2147483648 as well. A similar argument applies
for setting an unsigned to a value in the range 2147483648 to 4294967295. 

On the other hand, setting an unsigned to a negative value does not give any
warning. Setting an unsigned to e.g. -1 is totally unnecessary, since you can
write ~0 instead, which is also preferable.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[schwab@linux-m68k.org]

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

--- Comment #11 from Andreas Schwab <schwab@linux-m68k.org> 2010-09-30 11:33:54 UTC ---
-1 works for any integer type, ~0 only works for unsigned (int|short|char).

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #12 from Jakub Jelinek <jakub at gcc dot gnu.org> 2010-09-30 11:56:41 UTC ---
And the warnings you mention are of course reasonable, -2147483648 in C/C++
is the integer constant 2147483648 (which doesn't fit into int), which is
afterwards negated, you should write -2147483647-1, and you should be using
4294967295U if you want an unsigned int constant.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[manu at gcc dot gnu.org]

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

--- Comment #13 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2010-09-30 12:12:17 UTC ---
(In reply to comment #10)
> To get to know what a formula does, I usually compute some examples. When doing
> so, I was warned, but ignored them and that was stupid.
> 
> There are however also warnings that are stupid. I now think of setting an
> integer to -2147483648. 2147483648 is too large for an integer and it is good
> that the compiler warns you. Unfortunately, the compiler ignores the context of
> 2147483648 and thus warns for -2147483648 as well. A similar argument applies
> for setting an unsigned to a value in the range 2147483648 to 4294967295. 
> 
> On the other hand, setting an unsigned to a negative value does not give any
> warning. Setting an unsigned to e.g. -1 is totally unnecessary, since you can
> write ~0 instead, which is also preferable.

See: http://gcc.gnu.org/wiki/NewWconversion#Frequently_Asked_Questions

Please search also the C FAQs, your answers are there. We cannot change how C
works, even if it seems counter-intuitive at first glance.

If you find another specific problem, please open a new PR with a complete
testcase and expected/obtained output.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #14 from Michiel <MichieldeB at aim dot com> 2010-09-30 18:30:16 UTC ---
Remove signed/unsigned warnings, or even overflow warnings, for constants that
are used in an expression with the following operations only:

casts to integral type of smaller or equal size,
casts to boolean, !, == and !=,
casts from boolean to integral type, ? :,
+ - * << & | ^.

Probably I missed some, but I hope you see what I mean. Then you will
understand that /, %, >> and casts to larger integral type (or float, double)
do not belong to this list.

Is that really too hard?

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[manu at gcc dot gnu.org]

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

--- Comment #15 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2010-09-30 18:51:33 UTC ---
(In reply to comment #14)
>
> Is that really too hard?

You are ignoring everything everybody is saying. If you think it is trivial,
just take one single little case of the ones that bother you and fix it:

http://gcc.gnu.org/contribute.html

GCC needs more developers anyway, so you are welcome on board.

[Bug c/45831] 0 = 10 (with -O0, 0 = 0 with -O1, but 10 = 10 expected)

[MichieldeB at aim dot com]

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

--- Comment #16 from Michiel <MichieldeB at aim dot com> 2010-09-30 19:38:55 UTC ---
(In reply to comment #15)
> (In reply to comment #14)
> >
> > Is that really too hard?
>
> You are ignoring everything everybody is saying. If you think it is trivial,
> just take one single little case of the ones that bother you and fix it:
> 
> http://gcc.gnu.org/contribute.html
> 
> GCC needs more developers anyway, so you are welcome on board.

I am not ignoring everyone, since I formulated things far more concrete than
before. And I failed to formulate similar things to warnings for assigning
negative expressions to unsigned integers.

Another thing that is worth noting, is that recognizing expression as mentioned
above is also valuable for optimization, namely if you convert the result later
to a smaller integral type, and the larger integral type is larger than the
machines integral type, then you better do the computations with the smaller
integral type instead.

I have to apologize. There are already too many technically interesting things,
or just interesting things that are also technically, that I want to do.
Furthermore, I think that it will take very much time before I can make my
first contribution to the compiler, but I should browse the source to get a
better opinion on that. Some library routines would be more attainable, I will
think about that.