Re: java/8204: gcj -O2 to native reorders certain instructions improperly.

Re: java/8204: gcj -O2 to native reorders certain instructions improperly.

[bangerth]

Synopsis: gcj -O2 to native reorders certain instructions improperly.

State-Changed-From-To: feedback->open
State-Changed-By: bangerth
State-Changed-When: Mon Mar 24 15:16:42 2003
State-Changed-Why:
    Leave this to the Java experts

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8204

Re: java/8204: gcj -O2 to native reorders certain instructions improperly.

[Tom Tromey]

The following reply was made to PR java/8204; it has been noted by GNATS.

From: Tom Tromey <tromey@redhat.com>
To: bangerth@dealii.org
Cc: gcc-bugs@gcc.gnu.org, gcc-prs@gcc.gnu.org, java-prs@gcc.gnu.org,
        nobody@gcc.gnu.org, rsdio@metastatic.org, gcc-gnats@gcc.gnu.org
Subject: Re: java/8204: gcj -O2 to native reorders certain instructions improperly.
Date: 25 Mar 2003 15:36:42 -0700

 >>>>> ">" == bangerth  <bangerth@dealii.org> writes:
 
 >>       (f(s.charAt(i++)) << 4) | (f(s.charAt(i++))))
 >>     I don't know enough about Java, but in C/C++ this will invoke
 >>     undefined behavior, since the standard doesn't prescribe
 >>     which of the two function calls happen first, and with
 >>     which value of i. Is this different in Java, i.e. does
 >>     the Java standard give guarantees as to the order in which
 >>     the sub-statements are executed?
     
 Yes, Java specifies left-to-right evaluation in this situation.
 
 Chances are that this bug is fixed, but I haven't tried it.
 
 Tom

Re: java/8204: gcj -O2 to native reorders certain instructions improperly.

[Casey Marshall]

The following reply was made to PR java/8204; it has been noted by GNATS.

From: Casey Marshall <rsdio@metastatic.org>
To: bangerth@dealii.org,  gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: java/8204: gcj -O2 to native reorders certain instructions improperly.
Date: Sat, 22 Mar 2003 16:00:40 -0800

 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA1
 
 bangerth@dealii.org wrote:
 | Synopsis: gcj -O2 to native reorders certain instructions improperly.
 |
 | State-Changed-From-To: open->feedback
 | State-Changed-By: bangerth
 | State-Changed-When: Sat Mar 22 18:09:51 2003
 | State-Changed-Why:
 |     In your code, you are modifying i twice in the same line:
 |       (f(s.charAt(i++)) << 4) | (f(s.charAt(i++))))
 |     I don't know enough about Java, but in C/C++ this will invoke
 |     undefined behavior, since the standard doesn't prescribe
 |     which of the two function calls happen first, and with
 |     which value of i. Is this different in Java, i.e. does
 |     the Java standard give guarantees as to the order in which
 |     the sub-statements are executed?
 |
 
 I haven't gone through the JLS very carefully, but it does seem that a
 construction of this sort *should* produce the behavior I'd expect.
 Specifically, the JLS says that when evaluating expressions (chapter 15):
 
 1. The left operand of a binary operator is evaluated first.
 2. Respect is paid to operator precedence and parentheses.
 3. Operands are evaluated fully before operation.
 
 The problem appeared to be that when compiled with -O2 the right
 expression was evaluated first, rather than the left (at least this is
 what the result *looked* like). It would seem out of character for some
 behavior to be undefined in Java anyway ;)
 
 That said, this type of statement *is* unnecessary, and I can do without it.
 
 Cheers,
 
 - --
 Casey Marshall || rsdio@metastatic.org
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.2.1 (GNU/Linux)
 Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org
 
 iD8DBQE+fPkngAuWMgRGsWsRAgfrAJ9hZQv3K56c1udOyKsdMFgTUeAApgCfS+QP
 uuQ/e75sLqsfNYtciqpic2k=
 =bTs/
 -----END PGP SIGNATURE-----
 

Re: java/8204: gcj -O2 to native reorders certain instructions improperly.

[bangerth]

Synopsis: gcj -O2 to native reorders certain instructions improperly.

State-Changed-From-To: open->feedback
State-Changed-By: bangerth
State-Changed-When: Sat Mar 22 18:09:51 2003
State-Changed-Why:
    In your code, you are modifying i twice in the same line:
      (f(s.charAt(i++)) << 4) | (f(s.charAt(i++))))
    I don't know enough about Java, but in C/C++ this will invoke
    undefined behavior, since the standard doesn't prescribe
    which of the two function calls happen first, and with
    which value of i. Is this different in Java, i.e. does
    the Java standard give guarantees as to the order in which
    the sub-statements are executed?
    
    W.

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8204