Merge remote-tracking branch 'refs/remotes/ReadyTalk/master' into avian-droid

.gitignore

@@ -9,3 +9,4 @@ bin
 /distrib
 *.pdb
 *.swp
+/*.sublime-*

classpath/java/util/concurrent/ConcurrentLinkedQueue.java

@@ -56,7 +56,7 @@ public class ConcurrentLinkedQueue<T> {
     return poll(true);
   }
 
-  public T poll(boolean remove) {
+  private T poll(boolean remove) {
     while (true) {
       Node<T> h = head;
       Node<T> t = tail;

src/classpath-openjdk.cpp

@@ -698,15 +698,6 @@ class MyClasspath : public Classpath {
 #else // not AVIAN_OPENJDK_SRC
     expect(t, loadLibrary(t, libraryPath, "verify", true, true));
     expect(t, loadLibrary(t, libraryPath, "java", true, true));
-#  ifndef PLATFORM_WINDOWS
-    // at one point, loading libmawt ahead of time was necessary to
-    // make AWT work, but recent versions of OpenJDK seem to take care
-    // of this from Java code, in which case loading it ahead of time
-    // actually causes trouble, so we comment it out for now until we
-    // know exactly when it's needed:
-
-    //loadLibrary(t, libraryPath, "mawt", true, true, false);
-#  endif
 #endif // not AVIAN_OPENJDK_SRC
 
     { object assertionLock = resolveField

src/compile.cpp

@@ -3234,7 +3234,11 @@ compileDirectInvoke(MyThread* t, Frame* frame, object target, bool tailCall)
 
   Compiler::Operand* result = 0;
 
-  if (emptyMethod(t, target)) {
+  // don't bother calling an empty method unless calling it might
+  // cause the class to be initialized, which may have side effects
+  if (emptyMethod(t, target)
+      and (not classNeedsInit(t, methodClass(t, target))))
+  {
     tailCall = false;
   } else {
     BootContext* bc = frame->context->bootContext;

test/Misc.java

@@ -23,6 +23,16 @@ public class Misc {
     }
   }
 
+  private static class Static {
+    static {
+      staticRan = true;
+    }
+
+    public static void run() { }
+  }
+
+  private static boolean staticRan;
+
   private static int alpha;
   private static int beta;
   private static byte byte1, byte2, byte3;
@@ -299,6 +309,10 @@ public class Misc {
     } catch (java.net.UnknownHostException e) {
       // cool
     }
+
+    expect(! staticRan);
+    Static.run();
+    expect(staticRan);
   }
 
   protected class Protected { }

unittest/codegen/assembler-test.cpp

@@ -62,25 +62,12 @@ public:
 };
 
 
-class BasicAssemblerTest : public Test {
+TEST(BasicAssembler) {
-public:
-  BasicAssemblerTest():
-    Test("BasicAssembler")
-  {}
-
-  virtual void run() {
   BasicEnv env;
   Asm a(env);
-  }
+}
-} basicAssemblerTest;
 
-class ArchitecturePlanTest : public Test {
+TEST(ArchitecturePlan) {
-public:
-  ArchitecturePlanTest():
-    Test("ArchitecturePlan")
-  {}
-
-  virtual void run() {
   BasicEnv env;
 
   for(int op = (int)lir::Call; op < (int)lir::AlignedJump; op++) {
@@ -92,5 +79,4 @@ public:
     assertNotEqual(static_cast<uint64_t>(0), mask.registerMask);
   }
 
-  }
+}
-} architecturePlanTest;

unittest/codegen/registers-test.cpp

@@ -19,13 +19,7 @@ using namespace avian::codegen;
 using namespace vm;
 
 
-class RegisterIteratorTest : public Test {
+TEST(RegisterIterator) {
-public:
-  RegisterIteratorTest():
-    Test("RegisterIterator")
-  {}
-
-  virtual void run() {
   RegisterMask regs(0x55);
   assertEqual<unsigned>(0, regs.start);
   assertEqual<unsigned>(7, regs.limit);
@@ -40,5 +34,4 @@ public:
   assertTrue(it.hasNext());
   assertEqual<unsigned>(6, it.next());
   assertFalse(it.hasNext());
-  }
+}
-} registerIteratorTest;

unittest/test-harness.h

@@ -15,38 +15,41 @@
 #include <stdio.h>
 
 class Test {
-private:
+ private:
   Test* next;
   static Test* first;
   static Test** last;
 
   friend int main(int argc, char** argv);
 
-
+  void print(uint64_t value)
-  void print(uint64_t value) {
+  {
     fprintf(stderr, "%p", reinterpret_cast<void*>(value));
   }
 
-  void print(uint32_t value) {
+  void print(uint32_t value)
+  {
     fprintf(stderr, "%p", reinterpret_cast<void*>(value));
   }
 
-
+  void print(uint8_t value)
-  void print(uint8_t value) {
+  {
     print(static_cast<uint32_t>(value));
   }
 
-  void print(bool value) {
+  void print(bool value)
+  {
     fprintf(stderr, "%s", value ? "true" : "false");
   }
 
   int failures;
   int runs;
 
-protected:
+ protected:
-  template<class T>
+  template <class T>
-  void assertEqual(T expected, T actual) {
+  void assertEqual(T expected, T actual)
-    if(expected != actual) {
+  {
+    if (expected != actual) {
       fprintf(stderr, "assertion failure, expected: ");
       print(expected);
       fprintf(stderr, ", actual: ");
@@ -57,17 +60,23 @@ protected:
     runs++;
   }
 
-  void assertEqual(const char* expected, const char* actual) {
+  void assertEqual(const char* expected, const char* actual)
-    if((expected == 0 && actual != 0) || (expected != 0 && actual == 0) || strcmp(expected, actual) != 0) {
+  {
-      fprintf(stderr, "assertion failure, expected: \"%s\", actual: \"%s\"\n", expected, actual);
+    if ((expected == 0 && actual != 0) || (expected != 0 && actual == 0)
+        || strcmp(expected, actual) != 0) {
+      fprintf(stderr,
+              "assertion failure, expected: \"%s\", actual: \"%s\"\n",
+              expected,
+              actual);
       failures++;
     }
     runs++;
   }
 
-  template<class T>
+  template <class T>
-  void assertNotEqual(T expected, T actual) {
+  void assertNotEqual(T expected, T actual)
-    if(expected == actual) {
+  {
+    if (expected == actual) {
       fprintf(stderr, "assertion failure, expected: not ");
       print(expected);
       fprintf(stderr, ", actual: ");
@@ -78,15 +87,17 @@ protected:
     runs++;
   }
 
-  void assertTrue(bool value) {
+  void assertTrue(bool value)
+  {
     assertEqual(true, value);
   }
 
-  void assertFalse(bool value) {
+  void assertFalse(bool value)
+  {
     assertEqual(false, value);
   }
 
-public:
+ public:
   const char* const name;
   Test(const char* name);
 
@@ -95,4 +106,14 @@ public:
   static bool runAll();
 };
 
+#define TEST(name)                      \
+  class name##TestClass : public Test { \
+   public:                              \
+    name##TestClass() : Test(#name)     \
+    {                                   \
+    }                                   \
+    virtual void run();                 \
+  } name##TestInstance;                 \
+  void name##TestClass::run()
+
 #endif  // TEST_HARNESS_H

unittest/util/arg-parser-test.cpp

@@ -19,13 +19,7 @@
 
 using namespace avian::util;
 
-class ArgParserTest : public Test {
+TEST(ArgParser) {
-public:
-  ArgParserTest():
-    Test("ArgParser")
-  {}
-
-  virtual void run() {
   {
     ArgParser parser;
     Arg arg1(parser, false, "arg1", "<value>");
@@ -65,5 +59,4 @@ public:
     };
     assertFalse(parser.parse(sizeof(args) / sizeof(char*) - 1, args));
   }
-  }
+}
-} argParserTest;