cvm.c

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 * @(#)CVM.c	1.82 06/10/30
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.  
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER  
 *   
 * This program is free software; you can redistribute it and/or  
 * modify it under the terms of the GNU General Public License version  
 * 2 only, as published by the Free Software Foundation.   
 *   
 * This program is distributed in the hope that it will be useful, but  
 * WITHOUT ANY WARRANTY; without even the implied warranty of  
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  
 * General Public License version 2 for more details (a copy is  
 * included at /legal/license.txt).   
 *   
 * You should have received a copy of the GNU General Public License  
 * version 2 along with this work; if not, write to the Free Software  
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  
 * 02110-1301 USA   
 *   
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa  
 * Clara, CA 95054 or visit www.sun.com if you need additional  
 * information or have any questions. 
 *
 */

/*
 * All methods in this file use the CNI native method interface. See
 * cni.h for details.
 */

#include "javavm/include/interpreter.h"
#ifdef CVM_DUAL_STACK
#include "javavm/include/dualstack_impl.h"
#endif
#include "javavm/include/directmem.h"
#include "javavm/include/indirectmem.h"
#include "javavm/include/utils.h"
#include "javavm/include/common_exceptions.h"
#include "javavm/include/gc_common.h"
#include "javavm/include/stackmaps.h"
#include "javavm/include/preloader.h"
#include "javavm/export/jvm.h"
#include "generated/offsets/java_lang_Thread.h"

#include "jni.h"
#include "generated/javavm/include/build_defs.h"

#ifdef CVM_TRACE_JIT
#include "javavm/include/jit/jitutils.h"
#endif
#ifdef CVM_JIT
#include "javavm/include/jit/jit.h"
#include "javavm/include/jit/jitcodebuffer.h"
#endif
#ifndef CDC_10
#include "javavm/include/javaAssertions.h"
#endif
#ifdef CVM_XRUN
#include "javavm/include/xrun.h"
#endif
#include "javavm/include/porting/time.h"
#ifdef CVM_JVMTI
#include "javavm/include/jvmti_jni.h"
#endif

/* Set the systemClassLoader */
CNIEXPORT CNIResultCode
CNIsun_misc_CVM_setSystemClassLoader(CVMExecEnv*ee, CVMStackVal32 *arguments,
                                     CVMMethodBlock **p_mb)
{
    jobject loaderObj = &arguments[0].j.r;
    CVMD_gcSafeExec(ee, {
        CVMclassSetSystemClassLoader(ee, loaderObj);
    });
    return CNI_VOID;
}

#ifdef CVM_DEBUG_ASSERTS
#define CVMassertOKToCopyArrayOfType(expectedType_) \
    {                                                                   \
        CVMClassBlock *srcCb, *dstCb;                                   \
        CVMClassBlock *srcElemCb, *dstElemCb;                           \
        size_t srclen, dstlen;                                          \
                                                                        \
        CVMassert(srcArr != NULL);                                      \
        CVMassert(dstArr != NULL);                                      \
                                                                        \
        srcCb = CVMobjectGetClass(srcArr);                              \
        dstCb = CVMobjectGetClass(dstArr);                              \
        CVMassert(CVMisArrayClass(srcCb));                              \
        CVMassert(CVMisArrayClass(dstCb));                              \
                                                                        \
        srcElemCb = CVMarrayElementCb(srcCb);                           \
        dstElemCb = CVMarrayElementCb(dstCb);                           \
        if (expectedType_ != CVM_T_CLASS) {                             \
            CVMassert(srcElemCb == dstElemCb);                          \
        } else {                                                        \
            CVMassert((srcElemCb == dstElemCb) ||                       \
                      (dstElemCb == CVMsystemClass(java_lang_Object))); \
        }                                                               \
        CVMassert(CVMarrayElemTypeCode(srcCb) == expectedType_);        \
                                                                        \
        srclen = CVMD_arrayGetLength(srcArr);                           \
        dstlen = CVMD_arrayGetLength(dstArr);                           \
                                                                        \
        CVMassert(!(length < 0));                                       \
        CVMassert(!(src_pos < 0));                                      \
        CVMassert(!(dst_pos < 0));                                      \
        CVMassert(!(length + src_pos > srclen));                        \
        CVMassert(!(length + dst_pos > dstlen));                        \
    }
#else
#define CVMassertOKToCopyArrayOfType(expectedType_)
#endif

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyBooleanArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                 CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfBoolean *srcArr;
    CVMArrayOfBoolean *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfBoolean *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfBoolean *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_BOOLEAN);
    CVMD_arrayCopyBoolean(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyByteArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                              CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfByte *srcArr;
    CVMArrayOfByte *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfByte *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfByte *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_BYTE);
    CVMD_arrayCopyByte(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyShortArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                               CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfShort *srcArr;
    CVMArrayOfShort *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfShort *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfShort *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_SHORT);
    CVMD_arrayCopyShort(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyCharArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                              CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfChar *srcArr;
    CVMArrayOfChar *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfChar *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfChar *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_CHAR);
    CVMD_arrayCopyChar(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyIntArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                             CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfInt *srcArr;
    CVMArrayOfInt *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfInt *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfInt *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_INT);
    CVMD_arrayCopyInt(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyLongArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                              CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfLong *srcArr;
    CVMArrayOfLong *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfLong *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfLong *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_LONG);
    CVMD_arrayCopyLong(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyFloatArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                               CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfFloat *srcArr;
    CVMArrayOfFloat *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfFloat *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfFloat *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_FLOAT);
    CVMD_arrayCopyFloat(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyDoubleArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfDouble *srcArr;
    CVMArrayOfDouble *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfDouble *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfDouble *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_DOUBLE);
    CVMD_arrayCopyDouble(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

/* Purpose: This method copies array elements from one array to another.
   Unlike System.arraycopy(), this method can only copy elements for
   non-primitive arrays with some restrictions.  The restrictions are that
   the src and dest array must be of the same type, or the destination
   array must be of type java.lang.Object[] (not just a compatible sub-type).
   The caller is responsible for doing the appropriate null checks, bounds
   checks, array element type assignment checks if necessary, and ensure that
   the passed in arguments do violate any of these checks and restrictions.
   If the condition of these checks and restrictions are not taken cared of
   by the caller, copyObjectArray() can fail in unpredictable ways.
*/
CNIEXPORT CNIResultCode
CNIsun_misc_CVM_copyObjectArray(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                CVMMethodBlock **p_mb)
{
    jobject src  = &arguments[0].j.r;
    jint src_pos =  arguments[1].j.i;
    jobject dst  = &arguments[2].j.r;
    jint dst_pos =  arguments[3].j.i;
    jint length  =  arguments[4].j.i;
    CVMArrayOfRef *srcArr;
    CVMArrayOfRef *dstArr;

    /* CNI policy: offer a gc-safe checkpoint */
    CVMD_gcSafeCheckPoint(ee, {}, {});

    srcArr = (CVMArrayOfRef *)CVMID_icellDirect(ee, src);
    dstArr = (CVMArrayOfRef *)CVMID_icellDirect(ee, dst);
    CVMassertOKToCopyArrayOfType(CVM_T_CLASS);
    CVMD_arrayCopyRef(srcArr, src_pos, dstArr, dst_pos, length);
    return CNI_VOID;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_checkDebugFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
				CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_ENABLED
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMcheckDebugFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_setDebugFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
			      CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_ENABLED
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMsetDebugFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_clearDebugFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
				CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_ENABLED
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMclearDebugFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_restoreDebugFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
				  CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_ENABLED
    CVMJavaInt flags = arguments[0].j.i;
    CVMJavaInt oldvalue = arguments[1].j.i;
    arguments[0].j.i = CVMrestoreDebugFlags(flags, oldvalue);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_checkDebugJITFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                   CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_JIT
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMcheckDebugJITFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_setDebugJITFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                 CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_JIT
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMsetDebugJITFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_clearDebugJITFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                   CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_JIT
    CVMJavaInt flags = arguments[0].j.i;
    arguments[0].j.i = CVMclearDebugJITFlags(flags);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_restoreDebugJITFlags(CVMExecEnv* ee, CVMStackVal32 *arguments,
                                     CVMMethodBlock **p_mb)
{
#ifdef CVM_TRACE_JIT
    CVMJavaInt flags = arguments[0].j.i;
    CVMJavaInt oldvalue = arguments[1].j.i;
    arguments[0].j.i = CVMrestoreDebugJITFlags(flags, oldvalue);
#else
    arguments[0].j.i = 0;
#endif
    return CNI_SINGLE;
}

/*
 * executeClinit is responsible for getting the <clinit> method of the
 * specified class executed. It could do this by just using JNI to
 * invoke the <clinit> method, but this causes undesireable C recursion
 * in the interpreter. Instead we just store the mb of the <clinit>
 * method in *p_mb, and return CVM_NEW_MB to the interpreter. This
 * signals the interpreter to invoke the method stored in *p_mb.
 */
CNIEXPORT CNIResultCode
CNIsun_misc_CVM_executeClinit(CVMExecEnv* ee, CVMStackVal32 *arguments,
			      CVMMethodBlock **p_mb)
{
    CVMClassBlock* cb = CVMgcUnsafeClassRef2ClassBlock(ee, &arguments[0].j.r);
    CVMMethodBlock* clinitmb;
    CVMD_gcSafeExec(ee, {
	clinitmb = CVMclassGetStaticMethodBlock(cb, CVMglobals.clinitTid);
    });
    CVMtraceClinit(("[Initializing %C]\n", cb));
    if (clinitmb != NULL) {
	CVMtraceClinit(("[Running static initializer for %C]\n", cb));
	/* Return the new mb */
	*p_mb = clinitmb;
	return CNI_NEW_MB;
    } else {
	return CNI_VOID;
    }
}

/*
 * If the class is dynamically loaded and has a <clinit> method, then
 * free up the memory allocated for the <clinit> method. Note the mb,
 * stays around, but all the code and other data located in the jmd
 * is freed up.
 *
 * (Formerly, the entire body of this was bracketed by the
 * ifdef CVM_CLASSLOADING block. But now that we want to
 * free the stackmaps even for preloaded classes, we need to
 * go through the motions anyway.)
 */

CNIEXPORT CNIResultCode
CNIsun_misc_CVM_freeClinit(CVMExecEnv* ee, CVMStackVal32 *arguments,
			   CVMMethodBlock **p_mb)
{
    /*
     * Both JVMTI and JVMPI require that the jmd for the clinit
     * not be freed.
     */
#if !defined(CVM_JVMTI) && !defined(CVM_JVMPI)
    CVMClassBlock* cb = CVMgcUnsafeClassRef2ClassBlock(ee, &arguments[0].j.r);
    CVMMethodBlock* clinitmb;
    CVMJavaMethodDescriptor* jmd;

    CVMD_gcSafeExec(ee, {
	clinitmb = CVMclassGetStaticMethodBlock(cb, CVMglobals.clinitTid);
	if (clinitmb != NULL) {
	    if (CVMmbIsJava(clinitmb)) {
                CVMStackMaps *maps;
		jmd = CVMmbJmd(clinitmb);
                /* Need to acquire the heapLock before accessing the
                 * stackmaps list to avoid contention with a gc thread,
                 * which may also manipulate the list.
                 */
                CVMsysMutexLock(ee, &CVMglobals.heapLock);
		if ((maps = CVMstackmapFind(ee, clinitmb)) != NULL) {
                    CVMstackmapDestroy(ee, maps);
		}
                CVMsysMutexUnlock(ee, &CVMglobals.heapLock);

		if ((!CVMcbIsInROM(cb)) 
		    || (CVMjmdFlags(jmd) & CVM_JMD_DID_REWRITE)) {
		    CVMmbJmd(clinitmb) = NULL;
		    free(jmd);
		}
		if (!CVMcbIsInROM(cb)) {
		    CVMclassFreeLocalVariableTableFieldIDs(ee, clinitmb);
		}
	    }
	}
    });
#endif
    return CNI_VOID;
}