2002-09-30 David Carlton <carlton@math.stanford.edu>
[external/binutils.git] / gdb / ppc-sysv-tdep.c
1 /* Target-dependent code for PowerPC systems using the SVR4 ABI
2    for GDB, the GNU debugger.
3
4    Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU 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., 59 Temple Place - Suite 330,
21    Boston, MA 02111-1307, USA.  */
22
23 #include "defs.h"
24 #include "gdbcore.h"
25 #include "inferior.h"
26 #include "regcache.h"
27 #include "value.h"
28 #include "gdb_string.h"
29
30 #include "ppc-tdep.h"
31
32 /* round2 rounds x up to the nearest multiple of s assuming that s is a
33    power of 2 */
34
35 #undef round2
36 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
37
38 /* Pass the arguments in either registers, or in the stack. Using the
39    ppc sysv ABI, the first eight words of the argument list (that might
40    be less than eight parameters if some parameters occupy more than one
41    word) are passed in r3..r10 registers.  float and double parameters are
42    passed in fpr's, in addition to that. Rest of the parameters if any
43    are passed in user stack. 
44
45    If the function is returning a structure, then the return address is passed
46    in r3, then the first 7 words of the parametes can be passed in registers,
47    starting from r4. */
48
49 CORE_ADDR
50 ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
51                              int struct_return, CORE_ADDR struct_addr)
52 {
53   int argno;
54   /* Next available general register for non-float, non-vector arguments. */
55   int greg;
56   /* Next available floating point register for float arguments. */
57   int freg;
58   /* Next available vector register for vector arguments. */
59   int vreg;
60   int argstkspace;
61   int structstkspace;
62   int argoffset;
63   int structoffset;
64   struct value *arg;
65   struct type *type;
66   int len;
67   char old_sp_buf[4];
68   CORE_ADDR saved_sp;
69
70   greg = struct_return ? 4 : 3;
71   freg = 1;
72   vreg = 2;
73   argstkspace = 0;
74   structstkspace = 0;
75
76   /* Figure out how much new stack space is required for arguments
77      which don't fit in registers.  Unlike the PowerOpen ABI, the
78      SysV ABI doesn't reserve any extra space for parameters which
79      are put in registers. */
80   for (argno = 0; argno < nargs; argno++)
81     {
82       arg = args[argno];
83       type = check_typedef (VALUE_TYPE (arg));
84       len = TYPE_LENGTH (type);
85
86       if (TYPE_CODE (type) == TYPE_CODE_FLT)
87         {
88           if (freg <= 8)
89             freg++;
90           else
91             {
92               /* SysV ABI converts floats to doubles when placed in
93                  memory and requires 8 byte alignment */
94               if (argstkspace & 0x4)
95                 argstkspace += 4;
96               argstkspace += 8;
97             }
98         }
99       else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)   /* long long */
100         {
101           if (greg > 9)
102             {
103               greg = 11;
104               if (argstkspace & 0x4)
105                 argstkspace += 4;
106               argstkspace += 8;
107             }
108           else
109             {
110               if ((greg & 1) == 0)
111                 greg++;
112               greg += 2;
113             }
114         }
115       else if (!TYPE_VECTOR (type))
116         {
117           if (len > 4
118               || TYPE_CODE (type) == TYPE_CODE_STRUCT
119               || TYPE_CODE (type) == TYPE_CODE_UNION)
120             {
121               /* Rounding to the nearest multiple of 8 may not be necessary,
122                  but it is safe.  Particularly since we don't know the
123                  field types of the structure */
124               structstkspace += round2 (len, 8);
125             }
126           if (greg <= 10)
127             greg++;
128           else
129             argstkspace += 4;
130         }
131       else
132         {
133           if (len == 16
134               && TYPE_CODE (type) == TYPE_CODE_ARRAY
135               && TYPE_VECTOR (type))
136             {
137               if (vreg <= 13)
138                 vreg++;
139               else
140                 {
141                   /* Vector arguments must be aligned to 16 bytes on
142                      the stack. */
143                   argstkspace += round2 (argstkspace, 16);
144                   argstkspace += 16;
145                 }
146             }
147         }
148     }
149
150   /* Get current SP location */
151   saved_sp = read_sp ();
152
153   sp -= argstkspace + structstkspace;
154
155   /* Allocate space for backchain and callee's saved lr */
156   sp -= 8;
157
158   /* Make sure that we maintain 16 byte alignment */
159   sp &= ~0x0f;
160
161   /* Update %sp before proceeding any further */
162   write_register (SP_REGNUM, sp);
163
164   /* write the backchain */
165   store_address (old_sp_buf, 4, saved_sp);
166   write_memory (sp, old_sp_buf, 4);
167
168   argoffset = 8;
169   structoffset = argoffset + argstkspace;
170   freg = 1;
171   greg = 3;
172   vreg = 2;
173   /* Fill in r3 with the return structure, if any */
174   if (struct_return)
175     {
176       char val_buf[4];
177       store_address (val_buf, 4, struct_addr);
178       memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4);
179       greg++;
180     }
181   /* Now fill in the registers and stack... */
182   for (argno = 0; argno < nargs; argno++)
183     {
184       arg = args[argno];
185       type = check_typedef (VALUE_TYPE (arg));
186       len = TYPE_LENGTH (type);
187
188       if (TYPE_CODE (type) == TYPE_CODE_FLT)
189         {
190           if (freg <= 8)
191             {
192               if (len > 8)
193                 printf_unfiltered (
194                                    "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
195               memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + freg)],
196                       VALUE_CONTENTS (arg), len);
197               freg++;
198             }
199           else
200             {
201               /* SysV ABI converts floats to doubles when placed in
202                  memory and requires 8 byte alignment */
203               /* FIXME: Convert floats to doubles */
204               if (argoffset & 0x4)
205                 argoffset += 4;
206               write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
207               argoffset += 8;
208             }
209         }
210       else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)   /* long long */
211         {
212           if (greg > 9)
213             {
214               greg = 11;
215               if (argoffset & 0x4)
216                 argoffset += 4;
217               write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
218               argoffset += 8;
219             }
220           else
221             {
222               if ((greg & 1) == 0)
223                 greg++;
224
225               memcpy (&registers[REGISTER_BYTE (greg)],
226                       VALUE_CONTENTS (arg), 4);
227               memcpy (&registers[REGISTER_BYTE (greg + 1)],
228                       VALUE_CONTENTS (arg) + 4, 4);
229               greg += 2;
230             }
231         }
232       else if (!TYPE_VECTOR (type))
233         {
234           char val_buf[4];
235           if (len > 4
236               || TYPE_CODE (type) == TYPE_CODE_STRUCT
237               || TYPE_CODE (type) == TYPE_CODE_UNION)
238             {
239               write_memory (sp + structoffset, VALUE_CONTENTS (arg), len);
240               store_address (val_buf, 4, sp + structoffset);
241               structoffset += round2 (len, 8);
242             }
243           else
244             {
245               memset (val_buf, 0, 4);
246               memcpy (val_buf, VALUE_CONTENTS (arg), len);
247             }
248           if (greg <= 10)
249             {
250               memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4);
251               greg++;
252             }
253           else
254             {
255               write_memory (sp + argoffset, val_buf, 4);
256               argoffset += 4;
257             }
258         }
259       else
260         {
261           if (len == 16
262               && TYPE_CODE (type) == TYPE_CODE_ARRAY
263               && TYPE_VECTOR (type))
264             {
265               struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
266               char *v_val_buf = alloca (16);
267               memset (v_val_buf, 0, 16);
268               memcpy (v_val_buf, VALUE_CONTENTS (arg), len);
269               if (vreg <= 13)
270                 {
271                   memcpy (&registers[REGISTER_BYTE (tdep->ppc_vr0_regnum
272                                                     + vreg)],
273                           v_val_buf, 16);
274                   vreg++;
275                 }
276               else
277                 {
278                   write_memory (sp + argoffset, v_val_buf, 16);
279                   argoffset += 16;
280                 }
281             }
282         }
283     }
284
285   target_store_registers (-1);
286   return sp;
287 }
288
289 /* Until November 2001, gcc was not complying to the SYSV ABI for 
290    returning structures less than or equal to 8 bytes in size.  It was
291    returning everything in memory.  When this was corrected, it wasn't
292    fixed for native platforms.  */
293 int     
294 ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
295 {  
296   if (TYPE_LENGTH (value_type) == 16 
297       && TYPE_VECTOR (value_type))
298     return 0;                            
299
300   return generic_use_struct_convention (gcc_p, value_type);
301 }
302
303 /* Structures 8 bytes or less long are returned in the r3 & r4
304    registers, according to the SYSV ABI. */
305 int
306 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
307 {
308   if (TYPE_LENGTH (value_type) == 16
309       && TYPE_VECTOR (value_type))
310     return 0;
311
312   return (TYPE_LENGTH (value_type) > 8);
313 }