globals.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 1,369 行 · 第 1/3 页

    {
	CVM_TRUE,  /* nonstatic */
	CVMsystemClass(java_lang_Thread),
        "initMainThread", "(IJ)V",
        &CVMglobals.java_lang_Thread_initMainThread
        /* NOTE: java.lang.Thread has a static initializer.  The clinit
                 will be done explicitly in JNI_CreateJavaVM(). */
    },
    /* java.lang.Thread.initAttachedThread() */
    {
	CVM_TRUE,  /* static */
	CVMsystemClass(java_lang_Thread),
        "initAttachedThread",
	    "(Ljava/lang/ThreadGroup;Ljava/lang/String;IJZ)"
	    "Ljava/lang/Thread;",
        &CVMglobals.java_lang_Thread_initAttachedThread
        /* NOTE: java.lang.Thread has a static initializer.  The clinit
                 will be done explicitly in JNI_CreateJavaVM(). */
    },
    /* java.lang.Thread.nextThreadNum() */
    {
	CVM_TRUE,  /* static */
	CVMsystemClass(java_lang_Thread),
        "nextThreadNum", "()I",
        &CVMglobals.java_lang_Thread_nextThreadNum,
        /* NOTE: java.lang.Thread has a static initializer.  The clinit
                 will be done explicitly in JNI_CreateJavaVM(). */
    },

#ifdef CVM_AOT
    /* sun.misc.Warmup.runit() */
    {
        CVM_TRUE, /* static */
        CVMsystemClass(sun_misc_Warmup),
        "runit", "(Ljava/lang/String;Ljava/lang/String;)V",
        &CVMglobals.sun_misc_Warmup_runit,
    },
#endif

#ifdef CVM_JVMPI
    /* java.lang.Thread.initDaemonThread() */
    {
	CVM_TRUE,  /* nonstatic */
	CVMsystemClass(java_lang_Thread),
        "initDaemonThread", "(Ljava/lang/String;I)Ljava/lang/Thread;",
        &CVMglobals.java_lang_Thread_initDaemonThread
        /* NOTE: java.lang.Thread has a static initializer.  The clinit
                 will be done explicitly in JNI_CreateJavaVM(). */
    },
#endif

    /**********************************************************
     * The following are for native application class loading.
     **********************************************************/
    /* sun.misc.Launcher.AppClassLoader.setExtInfo() */
    {
	CVM_TRUE,  /* static */
	CVMsystemClass(sun_misc_Launcher_AppClassLoader),
        "setExtInfo", "()V",
        &CVMglobals.sun_misc_Launcher_AppClassLoader_setExtInfo
        /* NOTE: sun.misc.Launcher.AppClassLoader has a static initializer.
                 The clinit will be checked for and done at the site of use.*/
    },
    /* sun.misc.Launcher.ClassContainer.<init>(URL, String, Jarfile) */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(sun_misc_Launcher_ClassContainer),
        "<init>", 
	    "(Ljava/net/URL;"
	    "Ljava/lang/String;"
	    "Ljava/util/jar/JarFile;)V",
        &CVMglobals.sun_misc_Launcher_ClassContainer_init
        /* NOTE: sun.misc.Launcher.ClassContainer has no static initializer.
                 Hence, no clinit needed. */
    },
    /* sun.misc.Launcher.ClassContainer.<init>(URL, Class, String, Jarfile) */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(sun_misc_Launcher_ClassContainer),
        "<init>", 
	    "(Ljava/net/URL;"
	    "Ljava/lang/Class;"
	    "Ljava/lang/String;"
	    "Ljava/util/jar/JarFile;)V",
        &CVMglobals.sun_misc_Launcher_ClassContainer_init_withClass
        /* NOTE: sun.misc.Launcher.ClassContainer has no static initializer.
                 Hence, no clinit needed. */
    },
    /* sun.misc.Launcher.getFileURL(File) */
    {
	CVM_TRUE,  /* static */
	CVMsystemClass(sun_misc_Launcher),
        "getFileURL", "(Ljava/io/File;)Ljava/net/URL;",
        &CVMglobals.sun_misc_Launcher_getFileURL
        /* NOTE: sun.misc.Launcher has a static initializer.  The clinit will
                 be checked for and done at the site of use. */
    },
    /* java.io.FILE.<init>(File) */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(java_io_File),
        "<init>", "(Ljava/lang/String;)V",
        &CVMglobals.java_io_File_init
        /* NOTE: java.io.FILE has a static initializer.  The clinit will be
                 checked for and done at the site of use. */
    },
    /* java.util.jar.JarFile.<init>(File) */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(java_util_jar_JarFile),
        "<init>", "(Ljava/io/File;)V",
        &CVMglobals.java_util_jar_JarFile_init
        /* NOTE: java.util.jar.JarFile's superclass has a static initializer.
                 The clinit will be checked for and done at the site of use. */
    },
    /* java.security.CodeSource.<init>(String)  */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(java_security_CodeSource),
        "<init>", "(Ljava/net/URL;[Ljava/security/cert/Certificate;)V",
        &CVMglobals.java_security_CodeSource_init
        /* NOTE: java.security.CodeSource has no static initializer.
                 Hence, no clinit needed. */
    },
    /* java.security.SecureClassLoader.getProtectionDomain(CodeSource) */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(java_security_SecureClassLoader),
        "getProtectionDomain", 
	"(Ljava/security/CodeSource;)Ljava/security/ProtectionDomain;",
        &CVMglobals.java_security_SecureClassLoader_getProtectionDomain
        /* NOTE: java.security.SecureClassLoader has a static initializer, but
                 does not need a clinit check because this mb is for a virtual
                 method i.e. the class was already initialized previously
                 when the object was instantiated. */
    },
    /* java.lang.ClassLoader.checkCerts */
    {
	CVM_FALSE, /* nonstatic */
	CVMsystemClass(java_lang_ClassLoader),
        "checkCerts", "(Ljava/lang/String;Ljava/security/CodeSource;)V",
        &CVMglobals.java_lang_ClassLoader_checkCerts
        /* NOTE: java.lang.ClassLoader has a static initializer.
                 Hence, no clinit needed. */
    },
};

