* src/vm/jit/powerpc/netbsd/md-abi.c: Blindly ported to
[cacao.git] / src / vm / jit / powerpc / linux / md-abi.c
1 /* src/vm/jit/powerpc/linux/md-abi.c - functions for PowerPC Linux 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    Contact: cacao@cacaojvm.org
26
27    Authors: Christian Thalinger
28
29    Changes: Christian Ullrich
30
31    $Id: md-abi.c 5634 2006-10-02 14:18:04Z edwin $
32
33 */
34
35
36 #include "config.h"
37 #include "vm/types.h"
38
39 #include "vm/jit/powerpc/linux/md-abi.h"
40
41 #include "vm/descriptor.h"
42 #include "vm/global.h"
43 #include "vm/jit/abi.h"
44
45
46 #define _ALIGN(a)    do { if ((a) & 1) (a)++; } while (0)
47
48
49 /* register descripton array **************************************************/
50
51 s4 nregdescint[] = {
52         /* zero,      sp, NO(sys),   a0/v0,   a0/v1,      a2,      a3,      a4,   */
53         REG_RES, REG_RES, REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
54
55         /*   a5,      a6,      a7,   itmp1,   itmp2,      pv,      s0,      s1,   */
56         REG_ARG, REG_ARG, REG_ARG, REG_RES, REG_RES, REG_RES, REG_SAV, REG_SAV,
57
58         /*itmp3,      t0,      t1,      t2,      t3,      t4,      t5,      t6,   */
59         REG_RES, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
60
61         /*   s2,      s3,      s4,      s5,      s6,      s7,      s8,      s9,   */
62         REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
63
64         REG_END
65 };
66
67 char *regs[] = {
68         "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
69         "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
70         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
71         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
72 };
73
74
75 s4 nregdescfloat[] = {
76         /*ftmp3,  fa0/v0,     fa1,     fa2,     fa3,     fa4,     fa5,     fa6,   */
77         REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
78
79         /*  fa7,     ft0,     ft1,     ft2,     ft3,     ft4,     fs0,     fs1,   */
80         REG_ARG, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_SAV, REG_SAV,
81
82         /*ftmp1,   ftmp2,     ft5,     ft6,     ft7,     ft8,     ft9,    ft10,   */
83         REG_RES, REG_RES, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
84
85         /*  fs2,     fs3,     fs4,     fs5,     fs6,     fs7,     fs8,     fs9    */
86         REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
87
88         REG_END
89 };
90
91
92 /* md_param_alloc **************************************************************
93
94    Allocate Arguments to Stackslots according the Calling Conventions
95
96    --- in
97    md->paramcount:           Number of arguments for this method
98    md->paramtypes[].type:    Argument types
99
100    --- out
101    md->params[].inmemory:    Argument spilled on stack
102    md->params[].regoff:      Stack offset or rd->arg[int|flt]regs index
103    md->memuse:               Stackslots needed for argument spilling
104    md->argintreguse:         max number of integer arguments used
105    md->argfltreguse:         max number of float arguments used
106
107 *******************************************************************************/
108
109 void md_param_alloc(methoddesc *md)
110 {
111         paramdesc *pd;
112         s4         i;
113         s4         iarg;
114         s4         farg;
115         s4         stacksize;
116
117         /* set default values */
118
119         iarg = 0;
120         farg = 0;
121         stacksize = LA_SIZE_IN_POINTERS;
122
123         /* get params field of methoddesc */
124
125         pd = md->params;
126
127         for (i = 0; i < md->paramcount; i++, pd++) {
128                 switch (md->paramtypes[i].type) {
129                 case TYPE_INT:
130                 case TYPE_ADR:
131                         if (iarg < INT_ARG_CNT) {
132                                 pd->inmemory = false;
133                                 pd->regoff = iarg;
134                                 iarg++;
135                         } else {
136                                 pd->inmemory = true;
137                                 pd->regoff = stacksize;
138                                 stacksize++;
139                         }
140                         break;
141                 case TYPE_LNG:
142                         if (iarg < INT_ARG_CNT - 1) {
143                                 _ALIGN(iarg);
144                                 pd->inmemory = false;
145                                                              /* rd->arg[int|flt]regs index !! */
146                                 pd->regoff = PACK_REGS(iarg + 1, iarg); 
147                                 iarg += 2;
148                         } else {
149                                 _ALIGN(stacksize);
150                                 pd->inmemory = true;
151                                 pd->regoff = stacksize;
152                                 iarg = INT_ARG_CNT;
153                                 stacksize += 2;
154                         }
155                         break;
156                 case TYPE_FLT:
157                         if (farg < FLT_ARG_CNT) {
158                                 pd->inmemory = false;
159                                 pd->regoff = farg;
160                                 farg++;
161                         } else {
162                                 pd->inmemory = true;
163                                 pd->regoff = stacksize;
164                                 stacksize++;
165                         }
166                         break;
167                 case TYPE_DBL:
168                         if (farg < FLT_ARG_CNT) {
169                                 pd->inmemory = false;
170                                 pd->regoff = farg;
171                                 farg++;
172                         } else {
173                                 _ALIGN(stacksize);
174                                 pd->inmemory = true;
175                                 pd->regoff = stacksize;
176                                 stacksize += 2;
177                         }
178                         break;
179                 }
180         }
181
182         /* Since R3/R4, F1 (==A0/A1, A0) are used for passing return values, this */
183         /* argument register usage has to be regarded, too                        */
184         if (IS_INT_LNG_TYPE(md->returntype.type)) {
185                 if (iarg < (IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1))
186                         iarg = IS_2_WORD_TYPE(md->returntype.type) ? 2 : 1;
187         } else {
188                 if (IS_FLT_DBL_TYPE(md->returntype.type))
189                         if (farg < 1)
190                                 farg = 1;
191         }
192
193         /* fill register and stack usage */
194
195         md->argintreguse = iarg;
196         md->argfltreguse = farg;
197         md->memuse = stacksize;
198 }
199
200
201 /* md_return_alloc *************************************************************
202
203    Precolor the Java Stackelement containing the Return Value, if
204    possible.  (R3==a00 for int/adr, R4/R3 == a01/a00 for long, F1==a00
205    for float/double)
206
207    --- in
208    jd:                      jitdata of the current method
209    stackslot:               Java Stackslot to contain the Return Value
210
211    --- out
212    if precoloring was possible:
213    VAR(stackslot->varnum)->flags       = PREALLOC
214                                      ->regoff      = [REG_RESULT|REG_FRESULT]
215    rd->arg[flt|int]reguse   set to a value according the register usage
216
217    NOTE: Do not pass a LOCALVAR in stackslot->varnum.
218
219 *******************************************************************************/
220
221 void md_return_alloc(jitdata *jd, stackptr stackslot)
222 {
223         methodinfo   *m;
224         registerdata *rd;
225         methoddesc   *md;
226
227         /* get required compiler data */
228
229         m  = jd->m;
230         rd = jd->rd;
231
232         md = m->parseddesc;
233
234         /* In Leafmethods Local Vars holding parameters are precolored to
235            their argument register -> so leafmethods with paramcount > 0
236            could already use R3 == a00! */
237
238         if (!jd->isleafmethod || (md->paramcount == 0)) {
239                 /* Only precolor the stackslot, if it is not a SAVEDVAR <->
240                    has not to survive method invokations. */
241
242                 if (!(stackslot->flags & SAVEDVAR)) {
243                         VAR(stackslot->varnum)->flags = PREALLOC;
244
245                         if (IS_INT_LNG_TYPE(md->returntype.type)) {
246                                 if (!IS_2_WORD_TYPE(md->returntype.type)) {
247                                         if (rd->argintreguse < 1)
248                                                 rd->argintreguse = 1;
249
250                                         VAR(stackslot->varnum)->vv.regoff = REG_RESULT;
251                                 }
252                                 else {
253                                         if (rd->argintreguse < 2)
254                                                 rd->argintreguse = 2;
255
256                                         VAR(stackslot->varnum)->vv.regoff = REG_RESULT_PACKED;
257                                 }
258                         }
259                         else { /* float/double */
260                                 if (rd->argfltreguse < 1)
261                                         rd->argfltreguse = 1;
262
263                                 VAR(stackslot->varnum)->vv.regoff = REG_FRESULT;
264                         }
265                 }
266         }
267 }
268
269
270 /*
271  * These are local overrides for various environment variables in Emacs.
272  * Please do not remove this and leave it at the end of the file, where
273  * Emacs will automagically detect them.
274  * ---------------------------------------------------------------------
275  * Local variables:
276  * mode: c
277  * indent-tabs-mode: t
278  * c-basic-offset: 4
279  * tab-width: 4
280  * End:
281  */