2003-09-11 Andrew Cagney <cagney@redhat.com>
[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_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
51                               struct regcache *regcache, CORE_ADDR bp_addr,
52                               int nargs, struct value **args, CORE_ADDR sp,
53                               int struct_return, CORE_ADDR struct_addr)
54 {
55   int argno;
56   /* Next available general register for non-float, non-vector arguments. */
57   int greg;
58   /* Next available floating point register for float arguments. */
59   int freg;
60   /* Next available vector register for vector arguments. */
61   int vreg;
62   int argstkspace;
63   int structstkspace;
64   int argoffset;
65   int structoffset;
66   struct type *type;
67   int len;
68   char old_sp_buf[4];
69   CORE_ADDR saved_sp;
70   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
71
72   greg = 3;
73   freg = 1;
74   vreg = 2;
75   argstkspace = 0;
76   structstkspace = 0;
77
78   /* If the function is returning a `struct', then the first word
79      (which will be passed in r3) is used for struct return address.
80      In that case we should advance one word and start from r4
81      register to copy parameters.  */
82   if (struct_return)
83     {
84       regcache_raw_write_signed (regcache, tdep->ppc_gp0_regnum + greg,
85                                  struct_addr);
86       greg++;
87     }
88
89   /* Figure out how much new stack space is required for arguments
90      which don't fit in registers.  Unlike the PowerOpen ABI, the
91      SysV ABI doesn't reserve any extra space for parameters which
92      are put in registers. */
93   for (argno = 0; argno < nargs; argno++)
94     {
95       struct value *arg = args[argno];
96       type = check_typedef (VALUE_TYPE (arg));
97       len = TYPE_LENGTH (type);
98
99       if (TYPE_CODE (type) == TYPE_CODE_FLT
100           && ppc_floating_point_unit_p (current_gdbarch))
101         {
102           if (freg <= 8)
103             freg++;
104           else
105             {
106               /* SysV ABI converts floats to doubles when placed in
107                  memory and requires 8 byte alignment */
108               if (argstkspace & 0x4)
109                 argstkspace += 4;
110               argstkspace += 8;
111             }
112         }
113       else if (len == 8 
114                && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
115                    || (!ppc_floating_point_unit_p (current_gdbarch)
116                        && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
117         {
118           if (greg > 9)
119             {
120               greg = 11;
121               if (argstkspace & 0x4)
122                 argstkspace += 4;
123               argstkspace += 8;
124             }
125           else
126             {
127               if ((greg & 1) == 0)
128                 greg++;
129               greg += 2;
130             }
131         }
132       else if (!TYPE_VECTOR (type))
133         {
134           if (len > 4
135               || TYPE_CODE (type) == TYPE_CODE_STRUCT
136               || TYPE_CODE (type) == TYPE_CODE_UNION)
137             {
138               /* Rounding to the nearest multiple of 8 may not be necessary,
139                  but it is safe.  Particularly since we don't know the
140                  field types of the structure */
141               structstkspace += round2 (len, 8);
142             }
143           if (greg <= 10)
144             greg++;
145           else
146             argstkspace += 4;
147         }
148       else
149         {
150           if (len == 16
151               && TYPE_CODE (type) == TYPE_CODE_ARRAY
152               && TYPE_VECTOR (type))
153             {
154               if (vreg <= 13)
155                 vreg++;
156               else
157                 {
158                   /* Vector arguments must be aligned to 16 bytes on
159                      the stack. */
160                   argstkspace += round2 (argstkspace, 16);
161                   argstkspace += 16;
162                 }
163             }
164           else if (len == 8 
165                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
166                    && TYPE_VECTOR (type))
167             {
168               if (greg <= 10)
169                 greg++;
170               else
171                 {
172                   /* Vector arguments must be aligned to 8 bytes on
173                      the stack. */
174                   argstkspace += round2 (argstkspace, 8);
175                   argstkspace += 8;
176                 }
177             }
178         }
179     }
180
181   /* Get current SP location */
182   saved_sp = read_sp ();
183
184   sp -= argstkspace + structstkspace;
185
186   /* Allocate space for backchain and callee's saved lr */
187   sp -= 8;
188
189   /* Make sure that we maintain 16 byte alignment */
190   sp &= ~0x0f;
191
192   /* Update %sp before proceeding any further.   */
193   regcache_raw_write_signed (regcache, SP_REGNUM, sp);
194
195   /* write the backchain */
196   store_unsigned_integer (old_sp_buf, 4, saved_sp);
197   write_memory (sp, old_sp_buf, 4);
198
199   argoffset = 8;
200   structoffset = argoffset + argstkspace;
201   freg = 1;
202   greg = 3;
203   vreg = 2;
204
205   /* Fill in r3 with the return structure, if any */
206   if (struct_return)
207     {
208       write_register (tdep->ppc_gp0_regnum + greg, struct_addr);
209       greg++;
210     }
211
212   /* Now fill in the registers and stack... */
213   for (argno = 0; argno < nargs; argno++)
214     {
215       struct value *arg = args[argno];
216       char *val = VALUE_CONTENTS (arg);
217       type = check_typedef (VALUE_TYPE (arg));
218       len = TYPE_LENGTH (type);
219
220       if (TYPE_CODE (type) == TYPE_CODE_FLT
221           && ppc_floating_point_unit_p (current_gdbarch))
222         {
223           if (freg <= 8)
224             {
225               ULONGEST regval;
226               if (len > 8)
227                 printf_unfiltered (
228                                    "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
229               regval = extract_unsigned_integer (val, len);
230               write_register (FP0_REGNUM + freg, regval);
231               freg++;
232             }
233           else
234             {
235               /* SysV ABI converts floats to doubles when placed in
236                  memory and requires 8 byte alignment */
237               /* FIXME: Convert floats to doubles */
238               if (argoffset & 0x4)
239                 argoffset += 4;
240               write_memory (sp + argoffset, val, len);
241               argoffset += 8;
242             }
243         }
244       else if (len == 8 
245                && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
246                    || (!ppc_floating_point_unit_p (current_gdbarch)
247                         && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
248         {
249           if (greg > 9)
250             {
251               greg = 11;
252               if (argoffset & 0x4)
253                 argoffset += 4;
254               write_memory (sp + argoffset, val, len);
255               argoffset += 8;
256             }
257           else
258             {
259               ULONGEST regval;
260               if ((greg & 1) == 0)
261                 greg++;
262               regval = extract_unsigned_integer (val, 4);
263               write_register (tdep->ppc_gp0_regnum + greg, regval);
264               regval = extract_unsigned_integer (val + 4, 4);
265               write_register (tdep->ppc_gp0_regnum + greg + 1, regval);
266               greg += 2;
267             }
268         }
269       else if (!TYPE_VECTOR (type))
270         {
271           char val_buf[4];
272           if (len > 4
273               || TYPE_CODE (type) == TYPE_CODE_STRUCT
274               || TYPE_CODE (type) == TYPE_CODE_UNION)
275             {
276               write_memory (sp + structoffset, val, len);
277               store_unsigned_integer (val_buf, 4, sp + structoffset);
278               structoffset += round2 (len, 8);
279             }
280           else
281             {
282               memset (val_buf, 0, 4);
283               memcpy (val_buf, val, len);
284             }
285           if (greg <= 10)
286             {
287               ULONGEST regval = extract_unsigned_integer (val_buf, 4);
288               write_register (tdep->ppc_gp0_regnum + greg, regval);
289               greg++;
290             }
291           else
292             {
293               write_memory (sp + argoffset, val_buf, 4);
294               argoffset += 4;
295             }
296         }
297       else
298         {
299           if (len == 16
300               && TYPE_CODE (type) == TYPE_CODE_ARRAY
301               && TYPE_VECTOR (type))
302             {
303               char *v_val_buf = alloca (16);
304               memset (v_val_buf, 0, 16);
305               memcpy (v_val_buf, val, len);
306               if (vreg <= 13)
307                 {
308                   regcache_cooked_write (current_regcache,
309                                          tdep->ppc_vr0_regnum + vreg,
310                                          v_val_buf);
311                   vreg++;
312                 }
313               else
314                 {
315                   write_memory (sp + argoffset, v_val_buf, 16);
316                   argoffset += 16;
317                 }
318             }
319           else if (len == 8 
320                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
321                    && TYPE_VECTOR (type))
322             {
323               char *v_val_buf = alloca (8);
324               memset (v_val_buf, 0, 8);
325               memcpy (v_val_buf, val, len);
326               if (greg <= 10)
327                 {
328                   regcache_cooked_write (current_regcache,
329                                          tdep->ppc_ev0_regnum + greg,
330                                          v_val_buf);
331                   greg++;
332                 }
333               else
334                 {
335                   write_memory (sp + argoffset, v_val_buf, 8);
336                   argoffset += 8;
337                 }
338             }
339         }
340     }
341
342   /* Point the inferior function call's return address at the dummy's
343      breakpoint.  */
344   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
345
346   target_store_registers (-1);
347   return sp;
348 }
349
350 /* Until November 2001, gcc was not complying to the SYSV ABI for 
351    returning structures less than or equal to 8 bytes in size.  It was
352    returning everything in memory.  When this was corrected, it wasn't
353    fixed for native platforms.  */
354 int     
355 ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
356 {  
357   if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
358       && TYPE_VECTOR (value_type))
359     return 0;                            
360
361   return generic_use_struct_convention (gcc_p, value_type);
362 }
363
364 /* Structures 8 bytes or less long are returned in the r3 & r4
365    registers, according to the SYSV ABI. */
366 int
367 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
368 {
369   if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
370       && TYPE_VECTOR (value_type))
371     return 0;
372
373   return (TYPE_LENGTH (value_type) > 8);
374 }