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