ccm_runtime.c

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

/*
 * @(#)ccm_runtime.c	1.74 06/10/10
 *
 * 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. 
 *
 */

#include "javavm/include/defs.h"
#include "javavm/include/objects.h"
#include "javavm/include/classes.h"

#include "javavm/include/basictypes.h"
#include "javavm/include/common_exceptions.h"
#include "javavm/include/directmem.h"
#include "javavm/include/gc_common.h"
#include "javavm/include/globals.h"
#include "javavm/include/indirectmem.h"
#include "javavm/include/interpreter.h"
#include "javavm/include/limits.h"
#include "javavm/include/stacks.h"
#include "javavm/include/sync.h"
#include "javavm/include/utils.h"

#include "javavm/include/ccm_runtime.h"
#include "javavm/include/ccee.h"

#include "javavm/include/porting/doubleword.h"
#include "javavm/include/porting/float.h"
#include "javavm/include/porting/int.h"
#include "javavm/include/porting/system.h"
#include "javavm/include/porting/jit/jit.h"


/* NOTE: See comments in ccm_runtime.h for a description of the categorization
         of CCM helper function types. */

/* Purpose: Handles exceptions caused by compiled code by returning
 * directly to the interpreter so it can handle the exception.
 *
 * NOTE: compiled code will never execute while an exception is pending.
 *       We always detect the exception before returning to compiled
 *       code and return to the interpreter instead.
 */
void CVMCCMhandleException(CVMCCExecEnv* ccee)
{
    /*
     * CVMJITgoNative() will blow away our current ccee and the
     * CVMJITgoNative() C frame and return to the CVMJITgoNative() caller
     * which will deal with the pending exception.
     */
    CVMCCMruntimeLazyFixups(CVMcceeGetEE(ccee));
    CVMJITexitNative(ccee);
}

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_IDIV
/* Purpose: Computes value1 / value2. */
/* Type: STATE_NOT_FLUSHED THROWS_SINGLE */
/* Throws: ArithmeticException. */
CVMJavaInt CVMCCMruntimeIDiv(CVMJavaInt value1, CVMJavaInt value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeIDiv);
    return CVMintDiv(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_IREM
/* Purpose: Computes value1 % value2. */
/* Type: STATE_NOT_FLUSHED THROWS_SINGLE */
/* Throws: ArithmeticException. */
CVMJavaInt CVMCCMruntimeIRem(CVMJavaInt value1, CVMJavaInt value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeIRem);
    return CVMintRem(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LMUL
/* Purpose: Computes value1 * value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLMul(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLMul);
    return CVMlongMul(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LDIV
/* Purpose: Computes value1 / value2. */
/* Type: STATE_NOT_FLUSHED THROWS_SINGLE */
/* Throws: ArithmeticException. */
CVMJavaLong CVMCCMruntimeLDiv(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLDiv);
    return CVMlongDiv(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LREM
/* Purpose: Computes value1 % value2. */
/* Type: STATE_NOT_FLUSHED THROWS_SINGLE */
/* Throws: ArithmeticException. */
CVMJavaLong CVMCCMruntimeLRem(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLRem);
    return CVMlongRem(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LNEG
/* Purpose: Computes -value. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLNeg(CVMJavaLong value)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLNeg);
    return CVMlongNeg(value);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LSHL
/* Purpose: Computes value1 << value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLShl(CVMJavaLong value1, CVMJavaInt value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLShl);
    return CVMlongShl(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LSHR
/* Purpose: Computes value1 >> value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLShr(CVMJavaLong value1, CVMJavaInt value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLShr);
    return CVMlongShr(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LUSHR
/* Purpose: Computes value1 >>> value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLUshr(CVMJavaLong value1, CVMJavaInt value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLUshr);
    return CVMlongUshr(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LAND
/* Purpose: Computes value1 & value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLAnd(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLAnd);
    return CVMlongAnd(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LOR
/* Purpose: Computes value1 | value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLOr(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLOr);
    return CVMlongOr(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_LXOR
/* Purpose: Computes value1 ^ value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeLXor(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeLXor);
    return CVMlongXor(value1, value2);
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FADD
/* Purpose: Computes value1 + value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFAdd(CVMUint32 value1, CVMUint32 value2)
{
    CVMJavaVal32 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFAdd);
    v1.raw = value1;
    v2.raw = value2;
    res.f = CVMfloatAdd(v1.f, v2.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FSUB
/* Purpose: Computes value1 - value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFSub(CVMUint32 value1, CVMUint32 value2)
{
    CVMJavaVal32 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFSub);
    v1.raw = value1;
    v2.raw = value2;
    res.f = CVMfloatSub(v1.f, v2.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FMUL
/* Purpose: Computes value1 * value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFMul(CVMUint32 value1, CVMUint32 value2)
{
    CVMJavaVal32 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFMul);
    v1.raw = value1;
    v2.raw = value2;
    res.f = CVMfloatMul(v1.f, v2.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FDIV
/* Purpose: Computes value1 / value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFDiv(CVMUint32 value1, CVMUint32 value2)
{
    CVMJavaVal32 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFDiv);
    v1.raw = value1;
    v2.raw = value2;
    res.f = CVMfloatDiv(v1.f, v2.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FREM
/* Purpose: Computes value1 % value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFRem(CVMUint32 value1, CVMUint32 value2)
{
    CVMJavaVal32 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFRem);
    v1.raw = value1;
    v2.raw = value2;
    res.f = CVMfloatRem(v1.f, v2.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_FNEG
/* Purpose: Computes -value. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMUint32 CVMCCMruntimeFNeg(CVMUint32 value)
{
    CVMJavaVal32 v32, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeFNeg);
    v32.raw = value;
    res.f = CVMfloatNeg(v32.f);
    return res.raw;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DADD
/* Purpose: Computes value1 + value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDAdd(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMJavaVal64 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDAdd);
    v1.l = value1;
    v2.l = value2;
    res.d = CVMdoubleAdd(v1.d, v2.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DSUB
/* Purpose: Computes value1 - value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDSub(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMJavaVal64 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDSub);
    v1.l = value1;
    v2.l = value2;
    res.d = CVMdoubleSub(v1.d, v2.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DMUL
/* Purpose: Computes value1 * value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDMul(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMJavaVal64 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDMul);
    v1.l = value1;
    v2.l = value2;
    res.d = CVMdoubleMul(v1.d, v2.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DDIV
/* Purpose: Computes value1 / value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDDiv(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMJavaVal64 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDDiv);
    v1.l = value1;
    v2.l = value2;
    res.d = CVMdoubleDiv(v1.d, v2.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DREM
/* Purpose: Computes value1 % value2. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDRem(CVMJavaLong value1, CVMJavaLong value2)
{
    CVMJavaVal64 v1, v2, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDRem);
    v1.l = value1;
    v2.l = value2;
    res.d = CVMdoubleRem(v1.d, v2.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_DNEG
/* Purpose: Computes -value. */
/* Type: STATE_NOT_FLUSHED THROWS_NONE */
CVMJavaLong CVMCCMruntimeDNeg(CVMJavaLong value)
{
    CVMJavaVal64 v, res;
    CVMCCMstatsInc(CVMgetEE(), CVMCCM_STATS_CVMCCMruntimeDNeg);
    v.l = value;
    res.d = CVMdoubleNeg(v.d);
    return res.l;
}
#endif

#ifndef CVMCCM_HAVE_PLATFORM_SPECIFIC_I2L
/* Purpose: Converts an int value to a long value. */