PatchSet 6770
Date: 2005/07/29 17:30:55
Author: guilhem
Branch: HEAD
Tag: (none)
Log:
Apple/ppc fixlets.
2005-07-29 Guilhem Lavaux <[EMAIL PROTECTED]>
Riccardo Mottola <[EMAIL PROTECTED]>
* config/powerpc/callmethod_ppc.h: Updated register names to match
GAS syntax.
* config/powerpc/sysdepCallMethod.h
(ARG_DISPLACEMENT): By tests, chose -2 on APPLE.
Members:
ChangeLog:1.4295->1.4296
config/powerpc/callmethod_ppc.h:1.4->1.5
config/powerpc/sysdepCallMethod.h:INITIAL->1.8
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4295 kaffe/ChangeLog:1.4296
--- kaffe/ChangeLog:1.4295 Wed Jul 27 22:47:07 2005
+++ kaffe/ChangeLog Fri Jul 29 17:30:55 2005
@@ -1,3 +1,12 @@
+2005-07-29 Guilhem Lavaux <[EMAIL PROTECTED]>
+ Riccardo Mottola <[EMAIL PROTECTED]>
+
+ * config/powerpc/callmethod_ppc.h: Updated register names to match
+ GAS syntax.
+
+ * config/powerpc/sysdepCallMethod.h
+ (ARG_DISPLACEMENT): By tests, chose -2 on APPLE.
+
2005-07-28 Ito Kazumitsu <[EMAIL PROTECTED]>
* test/regression/SecureRandomTest.java:
Index: kaffe/config/powerpc/callmethod_ppc.h
diff -u kaffe/config/powerpc/callmethod_ppc.h:1.4
kaffe/config/powerpc/callmethod_ppc.h:1.5
--- kaffe/config/powerpc/callmethod_ppc.h:1.4 Fri Sep 17 18:48:40 2004
+++ kaffe/config/powerpc/callmethod_ppc.h Fri Jul 29 17:30:59 2005
@@ -83,9 +83,9 @@
n = 0;
f = 0;
argidx = 0;
-
+
/* set up a pointer to the stack parameter area */
- __asm__ __volatile__ ( "addi %0,1,8" : "=r" (p) : /* no inputs */ );
+ __asm__ __volatile__ ( "addi %0,r1,8" : "=r" (p) : /* no inputs */ );
/* now loop through each argument and assign it properly to
either gpr, fpr, or the param area */
@@ -171,27 +171,27 @@
__asm__ __volatile__ (
"
- lwz 3, 0(%3)
- lwz 4, 4(%3)
- lwz 5, 8(%3)
- lwz 6, 12(%3)
- lwz 7, 16(%3)
- lwz 8, 20(%3)
- lwz 9, 24(%3)
- lwz 10, 28(%3)
- lfd 1, 0(%4)
- lfd 2, 8(%4)
- lfd 3, 16(%4)
- lfd 4, 24(%4)
- lfd 5, 32(%4)
- lfd 6, 40(%4)
- lfd 7, 48(%4)
- lfd 8, 56(%4)
+ lwz r3, 0(%3)
+ lwz r4, 4(%3)
+ lwz r5, 8(%3)
+ lwz r6, 12(%3)
+ lwz r7, 16(%3)
+ lwz r8, 20(%3)
+ lwz r9, 24(%3)
+ lwz r10, 28(%3)
+ lfd f1, 0(%4)
+ lfd f2, 8(%4)
+ lfd f3, 16(%4)
+ lfd f4, 24(%4)
+ lfd f5, 32(%4)
+ lfd f6, 40(%4)
+ lfd f7, 48(%4)
+ lfd f8, 56(%4)
mtctr %5
bctrl
- mr %1, 3
- mr %2, 4
- fmr %0, 1
+ mr %1, r3
+ mr %2, r4
+ fmr %0, f1
" : "=f" (dret), "=r" (iret), "=r" (iret2)
: "r" (gpr), "r" (fpr), "r" (CALL->function)
: "0", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"
===================================================================
Checking out kaffe/config/powerpc/sysdepCallMethod.h
RCS: /home/cvs/kaffe/kaffe/config/powerpc/sysdepCallMethod.h,v
VERS: 1.8
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/config/powerpc/sysdepCallMethod.h Fri Jul 29 17:38:36 2005
@@ -0,0 +1,567 @@
+/*
+ * powerpc/sysdepCallMethod.h
+ * Dynamically build function calls using PowerPC SVR4 ABI, AIX ABI or
+ * Dawin ABI.
+ *
+ * Copyright (c) 2001, 2004
+ * Edouard G. Parmelan. All rights reserved.
+ *
+ * Copyright (c) 2001
+ * Transvirtual Technologies, Inc. All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+/* Needed for callMethodInfo declaration */
+#include "support.h"
+
+/* ARG_TYPE is the type of a register used for passing arguments. */
+#define ARG_TYPE long
+
+/* ARG_TYPES is a parameter list declaration for a function type
+ that takes all possible arguments in registers. */
+#define ARG_TYPES ARG_TYPE, ARG_TYPE, ARG_TYPE, ARG_TYPE, ARG_TYPE,
ARG_TYPE, ARG_TYPE, ARG_TYPE
+
+/* ARG_LIST is the argument list for such a function. */
+#define ARG_LIST a0, a1, a2, a3, a4, a5, a6, a7
+
+/* GPR_ARGS is the number of GPR (integer) registers for passing
+ arguments. */
+#define GPR_ARGS 8
+
+/* FPR_ARGS is the number of FPR (float) registers for passing
+ arguments. */
+#if defined(__APPLE__) || defined(_AIX)
+# define FPR_ARGS 13
+#else
+# ifndef _SOFT_FLOAT
+# define FPR_ARGS 8
+# endif /* !_SOFT_FLOAT */
+#endif
+
+/* ARG_DISPLACEMENT is the offset between the beginning of a
+ variable-sized array, allocated in the stack, and the position of
+ the first argument that can't be passed in a register. */
+#if defined(__APPLE__)
+ /* -6 but __buildin_alloca() handle it */
+ /* it was 0, but it was displaced by 2.... so we try standard PPC
displacement */
+# define ARG_DISPLACEMENT -2
+#elif defined(_AIX)
+# define ARG_DISPLACEMENT -6
+#else
+# define ARG_DISPLACEMENT -2
+#endif
+
+/* ARG_GPR a case label and a statement that arranges for one integer
+ argument to be passed. */
+#define ARG_GPR(N) \
+ case N+1: a##N = gpr[N];
+
+/* ARG_FPR a case label and a statement that arranges for one float
+ argument to be passed. */
+#define ARG_FPR(N) \
+ case N+1: d##N = fpr[N];
+
+
+/* Make a call to a native or Java (JIT) method. This assembly code should
+ build a standard C call using the passed call information. By its
+ nature this is highly processor specific. This function is mandatory
+ for both JIT and Interpreter (since stubs have now been deprecated). */
+static inline void sysdepCallMethod(callMethodInfo* call) ALWAYS_INLINE;
+
+#if defined(__APPLE__)
+static inline void sysdepCallMethod(callMethodInfo* call)
+{
+ void *func = call->function;
+ jvalue *callargs = call->args;
+ char *calltype = call->calltype;
+ jvalue *args = callargs;
+ jvalue *last = &callargs[call->nrargs];
+
+ int nr_gpr = 0;
+
+ unsigned long *stack;
+ unsigned long *gpr;
+ int nr_fpr = 0;
+ double *fpr;
+
+ /* Compute gpr[], fpr[] and stack[] arrays' size */
+ while (args != last) {
+ switch (calltype[(args++) - callargs]) {
+ case 'D':
+ if (nr_fpr < FPR_ARGS)
+ nr_fpr++;
+ nr_gpr += 2;
+ break;
+
+ case 'F':
+ if (nr_fpr < FPR_ARGS)
+ nr_fpr++;
+ nr_gpr++;
+ break;
+
+ case 'J':
+ nr_gpr += 2;
+ break;
+
+ default:
+ nr_gpr++;
+ break;
+ }
+ }
+
+ /* Allocate all arrays with one big alloca() */
+ {
+ int nr;
+
+ /* Must allocate space of _all_ GPR_ARGS even if they are not
+ used. */
+ if (nr_gpr < GPR_ARGS)
+ nr_gpr = GPR_ARGS;
+ nr = nr_gpr + 2 * nr_fpr;
+
+ /* stack must be 16 bytes aligned */
+ nr = nr ^ (nr & 3);
+
+ stack = __builtin_alloca (4 * nr);
+
+ /* fpr[] is in callee local variables area. */
+ fpr = (double*)(stack + nr_gpr);
+
+ /* gpr[] and stack[] are in called parameters area. */
+ stack += ARG_DISPLACEMENT;
+ gpr = stack - GPR_ARGS;
+ stack = gpr;
+ }
+
+ /* build gpr[], fpr[] and stack[] arrays */
+#ifndef _SOFT_FLOAT
+ nr_fpr = 0;
+#endif
+ args = callargs;
+
+ while (args != last) {
+ switch (calltype[args - callargs]) {
+ case 'D':
+ if (nr_fpr < FPR_ARGS)
+ fpr[nr_fpr++] = args->d;
+ else
+ *(double*)stack = args->d;
+ stack += 2;
+ break;
+
+ case 'F':
+ if (nr_fpr < FPR_ARGS)
+ fpr[nr_fpr++] = (double)args->f;
+ else
+ *(float*)stack = args->f;
+ stack++;
+ break;
+
+ case 'J':
+ *(long long*)stack = args->j;
+ stack += 2;
+ break;
+
+ default:
+ *(long*)stack = args->i;
+ stack++;
+ break;
+ }
+ args++;
+ }
+
+ nr_gpr = stack - gpr;
+ if (nr_gpr > GPR_ARGS)
+ nr_gpr = GPR_ARGS;
+
+ {
+ register ARG_TYPE a0 asm("r3");
+ register ARG_TYPE a1 asm("r4");
+ register ARG_TYPE a2 asm("r5");
+ register ARG_TYPE a3 asm("r6");
+ register ARG_TYPE a4 asm("r7");
+ register ARG_TYPE a5 asm("r8");
+ register ARG_TYPE a6 asm("r9");
+ register ARG_TYPE a7 asm("r10");
+
+#ifndef _SOFT_FLOAT
+ register double d0 asm("fr1");
+ register double d1 asm("fr2");
+ register double d2 asm("fr3");
+ register double d3 asm("fr4");
+ register double d4 asm("fr5");
+ register double d5 asm("fr6");
+ register double d6 asm("fr7");
+ register double d7 asm("fr8");
+
+#if FPR_ARGS == 13
+ register double d8 asm("fr9");
+ register double d9 asm("fr10");
+ register double d10 asm("fr11");
+ register double d11 asm("fr12");
+ register double d12 asm("fr13");
+#endif
+
+ /* load FPR registers from fpr[] */
+ switch (nr_fpr) {
+#if FPR_ARGS == 13
+ ARG_FPR(12);
+ ARG_FPR(11);
+ ARG_FPR(10);
+ ARG_FPR(9);
+ ARG_FPR(8);
+#endif
+
+ ARG_FPR(7);
+ ARG_FPR(6);
+ ARG_FPR(5);
+ ARG_FPR(4);
+ ARG_FPR(3);
+ ARG_FPR(2);
+ ARG_FPR(1);
+ ARG_FPR(0);
+ /* case 0: */
+ }
+#endif /* !_SOFT_FLOAT */
+
+ /* load GPR registers from gpr[] */
+ switch (nr_gpr) {
+ ARG_GPR(7);
+ ARG_GPR(6);
+ ARG_GPR(5);
+ ARG_GPR(4);
+ ARG_GPR(3);
+ ARG_GPR(2);
+ ARG_GPR(1);
+ ARG_GPR(0);
+ /* case 0: */
+ }
+
+#ifndef _SOFT_FLOAT
+ /* Ensure that the assignments to f* registers won't be optimized away.
*/
+ asm ("" ::
+ "f" (d0), "f" (d1), "f" (d2), "f" (d3),
+ "f" (d4), "f" (d5), "f" (d6), "f" (d7));
+#if FPR_ARGS == 13
+ asm ("" ::
+ "f" (d8), "f" (d9), "f" (d10), "f" (d11), "f" (d12));
+#endif
+#endif /* _SOFT_FLOAT */
+
+ switch(call->retsize) {
+ case 0:
+ /* Must be void. */
+ ((void (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+
+ case 1:
+ if (call->rettype == 'F')
+ call->ret->f = ((jfloat (*)(ARG_TYPES))(func))(ARG_LIST);
+ else /* Must be 32-bit or smaller int. */
+ call->ret->i = ((jint (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+
+ default:
+ /* It could've been `case 2;', but then we'd get an additional cmp
+ * that we don't really need. */
+ if (call->rettype == 'D')
+ call->ret->d = ((jdouble (*)(ARG_TYPES))(func))(ARG_LIST);
+ else /* Must be jlong. */
+ call->ret->j = ((jlong (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+ }
+ }
+}
+
+#else
+
+static inline void sysdepCallMethod(callMethodInfo* call)
+{
+ void *func = call->function;
+ jvalue *callargs = call->args;
+ char *calltype = call->calltype;
+ jvalue *args = callargs;
+ jvalue *last = &callargs[call->nrargs];
+
+ int nr_gpr = 0;
+ int nr_stack = 0;
+
+ unsigned long *stack;
+ unsigned long *gpr;
+#if !defined(_SOFT_FLOAT)
+ int nr_fpr = 0;
+ double *fpr;
+#endif
+
+ /* Compute gpr[], fpr[] and stack[] arrays' size */
+ while (args != last) {
+ switch (calltype[(args++) - callargs]) {
+ case 'D':
+#ifdef _SOFT_FLOAT
+ if (nr_gpr & 1)
+ nr_gpr++;
+ if ((nr_gpr + 1) < GPR_ARGS) {
+ nr_gpr += 2;
+ }
+#else
+ if (nr_fpr < FPR_ARGS) {
+ nr_fpr++;
+ }
+#endif /* _SOFT_FLOAT */
+ else {
+ if (nr_stack & 1)
+ nr_stack += 3;
+ else
+ nr_stack += 2;
+ }
+ break;
+
+ case 'F':
+#ifdef _SOFT_FLOAT
+ if (nr_gpr < GPR_ARGS)
+ nr_gpr++;
+#else
+ if (nr_fpr < FPR_ARGS) {
+ nr_fpr++;
+ }
+#endif /* _SOFT_FLOAT */
+ else {
+ nr_stack++;
+ }
+ break;
+
+ case 'J':
+ if (nr_gpr & 1)
+ nr_gpr++;
+ if ((nr_gpr + 1) < GPR_ARGS) {
+ nr_gpr += 2;
+ }
+ else {
+ if (nr_stack & 1)
+ nr_stack += 3;
+ else
+ nr_stack += 2;
+ }
+ break;
+
+ default:
+ if (nr_gpr < GPR_ARGS) {
+ nr_gpr++;
+ }
+ else {
+ nr_stack++;
+ }
+ break;
+ }
+ }
+
+ /* Allocate all arrays with one big alloca() */
+ {
+ int nr = nr_gpr
+#ifndef _SOFT_FLOAT
+ + 2 * nr_fpr
+#endif
+ + nr_stack;
+
+ /* stack, if used, must be 16 bytes aligned */
+ if (nr_stack)
+ nr = nr ^ (nr & 3);
+
+ /* stack[] is in called parameters area. */
+ stack = __builtin_alloca (4 * nr);
+
+ /* gpr[] and fpr[] are in callee local variable area. */
+ gpr = stack + nr_stack;
+#ifndef _SOFT_FLOAT
+ fpr = (double*)(gpr + nr_gpr);
+#endif
+ /* if __buildin_alloc() does not handle link-area, skip it. */
+ stack += ARG_DISPLACEMENT;
+
+ nr_gpr = 0;
+ nr_stack = 0;
+ }
+
+ /* build gpr[], fpr[] and stack[] arrays */
+#ifndef _SOFT_FLOAT
+ nr_fpr = 0;
+#endif
+ args = callargs;
+
+ while (args != last) {
+ switch (calltype[args - callargs]) {
+ case 'D':
+#ifdef _SOFT_FLOAT
+ if (nr_gpr & 1)
+ nr_gpr++;
+ if ((nr_gpr + 1) < GPR_ARGS) {
+ *((double *) (&gpr[nr_gpr])) = args->d;
+ nr_gpr += 2;
+ }
+#else
+ if (nr_fpr < FPR_ARGS) {
+ fpr[nr_fpr++] = args->d;
+ }
+#endif /* _SOFT_FLOAT */
+ else {
+ if (((long)stack) & 4)
+ stack++;
+ *(double*)stack = args->d;
+ stack += 2;
+ }
+ break;
+
+ case 'F':
+#ifdef _SOFT_FLOAT
+ if (nr_gpr < GPR_ARGS) {
+ *((double *) (&gpr[nr_gpr])) = args->f;
+ nr_gpr++;
+ }
+#else
+ if (nr_fpr < FPR_ARGS) {
+ fpr[nr_fpr++] = (double)args->f;
+ }
+#endif /* _SOFT_FLOAT */
+ else {
+ *(float*)stack = args->f;
+ stack++;
+ }
+ break;
+
+ case 'J':
+ if (nr_gpr & 1)
+ nr_gpr++;
+ if ((nr_gpr + 1) < GPR_ARGS) {
+ *((long long *) (&gpr[nr_gpr])) = args->j;
+ nr_gpr += 2;
+ }
+ else {
+ if (((long)stack) & 4)
+ stack++;
+ *(long long*)stack = args->j;
+ stack += 2;
+ }
+ break;
+
+ default:
+ if (nr_gpr < GPR_ARGS) {
+ gpr[nr_gpr++] = args->i;
+ }
+ else {
+ *(long*)stack = args->i;
+ stack++;
+ }
+ }
+ args++;
+ }
+
+ {
+ register ARG_TYPE a0 asm("r3");
+ register ARG_TYPE a1 asm("r4");
+ register ARG_TYPE a2 asm("r5");
+ register ARG_TYPE a3 asm("r6");
+ register ARG_TYPE a4 asm("r7");
+ register ARG_TYPE a5 asm("r8");
+ register ARG_TYPE a6 asm("r9");
+ register ARG_TYPE a7 asm("r10");
+
+#ifndef _SOFT_FLOAT
+ register double d0 asm("fr1");
+ register double d1 asm("fr2");
+ register double d2 asm("fr3");
+ register double d3 asm("fr4");
+ register double d4 asm("fr5");
+ register double d5 asm("fr6");
+ register double d6 asm("fr7");
+ register double d7 asm("fr8");
+
+#if FPR_ARGS == 13
+ register double d8 asm("fr9");
+ register double d9 asm("fr10");
+ register double d10 asm("fr11");
+ register double d11 asm("fr12");
+ register double d12 asm("fr13");
+#endif
+
+ /* load FPR registers from fpr[] */
+ switch (nr_fpr) {
+#if FPR_ARGS == 13
+ ARG_FPR(12);
+ ARG_FPR(11);
+ ARG_FPR(10);
+ ARG_FPR(9);
+ ARG_FPR(8);
+#endif
+
+ ARG_FPR(7);
+ ARG_FPR(6);
+ ARG_FPR(5);
+ ARG_FPR(4);
+ ARG_FPR(3);
+ ARG_FPR(2);
+ ARG_FPR(1);
+ ARG_FPR(0);
+ /* case 0: */
+ }
+#endif /* !_SOFT_FLOAT */
+
+ /* load GPR registers from gpr[] */
+ switch (nr_gpr) {
+ ARG_GPR(7);
+ ARG_GPR(6);
+ ARG_GPR(5);
+ ARG_GPR(4);
+ ARG_GPR(3);
+ ARG_GPR(2);
+ ARG_GPR(1);
+ ARG_GPR(0);
+ /* case 0: */
+ }
+
+#ifndef _SOFT_FLOAT
+ /* Ensure that the assignments to f* registers won't be optimized away.
*/
+ asm ("" ::
+ "f" (d0), "f" (d1), "f" (d2), "f" (d3),
+ "f" (d4), "f" (d5), "f" (d6), "f" (d7));
+#if FPR_ARGS == 13
+ asm ("" ::
+ "f" (d8), "f" (d9), "f" (d10), "f" (d11), "f" (d12));
+#endif
+#endif /* _SOFT_FLOAT */
+
+ switch(call->retsize) {
+ case 0:
+ /* Must be void. */
+ ((void (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+
+ case 1:
+ if (call->rettype == 'F')
+ call->ret->f = ((jfloat (*)(ARG_TYPES))(func))(ARG_LIST);
+ else /* Must be 32-bit or smaller int. */
+ call->ret->i = ((jint (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+
+ default:
+ /* It could've been `case 2;', but then we'd get an additional cmp
+ * that we don't really need. */
+ if (call->rettype == 'D')
+ call->ret->d = ((jdouble (*)(ARG_TYPES))(func))(ARG_LIST);
+ else /* Must be jlong. */
+ call->ret->j = ((jlong (*)(ARG_TYPES))(func))(ARG_LIST);
+ break;
+ }
+ }
+}
+#endif
+
+#undef ARG_TYPE
+#undef ARG_TYPES
+#undef ARG_LIST
+#undef GPR_ARGS
+#undef FPR_ARGS
+#undef ARG_DISPLACEMENT
+#undef ARG_GPR
+#undef ARG_FPR
_______________________________________________
kaffe mailing list
[email protected]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
