possible bug with synchronized methods

[Godmar Back <gback at cs dot utah dot edu>]

I am trying to figure out how gcj exits the monitors associated with
synchronized methods when an exception occurs.

The following test case fails for a gcj/libgcj configured with 
--enable-threads=posix.  I've filed a bug report, feel free to include
the program in the test suite if you think it would be useful.

From looking at the code, I don't quite understand why this program
fails.  In decl.c, the method body is wrapped in a mon_enter with
a mon_exit as a "cleanup" clause.  In stmt.c, a comment above
expand_decl_cleanup says that the cleanup cause is invoked in the
case of exceptions.  So it should work, should it not?

Does anybody know what's going on?

	- Godmar


/**
 * Test that locks taken in synchronized methods are properly unlocked
 * when an exception occurs.  Note that different mechanisms are used in
 * compiler & interpreter.
 *
 * @author Godmar Back <gback@cs.utah.edu>
 */
public class TestUnlock {
    synchronized void throwException() throws Exception {
        throw new Exception();
    }

    synchronized void success() {
        System.out.println("Success.");
    }

    public static void main(String av[]) throws Exception {
        final TestUnlock me = new TestUnlock();

        new Thread() {
            public void run() {
               try {
                   Thread.sleep(2000);
               } catch (Exception _) { }
               System.out.println("Time out.  Failure.");
               System.exit(-1);
            }
        }.start();

        Thread t = new Thread() {
            public void run() {
               try {
                   me.throwException();
               } catch (Exception _) {
               }
            }
        };
        t.start();
        t.join();

        Thread t2 = new Thread() {
            public void run() {
               me.success();
            }
        };
        t2.start();
        t2.join();
        System.exit(0);
    }
}

/* Expected Output:
Success.
*/