static void
CVMdestroyGlobalSysMutexes(int n)
{
    int i;
    for (i = 0; i < n; i++) {
	CVMsysMutexDestroy(globalSysMutexes[i].mutex);
    }
}

static void
CVMdestroyMicroLocks(CVMMicroLock *locks, int n)
{
    int i;
    for (i = 0; i < n; ++i) {
	CVMmicrolockDestroy(&locks[i]);
    }
}

static void
CVMdestroyCstates(int n)
{
    int i;
    for (i = 0; i < n; ++i) {
	CVMcsDestroy(CVM_CSTATE(i));
    }
}

static CVMBool
initCstates()    
{
    int i;
    CVMUint8 rank = CVM_SYSMUTEX_MAX_RANK - CVM_NUM_CONSISTENT_STATES;
    
    for (i = 0; i < CVM_NUM_CONSISTENT_STATES; ++i) {
	if (!CVMcsInit(CVM_CSTATE(i), CVMcstateNames[i], rank)) {
	    CVMdestroyCstates(i);
	    return CVM_FALSE;
	}
	++rank;
    }
    return CVM_TRUE;
}

#define CVM_NUM_GLOBAL_METHODBLOCKS \
    (sizeof(globalMethodBlocks) / sizeof(CVMGlobalMethodBlockEntry))

static const CVMSubOptionData knownOptSubOptions[] = {

#ifdef CVM_HAS_PLATFORM_SPECIFIC_SUBOPTIONS
#include "javavm/include/opt_md.h"
#endif

    {"stackChunkSize", "Java stack chunk size",
	CVM_INTEGER_OPTION,
#ifdef CVM_JIT
	{{32, 64 * 1024, 2 * 1024}},
#else
	{{32, 64 * 1024, 1 * 1024}},
#endif
	&CVMglobals.config.javaStackChunkSize},

    {"stackMinSize", "Java stack minimum size",
	CVM_INTEGER_OPTION,
#ifdef CVM_JIT
	{{32, 64 * 1024, 3*1024}},
#else
	{{32, 64 * 1024, 1*1024}},
#endif
	&CVMglobals.config.javaStackMinSize},

    {"stackMaxSize", "Java stack maximum size",
	CVM_INTEGER_OPTION,
	{{1024, 1 * 1024 * 1024, 128 * 1024}},
	&CVMglobals.config.javaStackMaxSize},

    {NULL, NULL, CVM_NULL_OPTION, {{0, 0, 0}}, NULL}
};

