/* src/vm/jit/powerpc/linux/md-abi.c - functions for PowerPC Linux ABI
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Christian Thalinger
-
- Changes: Christian Ullrich
-
- $Id: md-abi.c 5115 2006-07-12 14:55:04Z twisti $
-
*/
#include "config.h"
-#include "vm/types.h"
+
+#include <assert.h>
+#include <stdint.h>
#include "vm/jit/powerpc/linux/md-abi.h"
-#include "vm/descriptor.h"
#include "vm/global.h"
-#include "vm/jit/abi.h"
+#include "vm/jit/abi.h"
-#define _ALIGN(a) do { if ((a) & 1) (a)++; } while (0)
+#include "vmcore/descriptor.h"
-/* register descripton array **************************************************/
+/* register descripton arrays *************************************************/
-s4 nregdescint[] = {
- /* zero, sp, NO(sys), a0/v0, a0/v1, a2, a3, a4, */
+int nregdescint[] = {
+ /* zero, sp, NO(sys), a0/v0, a1/v1, a2, a3, a4, */
REG_RES, REG_RES, REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
/* a5, a6, a7, itmp1, itmp2, pv, s0, s1, */
REG_END
};
-char *regs[] = {
+const char *abi_registers_integer_name[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
};
+const int abi_registers_integer_argument[] = {
+ 3, /* a0 */
+ 4, /* a1 */
+ 5, /* a2 */
+ 6, /* a3 */
+ 7, /* a4 */
+ 8, /* a5 */
+ 9, /* a6 */
+ 10, /* a7 */
+};
+
+const int abi_registers_integer_saved[] = {
+ 14, /* s0 */
+ 15, /* s1 */
+ 24, /* s2 */
+ 25, /* s3 */
+ 26, /* s4 */
+ 27, /* s5 */
+ 28, /* s6 */
+ 29, /* s7 */
+ 30, /* s8 */
+ 31, /* s9 */
+};
+
+const int abi_registers_integer_temporary[] = {
+ 17, /* t0 */
+ 18, /* t1 */
+ 19, /* t2 */
+ 20, /* t3 */
+ 21, /* t4 */
+ 22, /* t5 */
+ 23, /* t6 */
+};
+
-s4 nregdescfloat[] = {
+int nregdescfloat[] = {
/*ftmp3, fa0/v0, fa1, fa2, fa3, fa4, fa5, fa6, */
REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
};
+const int abi_registers_float_argument[] = {
+ 1, /* fa0 */
+ 2, /* fa1 */
+ 3, /* fa2 */
+ 4, /* fa3 */
+ 5, /* fa4 */
+ 6, /* fa5 */
+ 7, /* fa6 */
+ 8, /* fa7 */
+};
+
+const int abi_registers_float_saved[] = {
+ 14, /* fs0 */
+ 15, /* fs1 */
+ 24, /* fs2 */
+ 25, /* fs3 */
+ 26, /* fs4 */
+ 27, /* fs5 */
+ 28, /* fs6 */
+ 29, /* fs7 */
+ 30, /* fs8 */
+ 31, /* fs9 */
+};
+
+const int abi_registers_float_temporary[] = {
+ 9, /* ft0 */
+ 10, /* ft1 */
+ 11, /* ft2 */
+ 12, /* ft3 */
+ 13, /* ft4 */
+ 18, /* ft5 */
+ 19, /* ft6 */
+ 20, /* ft7 */
+ 21, /* ft8 */
+ 22, /* ft9 */
+ 23, /* ft10 */
+};
+
+
/* md_param_alloc **************************************************************
Allocate Arguments to Stackslots according the Calling Conventions
void md_param_alloc(methoddesc *md)
{
paramdesc *pd;
- s4 i;
- s4 iarg;
- s4 farg;
- s4 stacksize;
+ int i;
+ int iarg;
+ int farg;
+ int stacksize;
/* set default values */
iarg = 0;
farg = 0;
- stacksize = LA_WORD_SIZE;
+ stacksize = LA_SIZE_IN_POINTERS;
/* get params field of methoddesc */
case TYPE_ADR:
if (iarg < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = iarg;
+ pd->index = iarg;
+ pd->regoff = abi_registers_integer_argument[iarg];
iarg++;
- } else {
+ }
+ else {
pd->inmemory = true;
- pd->regoff = stacksize;
+ pd->index = stacksize;
+ pd->regoff = stacksize * 8;
stacksize++;
}
break;
+
case TYPE_LNG:
if (iarg < INT_ARG_CNT - 1) {
- _ALIGN(iarg);
+ ALIGN_2(iarg);
pd->inmemory = false;
- /* rd->arg[int|flt]regs index !! */
- pd->regoff = PACK_REGS(iarg + 1, iarg);
+ pd->index = PACK_REGS(iarg + 1, iarg);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[iarg + 1],
+ abi_registers_integer_argument[iarg]);
iarg += 2;
- } else {
- _ALIGN(stacksize);
+ }
+ else {
pd->inmemory = true;
- pd->regoff = stacksize;
- iarg = INT_ARG_CNT;
- stacksize += 2;
+ pd->index = stacksize;
+ pd->regoff = stacksize * 8;
+ iarg = INT_ARG_CNT;
+ stacksize++;
}
break;
+
case TYPE_FLT:
+ case TYPE_DBL:
if (farg < FLT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = farg;
+ pd->index = farg;
+ pd->regoff = abi_registers_float_argument[farg];
farg++;
- } else {
+ }
+ else {
pd->inmemory = true;
- pd->regoff = stacksize;
+ pd->index = stacksize;
+ pd->regoff = stacksize * 8;
stacksize++;
}
break;
+
+ default:
+ assert(0);
+ }
+ }
+
+ /* Since R3/R4, F1 (==A0/A1, A0) are used for passing return
+ values, this argument register usage has to be regarded,
+ too. */
+
+ if (IS_INT_LNG_TYPE(md->returntype.type)) {
+ if (iarg < (IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1))
+ iarg = IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1;
+ }
+ else {
+ if (IS_FLT_DBL_TYPE(md->returntype.type))
+ if (farg < 1)
+ farg = 1;
+ }
+
+ /* fill register and stack usage */
+
+ md->argintreguse = iarg;
+ md->argfltreguse = farg;
+ md->memuse = stacksize;
+}
+
+
+/* md_param_alloc_native *******************************************************
+
+ Pre-allocate arguments according the native ABI.
+
+*******************************************************************************/
+
+void md_param_alloc_native(methoddesc *md)
+{
+ paramdesc *pd;
+ int i;
+ int iarg;
+ int farg;
+ int stacksize;
+
+ /* set default values */
+
+ iarg = 0;
+ farg = 0;
+ stacksize = LA_SIZE_IN_POINTERS;
+
+ /* get params field of methoddesc */
+
+ pd = md->params;
+
+ for (i = 0; i < md->paramcount; i++, pd++) {
+ switch (md->paramtypes[i].type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ if (iarg < INT_ARG_CNT) {
+ pd->inmemory = false;
+ pd->regoff = abi_registers_integer_argument[iarg];
+ iarg++;
+ }
+ else {
+ pd->inmemory = true;
+ pd->regoff = stacksize * 4;
+ stacksize++;
+ }
+ break;
+
+ case TYPE_LNG:
+ if (iarg < INT_ARG_CNT - 1) {
+ ALIGN_2(iarg);
+ pd->inmemory = false;
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[iarg + 1],
+ abi_registers_integer_argument[iarg]);
+ iarg += 2;
+ }
+ else {
+ ALIGN_2(stacksize);
+ pd->inmemory = true;
+ pd->regoff = stacksize * 4;
+ iarg = INT_ARG_CNT;
+ stacksize += 2;
+ }
+ break;
+
+ case TYPE_FLT:
+ if (farg < FLT_ARG_CNT) {
+ pd->inmemory = false;
+ pd->regoff = abi_registers_float_argument[farg];
+ farg++;
+ }
+ else {
+ pd->inmemory = true;
+ pd->regoff = stacksize * 4;
+ stacksize++;
+ }
+ break;
+
case TYPE_DBL:
if (farg < FLT_ARG_CNT) {
- pd->inmemory = false;
- pd->regoff = farg;
+ pd->inmemory = false;
+ pd->regoff = abi_registers_float_argument[farg];
farg++;
- } else {
- _ALIGN(stacksize);
- pd->inmemory = true;
- pd->regoff = stacksize;
- stacksize += 2;
+ }
+ else {
+ ALIGN_2(stacksize);
+ pd->inmemory = true;
+ pd->regoff = stacksize * 4;
+ stacksize += 2;
}
break;
+
+ default:
+ assert(0);
}
}
- /* Since R3/R4, F1 (==A0/A1, A0) are used for passing return values, this */
- /* argument register usage has to be regarded, too */
+ /* Since R3/R4, F1 (==A0/A1, A0) are used for passing return
+ values, this argument register usage has to be regarded,
+ too. */
+
if (IS_INT_LNG_TYPE(md->returntype.type)) {
if (iarg < (IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1))
iarg = IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1;
- } else {
+ }
+ else {
if (IS_FLT_DBL_TYPE(md->returntype.type))
if (farg < 1)
farg = 1;
md->argintreguse = iarg;
md->argfltreguse = farg;
- md->memuse = stacksize;
+ md->memuse = stacksize;
}
for float/double)
--- in
- m: Methodinfo of current method
- return_type: Return Type of the Method (TYPE_INT.. TYPE_ADR)
- TYPE_VOID is not allowed!
+ jd: jitdata of the current method
stackslot: Java Stackslot to contain the Return Value
--- out
if precoloring was possible:
- stackslot->varkind =ARGVAR
- ->varnum =-1
- ->flags =0
- ->regoff =[REG_RESULT, (REG_RESULT2/REG_RESULT), REG_FRESULT]
+ VAR(stackslot->varnum)->flags = PREALLOC
+ ->regoff = [REG_RESULT|REG_FRESULT]
rd->arg[flt|int]reguse set to a value according the register usage
+ NOTE: Do not pass a LOCALVAR in stackslot->varnum.
+
*******************************************************************************/
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
- codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- code = jd->code;
- rd = jd->rd;
+ m = jd->m;
+ rd = jd->rd;
- md = m->parseddesc;
+ md = m->parseddesc;
/* In Leafmethods Local Vars holding parameters are precolored to
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
- if (!code->isleafmethod || (md->paramcount == 0)) {
+ if (!jd->isleafmethod || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
if (!(stackslot->flags & SAVEDVAR)) {
- stackslot->varkind = ARGVAR;
- stackslot->varnum = -1;
- stackslot->flags = 0;
+ VAR(stackslot->varnum)->flags = PREALLOC;
if (IS_INT_LNG_TYPE(md->returntype.type)) {
if (!IS_2_WORD_TYPE(md->returntype.type)) {
if (rd->argintreguse < 1)
rd->argintreguse = 1;
- stackslot->regoff = REG_RESULT;
+ VAR(stackslot->varnum)->vv.regoff = REG_RESULT;
}
else {
if (rd->argintreguse < 2)
rd->argintreguse = 2;
- stackslot->regoff = REG_RESULT_PACKED;
+ VAR(stackslot->varnum)->vv.regoff = REG_RESULT_PACKED;
}
}
else { /* float/double */
if (rd->argfltreguse < 1)
rd->argfltreguse = 1;
- stackslot->regoff = REG_FRESULT;
+ VAR(stackslot->varnum)->vv.regoff = REG_FRESULT;
}
}
}