ccmintrinsics_asm_cpu.s

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

#undef OFFSET_OF_ARRAY_CHAR
	SET_SIZE( CVMCCMintrinsic_java_lang_String_indexOf_I)
#endif

/* 
 * Intrinsic version of sun.misc.CVM.copyCharArray(...)
 */
	ENTRY(CVMCCMintrinsic_sun_misc_CVM_copyCharArray)
ENTRY1 ( CVMCCMintrinsic_sun_misc_CVM_copyCharArray )
        /*Arguments: 
         *    r0 = srcArr 
         *    r1 = srcIndex
	 *    r2 = dstArr
         *    r3 = dstIndex
	 *    r6 = length	
	 */
	add	r0, r0, r1, LSL #1  /* r0 = src + (sIdx * 2) */
	add	r2, r2, r3, LSL #1  /* r2 = dst + (dIdx * 2) */
	add	r1, r0, #OFFSET_ARRAY_ELEMENTS /* r1 = src+(2*sIdx) + ofst */
	add	r0, r2, #OFFSET_ARRAY_ELEMENTS /* r0 = dst+(2*dIdx) + ofst */
	mov	r2, r6, LSL #1	    /* r2 = (length * 2) */
	b	SYM_NAME(CVMARMmemmove16Bit)
	SET_SIZE( CVMCCMintrinsic_sun_misc_CVM_copyCharArray )


/* 
 * Intrinsic version of sun.misc.CVM.copyObjectArray(...)
 */
#if (CVM_GCCHOICE == CVM_GC_GENERATIONAL) && !defined(CVM_SEGMENTED_HEAP)

#ifdef __RVCT__
	IMPORT CVMgcCardTableVirtualBasePtr
#endif

	ENTRY(CVMCCMintrinsic_sun_misc_CVM_copyObjectArray)
ENTRY1 ( CVMCCMintrinsic_sun_misc_CVM_copyObjectArray )
        /*Arguments: 
         *    r0 = srcArr 
         *    r1 = srcIndex
	 *    r2 = dstArr
         *    r3 = dstIndex
	 *    r6 = length
	 */

#define CARDSTART	ip
#define CARDEND		r3

	ldr	CARDSTART, SYMBOL(CVMgcCardTableVirtualBasePtr)

	/* Now do the copying.  NOTE: dstAddr is already in r3. */
	add	r0, r0, r1, LSL #2  /* r0 = src + (4 * sIdx) */
	add	r2, r2, r3, LSL #2  /* r2 = dst + (4 * dIdx) */
	ldr	CARDSTART, [CARDSTART]
	add	r1, r0, #OFFSET_ARRAY_ELEMENTS /* r1 = src+(4*sIdx) + ofst */
	add	r0, r2, #OFFSET_ARRAY_ELEMENTS /* r0 = dst+(4*dIdx) + ofst */
	mov	r2, r6, LSL #2	    /* r2 = (length * 4) */

	/* First, mark the card table. 
	   cardStart = CTVBptr + (dst / 512)
	   cardEnd = CTVBptr + ((dst + len - 4) / 512)
	*/
	ldr	CARDSTART, [CARDSTART]
	add	CARDEND, r0, r2
	sub	CARDEND, CARDEND, #4
	add	CARDEND, CARDSTART, CARDEND, LSR #CONSTANT_CVM_GENGC_CARD_SHIFT
	add	CARDSTART, CARDSTART, r0, LSR #CONSTANT_CVM_GENGC_CARD_SHIFT

	mov	r6, #CONSTANT_CARD_DIRTY_BYTE	/* CARD_DIRTY_BYTE is 1 */
LABEL(copyObjectArray_markCard)
	strb	r6, [CARDSTART], #1
	cmp	CARDSTART, CARDEND
	bls	copyObjectArray_markCard
	
#undef CARDSTART
#undef CARDEND

	b	SYM_NAME(CVMARMmemmove32Bit)

	SET_SIZE ( CVMCCMintrinsic_sun_misc_CVM_copyObjectArray )

#endif /* CVM_GCCHOICE && !CVM_SEGMENTED_HEAP */	

/* 
 * Intrinsic version of System.arraycopy(Object srcArr, int srcIndex,
 *	Object dstArr, int dstIndex, int length).
 */

#define CCEE	r0
#define SRC	r1
#define SRCIDX	r2
#define DST	r3
#define DSTIDX	r6
#define LENGTH	r7

#define SRCCB	ip
#define DSTCB	r0
#define	TYPE	r0
#undef  TEMP
#define TEMP	ip

	ENTRY(CVMCCMintrinsic_java_lang_System_arraycopyGlue)
