src/vm/jit/sparc64/md-abi.c

   1 /* src/vm/jit/sparc64/md-abi.c - functions for Sparc ABI
   2
   3    Copyright (C) 1996-2005, 2006, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27 #include "vm/types.h"
  28
  29 #include "vm/jit/sparc64/md-abi.h"
  30
  31 #include "vm/descriptor.hpp"
  32 #include "vm/global.h"
  33
  34 #include "vm/jit/abi.h"
  35 #include "vm/jit/stack.h"
  36
  37 /* temp */
  38 #include "mm/memory.hpp"
  39 #include <assert.h>
  40
  41
  42 /* register descripton array **************************************************/
  43
  44 /* callee point-of-view, after SAVE has been called. */
  45 s4 nregdescint[] = {
  46         /* zero  itmp1/g1 itmp2/g2 itmp3/g3 temp/g4  temp/g5  sys/g6   sys/g7 */
  47         REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES,
  48
  49         /* o0    o1       o2       o3       o4       pv/o5    sp/o6    ra/o7  */
  50         REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_RES, REG_RES, REG_RES,
  51
  52         /* l0    l1       l2       l3       l4       l5       l6       l7     */
  53         REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
  54
  55         /* i0    i1       i2       i3       i4       pv/i5    fp/i6    ra/i7  */
  56         REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_RES, REG_RES, REG_RES,
  57         REG_END
  58 };
  59
  60 const char *abi_registers_integer_name[] = {
  61                 "zero",  "g1",  "g2",  "g3",  "g4",  "g5",  "g6",  "g7",
  62                 "o0",    "o1",  "o2",  "o3",  "o4",  "o5",  "sp",  "o7",
  63                 "l0",    "l1",  "l2",  "l3",  "l4",  "l5",  "l6",  "l7",
  64                 "i0",    "i1",  "i2",  "i3",  "i4",  "i5",  "fp",  "i7"
  65 };
  66
  67 const s4 abi_registers_integer_argument[] = {
  68         8,  /* o0  */
  69         9,  /* o1  */
  70         10, /* o2  */
  71         11, /* o3  */
  72         12, /* o4  */
  73 };
  74
  75 const s4 abi_registers_integer_saved[] = {
  76         16, /* l0  */
  77         17, /* l1  */
  78         18, /* l2  */
  79         19, /* l3  */
  80         20, /* l4  */
  81         21, /* l5  */
  82         22, /* l6  */
  83         23, /* l7  */
  84         24, /* i0  */
  85         25, /* i1  */
  86         26, /* i2  */
  87         27, /* i3  */
  88         28, /* i4  */
  89 };
  90
  91
  92
  93 s4 nregdescfloat[] = {
  94         REG_RET, REG_RES, REG_RES, REG_RES, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
  95         REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP, REG_TMP,
  96         REG_END
  97 };
  98
  99
 100 const s4 abi_registers_float_argument[] = {
 101         8,  /* f16  */
 102         9,  /* f18  */
 103         10, /* f20  */
 104         11, /* f22  */
 105         12, /* f24  */
 106 };
 107
 108 const s4 abi_registers_float_temporary[] = {
 109         4,  /* f8   */
 110         5,  /* f10  */
 111         6,  /* f12  */
 112         7,  /* f14  */
 113         13, /* f26  */
 114         14, /* f28  */
 115         15, /* f30  */
 116 };
 117
 118 s4 nat_argintregs[] = {
 119         REG_OUT0, REG_OUT1, REG_OUT2, REG_OUT3, REG_OUT4, REG_OUT5
 120 };
 121
 122
 123 /* md_param_alloc **************************************************************
 124
 125    Allocate Arguments to Stackslots according the Calling Conventions
 126
 127    --- in
 128    md->paramcount:           Number of arguments for this method
 129    md->paramtypes[].type:    Argument types
 130
 131    --- out
 132    md->params[].inmemory:    Argument spilled on stack
 133    md->params[].regoff:      Stack offset or rd->arg[int|flt]regs index
 134    md->memuse:               Stackslots needed for argument spilling
 135    md->argintreguse:         max number of integer arguments used
 136    md->argfltreguse:         max number of float arguments used
 137
 138 *******************************************************************************/
 139
 140 void md_param_alloc(methoddesc *md)
 141 {
 142         paramdesc *pd;
 143         s4         i;
 144         s4         reguse;
 145         s4         stacksize;
 146
 147         /* set default values */
 148
 149         reguse = 0;
 150         stacksize = 0;
 151
 152         /* get params field of methoddesc */
 153
 154         pd = md->params;
 155
 156         for (i = 0; i < md->paramcount; i++, pd++) {
 157                 switch (md->paramtypes[i].type) {
 158                 case TYPE_INT:
 159                 case TYPE_ADR:
 160                 case TYPE_LNG:
 161                         if (i < INT_ARG_CNT) {
 162                                 pd->inmemory = false;
 163                                 pd->index = reguse;
 164                                 pd->regoff   = abi_registers_integer_argument[reguse];
 165                                 reguse++;
 166                                 md->argintreguse = reguse;
 167                         }
 168                         else {
 169                                 pd->inmemory = true;
 170                                 pd->index = stacksize;
 171                                 pd->regoff = stacksize * 8;
 172                                 stacksize++;
 173                         }
 174                         break;
 175
 176                 case TYPE_FLT:
 177                 case TYPE_DBL:
 178                         if (i < FLT_ARG_CNT) {
 179                                 pd->inmemory = false;
 180                                 pd->index = reguse;
 181                                 pd->regoff   = abi_registers_float_argument[reguse];
 182                                 reguse++;
 183                                 md->argfltreguse = reguse;
 184                         }
 185                         else {
 186                                 pd->inmemory = true;
 187                                 pd->index = stacksize;
 188                                 pd->regoff = stacksize * 8;
 189                                 stacksize++;
 190                         }
 191                         break;
 192                 }
 193                 assert(pd->regoff != 26);
 194         }
 195
 196         /* Since O0 is used for passing return values, this */
 197         /* argument register usage has to be regarded, too                        */
 198         if (IS_INT_LNG_TYPE(md->returntype.type)) {
 199                 if (reguse < 1)
 200                         md->argintreguse = 1;
 201         }
 202
 203         /* fill register and stack usage */
 204
 205         md->memuse = stacksize;
 206 }
 207
 208
 209 /* md_param_alloc_native *******************************************************
 210  *
 211  *    Pre-allocate arguments according to the native ABI.
 212  *
 213  *    *******************************************************************************/
 214
 215 void md_param_alloc_native(methoddesc *md)
 216 {
 217         paramdesc *pd;
 218         s4         i;
 219         s4         reguse;
 220         s4         stacksize;
 221         s4         min_nat_regs;
 222
 223         /* Note: regoff will be set relative to a stack base of $sp+16 */
 224
 225         /* set default values */
 226         reguse = 0;
 227         stacksize = 6; /* abi params: allocated, but not used */
 228
 229         /* when we are above this, we have to increase the stacksize with every */
 230         /* single argument to create the proper argument array                  */
 231         min_nat_regs = MIN(INT_NATARG_CNT, FLT_NATARG_CNT);
 232
 233         /* get params field of methoddesc */
 234
 235         pd = md->params;
 236
 237         for (i = 0; i < md->paramcount; i++, pd++) {
 238                 switch (md->paramtypes[i].type) {
 239                 case TYPE_INT:
 240                 case TYPE_ADR:
 241                 case TYPE_LNG:
 242                         if (i < INT_NATARG_CNT) {
 243                                 pd->inmemory = false;
 244                                 pd->regoff = nat_argintregs[reguse];
 245                                 reguse++;
 246                                 md->argintreguse = reguse;
 247
 248                         } else {
 249                                 pd->inmemory = true;
 250                                 pd->regoff = reguse * 8;
 251                                 reguse++;
 252                         }
 253                         break;
 254                 case TYPE_FLT:
 255                 case TYPE_DBL:
 256                         if (i < FLT_NATARG_CNT) {
 257                                 pd->inmemory = false;
 258                                 pd->regoff = reguse;
 259                                 reguse++;
 260                                 md->argfltreguse = reguse;
 261                         } else {
 262                                 pd->inmemory = true;
 263                                 pd->regoff = reguse * 8;
 264                                 reguse++;
 265                         }
 266
 267                         break;
 268                 }
 269
 270                 if (i >= min_nat_regs)
 271                         stacksize++;
 272         }
 273
 274         /* Since O0 is used for passing return values, this */
 275         /* argument register usage has to be regarded, too                        */
 276         if (IS_INT_LNG_TYPE(md->returntype.type)) {
 277                 if (reguse < 1)
 278                         md->argintreguse = 1;
 279         }
 280
 281         /* fill register and stack usage */
 282
 283         md->memuse = stacksize;
 284 }
 285
 286 /* md_return_alloc *************************************************************
 287
 288   XXX
 289
 290 *******************************************************************************/
 291
 292 void md_return_alloc(jitdata *jd, stackelement_t* stackslot)
 293 {
 294         /* XXX */
 295 }
 296
 297
 298 /*
 299  * These are local overrides for various environment variables in Emacs.
 300  * Please do not remove this and leave it at the end of the file, where
 301  * Emacs will automagically detect them.
 302  * ---------------------------------------------------------------------
 303  * Local variables:
 304  * mode: c
 305  * indent-tabs-mode: t
 306  * c-basic-offset: 4
 307  * tab-width: 4
 308  * End:
 309  * vim:noexpandtab:sw=4:ts=4:
 310  */