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