void
CVMoptPrintUsage()
{
    CVMconsolePrintf("Valid -Xopt options include:\n");
    CVMprintSubOptionsUsageString(knownOptSubOptions);
}

CVMBool
CVMoptParseXoptOptions(const char* optAttributesStr)
{
    if (!CVMinitParsedSubOptions(&CVMglobals.parsedSubOptions,
				 optAttributesStr))
    {
	return CVM_FALSE;
    }

    if (!CVMprocessSubOptions(knownOptSubOptions, "-Xopt",
                              &CVMglobals.parsedSubOptions)) {
	CVMoptPrintUsage();
	return CVM_FALSE;
    }

    return CVM_TRUE;
}

CVMBool
CVMoptParseXssOption(const char* xssStr)
{
    CVMInt32 nativeStackSize = CVMoptionToInt32(xssStr);
    if (nativeStackSize == -1) {
	CVMconsolePrintf("Warning: Could not parse "
			 "stack size string \"%s\", setting default\n",
			 xssStr);
	/* gs->nativeStackSize remains 0 */
	return CVM_TRUE;
    } else if (nativeStackSize < CVM_THREAD_MIN_C_STACK_SIZE) {
	CVMconsolePrintf("Stack size %d below minimum stack size (%d)\n",
			 nativeStackSize, CVM_THREAD_MIN_C_STACK_SIZE);
	return CVM_FALSE;
    } else {
	CVMglobals.config.nativeStackSize = nativeStackSize;
	return CVM_TRUE;
    }
}

#if defined(CVM_DEBUG) || defined(CVM_INSPECTOR)
void CVMdumpGlobalsSubOptionValues()
{
    CVMprintSubOptionValues(knownOptSubOptions);
}
#endif /* CVM_DEBUG || CVM_INSPECTOR */

