]> Git Repo - binutils.git/blob - gdb/rs6000-lynx178-tdep.c
Automatic date update in version.in
[binutils.git] / gdb / rs6000-lynx178-tdep.c
1 /* Copyright (C) 2012-2022 Free Software Foundation, Inc.
2
3    This file is part of GDB.
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 3 of the License, or
8    (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17
18 #include "defs.h"
19 #include "osabi.h"
20 #include "regcache.h"
21 #include "gdbcore.h"
22 #include "gdbtypes.h"
23 #include "infcall.h"
24 #include "ppc-tdep.h"
25 #include "target-float.h"
26 #include "value.h"
27 #include "xcoffread.h"
28
29 /* Implement the "push_dummy_call" gdbarch method.  */
30
31 static CORE_ADDR
32 rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
33                                 struct value *function,
34                                 struct regcache *regcache, CORE_ADDR bp_addr,
35                                 int nargs, struct value **args, CORE_ADDR sp,
36                                 function_call_return_method return_method,
37                                 CORE_ADDR struct_addr)
38 {
39   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
40   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
41   int ii;
42   int len = 0;
43   int argno;                    /* current argument number */
44   int argbytes;                 /* current argument byte */
45   gdb_byte tmp_buffer[50];
46   int f_argno = 0;              /* current floating point argno */
47   int wordsize = tdep->wordsize;
48
49   struct value *arg = 0;
50   struct type *type;
51
52   ULONGEST saved_sp;
53
54   /* The calling convention this function implements assumes the
55      processor has floating-point registers.  We shouldn't be using it
56      on PPC variants that lack them.  */
57   gdb_assert (ppc_floating_point_unit_p (gdbarch));
58
59   /* The first eight words of ther arguments are passed in registers.
60      Copy them appropriately.  */
61   ii = 0;
62
63   /* If the function is returning a `struct', then the first word
64      (which will be passed in r3) is used for struct return address.
65      In that case we should advance one word and start from r4
66      register to copy parameters.  */
67   if (return_method == return_method_struct)
68     {
69       regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
70                                    struct_addr);
71       ii++;
72     }
73
74   /* Effectively indirect call... gcc does...
75
76      return_val example( float, int);
77
78      eabi:
79      float in fp0, int in r3
80      offset of stack on overflow 8/16
81      for varargs, must go by type.
82      power open:
83      float in r3&r4, int in r5
84      offset of stack on overflow different
85      both:
86      return in r3 or f0.  If no float, must study how gcc emulates floats;
87      pay attention to arg promotion.
88      User may have to cast\args to handle promotion correctly
89      since gdb won't know if prototype supplied or not.  */
90
91   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
92     {
93       int reg_size = register_size (gdbarch, ii + 3);
94
95       arg = args[argno];
96       type = check_typedef (value_type (arg));
97       len = type->length ();
98
99       if (type->code () == TYPE_CODE_FLT)
100         {
101
102           /* Floating point arguments are passed in fpr's, as well as gpr's.
103              There are 13 fpr's reserved for passing parameters.  At this point
104              there is no way we would run out of them.
105
106              Always store the floating point value using the register's
107              floating-point format.  */
108           const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
109           gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
110           struct type *reg_type = register_type (gdbarch, fp_regnum);
111
112           gdb_assert (len <= 8);
113
114           target_float_convert (value_contents (arg).data (), type, reg_val,
115                                 reg_type);
116           regcache->cooked_write (fp_regnum, reg_val);
117           ++f_argno;
118         }
119
120       if (len > reg_size)
121         {
122
123           /* Argument takes more than one register.  */
124           while (argbytes < len)
125             {
126               gdb_byte word[PPC_MAX_REGISTER_SIZE];
127               memset (word, 0, reg_size);
128               memcpy (word,
129                       ((char *) value_contents (arg).data ()) + argbytes,
130                       (len - argbytes) > reg_size
131                         ? reg_size : len - argbytes);
132               regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word);
133               ++ii, argbytes += reg_size;
134
135               if (ii >= 8)
136                 goto ran_out_of_registers_for_arguments;
137             }
138           argbytes = 0;
139           --ii;
140         }
141       else
142         {
143           /* Argument can fit in one register.  No problem.  */
144           gdb_byte word[PPC_MAX_REGISTER_SIZE];
145
146           memset (word, 0, reg_size);
147           memcpy (word, value_contents (arg).data (), len);
148           regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word);
149         }
150       ++argno;
151     }
152
153 ran_out_of_registers_for_arguments:
154
155   regcache_cooked_read_unsigned (regcache,
156                                  gdbarch_sp_regnum (gdbarch),
157                                  &saved_sp);
158
159   /* Location for 8 parameters are always reserved.  */
160   sp -= wordsize * 8;
161
162   /* Another six words for back chain, TOC register, link register, etc.  */
163   sp -= wordsize * 6;
164
165   /* Stack pointer must be quadword aligned.  */
166   sp = align_down (sp, 16);
167
168   /* If there are more arguments, allocate space for them in
169      the stack, then push them starting from the ninth one.  */
170
171   if ((argno < nargs) || argbytes)
172     {
173       int space = 0, jj;
174
175       if (argbytes)
176         {
177           space += align_up (len - argbytes, 4);
178           jj = argno + 1;
179         }
180       else
181         jj = argno;
182
183       for (; jj < nargs; ++jj)
184         {
185           struct value *val = args[jj];
186
187           space += align_up (value_type (val)->length (), 4);
188         }
189
190       /* Add location required for the rest of the parameters.  */
191       space = align_up (space, 16);
192       sp -= space;
193
194       /* This is another instance we need to be concerned about
195          securing our stack space.  If we write anything underneath %sp
196          (r1), we might conflict with the kernel who thinks he is free
197          to use this area.  So, update %sp first before doing anything
198          else.  */
199
200       regcache_raw_write_signed (regcache,
201                                  gdbarch_sp_regnum (gdbarch), sp);
202
203       /* If the last argument copied into the registers didn't fit there
204          completely, push the rest of it into stack.  */
205
206       if (argbytes)
207         {
208           write_memory (sp + 24 + (ii * 4),
209                         value_contents (arg).data () + argbytes,
210                         len - argbytes);
211           ++argno;
212           ii += align_up (len - argbytes, 4) / 4;
213         }
214
215       /* Push the rest of the arguments into stack.  */
216       for (; argno < nargs; ++argno)
217         {
218
219           arg = args[argno];
220           type = check_typedef (value_type (arg));
221           len = type->length ();
222
223
224           /* Float types should be passed in fpr's, as well as in the
225              stack.  */
226           if (type->code () == TYPE_CODE_FLT && f_argno < 13)
227             {
228
229               gdb_assert (len <= 8);
230
231               regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno,
232                                       value_contents (arg).data ());
233               ++f_argno;
234             }
235
236           write_memory (sp + 24 + (ii * 4), value_contents (arg).data (), len);
237           ii += align_up (len, 4) / 4;
238         }
239     }
240
241   /* Set the stack pointer.  According to the ABI, the SP is meant to
242      be set _before_ the corresponding stack space is used.  On AIX,
243      this even applies when the target has been completely stopped!
244      Not doing this can lead to conflicts with the kernel which thinks
245      that it still has control over this not-yet-allocated stack
246      region.  */
247   regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
248
249   /* Set back chain properly.  */
250   store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
251   write_memory (sp, tmp_buffer, wordsize);
252
253   /* Point the inferior function call's return address at the dummy's
254      breakpoint.  */
255   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
256
257   target_store_registers (regcache, -1);
258   return sp;
259 }
260
261 /* Implement the "return_value" gdbarch method.  */
262
263 static enum return_value_convention
264 rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
265                              struct type *valtype, struct regcache *regcache,
266                              gdb_byte *readbuf, const gdb_byte *writebuf)
267 {
268   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
269   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
270
271   /* The calling convention this function implements assumes the
272      processor has floating-point registers.  We shouldn't be using it
273      on PowerPC variants that lack them.  */
274   gdb_assert (ppc_floating_point_unit_p (gdbarch));
275
276   /* AltiVec extension: Functions that declare a vector data type as a
277      return value place that return value in VR2.  */
278   if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
279       && valtype->length () == 16)
280     {
281       if (readbuf)
282         regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf);
283       if (writebuf)
284         regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);
285
286       return RETURN_VALUE_REGISTER_CONVENTION;
287     }
288
289   /* If the called subprogram returns an aggregate, there exists an
290      implicit first argument, whose value is the address of a caller-
291      allocated buffer into which the callee is assumed to store its
292      return value.  All explicit parameters are appropriately
293      relabeled.  */
294   if (valtype->code () == TYPE_CODE_STRUCT
295       || valtype->code () == TYPE_CODE_UNION
296       || valtype->code () == TYPE_CODE_ARRAY)
297     return RETURN_VALUE_STRUCT_CONVENTION;
298
299   /* Scalar floating-point values are returned in FPR1 for float or
300      double, and in FPR1:FPR2 for quadword precision.  Fortran
301      complex*8 and complex*16 are returned in FPR1:FPR2, and
302      complex*32 is returned in FPR1:FPR4.  */
303   if (valtype->code () == TYPE_CODE_FLT
304       && (valtype->length () == 4 || valtype->length () == 8))
305     {
306       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
307       gdb_byte regval[8];
308
309       /* FIXME: kettenis/2007-01-01: Add support for quadword
310          precision and complex.  */
311
312       if (readbuf)
313         {
314           regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval);
315           target_float_convert (regval, regtype, readbuf, valtype);
316         }
317       if (writebuf)
318         {
319           target_float_convert (writebuf, valtype, regval, regtype);
320           regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
321         }
322
323       return RETURN_VALUE_REGISTER_CONVENTION;
324   }
325
326   /* Values of the types int, long, short, pointer, and char (length
327      is less than or equal to four bytes), as well as bit values of
328      lengths less than or equal to 32 bits, must be returned right
329      justified in GPR3 with signed values sign extended and unsigned
330      values zero extended, as necessary.  */
331   if (valtype->length () <= tdep->wordsize)
332     {
333       if (readbuf)
334         {
335           ULONGEST regval;
336
337           /* For reading we don't have to worry about sign extension.  */
338           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
339                                          &regval);
340           store_unsigned_integer (readbuf, valtype->length (), byte_order,
341                                   regval);
342         }
343       if (writebuf)
344         {
345           /* For writing, use unpack_long since that should handle any
346              required sign extension.  */
347           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
348                                           unpack_long (valtype, writebuf));
349         }
350
351       return RETURN_VALUE_REGISTER_CONVENTION;
352     }
353
354   /* Eight-byte non-floating-point scalar values must be returned in
355      GPR3:GPR4.  */
356
357   if (valtype->length () == 8)
358     {
359       gdb_assert (valtype->code () != TYPE_CODE_FLT);
360       gdb_assert (tdep->wordsize == 4);
361
362       if (readbuf)
363         {
364           gdb_byte regval[8];
365
366           regcache->cooked_read (tdep->ppc_gp0_regnum + 3, regval);
367           regcache->cooked_read (tdep->ppc_gp0_regnum + 4, regval + 4);
368           memcpy (readbuf, regval, 8);
369         }
370       if (writebuf)
371         {
372           regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
373           regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
374         }
375
376       return RETURN_VALUE_REGISTER_CONVENTION;
377     }
378
379   return RETURN_VALUE_STRUCT_CONVENTION;
380 }
381
382 /* PowerPC Lynx178 OSABI sniffer.  */
383
384 static enum gdb_osabi
385 rs6000_lynx178_osabi_sniffer (bfd *abfd)
386 {
387   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
388     return GDB_OSABI_UNKNOWN;
389
390   /* The only noticeable difference between Lynx178 XCOFF files and
391      AIX XCOFF files comes from the fact that there are no shared
392      libraries on Lynx178.  So if the number of import files is
393      different from zero, it cannot be a Lynx178 binary.  */
394   if (xcoff_get_n_import_files (abfd) != 0)
395     return GDB_OSABI_UNKNOWN;
396
397   return GDB_OSABI_LYNXOS178;
398 }
399
400 /* Callback for powerpc-lynx178 initialization.  */
401
402 static void
403 rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
404 {
405   set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
406   set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
407   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
408 }
409
410 void _initialize_rs6000_lynx178_tdep ();
411 void
412 _initialize_rs6000_lynx178_tdep ()
413 {
414   gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
415                                   bfd_target_xcoff_flavour,
416                                   rs6000_lynx178_osabi_sniffer);
417   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
418                           rs6000_lynx178_init_osabi);
419 }
420
This page took 0.046067 seconds and 4 git commands to generate.