int classlibInitialiseNatives() { Class *field_accessor; FieldBlock *base_fb = NULL; char *dll_path = getBootDllPath(); char *dll_name = getDllName("java"); char path[strlen(dll_path) + strlen(dll_name) + 2]; strcat(strcat(strcpy(path, dll_path), "/"), dll_name); sysFree(dll_name); if(!resolveDll(path, NULL)) { jam_fprintf(stderr, "Error initialising natives: couldn't open " "libjava.so: use -verbose:jni for more " "information\n"); return FALSE; } field_accessor = findSystemClass0(SYMBOL( sun_reflect_UnsafeStaticFieldAccessorImpl)); if(field_accessor != NULL) base_fb = findField(field_accessor, SYMBOL(base), SYMBOL(sig_java_lang_Object)); if(base_fb == NULL) { jam_fprintf(stderr, "Error initialising natives: %s " "missing or malformed\n", SYMBOL(sun_reflect_UnsafeStaticFieldAccessorImpl)); return FALSE; } hideFieldFromGC(base_fb); return initialiseJVMInterface(); }
void signalChainedExceptionEnum(int excep_enum, char *message, Object *cause) { if(!inited) { char *excep_name = symbol_values[exception_symbols[excep_enum]]; jam_fprintf(stderr, "Exception occurred while VM initialising.\n"); if(message) jam_fprintf(stderr, "%s: %s\n", excep_name, message); else jam_fprintf(stderr, "%s\n", excep_name); exit(1); } signalChainedExceptionClass(exceptions[excep_enum], message, cause); }
void signalChainedExceptionName(char *excep_name, char *message, Object *cause) { if(!inited) { jam_fprintf(stderr, "Exception occurred while VM initialising.\n"); if(message) jam_fprintf(stderr, "%s: %s\n", excep_name, message); else jam_fprintf(stderr, "%s\n", excep_name); exit(1); } else { Class *exception = findSystemClass(excep_name); if(!exceptionOccurred()) signalChainedExceptionClass(exception, message, cause); } }
void initialiseString() { FieldBlock *count = NULL, *value, *offset; string_class = findSystemClass0(SYMBOL(java_lang_String)); registerStaticClassRef(&string_class); if(string_class != NULL) { count = findField(string_class, SYMBOL(count), SYMBOL(I)); value = findField(string_class, SYMBOL(value), SYMBOL(array_C)); offset = findField(string_class, SYMBOL(offset), SYMBOL(I)); } /* findField doesn't throw an exception... */ if((count == NULL) || (value == NULL) || (offset == NULL)) { jam_fprintf(stderr, "Error initialising VM (initialiseString)\n"); exitVM(1); } count_offset = count->offset; value_offset = value->offset; offset_offset = offset->offset; /* Init hash table and create lock */ initHashTable(hash_table, HASHTABSZE, TRUE); }
int classlibInitialiseNatives() { // printf("classlib\n"); FieldBlock *pd = findField(java_lang_Class, SYMBOL(pd), SYMBOL(sig_java_security_ProtectionDomain)); // printf("%p\n",pd); if(pd == NULL) { jam_fprintf(stderr, "Expected \"pd\" field missing in " "java.lang.Class\n"); return FALSE; } pd_offset = pd->u.offset; return TRUE; }
void classlibCacheClassLoaderFields(Class *loader_class) { FieldBlock *classes_fb = findField(loader_class, SYMBOL(classes), SYMBOL(sig_java_util_vector)); FieldBlock *parent_fb = findField(loader_class, SYMBOL(parent), SYMBOL(sig_java_lang_ClassLoader)); if(classes_fb == NULL || parent_fb == NULL) { jam_fprintf(stderr, "Expected \"classes\" and/or \"parent\" field " "missing in java.lang.ClassLoader\n"); exitVM(1); } hideFieldFromGC(classes_fb); ldr_classes_offset = classes_fb->u.offset; ldr_parent_offset = parent_fb->u.offset; }
void initialiseException() { FieldBlock *bcktrce; int i; ste_class = findSystemClass0(SYMBOL(java_lang_StackTraceElement)); ste_array_class = findArrayClass(SYMBOL(array_java_lang_StackTraceElement)); vmthrow_class = findSystemClass0(SYMBOL(java_lang_VMThrowable)); throw_class = findSystemClass0(SYMBOL(java_lang_Throwable)); bcktrce = findField(vmthrow_class, SYMBOL(backtrace), SYMBOL(sig_java_lang_Object)); vmthrow_init_mb = findMethod(ste_class, SYMBOL(object_init), SYMBOL(_java_lang_String_I_java_lang_String_java_lang_String_Z__V)); if((bcktrce == NULL) || (vmthrow_init_mb == NULL)) { jam_fprintf(stderr, "Error initialising VM (initialiseException)\n"); exitVM(1); } CLASS_CB(vmthrow_class)->flags |= VMTHROWABLE; backtrace_offset = bcktrce->offset; registerStaticClassRef(&ste_class); registerStaticClassRef(&ste_array_class); registerStaticClassRef(&vmthrow_class); registerStaticClassRef(&throw_class); /* Load and register the exceptions used within the VM. These are preloaded to speed up access. The VM will abort if any can't be loaded */ for(i = 0; i < MAX_EXCEPTION_ENUM; i++) { exceptions[i] = findSystemClass0(symbol_values[exception_symbols[i]]); registerStaticClassRef(&exceptions[i]); } inited = TRUE; }
void initialiseThreadStage2(InitArgs *args) { Object *java_thread; Class *thrdGrp_class; MethodBlock *run, *remove_thread; FieldBlock *group, *priority, *root, *threadId; FieldBlock *vmThread = NULL, *thread = NULL; FieldBlock *vmData, *daemon, *name; /* Load thread class and register reference for compaction threading */ thread_class = findSystemClass0(SYMBOL(java_lang_Thread)); registerStaticClassRef(&thread_class); if(thread_class != NULL) { vmThread = findField(thread_class, SYMBOL(vmThread), SYMBOL(sig_java_lang_VMThread)); daemon = findField(thread_class, SYMBOL(daemon), SYMBOL(Z)); name = findField(thread_class, SYMBOL(name), SYMBOL(sig_java_lang_String)); group = findField(thread_class, SYMBOL(group), SYMBOL(sig_java_lang_ThreadGroup)); priority = findField(thread_class, SYMBOL(priority), SYMBOL(I)); threadId = findField(thread_class, SYMBOL(threadId), SYMBOL(J)); init_mb = findMethod(thread_class, SYMBOL(object_init), SYMBOL(_java_lang_VMThread_java_lang_String_I_Z__V)); run = findMethod(thread_class, SYMBOL(run), SYMBOL(___V)); vmthread_class = findSystemClass0(SYMBOL(java_lang_VMThread)); CLASS_CB(vmthread_class)->flags |= VMTHREAD; /* Register class reference for compaction threading */ registerStaticClassRef(&vmthread_class); if(vmthread_class != NULL) { thread = findField(vmthread_class, SYMBOL(thread), SYMBOL(sig_java_lang_Thread)); vmData = findField(vmthread_class, SYMBOL(vmData), SYMBOL(I)); } } /* findField and findMethod do not throw an exception... */ if((init_mb == NULL) || (vmData == NULL) || (run == NULL) || (daemon == NULL) || (name == NULL) || (group == NULL) || (priority == NULL) || (vmThread == NULL) || (thread == NULL) || (threadId == NULL)) goto error; vmthread_offset = vmThread->offset; thread_offset = thread->offset; vmData_offset = vmData->offset; daemon_offset = daemon->offset; group_offset = group->offset; priority_offset = priority->offset; threadId_offset = threadId->offset; name_offset = name->offset; run_mtbl_idx = run->method_table_index; /* Initialise the Java-level thread objects for the main thread */ java_thread = initJavaThread(&main_thread, FALSE, "main"); /* Main thread is now sufficiently setup to be able to run the thread group initialiser. This is essential to create the root thread group */ thrdGrp_class = findSystemClass(SYMBOL(java_lang_ThreadGroup)); root = findField(thrdGrp_class, SYMBOL(root), SYMBOL(sig_java_lang_ThreadGroup)); addThread_mb = findMethod(thrdGrp_class, SYMBOL(addThread), SYMBOL(_java_lang_Thread_args__void)); remove_thread = findMethod(thrdGrp_class, SYMBOL(removeThread), SYMBOL(_java_lang_Thread_args__void)); /* findField and findMethod do not throw an exception... */ if((root == NULL) || (addThread_mb == NULL) || (remove_thread == NULL)) goto error; rmveThrd_mtbl_idx = remove_thread->method_table_index; /* Add the main thread to the root thread group */ INST_DATA(java_thread)[group_offset] = root->static_value; { DummyFrame dummy; executeMethod(&dummy, ((Object*)root->static_value), addThread_mb, java_thread); } // dyn INST_DATA(java_thread)[vmthread_offset] = 0; /* Setup signal handling. This will be inherited by all threads created within Java */ initialiseSignals(); /* Create the signal handler thread. It is responsible for catching and handling SIGQUIT (thread dump) and SIGINT (user-termination of the VM, e.g. via Ctrl-C). Note it must be a valid Java-level thread as it needs to run the shutdown hooks in the event of user-termination */ createVMThread("Signal Handler", dumpThreadsLoop); return; error: jam_fprintf(stderr, "Error initialising VM (initialiseMainThread)\nCheck " "the README for compatible versions of GNU Classpath\n"); printException(); exitVM(1); }