ENTRY1 ( CVMCCMintrinsic_java_lang_System_arraycopyGlue )
        /*Arguments: 
	 *    r0 = ccee
         *    r1 = srcArr 
         *    r2 = srcIndex
	 *    r3 = dstArr
         *    r6 = dstIndex
	 *    r7 = length
	 */

#ifndef CVMJIT_TRAP_BASED_NULL_CHECKS
	cmp	SRC, #0
	beq	slowArraycopy
	cmp	DST, #0
	beq	slowArraycopy
#endif
	
	/* Check array parameters: */
	/* IAI-23 */
	/* Ensure: srcIndex, dstIndex, and length are >= 0 i.e. NOT < 0: */
	orrs	TEMP, SRCIDX, DSTIDX
	orrges	TEMP, TEMP, LENGTH
	ldr	TEMP, [SRC, #OFFSET_ARRAY_LENGTH]
	blt	slowArraycopy

	ldr	DSTCB, [DST]	/* dst classblock */

	/* Ensure: length + srcIndex <= srcLen: */
	sub	TEMP, TEMP, LENGTH
	cmp	SRCIDX, TEMP
	ldr	TEMP, [DST, #OFFSET_ARRAY_LENGTH]
	bgt	slowArraycopy

	/* Ensure: length + dstIndex <= dstLen: */
	sub	TEMP, TEMP, LENGTH
	cmp	DSTIDX, TEMP
	ldr	SRCCB, [SRC]	/* src classblock */
	bgt	slowArraycopy

	bic	DSTCB, DSTCB, #3   /* Clear the low bits of dst arrayCb */
	bic	SRCCB, SRCCB, #3   /* Clear the low bits of src arrayCb */
	cmp	SRCCB, DSTCB
	ldr	TYPE, [SRCCB, #OFFSET_CVMClassBlock_classNameX] /* typeid */
	bne	slowArraycopy

	/* src & dst are same types: */
	/* Check to see if they are arrays:
	   NOTE: The typeids for the primitive arrays are:
		int[]	  0x4003  // Dimension 1, Element 0x3
		short[]	  0x4004  // Dimension 1, Element 0x4
		char[]	  0x4005  // Dimension 1, Element 0x5
		long[]	  0x4006  // Dimention 1, Element 0x6
		byte[]	  0x4007  // Dimension 1, Element 0x7
		float[]	  0x4008  // Dimension 1, Element 0x8
		double[]  0x4009  // Dimension 1, Element 0x9
		boolean[] 0x400a  // Dimension 1, Element 0xa

           Object arrays will have dimension >= 1, and element type which is
	   not in the base types above.
	   A dimension of 0 means not an array type.
	*/

	/* First get the array dimension from the typeid: */
	movs	TEMP, TYPE, LSR #CONSTANT_CVMtypeidArrayShift
	beq	slowArraycopy	/* If 0, then it's not an array. */

	/* We now know that it's an array: */
	cmp	TEMP, #0x1	/* Check if dimension is greater than 1. */
	bne	arraycopyObject	/* typeid not between 0x4003 and 0x400a */

	/* Check the element/base type range: */
	bic	TYPE, TYPE, #CONSTANT_CVMtypeidArrayMask
	cmp	TYPE, #0x3
	blt	slowArraycopy	/* typeid < 0x4003.  Something's wrong. */
	cmp	TYPE, #0xa
	bgt	arraycopyObject	/* typeid not between 0x4003 and 0x400a */

	/* We now know that we have a primitive array.  Dispatch to the
	   specific array copier: */
	sub	TYPE, TYPE, #3
	add	pc, pc, TYPE, LSL #2
	nop

	b	arraycopy32bit	/* arraycopyInt */
	b	arraycopy16bit	/* arraycopyShort */
	b	arraycopy16bit	/* arraycopyChar */
	b	arraycopy64bit	/* arraycopyLong */
	b	arraycopy8bit	/* arraycopyByte */
	b	arraycopy32bit	/* arraycopyFloat */
	b	arraycopy64bit	/* arraycopyDouble */
	b	arraycopy8bit	/* arraycopyBoolean */

LABEL(arraycopy8bit)
	add	r1, SRC, SRCIDX
	add	r1, r1, #OFFSET_ARRAY_ELEMENTS	/* srcAddr */
	mov	r2, LENGTH			/* length */
	add	r3, DST, DSTIDX
	add	r0, r3, #OFFSET_ARRAY_ELEMENTS	/* dstAddr */
	b	SYM_NAME(CVMARMmemmove8Bit)

LABEL(arraycopy16bit)
	add	r1, SRC, SRCIDX, LSL #1
	add	r1, r1, #OFFSET_ARRAY_ELEMENTS	/* srcAddr */
	mov	r2, LENGTH, LSL #1		/* length */
	add	r3, DST, DSTIDX, LSL #1
	add	r0, r3, #OFFSET_ARRAY_ELEMENTS	/* dstAddr */
	b	SYM_NAME(CVMARMmemmove16Bit)

LABEL(arraycopy32bit)
	add	r1, SRC, SRCIDX, LSL #2
	add	r1, r1, #OFFSET_ARRAY_ELEMENTS	/* srcAddr */
	mov	r2, LENGTH, LSL #2		/* length */
	add	r3, DST, DSTIDX, LSL #2
	add	r0, r3, #OFFSET_ARRAY_ELEMENTS	/* dstAddr */
	b	SYM_NAME(CVMARMmemmove32Bit)

LABEL(arraycopy64bit)
	add	r1, SRC, SRCIDX, LSL #3
	add	r1, r1, #OFFSET_ARRAY_ELEMENTS	/* srcAddr */
	mov	r2, LENGTH, LSL #3		/* length */
	add	r3, DST, DSTIDX, LSL #3
	add	r0, r3, #OFFSET_ARRAY_ELEMENTS	/* dstAddr */
	b	SYM_NAME(CVMARMmemmove32Bit)

LABEL(arraycopyObject)
#if (CVM_GCCHOICE == CVM_GC_GENERATIONAL) && !defined(CVM_SEGMENTED_HEAP)

#define CARDSTART	ip
#define CARDEND		DSTIDX	/* r6 */

	/* Compute arguments for CVMARMmemmove32Bit:
	   dst(r0), src(r1), length(r2)
	*/
	ldr	CARDSTART, SYMBOL(CVMgcCardTableVirtualBasePtr)
	add	r0, SRC, SRCIDX, LSL #2	/* r0 = src + (4 * sIdx) */
	add	r2, DST, DSTIDX, LSL #2 /* r2 = dst + (4 * dIdx) */
	ldr	CARDSTART, [CARDSTART]
	add	r1, r0, #OFFSET_ARRAY_ELEMENTS /* r1 = src+(4*sIdx) + ofst */
	add	r0, r2, #OFFSET_ARRAY_ELEMENTS /* r0 = dst+(4*dIdx) + ofst */
	mov	r2, LENGTH, LSL #2             /* r2 = (length * 4) */

	/* First, mark the card table. 
	   cardStart = CTVBptr + (dst / 512)
	   cardEnd = CTVBptr + ((dst + len - 4) / 512)
	*/
	ldr	CARDSTART, [CARDSTART]
	add	CARDEND, r0, r2
	sub	CARDEND, CARDEND, #4
	add	CARDEND, CARDSTART, CARDEND, LSR #CONSTANT_CVM_GENGC_CARD_SHIFT
	add	CARDSTART, CARDSTART, r0, LSR #CONSTANT_CVM_GENGC_CARD_SHIFT

	mov	r7, #CONSTANT_CARD_DIRTY_BYTE	/* CARD_DIRTY_BYTE is 1 */
LABEL(arraycopyObject_markCard)
	strb	r7, [CARDSTART], #1
	cmp	CARDSTART, CARDEND
	bls	arraycopyObject_markCard

#undef CARDSTART
#undef CARDEND

	/* Now do the copying.  NOTE: dstAddr is already in r3. */
	b	SYM_NAME(CVMARMmemmove32Bit)

#else

	/* Fall thru to the slow case coz we don't know how to handle it
	   (i.e. an unknown GC type): */

#endif /* CVM_GCCHOICE && !CVM_SEGMENTED_HEAP */	

LABEL(slowArraycopy)
	/* NOTE: The C intrinsic function expects the 5th and 6th arguments
	   on the operand stack instead of in registers.  Hence, we need to
	   store these on the stack before calling the C intrinsic. */
	str	r6, [sp, #-8]
	mov	r0, sp	/* Reload the CCEE. */
	str	r7, [sp, #-4]
	str	lr, [sp, #OFFSET_CVMCCExecEnv_ccmStorage+0]
	sub	sp, sp, #8
	CALL_VM_FUNCTION(CVMCCMintrinsic_java_lang_System_arraycopy)
	add	sp, sp, #8
	ldr	pc, [sp, #OFFSET_CVMCCExecEnv_ccmStorage+0]
	/* Let the C intrinsic do the hard work: */

#undef CCEE
#undef SRC
#undef SIDX
#undef DST
#undef DIDX
#undef LENGTH

#undef SRCCB
#undef DSTCB
#undef TYPE
#undef TEMP

	SET_SIZE( CVMCCMintrinsic_java_lang_System_arraycopyGlue )

#endif /* CVM_JIT_CCM_USE_C_HELPER */

#endif /* CVMJIT_INTRINSICS */

        POOL