/* src/vm/vm.c - VM startup and shutdown functions
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Christian Thalinger
- Martin Platter
-
- $Id: vm.c 4357 2006-01-22 23:33:38Z twisti $
-
*/
#include <assert.h>
#include <errno.h>
+#include <stdint.h>
#include <stdlib.h>
-#if defined(WITH_JRE_LAYOUT)
-# include <libgen.h>
-# include <unistd.h>
-#endif
-
#include "vm/types.h"
+#include "arch.h"
+#include "md-abi.h"
+
+#include "vm/jit/abi-asm.h"
+
#include "mm/gc-common.h"
#include "mm/memory.h"
+
#include "native/jni.h"
+#include "native/llni.h"
#include "native/native.h"
-#if defined(ENABLE_THREADS)
-# include "threads/native/threads.h"
+#include "native/include/java_lang_Object.h" /* required by j.l.C */
+#include "native/include/java_lang_String.h" /* required by j.l.C */
+
+#if defined(WITH_CLASSPATH_SUN)
+# include "native/include/java_nio_ByteBuffer.h" /* required by j.l.CL */
+# include "native/include/java_lang_ClassLoader.h" /* required by j.l.C */
#endif
-#include "vm/classcache.h"
+#include "native/include/java_lang_Class.h"
+
+#include "native/vm/nativevm.h"
+
+#include "threads/threads-common.h"
+
+#include "toolbox/logging.h"
+
+#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/finalizer.h"
#include "vm/global.h"
#include "vm/initialize.h"
-#include "vm/options.h"
+#include "vm/primitive.h"
#include "vm/properties.h"
-#include "vm/rt-timing.h"
#include "vm/signallocal.h"
#include "vm/stringlocal.h"
-#include "vm/suck.h"
#include "vm/vm.h"
+
#include "vm/jit/jit.h"
+#include "vm/jit/md.h"
#include "vm/jit/asmpart.h"
#if defined(ENABLE_PROFILING)
#include "vm/jit/optimizing/recompile.h"
+#include "vmcore/classcache.h"
+#include "vmcore/options.h"
+#include "vmcore/statistics.h"
+#include "vmcore/suck.h"
+
#if defined(ENABLE_JVMTI)
# include "native/jvmti/cacaodbg.h"
#endif
+#if defined(ENABLE_VMLOG)
+#include <vmlog_cacao.h>
+#endif
+
/* Invocation API variables ***************************************************/
bool vm_initializing = false;
bool vm_exiting = false;
-char *cacao_prefix = NULL;
-char *cacao_libjvm = NULL;
-char *classpath_libdir = NULL;
-
-char *_Jv_bootclasspath; /* contains the boot classpath */
-char *_Jv_classpath; /* contains the classpath */
-char *_Jv_java_library_path;
-
char *mainstring = NULL;
classinfo *mainclass = NULL;
-char *specificmethodname = NULL;
-char *specificsignature = NULL;
-
-bool startit = true;
-
#if defined(ENABLE_INTRP)
u1 *intrp_main_stack = NULL;
#endif
OPT_HELP,
OPT_X,
+ OPT_XX,
+
+ OPT_EA,
+ OPT_DA,
OPT_ESA,
OPT_DSA,
OPT_VERBOSE1,
OPT_NOIEEE,
- OPT_SOFTNULL,
#if defined(ENABLE_STATISTICS)
OPT_TIME,
OPT_VERBOSETC,
#endif
#endif /* defined(ENABLE_VERIFIER) */
- OPT_EAGER,
/* optimization options */
#if defined(ENABLE_INLINING)
OPT_INLINING,
-#endif
+#if !defined(NDEBUG)
+ OPT_INLINE_LOG,
+#endif
+#if defined(ENABLE_INLINING_DEBUG)
+ OPT_INLINE_DEBUG_ALL,
+ OPT_INLINE_DEBUG_END,
+ OPT_INLINE_DEBUG_MIN,
+ OPT_INLINE_DEBUG_MAX,
+#endif /* defined(ENABLE_INLINING_DEBUG) */
+#endif /* defined(ENABLE_INLINING) */
#if defined(ENABLE_INTRP)
/* interpreter options */
OPT_AGENTPATH,
#endif
+#if defined(ENABLE_DEBUG_FILTER)
+ OPT_FILTER_VERBOSECALL_INCLUDE,
+ OPT_FILTER_VERBOSECALL_EXCLUDE,
+ OPT_FILTER_SHOW_METHOD,
+#endif
+
DUMMY
};
{ "help", false, OPT_HELP },
{ "?", false, OPT_HELP },
{ "X", false, OPT_X },
+ { "XX:", true, OPT_XX },
+ { "XX", false, OPT_XX },
+
+ { "ea:", true, OPT_EA },
+ { "da:", true, OPT_DA },
+ { "ea", false, OPT_EA },
+ { "da", false, OPT_DA },
{ "esa", false, OPT_ESA },
{ "enablesystemassertions", false, OPT_ESA },
{ "noasyncgc", false, OPT_IGNORE },
#if defined(ENABLE_VERIFIER)
{ "noverify", false, OPT_NOVERIFY },
+ { "Xverify:none", false, OPT_NOVERIFY },
#endif
{ "v", false, OPT_VERBOSE1 },
{ "verbose:", true, OPT_VERBOSE },
#if defined(__ALPHA__)
{ "noieee", false, OPT_NOIEEE },
#endif
- { "softnull", false, OPT_SOFTNULL },
#if defined(ENABLE_STATISTICS)
{ "time", false, OPT_TIME },
{ "stat", false, OPT_STAT },
{ "log", true, OPT_LOG },
{ "c", true, OPT_CHECK },
{ "l", false, OPT_LOAD },
- { "eager", false, OPT_EAGER },
#if !defined(NDEBUG)
{ "all", false, OPT_ALL },
{ "Xprof", false, OPT_PROF },
#endif
- /* keep these at the end of the list */
+ /* inlining options */
#if defined(ENABLE_INLINING)
- { "i", true, OPT_INLINING },
+#if defined(ENABLE_INLINING_DEBUG)
+ { "ia", false, OPT_INLINE_DEBUG_ALL },
+ { "ii", true, OPT_INLINE_DEBUG_MIN },
+ { "im", true, OPT_INLINE_DEBUG_MAX },
+ { "ie", true, OPT_INLINE_DEBUG_END },
+#endif /* defined(ENABLE_INLINING_DEBUG) */
+#if !defined(NDEBUG)
+ { "il", false, OPT_INLINE_LOG },
#endif
+ { "i", false, OPT_INLINING },
+#endif /* defined(ENABLE_INLINING) */
+
+ /* keep these at the end of the list */
#if !defined(NDEBUG)
{ "m", true, OPT_METHOD },
{ "s", true, OPT_SHOW },
{ "debug-color", false, OPT_DEBUGCOLOR },
+#if defined(ENABLE_DEBUG_FILTER)
+ { "XXfi", true, OPT_FILTER_VERBOSECALL_INCLUDE },
+ { "XXfx", true, OPT_FILTER_VERBOSECALL_EXCLUDE },
+ { "XXfm", true, OPT_FILTER_SHOW_METHOD },
+#endif
+
{ NULL, false, 0 }
};
puts(" or cacao [-options] -jar jarfile [arguments]");
puts(" (to run a standalone jar file)\n");
- puts("Java options:");
+ puts("where options include:");
puts(" -d32 use 32-bit data model if available");
puts(" -d64 use 64-bit data model if available");
puts(" -client compatibility (currently ignored)");
puts(" -showversion print product version and continue");
puts(" -help, -? print this help message");
puts(" -X print help on non-standard Java options");
+ puts(" -XX print help on debugging options");
+ puts(" -ea[:<packagename>...|:<classname>]");
+ puts(" -enableassertions[:<packagename>...|:<classname>]");
+ puts(" enable assertions with specified granularity");
+ puts(" -da[:<packagename>...|:<classname>]");
+ puts(" -disableassertions[:<packagename>...|:<classname>]");
+ puts(" disable assertions with specified granularity");
puts(" -esa | -enablesystemassertions");
puts(" enable system assertions");
puts(" -dsa | -disablesystemassertions");
puts(" disable system assertions");
- puts("");
#ifdef ENABLE_JVMTI
puts(" -agentlib:<agent-lib-name>=<options> library to load containg JVMTI agent");
puts(" -agentpath:<path-to-agent>=<options> path to library containg JVMTI agent");
#endif
- puts("CACAO options:");
+ /* exit with error code */
+
+ exit(1);
+}
+
+
+static void Xusage(void)
+{
+#if defined(ENABLE_JIT)
+ puts(" -Xjit JIT mode execution (default)");
+#endif
+#if defined(ENABLE_INTRP)
+ puts(" -Xint interpreter mode execution");
+#endif
+ puts(" -Xbootclasspath:<zip/jar files and directories separated by :>");
+ puts(" value is set as bootstrap class path");
+ puts(" -Xbootclasspath/a:<zip/jar files and directories separated by :>");
+ puts(" value is appended to the bootstrap class path");
+ puts(" -Xbootclasspath/p:<zip/jar files and directories separated by :>");
+ puts(" value is prepended to the bootstrap class path");
+ puts(" -Xbootclasspath/c:<zip/jar files and directories separated by :>");
+ puts(" value is used as Java core library, but the");
+ puts(" hardcoded VM interface classes are prepended");
+ printf(" -Xms<size> set the initial size of the heap (default: %dMB)\n", HEAP_STARTSIZE / 1024 / 1024);
+ printf(" -Xmx<size> set the maximum size of the heap (default: %dMB)\n", HEAP_MAXSIZE / 1024 / 1024);
+ printf(" -Xss<size> set the thread stack size (default: %dkB)\n", STACK_SIZE / 1024);
+
+#if defined(ENABLE_PROFILING)
+ puts(" -Xprof[:bb] collect and print profiling data");
+#endif
+
+#if defined(ENABLE_JVMTI)
+ /* -Xdebug option depend on gnu classpath JDWP options. options:
+ transport=dt_socket,address=<hostname:port>,server=(y|n),suspend(y|n) */
+ puts(" -Xdebug enable remote debugging\n");
+ puts(" -Xrunjdwp transport=[dt_socket|...],address=<hostname:port>,server=[y|n],suspend=[y|n]\n");
+ puts(" enable remote debugging\n");
+#endif
+
+ /* exit with error code */
+
+ exit(1);
+}
+
+
+#if 0
+static void XXusage(void)
+{
puts(" -v write state-information");
- puts(" -verbose[:call|exception|jit]");
+#if !defined(NDEBUG)
+ puts(" -verbose[:jit|threads]");
puts(" enable specific verbose output");
puts(" -debug-color colored output for ANSI terms");
+#endif
#ifdef TYPECHECK_VERBOSE
puts(" -verbosetc write debug messages while typechecking");
#endif
#if defined(ENABLE_VERIFIER)
puts(" -noverify don't verify classfiles");
#endif
- puts(" -softnull use software nullpointer check");
#if defined(ENABLE_STATISTICS)
puts(" -time measure the runtime");
puts(" -stat detailed compiler statistics");
puts(" -oloop optimize array accesses in loops");
#endif
puts(" -l don't start the class after loading");
- puts(" -eager perform eager class loading and linking");
#if !defined(NDEBUG)
puts(" -all compile all methods, no execution");
puts(" -m compile only a specific method");
puts(" (e)xceptionstubs disassembled exception stubs (only with -sa)");
puts(" (n)ative disassembled native stubs");
#endif
- puts(" (d)atasegment data segment listing");
+ puts(" (d)atasegment data segment listing");
+
#if defined(ENABLE_INLINING)
- puts(" -i n(line) activate inlining");
- puts(" v(irtual) inline virtual methods (uses/turns rt option on)");
- puts(" e(exception) inline methods with exceptions");
- puts(" p(aramopt) optimize argument renaming");
- puts(" o(utsiders) inline methods of foreign classes");
+ puts(" -i activate inlining");
+#if !defined(NDEBUG)
+ puts(" -il log inlining");
+#endif
+#if defined(ENABLE_INLINING_DEBUG)
+ puts(" -ia use inlining for all methods");
+ puts(" -ii <size> set minimum size for inlined result");
+ puts(" -im <size> set maximum size for inlined result");
+ puts(" -ie <number> stop inlining after the given number of roots");
+#endif /* defined(ENABLE_INLINING_DEBUG) */
#endif /* defined(ENABLE_INLINING) */
+
#if defined(ENABLE_IFCONV)
puts(" -ifconv use if-conversion");
#endif
#if defined(ENABLE_SSA)
puts(" -lsra use linear scan register allocation (with SSA)");
#endif
-
- /* exit with error code */
-
- exit(1);
-}
-
-
-static void Xusage(void)
-{
-#if defined(ENABLE_JIT)
- puts(" -Xjit JIT mode execution (default)");
-#endif
-#if defined(ENABLE_INTRP)
- puts(" -Xint interpreter mode execution");
-#endif
- puts(" -Xbootclasspath:<zip/jar files and directories separated by :>");
- puts(" value is set as bootstrap class path");
- puts(" -Xbootclasspath/a:<zip/jar files and directories separated by :>");
- puts(" value is appended to the bootstrap class path");
- puts(" -Xbootclasspath/p:<zip/jar files and directories separated by :>");
- puts(" value is prepended to the bootstrap class path");
- puts(" -Xbootclasspath/c:<zip/jar files and directories separated by :>");
- puts(" value is used as Java core library, but the");
- puts(" hardcoded VM interface classes are prepended");
- printf(" -Xms<size> set the initial size of the heap (default: %dMB)\n", HEAP_STARTSIZE / 1024 / 1024);
- printf(" -Xmx<size> set the maximum size of the heap (default: %dMB)\n", HEAP_MAXSIZE / 1024 / 1024);
- printf(" -Xss<size> set the thread stack size (default: %dkB)\n", STACK_SIZE / 1024);
-
-#if defined(ENABLE_PROFILING)
- puts(" -Xprof[:bb] collect and print profiling data");
+#if defined(ENABLE_DEBUG_FILTER)
+ puts(" -XXfi <regex> begin of dynamic scope for verbosecall filter");
+ puts(" -XXfx <regex> end of dynamic scope for verbosecall filter");
+ puts(" -XXfm <regex> filter for show options");
#endif
-
-#if defined(ENABLE_JVMTI)
- /* -Xdebug option depend on gnu classpath JDWP options. options:
- transport=dt_socket,address=<hostname:port>,server=(y|n),suspend(y|n) */
- puts(" -Xdebug enable remote debugging\n");
- puts(" -Xrunjdwp transport=[dt_socket|...],address=<hostname:port>,server=[y|n],suspend=[y|n]\n");
- puts(" enable remote debugging\n");
-#endif
-
/* exit with error code */
exit(1);
-}
+}
+#endif
/* version *********************************************************************
puts("java version \""JAVA_VERSION"\"");
puts("CACAO version "VERSION"");
- puts("Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,");
+ puts("Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,");
puts("C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,");
puts("E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,");
puts("J. Wenninger, Institut f. Computersprachen - TU Wien\n");
puts("This program is distributed in the hope that it will be useful, but");
puts("WITHOUT ANY WARRANTY; without even the implied warranty of");
puts("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU");
- puts("General Public License for more details.\n");
-
- puts("Configure/Build options:\n");
- puts(" ./configure: "VERSION_CONFIGURE_ARGS"");
-#if defined(__VERSION__)
- puts(" CC : "VERSION_CC" ("__VERSION__")");
-#else
- puts(" CC : "VERSION_CC"");
-#endif
- puts(" CFLAGS : "VERSION_CFLAGS"\n");
-
- puts("Default variables:\n");
- printf(" maximum heap size : %d\n", HEAP_MAXSIZE);
- printf(" initial heap size : %d\n", HEAP_STARTSIZE);
- printf(" stack size : %d\n", STACK_SIZE);
- puts(" java.boot.class.path : "CACAO_VM_ZIP":"CLASSPATH_GLIBJ_ZIP"");
- puts(" gnu.classpath.boot.library.path: "CLASSPATH_LIBDIR"/classpath\n");
-
- puts("Runtime variables:\n");
- printf(" maximum heap size : %d\n", opt_heapmaxsize);
- printf(" initial heap size : %d\n", opt_heapstartsize);
- printf(" stack size : %d\n", opt_stacksize);
- printf(" java.boot.class.path : %s\n", _Jv_bootclasspath);
- printf(" gnu.classpath.boot.library.path: %s\n", classpath_libdir);
+ puts("General Public License for more details.");
/* exit normally, if requested */
}
+void vm_printconfig(void)
+{
+ puts("Configure/Build options:\n");
+ puts(" ./configure: "VERSION_CONFIGURE_ARGS"");
+#if defined(__VERSION__)
+ puts(" CC : "VERSION_CC" ("__VERSION__")");
+#else
+ puts(" CC : "VERSION_CC"");
+#endif
+ puts(" CFLAGS : "VERSION_CFLAGS"\n");
+
+ puts("Default variables:\n");
+ printf(" maximum heap size : %d\n", HEAP_MAXSIZE);
+ printf(" initial heap size : %d\n", HEAP_STARTSIZE);
+ printf(" stack size : %d\n", STACK_SIZE);
+
+#if defined(WITH_JRE_LAYOUT)
+ /* When we're building with JRE-layout, the default paths are the
+ same as the runtime paths. */
+#else
+# if defined(WITH_CLASSPATH_GNU)
+ puts(" gnu.classpath.boot.library.path: "CLASSPATH_LIBDIR);
+ puts(" java.boot.class.path : "CACAO_VM_ZIP":"CLASSPATH_CLASSES"");
+# elif defined(WITH_CLASSPATH_SUN)
+ puts(" sun.boot.library.path : "CLASSPATH_LIBDIR);
+ puts(" java.boot.class.path : "CLASSPATH_CLASSES);
+# endif
+#endif
+
+ puts("");
+
+ puts("Runtime variables:\n");
+ printf(" maximum heap size : %d\n", opt_heapmaxsize);
+ printf(" initial heap size : %d\n", opt_heapstartsize);
+ printf(" stack size : %d\n", opt_stacksize);
+
+#if defined(WITH_CLASSPATH_GNU)
+ printf(" gnu.classpath.boot.library.path: %s\n", properties_get("gnu.classpath.boot.library.path"));
+#elif defined(WITH_CLASSPATH_SUN)
+ printf(" sun.boot.library.path : %s\n", properties_get("sun.boot.library.path"));
+#endif
+
+ printf(" java.boot.class.path : %s\n", properties_get("java.boot.class.path"));
+ printf(" java.class.path : %s\n", properties_get("java.class.path"));
+}
+
+
/* forward declarations *******************************************************/
static char *vm_get_mainclass_from_jar(char *mainstring);
/* get the VM and Env tables (must be set before vm_create) */
env = NEW(_Jv_JNIEnv);
+
+#if defined(ENABLE_JNI)
env->env = &_Jv_JNINativeInterface;
+#endif
/* XXX Set the global variable. Maybe we should do that differently. */
/* create and fill a JavaVM structure */
vm = NEW(_Jv_JavaVM);
+
+#if defined(ENABLE_JNI)
vm->functions = &_Jv_JNIInvokeInterface;
+#endif
/* XXX Set the global variable. Maybe we should do that differently. */
/* XXX JVMTI Agents needs a JavaVM */
if (!vm_create(_vm_args))
goto error;
-#if defined(ENABLE_JAVASE)
+#if defined(ENABLE_JNI)
/* setup the local ref table (must be created after vm_create) */
- if (!jni_init_localref_table())
+ if (!localref_table_init())
goto error;
#endif
bool vm_create(JavaVMInitArgs *vm_args)
{
- char *cp;
- s4 len;
- s4 opt;
- s4 i, j;
+ int len;
+ char *p;
+ char *boot_class_path;
+ char *class_path;
+ int opt;
+ int i, j;
bool opt_version;
bool opt_exit;
jdwp = agentbypath = false;
#endif
+#if defined(ENABLE_VMLOG)
+ vmlog_cacao_init(vm_args);
+#endif
+
/* check the JNI version requested */
switch (vm_args->version) {
if (opt_verbose)
log_text("CACAO started -------------------------------------------------------");
- /* set the VM starttime */
-
- _Jv_jvm->starttime = builtin_currenttimemillis();
-
- /* get stuff from the environment *****************************************/
-
-#if defined(DISABLE_GC)
- nogc_init(HEAP_MAXSIZE, HEAP_STARTSIZE);
-#endif
-
-#if defined(WITH_JRE_LAYOUT)
- /* SUN also uses a buffer of 4096-bytes (strace is your friend). */
-
- cacao_prefix = MNEW(char, 4096);
-
- if (readlink("/proc/self/exe", cacao_prefix, 4095) == -1)
- vm_abort("readlink failed: %s\n", strerror(errno));
-
- /* get the path of the current executable */
-
- cacao_prefix = dirname(cacao_prefix);
-
- if ((strlen(cacao_prefix) + strlen("/..") + strlen("0")) > 4096)
- vm_abort("libjvm name to long for buffer\n");
-
- /* concatenate the library name */
-
- strcat(cacao_prefix, "/..");
-
- /* now set path to libjvm.so */
-
- len = strlen(cacao_prefix) + strlen("/lib/libjvm") + strlen("0");
-
- cacao_libjvm = MNEW(char, len);
- strcpy(cacao_libjvm, cacao_prefix);
- strcat(cacao_libjvm, "/lib/libjvm");
-
- /* and finally set the path to GNU Classpath libraries */
-
- len = strlen(cacao_prefix) + strlen("/lib/classpath") + strlen("0");
-
- classpath_libdir = MNEW(char, len);
- strcpy(classpath_libdir, cacao_prefix);
- strcat(classpath_libdir, "/lib/classpath");
-#else
- cacao_prefix = CACAO_PREFIX;
- cacao_libjvm = CACAO_LIBDIR"/libjvm";
- classpath_libdir = CLASSPATH_LIBDIR"/classpath";
-#endif
-
- /* set the bootclasspath */
-
- cp = getenv("BOOTCLASSPATH");
-
- if (cp != NULL) {
- _Jv_bootclasspath = MNEW(char, strlen(cp) + strlen("0"));
- strcpy(_Jv_bootclasspath, cp);
- }
- else {
-#if defined(WITH_JRE_LAYOUT)
- len =
- strlen(cacao_prefix) +
- strlen("/share/cacao/vm.zip") +
- strlen(":") +
- strlen(cacao_prefix) +
- strlen("/share/classpath/glibj.zip") +
- strlen("0");
-
- _Jv_bootclasspath = MNEW(char, len);
- strcat(_Jv_bootclasspath, cacao_prefix);
- strcat(_Jv_bootclasspath, "/share/cacao/vm.zip");
- strcat(_Jv_bootclasspath, ":");
- strcat(_Jv_bootclasspath, cacao_prefix);
- strcat(_Jv_bootclasspath, "/share/classpath/glibj.zip");
-#else
- len =
- strlen(CACAO_VM_ZIP) +
- strlen(":") +
- strlen(CLASSPATH_GLIBJ_ZIP) +
- strlen("0");
-
- _Jv_bootclasspath = MNEW(char, len);
- strcat(_Jv_bootclasspath, CACAO_VM_ZIP);
- strcat(_Jv_bootclasspath, ":");
- strcat(_Jv_bootclasspath, CLASSPATH_GLIBJ_ZIP);
-#endif
- }
-
- /* set the classpath */
-
- cp = getenv("CLASSPATH");
+ /* We need to check if the actual size of a java.lang.Class object
+ is smaller or equal than the assumption made in
+ src/vmcore/class.h. */
- if (cp != NULL) {
- _Jv_classpath = MNEW(char, strlen(cp) + strlen("0"));
- strcat(_Jv_classpath, cp);
- }
- else {
- _Jv_classpath = MNEW(char, strlen(".") + strlen("0"));
- strcpy(_Jv_classpath, ".");
- }
-
- /* get and set java.library.path */
+ if (sizeof(java_lang_Class) > sizeof(dummy_java_lang_Class))
+ vm_abort("vm_create: java_lang_Class structure is bigger than classinfo.object (%d > %d)", sizeof(java_lang_Class), sizeof(dummy_java_lang_Class));
- _Jv_java_library_path = getenv("LD_LIBRARY_PATH");
+ /* set the VM starttime */
- if (_Jv_java_library_path == NULL)
- _Jv_java_library_path = "";
+ _Jv_jvm->starttime = builtin_currenttimemillis();
/* interpret the options **************************************************/
opt_version = false;
opt_exit = false;
- checknull = false;
opt_noieee = false;
opt_heapmaxsize = HEAP_MAXSIZE;
jvmti = false;
#endif
- /* initialize and fill properties before command-line handling */
+ /* Initialize and fill properties before command-line handling. */
- if (!properties_init())
- vm_abort("properties_init failed");
+ properties_init();
+ properties_set();
/* iterate over all passed options */
break;
case OPT_CLASSPATH:
- /* forget old classpath and set the argument as new classpath */
- MFREE(_Jv_classpath, char, strlen(_Jv_classpath));
+ /* Forget old classpath and set the argument as new
+ classpath. */
+
+ class_path = properties_get("java.class.path");
+
+ p = MNEW(char, strlen(opt_arg) + strlen("0"));
- _Jv_classpath = MNEW(char, strlen(opt_arg) + strlen("0"));
- strcpy(_Jv_classpath, opt_arg);
+ strcpy(p, opt_arg);
+
+#if defined(ENABLE_JAVASE)
+ properties_add("java.class.path", p);
+#endif
+
+ MFREE(class_path, char, strlen(class_path));
break;
case OPT_D:
/* Forget default bootclasspath and set the argument as
new boot classpath. */
- MFREE(_Jv_bootclasspath, char, strlen(_Jv_bootclasspath));
+ boot_class_path = properties_get("sun.boot.class.path");
- _Jv_bootclasspath = MNEW(char, strlen(opt_arg) + strlen("0"));
- strcpy(_Jv_bootclasspath, opt_arg);
+ p = MNEW(char, strlen(opt_arg) + strlen("0"));
+
+ strcpy(p, opt_arg);
+
+ properties_add("sun.boot.class.path", p);
+ properties_add("java.boot.class.path", p);
+
+ MFREE(boot_class_path, char, strlen(boot_class_path));
break;
case OPT_BOOTCLASSPATH_A:
- /* append to end of bootclasspath */
+ /* Append to bootclasspath. */
+
+ boot_class_path = properties_get("sun.boot.class.path");
- len = strlen(_Jv_bootclasspath);
+ len = strlen(boot_class_path);
- _Jv_bootclasspath = MREALLOC(_Jv_bootclasspath,
- char,
- len,
- len + strlen(":") +
- strlen(opt_arg) + strlen("0"));
+ p = MREALLOC(boot_class_path,
+ char,
+ len + strlen("0"),
+ len + strlen(":") +
+ strlen(opt_arg) + strlen("0"));
- strcat(_Jv_bootclasspath, ":");
- strcat(_Jv_bootclasspath, opt_arg);
+ strcat(p, ":");
+ strcat(p, opt_arg);
+
+ properties_add("sun.boot.class.path", p);
+ properties_add("java.boot.class.path", p);
break;
case OPT_BOOTCLASSPATH_P:
- /* prepend in front of bootclasspath */
+ /* Prepend to bootclasspath. */
+
+ boot_class_path = properties_get("sun.boot.class.path");
- cp = _Jv_bootclasspath;
- len = strlen(cp);
+ len = strlen(boot_class_path);
- _Jv_bootclasspath = MNEW(char, strlen(opt_arg) + strlen(":") +
- len + strlen("0"));
+ p = MNEW(char, strlen(opt_arg) + strlen(":") + len + strlen("0"));
- strcpy(_Jv_bootclasspath, opt_arg);
- strcat(_Jv_bootclasspath, ":");
- strcat(_Jv_bootclasspath, cp);
+ strcpy(p, opt_arg);
+ strcat(p, ":");
+ strcat(p, boot_class_path);
- MFREE(cp, char, len);
+ properties_add("sun.boot.class.path", p);
+ properties_add("java.boot.class.path", p);
+
+ MFREE(boot_class_path, char, len);
break;
case OPT_BOOTCLASSPATH_C:
- /* use as Java core library, but prepend VM interface classes */
+ /* Use as Java core library, but prepend VM interface
+ classes. */
- MFREE(_Jv_bootclasspath, char, strlen(_Jv_bootclasspath));
+ boot_class_path = properties_get("sun.boot.class.path");
- len = strlen(CACAO_VM_ZIP) +
+ len =
+ strlen(CACAO_VM_ZIP) +
strlen(":") +
strlen(opt_arg) +
strlen("0");
- _Jv_bootclasspath = MNEW(char, len);
+ p = MNEW(char, len);
- strcpy(_Jv_bootclasspath, CACAO_VM_ZIP);
- strcat(_Jv_bootclasspath, ":");
- strcat(_Jv_bootclasspath, opt_arg);
+ strcpy(p, CACAO_VM_ZIP);
+ strcat(p, ":");
+ strcat(p, opt_arg);
+
+ properties_add("sun.boot.class.path", p);
+ properties_add("java.boot.class.path", p);
+
+ MFREE(boot_class_path, char, strlen(boot_class_path));
break;
#if defined(ENABLE_JVMTI)
break;
case OPT_VERBOSE:
- if (strcmp("class", opt_arg) == 0)
+ if (strcmp("class", opt_arg) == 0) {
opt_verboseclass = true;
-
- else if (strcmp("gc", opt_arg) == 0)
+ }
+ else if (strcmp("gc", opt_arg) == 0) {
opt_verbosegc = true;
-
- else if (strcmp("jni", opt_arg) == 0)
+ }
+ else if (strcmp("jni", opt_arg) == 0) {
opt_verbosejni = true;
-
- else if (strcmp("call", opt_arg) == 0)
- opt_verbosecall = true;
-
+ }
+#if !defined(NDEBUG)
else if (strcmp("jit", opt_arg) == 0) {
opt_verbose = true;
loadverbose = true;
- linkverbose = true;
initverbose = true;
compileverbose = true;
}
- else if (strcmp("exception", opt_arg) == 0)
- opt_verboseexception = true;
- break;
- case OPT_DEBUGCOLOR:
+ else if (strcmp("threads", opt_arg) == 0) {
+ opt_verbosethreads = true;
+ }
+#endif
+ else {
+ printf("Unknown -verbose option: %s\n", opt_arg);
+ usage();
+ }
+ break;
+
+ case OPT_DEBUGCOLOR:
opt_debugcolor = true;
break;
break;
#endif
- case OPT_SOFTNULL:
- checknull = true;
- break;
-
#if defined(ENABLE_STATISTICS)
case OPT_TIME:
opt_getcompilingtime = true;
makeinitializations = false;
break;
- case OPT_EAGER:
- opt_eager = true;
- break;
-
#if !defined(NDEBUG)
case OPT_ALL:
compileall = true;
#endif
#if defined(ENABLE_INLINING)
+#if defined(ENABLE_INLINING_DEBUG)
+ case OPT_INLINE_DEBUG_ALL:
+ opt_inline_debug_all = true;
+ break;
+ case OPT_INLINE_DEBUG_END:
+ opt_inline_debug_end_counter = atoi(opt_arg);
+ break;
+ case OPT_INLINE_DEBUG_MIN:
+ opt_inline_debug_min_size = atoi(opt_arg);
+ break;
+ case OPT_INLINE_DEBUG_MAX:
+ opt_inline_debug_max_size = atoi(opt_arg);
+ break;
+#endif /* defined(ENABLE_INLINING_DEBUG) */
+#if !defined(NDEBUG)
+ case OPT_INLINE_LOG:
+ opt_inline_debug_log = true;
+ break;
+#endif /* !defined(NDEBUG) */
+
case OPT_INLINING:
- for (i = 0; i < strlen(opt_arg); i++) {
- switch (opt_arg[i]) {
- case 'n':
- /* define in options.h; Used in main.c, jit.c
- & inline.c inlining is currently
- deactivated */
- break;
- case 'v':
- inlinevirtuals = true;
- break;
- case 'e':
- inlineexceptions = true;
- break;
- case 'p':
- inlineparamopt = true;
- break;
- case 'o':
- inlineoutsiders = true;
- break;
- default:
- usage();
- }
- }
+ opt_inlining = true;
break;
#endif /* defined(ENABLE_INLINING) */
Xusage();
break;
+ case OPT_XX:
+ options_xx(opt_arg);
+ break;
+
+ case OPT_EA:
+ /* currently ignored */
+ break;
+
+ case OPT_DA:
+ /* currently ignored */
+ break;
+
case OPT_ESA:
_Jv_jvm->Java_java_lang_VMClassLoader_defaultAssertionStatus = true;
break;
break;
#endif
+#if defined(ENABLE_DEBUG_FILTER)
+ case OPT_FILTER_VERBOSECALL_INCLUDE:
+ opt_filter_verbosecall_include = opt_arg;
+ break;
+
+ case OPT_FILTER_VERBOSECALL_EXCLUDE:
+ opt_filter_verbosecall_exclude = opt_arg;
+ break;
+
+ case OPT_FILTER_SHOW_METHOD:
+ opt_filter_show_method = opt_arg;
+ break;
+
+#endif
default:
printf("Unknown option: %s\n",
vm_args->options[opt_index].optionString);
}
}
- /* now re-set some of the properties that may have changed */
-
- if (!properties_postinit())
- vm_abort("properties_postinit failed");
-
- /* Now we have all options handled and we can print the version
- information. */
-
- if (opt_version)
- version(opt_exit);
-
-
/* get the main class *****************************************************/
if (opt_index < vm_args->nOptions) {
if (opt_jar == true) {
/* free old classpath */
- MFREE(_Jv_classpath, char, strlen(_Jv_classpath));
+/* MFREE(_Jv_classpath, char, strlen(_Jv_classpath)); */
/* put jarfile into classpath */
- _Jv_classpath = MNEW(char, strlen(mainstring) + strlen("0"));
+ p = MNEW(char, strlen(mainstring) + strlen("0"));
+
+ strcpy(p, mainstring);
- strcpy(_Jv_classpath, mainstring);
+#if defined(ENABLE_JAVASE)
+ properties_add("java.class.path", p);
+#endif
}
else {
/* replace .'s with /'s in classname */
jvmti_set_phase(JVMTI_PHASE_PRIMORDIAL);
}
-
#endif
-
/* initialize this JVM ****************************************************/
vm_initializing = true;
+ /* initialize the garbage collector */
+
+ gc_init(opt_heapmaxsize, opt_heapstartsize);
+
#if defined(ENABLE_THREADS)
- /* pre-initialize some core thread stuff, like the stopworldlock,
- thus this has to happen _before_ gc_init()!!! */
+ /* AFTER: gc_init (directly after, as this initializes the
+ stopworldlock lock */
threads_preinit();
#endif
- /* initialize the garbage collector */
+ /* install architecture dependent signal handlers */
- gc_init(opt_heapmaxsize, opt_heapstartsize);
+ if (!signal_init())
+ vm_abort("vm_create: signal_init failed");
#if defined(ENABLE_INTRP)
/* Allocate main thread stack on the Java heap. */
}
#endif
- /* initialize the string hashtable stuff: lock (must be done
- _after_ threads_preinit) */
+ /* AFTER: threads_preinit */
if (!string_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: string_init failed");
- /* initialize the utf8 hashtable stuff: lock, often used utf8
- strings (must be done _after_ threads_preinit) */
+ /* AFTER: threads_preinit */
if (!utf8_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: utf8_init failed");
- /* initialize the classcache hashtable stuff: lock, hashtable
- (must be done _after_ threads_preinit) */
-
- if (!classcache_init())
- throw_main_exception_exit();
-
- /* initialize the loader with bootclasspath (must be done _after_
- thread_preinit) */
+ /* AFTER: thread_preinit */
if (!suck_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: suck_init failed");
suck_add_from_property("java.endorsed.dirs");
- suck_add(_Jv_bootclasspath);
+
+ /* Now we have all options handled and we can print the version
+ information.
+
+ AFTER: suck_add_from_property("java.endorsed.dirs"); */
+
+ if (opt_version)
+ version(opt_exit);
+
+ /* AFTER: utf8_init */
+
+ boot_class_path = properties_get("sun.boot.class.path");
+ suck_add(boot_class_path);
+
+ /* initialize the classcache hashtable stuff: lock, hashtable
+ (must be done _after_ threads_preinit) */
+
+ if (!classcache_init())
+ vm_abort("vm_create: classcache_init failed");
/* initialize the memory subsystem (must be done _after_
threads_preinit) */
if (!memory_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: memory_init failed");
/* initialize the finalizer stuff (must be done _after_
threads_preinit) */
if (!finalizer_init())
- throw_main_exception_exit();
-
- /* install architecture dependent signal handler used for exceptions */
-
- signal_init();
+ vm_abort("vm_create: finalizer_init failed");
/* initialize the codegen subsystems */
classcache_init) */
if (!loader_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: loader_init failed");
+
+ /* Link some important VM classes. */
+ /* AFTER: utf8_init */
if (!linker_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: linker_init failed");
- if (!native_init())
- throw_main_exception_exit();
+ if (!primitive_init())
+ vm_abort("vm_create: primitive_init failed");
if (!exceptions_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: exceptions_init failed");
if (!builtin_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: builtin_init failed");
+
+ /* Initialize the native subsystem. */
+ /* BEFORE: threads_init */
+
+ if (!native_init())
+ vm_abort("vm_create: native_init failed");
+
+ /* Register the native methods implemented in the VM. */
+ /* BEFORE: threads_init */
+ if (!nativevm_preinit())
+ vm_abort("vm_create: nativevm_preinit failed");
+
+#if defined(ENABLE_JNI)
/* Initialize the JNI subsystem (must be done _before_
threads_init, as threads_init can call JNI methods
(e.g. NewGlobalRef). */
if (!jni_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: jni_init failed");
+#endif
#if defined(ENABLE_THREADS)
if (!threads_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: threads_init failed");
#endif
+ /* Initialize the native VM subsystem. */
+ /* AFTER: threads_init (at least for SUN's classes) */
+
+ if (!nativevm_init())
+ vm_abort("vm_create: nativevm_init failed");
+
#if defined(ENABLE_PROFILING)
/* initialize profiling */
if (!profile_init())
- throw_main_exception_exit();
+ vm_abort("vm_create: profile_init failed");
#endif
#if defined(ENABLE_THREADS)
/* initialize recompilation */
if (!recompile_init())
- throw_main_exception_exit();
-
+ vm_abort("vm_create: recompile_init failed");
+
+ /* start the signal handler thread */
+
+#if defined(__LINUX__)
+ /* XXX Remove for exact-GC. */
+ if (threads_pthreads_implementation_nptl)
+#endif
+ if (!signal_start_thread())
+ vm_abort("vm_create: signal_start_thread failed");
+
/* finally, start the finalizer thread */
if (!finalizer_start_thread())
- throw_main_exception_exit();
+ vm_abort("vm_create: finalizer_start_thread failed");
+
+# if !defined(NDEBUG)
+ /* start the memory profiling thread */
+
+ if (opt_ProfileMemoryUsage || opt_ProfileGCMemoryUsage)
+ if (!memory_start_thread())
+ vm_abort("vm_create: memory_start_thread failed");
+# endif
/* start the recompilation thread (must be done before the
profiling thread) */
if (!recompile_start_thread())
- throw_main_exception_exit();
+ vm_abort("vm_create: recompile_start_thread failed");
# if defined(ENABLE_PROFILING)
/* start the profile sampling thread */
/* if (opt_prof) */
/* if (!profile_start_thread()) */
-/* throw_main_exception_exit(); */
+/* vm_abort("vm_create: profile_start_thread failed"); */
# endif
#endif
void vm_run(JavaVM *vm, JavaVMInitArgs *vm_args)
{
- utf *mainutf;
- classinfo *mainclass;
- methodinfo *m;
- java_objectarray *oa;
- s4 oalength;
- utf *u;
- java_lang_String *s;
- s4 status;
- s4 i;
+ utf *mainutf;
+ classinfo *mainclass;
+ java_handle_t *e;
+ methodinfo *m;
+ java_handle_objectarray_t *oa;
+ s4 oalength;
+ utf *u;
+ java_handle_t *s;
+ s4 status;
+ s4 i;
#if !defined(NDEBUG)
if (compileall) {
status = 0;
- if (opt_jar == true)
+ if (opt_jar == true) {
/* open jar file with java.util.jar.JarFile */
+
mainstring = vm_get_mainclass_from_jar(mainstring);
+ if (mainstring == NULL)
+ vm_exit(1);
+ }
+
/* load the main class */
mainutf = utf_new_char(mainstring);
#if defined(ENABLE_JAVAME_CLDC1_1)
- if (!(mainclass = load_class_bootstrap(mainutf)))
- throw_main_exception_exit();
+ mainclass = load_class_bootstrap(mainutf);
#else
- if (!(mainclass = load_class_from_sysloader(mainutf)))
- throw_main_exception_exit();
+ mainclass = load_class_from_sysloader(mainutf);
#endif
/* error loading class */
- if ((*exceptionptr != NULL) || (mainclass == NULL))
- throw_main_exception_exit();
+ e = exceptions_get_and_clear_exception();
- if (!link_class(mainclass))
- throw_main_exception_exit();
+ if ((e != NULL) || (mainclass == NULL)) {
+ exceptions_throw_noclassdeffounderror_cause(e);
+ exceptions_print_stacktrace();
+ vm_exit(1);
+ }
+
+ if (!link_class(mainclass)) {
+ exceptions_print_stacktrace();
+ vm_exit(1);
+ }
/* find the `main' method of the main class */
class_java_lang_Object,
false);
- if (*exceptionptr) {
- throw_main_exception_exit();
+ if (exceptions_get_exception()) {
+ exceptions_print_stacktrace();
+ vm_exit(1);
}
/* there is no main method or it isn't static */
if ((m == NULL) || !(m->flags & ACC_STATIC)) {
- *exceptionptr = NULL;
+ exceptions_clear_exception();
+ exceptions_throw_nosuchmethoderror(mainclass,
+ utf_new_char("main"),
+ utf_new_char("([Ljava/lang/String;)V"));
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodError, "main");
- throw_main_exception_exit();
+ exceptions_print_stacktrace();
+ vm_exit(1);
}
/* build argument array */
u = utf_new_char(vm_args->options[opt_index + i].optionString);
s = javastring_new(u);
- oa->data[i] = (java_objectheader *) s;
+ LLNI_objectarray_element_set(oa, i, s);
}
#ifdef TYPEINFO_DEBUG_TEST
jvmti_set_phase(JVMTI_PHASE_LIVE);
#endif
- /* increase total started thread count */
+ /* set ThreadMXBean variables */
+
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount++;
+ _Jv_jvm->java_lang_management_ThreadMXBean_TotalStartedThreadCount++;
- _Jv_jvm->total_started_thread_count++;
+ if (_Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount >
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount)
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount =
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount;
/* start the main thread */
/* exception occurred? */
- if (*exceptionptr) {
- throw_main_exception();
+ if (exceptions_get_exception()) {
+ exceptions_print_stacktrace();
status = 1;
}
/* unload the JavaVM */
- vm_destroy(vm);
+ (void) vm_destroy(vm);
/* and exit */
}
#endif
- if (!link_class(class_java_lang_System))
- throw_main_exception_exit();
+ if (!link_class(class_java_lang_System)) {
+ exceptions_print_stacktrace();
+ exit(1);
+ }
/* call java.lang.System.exit(I)V */
class_java_lang_Object,
true);
- if (m == NULL)
- throw_main_exception_exit();
+ if (m == NULL) {
+ exceptions_print_stacktrace();
+ exit(1);
+ }
/* call the exit function with passed exit status */
#endif
}
- mem_usagelog(1);
-
if (opt_getcompilingtime)
print_times();
#endif /* defined(ENABLE_STATISTICS) */
static char *vm_get_mainclass_from_jar(char *mainstring)
{
- classinfo *c;
- java_objectheader *o;
- methodinfo *m;
- java_lang_String *s;
+ classinfo *c;
+ java_handle_t *o;
+ methodinfo *m;
+ java_handle_t *s;
c = load_class_from_sysloader(utf_new_char("java/util/jar/JarFile"));
- if (c == NULL)
- throw_main_exception_exit();
-
+ if (c == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
+
/* create JarFile object */
o = builtin_new(c);
- if (o == NULL)
- throw_main_exception_exit();
-
+ if (o == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
m = class_resolveclassmethod(c,
utf_init,
class_java_lang_Object,
true);
- if (m == NULL)
- throw_main_exception_exit();
+ if (m == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
s = javastring_new_from_ascii(mainstring);
(void) vm_call_method(m, o, s);
- if (*exceptionptr)
- throw_main_exception_exit();
+ if (exceptions_get_exception()) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
/* get manifest object */
class_java_lang_Object,
true);
- if (m == NULL)
- throw_main_exception_exit();
+ if (m == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
o = vm_call_method(m, o);
if (o == NULL) {
fprintf(stderr, "Could not get manifest from %s (invalid or corrupt jarfile?)\n", mainstring);
- vm_exit(1);
+ return NULL;
}
class_java_lang_Object,
true);
- if (m == NULL)
- throw_main_exception_exit();
+ if (m == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
o = vm_call_method(m, o);
if (o == NULL) {
fprintf(stderr, "Could not get main attributes from %s (invalid or corrupt jarfile?)\n", mainstring);
- vm_exit(1);
+ return NULL;
}
class_java_lang_Object,
true);
- if (m == NULL)
- throw_main_exception_exit();
+ if (m == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
s = javastring_new_from_ascii("Main-Class");
o = vm_call_method(m, o, s);
- if (o == NULL)
- throw_main_exception_exit();
+ if (o == NULL) {
+ exceptions_print_stacktrace();
+ return NULL;
+ }
return javastring_tochar(o);
}
/* print out exception and cause */
- exceptions_print_exception(*exceptionptr);
+ exceptions_print_current_exception();
/* goto next class */
/* print out exception and cause */
- exceptions_print_exception(*exceptionptr);
+ exceptions_print_current_exception();
}
}
}
/* create, load and link the main class */
- if (!(mainclass = load_class_bootstrap(utf_new_char(mainstring))))
- throw_main_exception_exit();
+ mainclass = load_class_bootstrap(utf_new_char(mainstring));
+
+ if (mainclass == NULL)
+ exceptions_print_stacktrace();
if (!link_class(mainclass))
- throw_main_exception_exit();
+ exceptions_print_stacktrace();
if (opt_signature != NULL) {
m = class_resolveclassmethod(mainclass,
false);
}
- if (m == NULL) {
- char message[MAXLOGTEXT];
- sprintf(message, "%s%s", opt_method,
- opt_signature ? opt_signature : "");
-
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodException,
- message);
-
- throw_main_exception_exit();
- }
+ if (m == NULL)
+ vm_abort("vm_compile_method: java.lang.NoSuchMethodException: %s.%s",
+ opt_method, opt_signature ? opt_signature : "");
jit_compile(m);
}
#endif /* !defined(NDEBUG) */
-/* vm_vmargs_from_valist *******************************************************
+/* vm_array_store_int **********************************************************
- XXX
+ Helper function to store an integer into the argument array, taking
+ care of architecture specific issues.
*******************************************************************************/
-static void vm_vmargs_from_valist(methodinfo *m, java_objectheader *o,
- vm_arg *vmargs, va_list ap)
+static void vm_array_store_int(uint64_t *array, paramdesc *pd, int32_t value)
{
- typedesc *paramtypes;
- s4 i;
-
- paramtypes = m->parseddesc->paramtypes;
+ int32_t index;
- /* if method is non-static fill first block and skip `this' pointer */
+ if (!pd->inmemory) {
+ index = pd->index;
+ array[index] = (int64_t) value;
+ }
+ else {
+ index = ARG_CNT + pd->index;
+#if SIZEOF_VOID_P == 8
+ array[index] = (int64_t) value;
+#else
+# if WORDS_BIGENDIAN == 1
+ array[index] = ((int64_t) value) << 32;
+# else
+ array[index] = (int64_t) value;
+# endif
+#endif
+ }
+}
- i = 0;
- if (o != NULL) {
- /* the `this' pointer */
- vmargs[0].type = TYPE_ADR;
- vmargs[0].data.l = (u8) (ptrint) o;
+/* vm_array_store_lng **********************************************************
- paramtypes++;
- i++;
- }
+ Helper function to store a long into the argument array, taking
+ care of architecture specific issues.
- for (; i < m->parseddesc->paramcount; i++, paramtypes++) {
- switch (paramtypes->decltype) {
- /* primitive types */
- case PRIMITIVETYPE_BOOLEAN:
- case PRIMITIVETYPE_BYTE:
- case PRIMITIVETYPE_CHAR:
- case PRIMITIVETYPE_SHORT:
- case PRIMITIVETYPE_INT:
- vmargs[i].type = TYPE_INT;
- vmargs[i].data.l = (s8) va_arg(ap, s4);
- break;
+*******************************************************************************/
- case PRIMITIVETYPE_LONG:
- vmargs[i].type = TYPE_LNG;
- vmargs[i].data.l = (s8) va_arg(ap, s8);
- break;
+static void vm_array_store_lng(uint64_t *array, paramdesc *pd, int64_t value)
+{
+ int32_t index;
- case PRIMITIVETYPE_FLOAT:
- vmargs[i].type = TYPE_FLT;
-#if defined(__ALPHA__)
- /* this keeps the assembler function much simpler */
+#if SIZEOF_VOID_P == 8
+ if (!pd->inmemory)
+ index = pd->index;
+ else
+ index = ARG_CNT + pd->index;
- vmargs[i].data.d = (jdouble) va_arg(ap, jdouble);
+ array[index] = value;
#else
- vmargs[i].data.f = (jfloat) va_arg(ap, jdouble);
-#endif
- break;
+ if (!pd->inmemory) {
+ /* move low and high 32-bits into it's own argument slot */
- case PRIMITIVETYPE_DOUBLE:
- vmargs[i].type = TYPE_DBL;
- vmargs[i].data.d = (jdouble) va_arg(ap, jdouble);
- break;
+ index = GET_LOW_REG(pd->index);
+ array[index] = value & 0x00000000ffffffff;
- case TYPE_ADR:
- vmargs[i].type = TYPE_ADR;
- vmargs[i].data.l = (u8) (ptrint) va_arg(ap, void*);
- break;
- }
+ index = GET_HIGH_REG(pd->index);
+ array[index] = value >> 32;
+ }
+ else {
+ index = ARG_CNT + pd->index;
+ array[index] = value;
}
+#endif
}
-/* vm_vmargs_from_jvalue *******************************************************
+/* vm_array_store_flt **********************************************************
- XXX
+ Helper function to store a float into the argument array, taking
+ care of architecture specific issues.
*******************************************************************************/
-static void vm_vmargs_from_jvalue(methodinfo *m, java_objectheader *o,
- vm_arg *vmargs, jvalue *args)
+static void vm_array_store_flt(uint64_t *array, paramdesc *pd, uint64_t value)
{
- typedesc *paramtypes;
- s4 i;
- s4 j;
-
- paramtypes = m->parseddesc->paramtypes;
+ int32_t index;
- /* if method is non-static fill first block and skip `this' pointer */
+ if (!pd->inmemory) {
+#if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
+ index = pd->index;
+#else
+ index = INT_ARG_CNT + pd->index;
+#endif
+#if WORDS_BIGENDIAN == 1 && !defined(__POWERPC__) && !defined(__POWERPC64__) && !defined(__S390__)
+ array[index] = value >> 32;
+#else
+ array[index] = value;
+#endif
+ }
+ else {
+ index = ARG_CNT + pd->index;
+#if defined(__SPARC_64__)
+ array[index] = value >> 32;
+#else
+ array[index] = value;
+#endif
+ }
+}
- i = 0;
- if (o != NULL) {
- /* the `this' pointer */
- vmargs[0].type = TYPE_ADR;
- vmargs[0].data.l = (u8) (ptrint) o;
+/* vm_array_store_dbl **********************************************************
- paramtypes++;
- i++;
- }
+ Helper function to store a double into the argument array, taking
+ care of architecture specific issues.
- for (j = 0; i < m->parseddesc->paramcount; i++, j++, paramtypes++) {
- switch (paramtypes->decltype) {
- /* primitive types */
- case PRIMITIVETYPE_BOOLEAN:
- case PRIMITIVETYPE_BYTE:
- case PRIMITIVETYPE_CHAR:
- case PRIMITIVETYPE_SHORT:
- case PRIMITIVETYPE_INT:
- vmargs[i].type = TYPE_INT;
- vmargs[i].data.l = (s8) args[j].i;
- break;
+*******************************************************************************/
- case PRIMITIVETYPE_LONG:
- vmargs[i].type = TYPE_LNG;
- vmargs[i].data.l = (s8) args[j].j;
- break;
+static void vm_array_store_dbl(uint64_t *array, paramdesc *pd, uint64_t value)
+{
+ int32_t index;
- case PRIMITIVETYPE_FLOAT:
- vmargs[i].type = TYPE_FLT;
-#if defined(__ALPHA__)
- /* this keeps the assembler function much simpler */
+ if (!pd->inmemory) {
+#if SIZEOF_VOID_P != 8 && defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
+ index = GET_LOW_REG(pd->index);
+ array[index] = value & 0x00000000ffffffff;
- vmargs[i].data.d = (jdouble) args[j].f;
+ index = GET_HIGH_REG(pd->index);
+ array[index] = value >> 32;
#else
- vmargs[i].data.f = args[j].f;
+ index = INT_ARG_CNT + pd->index;
+ array[index] = value;
#endif
- break;
-
- case PRIMITIVETYPE_DOUBLE:
- vmargs[i].type = TYPE_DBL;
- vmargs[i].data.d = args[j].d;
- break;
-
- case TYPE_ADR:
- vmargs[i].type = TYPE_ADR;
- vmargs[i].data.l = (u8) (ptrint) args[j].l;
- break;
- }
+ }
+ else {
+ index = ARG_CNT + pd->index;
+ array[index] = value;
}
}
-/* vm_call_method **************************************************************
+/* vm_array_store_adr **********************************************************
- Calls a Java method with a variable number of arguments and returns
- an address.
+ Helper function to store an address into the argument array, taking
+ care of architecture specific issues.
*******************************************************************************/
-java_objectheader *vm_call_method(methodinfo *m, java_objectheader *o, ...)
+static void vm_array_store_adr(uint64_t *array, paramdesc *pd, void *value)
{
- va_list ap;
- java_objectheader *ro;
+ int32_t index;
- va_start(ap, o);
- ro = vm_call_method_valist(m, o, ap);
- va_end(ap);
+ if (!pd->inmemory) {
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+ /* When the architecture has address registers, place them
+ after integer and float registers. */
- return ro;
+ index = INT_ARG_CNT + FLT_ARG_CNT + pd->index;
+#else
+ index = pd->index;
+#endif
+ array[index] = (uint64_t) (intptr_t) value;
+ }
+ else {
+ index = ARG_CNT + pd->index;
+#if SIZEOF_VOID_P == 8
+ array[index] = (uint64_t) (intptr_t) value;
+#else
+# if WORDS_BIGENDIAN == 1
+ array[index] = ((uint64_t) (intptr_t) value) << 32;
+# else
+ array[index] = (uint64_t) (intptr_t) value;
+# endif
+#endif
+ }
}
-/* vm_call_method_valist *******************************************************
+/* vm_array_from_valist ********************************************************
- Calls a Java method with a variable number of arguments, passed via
- a va_list, and returns an address.
+ XXX
*******************************************************************************/
-java_objectheader *vm_call_method_valist(methodinfo *m, java_objectheader *o,
- va_list ap)
+uint64_t *vm_array_from_valist(methodinfo *m, java_object_t *o, va_list ap)
{
- s4 vmargscount;
- vm_arg *vmargs;
- java_objectheader *ro;
- s4 dumpsize;
+ methoddesc *md;
+ paramdesc *pd;
+ typedesc *td;
+ uint64_t *array;
+ int32_t i;
+ imm_union value;
- /* mark start of dump memory area */
+ /* get the descriptors */
- dumpsize = dump_size();
+ md = m->parseddesc;
+ pd = md->params;
+ td = md->paramtypes;
- /* get number of Java method arguments */
+ /* allocate argument array */
- vmargscount = m->parseddesc->paramcount;
+ array = DMNEW(uint64_t, INT_ARG_CNT + FLT_ARG_CNT + md->memuse);
- /* allocate vm_arg array */
+ /* if method is non-static fill first block and skip `this' pointer */
+
+ i = 0;
+
+ if (o != NULL) {
+ /* the `this' pointer */
+ vm_array_store_adr(array, pd, o);
- vmargs = DMNEW(vm_arg, vmargscount);
+ pd++;
+ td++;
+ i++;
+ }
- /* fill the vm_arg array from a va_list */
+ for (; i < md->paramcount; i++, pd++, td++) {
+ switch (td->type) {
+ case TYPE_INT:
+ value.i = va_arg(ap, int32_t);
+ vm_array_store_int(array, pd, value.i);
+ break;
- vm_vmargs_from_valist(m, o, vmargs, ap);
+ case TYPE_LNG:
+ value.l = va_arg(ap, int64_t);
+ vm_array_store_lng(array, pd, value.l);
+ break;
- /* call the Java method */
+ case TYPE_FLT:
+#if defined(__ALPHA__) || defined(__POWERPC__) || defined(__POWERPC64__)
+ /* This is required to load the correct float value in
+ assembler code. */
- ro = vm_call_method_vmarg(m, vmargscount, vmargs);
+ value.d = (double) va_arg(ap, double);
+#else
+ value.f = (float) va_arg(ap, double);
+#endif
+ vm_array_store_flt(array, pd, value.l);
+ break;
- /* release dump area */
+ case TYPE_DBL:
+ value.d = va_arg(ap, double);
+ vm_array_store_dbl(array, pd, value.l);
+ break;
- dump_release(dumpsize);
+ case TYPE_ADR:
+ value.a = va_arg(ap, void*);
+ vm_array_store_adr(array, pd, value.a);
+ break;
+ }
+ }
- return ro;
+ return array;
}
-/* vm_call_method_jvalue *******************************************************
+/* vm_array_from_jvalue ********************************************************
- Calls a Java method with a variable number of arguments, passed via
- a jvalue array, and returns an address.
+ XXX
*******************************************************************************/
-java_objectheader *vm_call_method_jvalue(methodinfo *m, java_objectheader *o,
- jvalue *args)
+static uint64_t *vm_array_from_jvalue(methodinfo *m, java_object_t *o,
+ const jvalue *args)
{
- s4 vmargscount;
- vm_arg *vmargs;
- java_objectheader *ro;
- s4 dumpsize;
+ methoddesc *md;
+ paramdesc *pd;
+ typedesc *td;
+ uint64_t *array;
+ int32_t i;
+ int32_t j;
- /* mark start of dump memory area */
+ /* get the descriptors */
- dumpsize = dump_size();
+ md = m->parseddesc;
+ pd = md->params;
+ td = md->paramtypes;
- /* get number of Java method arguments */
+ /* allocate argument array */
- vmargscount = m->parseddesc->paramcount;
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+ array = DMNEW(uint64_t, INT_ARG_CNT + FLT_ARG_CNT + ADR_ARG_CNT + md->memuse);
+#else
+ array = DMNEW(uint64_t, INT_ARG_CNT + FLT_ARG_CNT + md->memuse);
+#endif
- /* allocate vm_arg array */
+ /* if method is non-static fill first block and skip `this' pointer */
- vmargs = DMNEW(vm_arg, vmargscount);
+ i = 0;
- /* fill the vm_arg array from a va_list */
+ if (o != NULL) {
+ /* the `this' pointer */
+ vm_array_store_adr(array, pd, o);
- vm_vmargs_from_jvalue(m, o, vmargs, args);
+ pd++;
+ td++;
+ i++;
+ }
- /* call the Java method */
+ for (j = 0; i < md->paramcount; i++, j++, pd++, td++) {
+ switch (td->decltype) {
+ case TYPE_INT:
+ vm_array_store_int(array, pd, args[j].i);
+ break;
- ro = vm_call_method_vmarg(m, vmargscount, vmargs);
+ case TYPE_LNG:
+ vm_array_store_lng(array, pd, args[j].j);
+ break;
- /* release dump area */
+ case TYPE_FLT:
+ vm_array_store_flt(array, pd, args[j].j);
+ break;
- dump_release(dumpsize);
-
- return ro;
-}
-
-
-/* vm_call_method_vmarg ********************************************************
-
- Calls a Java method with a variable number of arguments, passed via
- a vm_arg array, and returns an address.
-
-*******************************************************************************/
-
-java_objectheader *vm_call_method_vmarg(methodinfo *m, s4 vmargscount,
- vm_arg *vmargs)
-{
- java_objectheader *o;
-
-#if defined(ENABLE_JIT)
-# if defined(ENABLE_INTRP)
- if (opt_intrp)
- o = intrp_asm_vm_call_method(m, vmargscount, vmargs);
- else
-# endif
- o = asm_vm_call_method(m, vmargscount, vmargs);
-#else
- o = intrp_asm_vm_call_method(m, vmargscount, vmargs);
-#endif
-
- return o;
-}
-
-
-/* vm_call_method_int **********************************************************
-
- Calls a Java method with a variable number of arguments and returns
- an integer (s4).
-
-*******************************************************************************/
-
-s4 vm_call_method_int(methodinfo *m, java_objectheader *o, ...)
-{
- va_list ap;
- s4 i;
+ case TYPE_DBL:
+ vm_array_store_dbl(array, pd, args[j].j);
+ break;
- va_start(ap, o);
- i = vm_call_method_int_valist(m, o, ap);
- va_end(ap);
+ case TYPE_ADR:
+ vm_array_store_adr(array, pd, args[j].l);
+ break;
+ }
+ }
- return i;
+ return array;
}
-/* vm_call_method_int_valist ***************************************************
+/* vm_array_from_objectarray ***************************************************
- Calls a Java method with a variable number of arguments, passed via
- a va_list, and returns an integer (s4).
+ XXX
*******************************************************************************/
-s4 vm_call_method_int_valist(methodinfo *m, java_objectheader *o, va_list ap)
+uint64_t *vm_array_from_objectarray(methodinfo *m, java_object_t *o,
+ java_handle_objectarray_t *params)
{
- s4 vmargscount;
- vm_arg *vmargs;
- s4 i;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_valist(m, o, vmargs, ap);
+ methoddesc *md;
+ paramdesc *pd;
+ typedesc *td;
+ uint64_t *array;
+ java_handle_t *param;
+ classinfo *c;
+ int type;
+ int32_t i;
+ int32_t j;
+ imm_union value;
- /* call the Java method */
+ /* get the descriptors */
- i = vm_call_method_int_vmarg(m, vmargscount, vmargs);
+ md = m->parseddesc;
+ pd = md->params;
+ td = md->paramtypes;
- /* release dump area */
+ /* allocate argument array */
- dump_release(dumpsize);
+ array = DMNEW(uint64_t, INT_ARG_CNT + FLT_ARG_CNT + md->memuse);
- return i;
-}
+ /* if method is non-static fill first block and skip `this' pointer */
+ i = 0;
-/* vm_call_method_int_jvalue ***************************************************
+ if (o != NULL) {
+ /* this pointer */
+ vm_array_store_adr(array, pd, o);
- Calls a Java method with a variable number of arguments, passed via
- a jvalue array, and returns an integer (s4).
+ pd++;
+ td++;
+ i++;
+ }
-*******************************************************************************/
+ for (j = 0; i < md->paramcount; i++, j++, pd++, td++) {
+ LLNI_objectarray_element_get(params, j, param);
-s4 vm_call_method_int_jvalue(methodinfo *m, java_objectheader *o, jvalue *args)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- s4 i;
- s4 dumpsize;
+ switch (td->type) {
+ case TYPE_INT:
+ if (param == NULL)
+ goto illegal_arg;
- /* mark start of dump memory area */
+ /* convert the value according to its declared type */
- dumpsize = dump_size();
+ c = param->vftbl->class;
+ type = primitive_type_get_by_wrapperclass(c);
- /* get number of Java method arguments */
+ switch (td->decltype) {
+ case PRIMITIVETYPE_BOOLEAN:
+ switch (type) {
+ case PRIMITIVETYPE_BOOLEAN:
+ /* This type is OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
+ break;
- vmargscount = m->parseddesc->paramcount;
+ case PRIMITIVETYPE_BYTE:
+ switch (type) {
+ case PRIMITIVETYPE_BYTE:
+ /* This type is OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
+ break;
- /* allocate vm_arg array */
+ case PRIMITIVETYPE_CHAR:
+ switch (type) {
+ case PRIMITIVETYPE_CHAR:
+ /* This type is OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
+ break;
- vmargs = DMNEW(vm_arg, vmargscount);
+ case PRIMITIVETYPE_SHORT:
+ switch (type) {
+ case PRIMITIVETYPE_BYTE:
+ case PRIMITIVETYPE_SHORT:
+ /* These types are OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
+ break;
+
+ case PRIMITIVETYPE_INT:
+ switch (type) {
+ case PRIMITIVETYPE_BYTE:
+ case PRIMITIVETYPE_SHORT:
+ case PRIMITIVETYPE_INT:
+ /* These types are OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
+ break;
- /* fill the vm_arg array from a va_list */
+ default:
+ vm_abort("vm_array_from_objectarray: invalid type %d",
+ td->decltype);
+ }
- vm_vmargs_from_jvalue(m, o, vmargs, args);
+ value = primitive_unbox(param);
+ vm_array_store_int(array, pd, value.i);
+ break;
- /* call the Java method */
+ case TYPE_LNG:
+ if (param == NULL)
+ goto illegal_arg;
- i = vm_call_method_int_vmarg(m, vmargscount, vmargs);
+ c = param->vftbl->class;
+ type = primitive_type_get_by_wrapperclass(c);
- /* release dump area */
+ assert(td->decltype == PRIMITIVETYPE_LONG);
- dump_release(dumpsize);
+ switch (type) {
+ case PRIMITIVETYPE_BYTE:
+ case PRIMITIVETYPE_SHORT:
+ case PRIMITIVETYPE_INT:
+ case PRIMITIVETYPE_LONG:
+ /* These types are OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
- return i;
-}
+ value = primitive_unbox(param);
+ vm_array_store_lng(array, pd, value.l);
+ break;
+ case TYPE_FLT:
+ if (param == NULL)
+ goto illegal_arg;
-/* vm_call_method_int_vmarg ****************************************************
+ c = param->vftbl->class;
+ type = primitive_type_get_by_wrapperclass(c);
- Calls a Java method with a variable number of arguments, passed via
- a vm_arg array, and returns an integer (s4).
+ assert(td->decltype == PRIMITIVETYPE_FLOAT);
-*******************************************************************************/
+ switch (type) {
+ case PRIMITIVETYPE_FLOAT:
+ /* This type is OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
-s4 vm_call_method_int_vmarg(methodinfo *m, s4 vmargscount, vm_arg *vmargs)
-{
- s4 i;
+ value = primitive_unbox(param);
+ vm_array_store_flt(array, pd, value.l);
+ break;
-#if defined(ENABLE_JIT)
-# if defined(ENABLE_INTRP)
- if (opt_intrp)
- i = intrp_asm_vm_call_method_int(m, vmargscount, vmargs);
- else
-# endif
- i = asm_vm_call_method_int(m, vmargscount, vmargs);
-#else
- i = intrp_asm_vm_call_method_int(m, vmargscount, vmargs);
-#endif
+ case TYPE_DBL:
+ if (param == NULL)
+ goto illegal_arg;
- return i;
-}
+ c = param->vftbl->class;
+ type = primitive_type_get_by_wrapperclass(c);
+ assert(td->decltype == PRIMITIVETYPE_DOUBLE);
-/* vm_call_method_long *********************************************************
+ switch (type) {
+ case PRIMITIVETYPE_FLOAT:
+ case PRIMITIVETYPE_DOUBLE:
+ /* These types are OK. */
+ break;
+ default:
+ goto illegal_arg;
+ }
- Calls a Java method with a variable number of arguments and returns
- a long (s8).
+ value = primitive_unbox(param);
+ vm_array_store_dbl(array, pd, value.l);
+ break;
+
+ case TYPE_ADR:
+ if (!resolve_class_from_typedesc(td, true, true, &c))
+ return false;
+
+ if (param != NULL) {
+ if (td->arraydim > 0) {
+ if (!builtin_arrayinstanceof(param, c))
+ goto illegal_arg;
+ }
+ else {
+ if (!builtin_instanceof(param, c))
+ goto illegal_arg;
+ }
+ }
-*******************************************************************************/
+ vm_array_store_adr(array, pd, param);
+ break;
-s8 vm_call_method_long(methodinfo *m, java_objectheader *o, ...)
-{
- va_list ap;
- s8 l;
+ default:
+ vm_abort("vm_array_from_objectarray: invalid type %d", td->type);
+ }
+ }
- va_start(ap, o);
- l = vm_call_method_long_valist(m, o, ap);
- va_end(ap);
+ return array;
- return l;
+illegal_arg:
+ exceptions_throw_illegalargumentexception();
+ return NULL;
}
-/* vm_call_method_long_valist **************************************************
+/* vm_call_method **************************************************************
- Calls a Java method with a variable number of arguments, passed via
- a va_list, and returns a long (s8).
+ Calls a Java method with a variable number of arguments.
*******************************************************************************/
-s8 vm_call_method_long_valist(methodinfo *m, java_objectheader *o, va_list ap)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- s8 l;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_valist(m, o, vmargs, ap);
-
- /* call the Java method */
-
- l = vm_call_method_long_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return l;
+#define VM_CALL_METHOD(name, type) \
+type vm_call_method##name(methodinfo *m, java_handle_t *o, ...) \
+{ \
+ va_list ap; \
+ type value; \
+ \
+ va_start(ap, o); \
+ value = vm_call_method##name##_valist(m, o, ap); \
+ va_end(ap); \
+ \
+ return value; \
}
+VM_CALL_METHOD(, java_handle_t *)
+VM_CALL_METHOD(_int, int32_t)
+VM_CALL_METHOD(_long, int64_t)
+VM_CALL_METHOD(_float, float)
+VM_CALL_METHOD(_double, double)
-/* vm_call_method_long_jvalue **************************************************
-
- Calls a Java method with a variable number of arguments, passed via
- a jvalue array, and returns a long (s8).
-
-*******************************************************************************/
-
-s8 vm_call_method_long_jvalue(methodinfo *m, java_objectheader *o, jvalue *args)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- s8 l;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_jvalue(m, o, vmargs, args);
- /* call the Java method */
-
- l = vm_call_method_long_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return l;
-}
-
-
-/* vm_call_method_long_vmarg ***************************************************
+/* vm_call_method_valist *******************************************************
Calls a Java method with a variable number of arguments, passed via
- a vm_arg array, and returns a long (s8).
+ a va_list.
*******************************************************************************/
-s8 vm_call_method_long_vmarg(methodinfo *m, s4 vmargscount, vm_arg *vmargs)
-{
- s8 l;
-
-#if defined(ENABLE_JIT)
-# if defined(ENABLE_INTRP)
- if (opt_intrp)
- l = intrp_asm_vm_call_method_long(m, vmargscount, vmargs);
- else
-# endif
- l = asm_vm_call_method_long(m, vmargscount, vmargs);
-#else
- l = intrp_asm_vm_call_method_long(m, vmargscount, vmargs);
-#endif
-
- return l;
+#define VM_CALL_METHOD_VALIST(name, type) \
+type vm_call_method##name##_valist(methodinfo *m, java_handle_t *o, \
+ va_list ap) \
+{ \
+ int32_t dumpsize; \
+ uint64_t *array; \
+ type value; \
+ \
+ dumpsize = dump_size(); \
+ array = vm_array_from_valist(m, o, ap); \
+ value = vm_call##name##_array(m, array); \
+ dump_release(dumpsize); \
+ \
+ return value; \
}
+VM_CALL_METHOD_VALIST(, java_handle_t *)
+VM_CALL_METHOD_VALIST(_int, int32_t)
+VM_CALL_METHOD_VALIST(_long, int64_t)
+VM_CALL_METHOD_VALIST(_float, float)
+VM_CALL_METHOD_VALIST(_double, double)
-/* vm_call_method_float ********************************************************
-
- Calls a Java method with a variable number of arguments and returns
- an float.
-
-*******************************************************************************/
-
-float vm_call_method_float(methodinfo *m, java_objectheader *o, ...)
-{
- va_list ap;
- float f;
-
- va_start(ap, o);
- f = vm_call_method_float_valist(m, o, ap);
- va_end(ap);
-
- return f;
-}
-
-
-/* vm_call_method_float_valist *************************************************
-
- Calls a Java method with a variable number of arguments, passed via
- a va_list, and returns a float.
-
-*******************************************************************************/
-
-float vm_call_method_float_valist(methodinfo *m, java_objectheader *o,
- va_list ap)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- float f;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
- vm_vmargs_from_valist(m, o, vmargs, ap);
-
- /* call the Java method */
-
- f = vm_call_method_float_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return f;
-}
-
-
-/* vm_call_method_float_jvalue *************************************************
+/* vm_call_method_jvalue *******************************************************
Calls a Java method with a variable number of arguments, passed via
- a jvalue array, and returns a float.
-
-*******************************************************************************/
-
-float vm_call_method_float_jvalue(methodinfo *m, java_objectheader *o,
- jvalue *args)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- float f;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_jvalue(m, o, vmargs, args);
-
- /* call the Java method */
-
- f = vm_call_method_float_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return f;
-}
-
-
-/* vm_call_method_float_vmarg **************************************************
-
- Calls a Java method with a variable number of arguments and returns
- an float.
-
-*******************************************************************************/
-
-float vm_call_method_float_vmarg(methodinfo *m, s4 vmargscount, vm_arg *vmargs)
-{
- float f;
-
-#if defined(ENABLE_JIT)
-# if defined(ENABLE_INTRP)
- if (opt_intrp)
- f = intrp_asm_vm_call_method_float(m, vmargscount, vmargs);
- else
-# endif
- f = asm_vm_call_method_float(m, vmargscount, vmargs);
-#else
- f = intrp_asm_vm_call_method_float(m, vmargscount, vmargs);
-#endif
-
- return f;
-}
-
-
-/* vm_call_method_double *******************************************************
-
- Calls a Java method with a variable number of arguments and returns
- a double.
+ a jvalue array.
*******************************************************************************/
-double vm_call_method_double(methodinfo *m, java_objectheader *o, ...)
-{
- va_list ap;
- double d;
-
- va_start(ap, o);
- d = vm_call_method_double_valist(m, o, ap);
- va_end(ap);
-
- return d;
+#define VM_CALL_METHOD_JVALUE(name, type) \
+type vm_call_method##name##_jvalue(methodinfo *m, java_handle_t *o, \
+ const jvalue *args) \
+{ \
+ int32_t dumpsize; \
+ uint64_t *array; \
+ type value; \
+ \
+ dumpsize = dump_size(); \
+ array = vm_array_from_jvalue(m, o, args); \
+ value = vm_call##name##_array(m, array); \
+ dump_release(dumpsize); \
+ \
+ return value; \
}
+VM_CALL_METHOD_JVALUE(, java_handle_t *)
+VM_CALL_METHOD_JVALUE(_int, int32_t)
+VM_CALL_METHOD_JVALUE(_long, int64_t)
+VM_CALL_METHOD_JVALUE(_float, float)
+VM_CALL_METHOD_JVALUE(_double, double)
-/* vm_call_method_double_valist ************************************************
-
- Calls a Java method with a variable number of arguments, passed via
- a va_list, and returns a double.
-
-*******************************************************************************/
-
-double vm_call_method_double_valist(methodinfo *m, java_objectheader *o,
- va_list ap)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- double d;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_valist(m, o, vmargs, ap);
-
- /* call the Java method */
-
- d = vm_call_method_double_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
- dump_release(dumpsize);
-
- return d;
-}
-
-
-/* vm_call_method_double_jvalue ************************************************
+/* vm_call_array ***************************************************************
Calls a Java method with a variable number of arguments, passed via
- a jvalue array, and returns a double.
+ an argument array.
*******************************************************************************/
-double vm_call_method_double_jvalue(methodinfo *m, java_objectheader *o,
- jvalue *args)
-{
- s4 vmargscount;
- vm_arg *vmargs;
- double d;
- s4 dumpsize;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- /* get number of Java method arguments */
-
- vmargscount = m->parseddesc->paramcount;
-
- /* allocate vm_arg array */
-
- vmargs = DMNEW(vm_arg, vmargscount);
-
- /* fill the vm_arg array from a va_list */
-
- vm_vmargs_from_jvalue(m, o, vmargs, args);
-
- /* call the Java method */
-
- d = vm_call_method_double_vmarg(m, vmargscount, vmargs);
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return d;
+#define VM_CALL_ARRAY(name, type) \
+type vm_call##name##_array(methodinfo *m, uint64_t *array) \
+{ \
+ methoddesc *md; \
+ void *pv; \
+ type value; \
+ \
+ md = m->parseddesc; \
+ \
+ if (m->code == NULL) \
+ if (!jit_compile(m)) \
+ return 0; \
+ \
+ pv = m->code->entrypoint; \
+ \
+ STATISTICS(count_calls_native_to_java++); \
+ \
+ value = asm_vm_call_method##name(pv, array, md->memuse); \
+ \
+ return value; \
}
-
-/* vm_call_method_double_vmarg *************************************************
-
- Calls a Java method with a variable number of arguments and returns
- a double.
-
-*******************************************************************************/
-
-double vm_call_method_double_vmarg(methodinfo *m, s4 vmargscount,
- vm_arg *vmargs)
-{
- double d;
-
-#if defined(ENABLE_JIT)
-# if defined(ENABLE_INTRP)
- if (opt_intrp)
- d = intrp_asm_vm_call_method_double(m, vmargscount, vmargs);
- else
-# endif
- d = asm_vm_call_method_double(m, vmargscount, vmargs);
-#else
- d = intrp_asm_vm_call_method_double(m, vmargscount, vmargs);
-#endif
-
- return d;
-}
+VM_CALL_ARRAY(, java_handle_t *)
+VM_CALL_ARRAY(_int, int32_t)
+VM_CALL_ARRAY(_long, int64_t)
+VM_CALL_ARRAY(_float, float)
+VM_CALL_ARRAY(_double, double)
/*
projects / cacao.git / blobdiff