CVMBool CVMinitVMGlobalState(CVMGlobalState *gs, CVMOptions *options)
{
    CVMExecEnv *ee = &gs->mainEE;
    /*
     * First zero everything out
     */
    memset((void*)gs, 0, sizeof(CVMGlobalState));

    /*
     * Now initialize the global state
     */
    CVMtraceMisc(("Initializing global state\n"));

#if CVM_USE_MMAP_APIS
    if (!CVMmemInit()) {
	goto out_of_memory;
    }
#endif

    /* init interpreter loop function pointer */
    gs->CVMgcUnsafeExecuteJavaMethodProcPtr = &CVMgcUnsafeExecuteJavaMethod;

    CVMinitJNIStatics();
    
    gs->exit_procs = NULL;

#ifdef CVM_MTASK
    gs->isServer = options->isServer;
#endif

#ifdef CVM_JVMPI
    /* Initialize these 2 lists before anyone instantiates any monitors: */
    gs->objMonitorList = NULL;
    gs->rawMonitorList = NULL;
#endif
#ifdef CVM_JVMTI
    /* Initialize high res clocks */
    CVMtimeClockInit();
#endif
    /*
     * Random number generator
     */
    CVMrandomInit();

    CVMpreloaderInit();

    gs->threadList = NULL;
    gs->threadIDCount = 0;

#if defined(CVM_HAVE_DEPRECATED) || defined(CVM_THREAD_SUSPENSION)
    gs->suspendCheckerInitialized = CVM_FALSE;
#endif

#ifndef CDC_10
    /* transfer assertion related globals */
    gs->javaAssertionsUserDefault = options->javaAssertionsUserDefault;
    gs->javaAssertionsSysDefault  = options->javaAssertionsSysDefault;
    gs->javaAssertionsClasses     = options->javaAssertionsClasses;
    gs->javaAssertionsPackages    = options->javaAssertionsPackages;
#endif

    /*
     * Initalize all of the global sys mutexes.
     */
    {
	CVMUint8 i;
	CVMassert(CVM_NUM_GLOBAL_SYSMUTEXES < 255);
	for (i = 0; i < CVM_NUM_GLOBAL_SYSMUTEXES; i++) {
	    if (!CVMsysMutexInit(globalSysMutexes[i].mutex,
				 globalSysMutexes[i].name,
				 (CVMUint8)(i+1) /* rank */))
	    {
		CVMdestroyGlobalSysMutexes(i);
		goto out_of_memory;
	    }
	}
    }

    if (!CVMcondvarInit(&gs->threadCountCV, &gs->threadLock.rmutex.mutex)) {
	goto out_of_memory;
    }

#ifdef CVM_INSPECTOR
    CVMgcLockerInit(&gs->inspectorGCLocker);
    if (!CVMcondvarInit(&gs->gcLockerCV, &gs->gcLockerLock.rmutex.mutex)) {
	goto out_of_memory;
    }
#endif

    /* NOTE: This is theoretically where the "checked" version of the
       JNI would be installed if we had it in our source tree.  Here,
       if JVMTI is present, we replace some functions in the JNI
       interface with the JVMTI's instrumented versions, which will
       call back into the debugger if native code uses the JNI to set
       or get a field. */

    /* NOTE: this should come BEFORE the first call to CVMinitExecEnv.
       This mutates the global JNI vector which later gets pointed to
       by the various execution environments. */
    /*
     * With JVMTI, we do the instrumentation when an agent connects
     */
#ifdef CVM_JVMTI
    CVMjvmtiSetDebugOption(options->debugging);
#endif    

#ifdef CVM_LVM /* %begin lvm */
    /* Logical VM global variables initialization (phase 1) 
     * Do this before invoking CVMinitExecEnv().
     * Phase 2 is taken place after initializing the main Logical VM */
    if (!CVMLVMglobalsInitPhase1(&gs->lvm)) {
	goto out_of_memory;
    }
#endif /* %end lvm */

    gs->userThreadCount = 1;
    gs->threadCount = 1;

    if (!initCstates()) {
	goto out_of_memory;
    }

    /*
     * Default sizes
     */

    if (!CVMoptParseXoptOptions(options->optAttributesStr)) {
	return CVM_FALSE;
    }

#if defined(CVM_DEBUG)
    CVMconsolePrintf("CVM Configuration:\n");
    CVMdumpGlobalsSubOptionValues();
#endif /* CVM_DEBUG */

    /* In the future, this should be map to a -Xopt sub-option */
    if (options->nativeStackSizeStr != NULL) {
	if (!CVMoptParseXssOption(options->nativeStackSizeStr)) {
	    return CVM_FALSE;
	}
    }

#ifdef CVM_TRACE_ENABLED
    /*
     * Turn off all debugging flags by default.
     */

    if (options->traceFlagsStr != NULL) {
	gs->debugFlags = strtol(options->traceFlagsStr, NULL, 0);
    } else {
	gs->debugFlags = 0;
    }
    CVMtraceInit();
#endif /* CVM_TRACE_ENABLED */

    if (!CVMinitExecEnv(ee, ee, NULL)) {
	return CVM_FALSE;
    }
    if (!CVMattachExecEnv(ee, CVM_TRUE)) {
	goto badEEnoDetach;
    }

    if (!CVMinitGCRootStack(ee, &gs->globalRoots,
		       CVM_INITIAL_GLOBALROOTS_STACK_SIZE,
		       CVM_MAX_GLOBALROOTS_STACK_SIZE, 
		       CVM_MIN_GLOBALROOTS_STACKCHUNK_SIZE,
		       CVM_FRAMETYPE_GLOBALROOT)) {
	goto badEE;
    }

    if (!CVMinitGCRootStack(ee, &gs->weakGlobalRoots,
		       CVM_INITIAL_WEAK_GLOBALROOTS_STACK_SIZE,
		       CVM_MAX_WEAK_GLOBALROOTS_STACK_SIZE, 
		       CVM_MIN_WEAK_GLOBALROOTS_STACKCHUNK_SIZE,
		       CVM_FRAMETYPE_GLOBALROOT)) {
	goto badEE;
    }

    if (!CVMinitGCRootStack(ee, &gs->classGlobalRoots,
		       CVM_INITIAL_CLASS_GLOBALROOTS_STACK_SIZE,