1 /* Copyright (C) 2012-2024 Free Software Foundation, Inc.
3 This file is part of GDB.
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.
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.
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/>. */
24 #include "target-float.h"
26 #include "xcoffread.h"
28 /* Implement the "push_dummy_call" gdbarch method. */
31 rs6000_lynx178_push_dummy_call (struct gdbarch
*gdbarch
,
32 struct value
*function
,
33 struct regcache
*regcache
, CORE_ADDR bp_addr
,
34 int nargs
, struct value
**args
, CORE_ADDR sp
,
35 function_call_return_method return_method
,
36 CORE_ADDR struct_addr
)
38 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
39 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
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
= tdep
->wordsize
;
48 struct value
*arg
= 0;
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
));
58 /* The first eight words of ther arguments are passed in registers.
59 Copy them appropriately. */
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 (return_method
== return_method_struct
)
68 regcache_raw_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
73 /* Effectively indirect call... gcc does...
75 return_val example( float, int);
78 float in fp0, int in r3
79 offset of stack on overflow 8/16
80 for varargs, must go by type.
82 float in r3&r4, int in r5
83 offset of stack on overflow different
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. */
90 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
92 int reg_size
= register_size (gdbarch
, ii
+ 3);
95 type
= check_typedef (arg
->type ());
96 len
= type
->length ();
98 if (type
->code () == TYPE_CODE_FLT
)
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.
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
);
111 gdb_assert (len
<= 8);
113 target_float_convert (arg
->contents ().data (), type
, reg_val
,
115 regcache
->cooked_write (fp_regnum
, reg_val
);
122 /* Argument takes more than one register. */
123 while (argbytes
< len
)
125 gdb_byte word
[PPC_MAX_REGISTER_SIZE
];
126 memset (word
, 0, reg_size
);
128 ((char *) arg
->contents ().data ()) + argbytes
,
129 (len
- argbytes
) > reg_size
130 ? reg_size
: len
- argbytes
);
131 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3 + ii
, word
);
132 ++ii
, argbytes
+= reg_size
;
135 goto ran_out_of_registers_for_arguments
;
142 /* Argument can fit in one register. No problem. */
143 gdb_byte word
[PPC_MAX_REGISTER_SIZE
];
145 memset (word
, 0, reg_size
);
146 memcpy (word
, arg
->contents ().data (), len
);
147 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
152 ran_out_of_registers_for_arguments
:
154 regcache_cooked_read_unsigned (regcache
,
155 gdbarch_sp_regnum (gdbarch
),
158 /* Location for 8 parameters are always reserved. */
161 /* Another six words for back chain, TOC register, link register, etc. */
164 /* Stack pointer must be quadword aligned. */
165 sp
= align_down (sp
, 16);
167 /* If there are more arguments, allocate space for them in
168 the stack, then push them starting from the ninth one. */
170 if ((argno
< nargs
) || argbytes
)
176 space
+= align_up (len
- argbytes
, 4);
182 for (; jj
< nargs
; ++jj
)
184 struct value
*val
= args
[jj
];
186 space
+= align_up (val
->type ()->length (), 4);
189 /* Add location required for the rest of the parameters. */
190 space
= align_up (space
, 16);
193 /* This is another instance we need to be concerned about
194 securing our stack space. If we write anything underneath %sp
195 (r1), we might conflict with the kernel who thinks he is free
196 to use this area. So, update %sp first before doing anything
199 regcache_raw_write_signed (regcache
,
200 gdbarch_sp_regnum (gdbarch
), sp
);
202 /* If the last argument copied into the registers didn't fit there
203 completely, push the rest of it into stack. */
207 write_memory (sp
+ 24 + (ii
* 4),
208 arg
->contents ().data () + argbytes
,
211 ii
+= align_up (len
- argbytes
, 4) / 4;
214 /* Push the rest of the arguments into stack. */
215 for (; argno
< nargs
; ++argno
)
219 type
= check_typedef (arg
->type ());
220 len
= type
->length ();
223 /* Float types should be passed in fpr's, as well as in the
225 if (type
->code () == TYPE_CODE_FLT
&& f_argno
< 13)
228 gdb_assert (len
<= 8);
230 regcache
->cooked_write (tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
231 arg
->contents ().data ());
235 write_memory (sp
+ 24 + (ii
* 4), arg
->contents ().data (), len
);
236 ii
+= align_up (len
, 4) / 4;
240 /* Set the stack pointer. According to the ABI, the SP is meant to
241 be set _before_ the corresponding stack space is used. On AIX,
242 this even applies when the target has been completely stopped!
243 Not doing this can lead to conflicts with the kernel which thinks
244 that it still has control over this not-yet-allocated stack
246 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
248 /* Set back chain properly. */
249 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
250 write_memory (sp
, tmp_buffer
, wordsize
);
252 /* Point the inferior function call's return address at the dummy's
254 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
256 target_store_registers (regcache
, -1);
260 /* Implement the "return_value" gdbarch method. */
262 static enum return_value_convention
263 rs6000_lynx178_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
264 struct type
*valtype
, struct regcache
*regcache
,
265 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
267 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
268 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
270 /* The calling convention this function implements assumes the
271 processor has floating-point registers. We shouldn't be using it
272 on PowerPC variants that lack them. */
273 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
275 /* AltiVec extension: Functions that declare a vector data type as a
276 return value place that return value in VR2. */
277 if (valtype
->code () == TYPE_CODE_ARRAY
&& valtype
->is_vector ()
278 && valtype
->length () == 16)
281 regcache
->cooked_read (tdep
->ppc_vr0_regnum
+ 2, readbuf
);
283 regcache
->cooked_write (tdep
->ppc_vr0_regnum
+ 2, writebuf
);
285 return RETURN_VALUE_REGISTER_CONVENTION
;
288 /* If the called subprogram returns an aggregate, there exists an
289 implicit first argument, whose value is the address of a caller-
290 allocated buffer into which the callee is assumed to store its
291 return value. All explicit parameters are appropriately
293 if (valtype
->code () == TYPE_CODE_STRUCT
294 || valtype
->code () == TYPE_CODE_UNION
295 || valtype
->code () == TYPE_CODE_ARRAY
)
296 return RETURN_VALUE_STRUCT_CONVENTION
;
298 /* Scalar floating-point values are returned in FPR1 for float or
299 double, and in FPR1:FPR2 for quadword precision. Fortran
300 complex*8 and complex*16 are returned in FPR1:FPR2, and
301 complex*32 is returned in FPR1:FPR4. */
302 if (valtype
->code () == TYPE_CODE_FLT
303 && (valtype
->length () == 4 || valtype
->length () == 8))
305 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
308 /* FIXME: kettenis/2007-01-01: Add support for quadword
309 precision and complex. */
313 regcache
->cooked_read (tdep
->ppc_fp0_regnum
+ 1, regval
);
314 target_float_convert (regval
, regtype
, readbuf
, valtype
);
318 target_float_convert (writebuf
, valtype
, regval
, regtype
);
319 regcache
->cooked_write (tdep
->ppc_fp0_regnum
+ 1, regval
);
322 return RETURN_VALUE_REGISTER_CONVENTION
;
325 /* Values of the types int, long, short, pointer, and char (length
326 is less than or equal to four bytes), as well as bit values of
327 lengths less than or equal to 32 bits, must be returned right
328 justified in GPR3 with signed values sign extended and unsigned
329 values zero extended, as necessary. */
330 if (valtype
->length () <= tdep
->wordsize
)
336 /* For reading we don't have to worry about sign extension. */
337 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
339 store_unsigned_integer (readbuf
, valtype
->length (), byte_order
,
344 /* For writing, use unpack_long since that should handle any
345 required sign extension. */
346 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
347 unpack_long (valtype
, writebuf
));
350 return RETURN_VALUE_REGISTER_CONVENTION
;
353 /* Eight-byte non-floating-point scalar values must be returned in
356 if (valtype
->length () == 8)
358 gdb_assert (valtype
->code () != TYPE_CODE_FLT
);
359 gdb_assert (tdep
->wordsize
== 4);
365 regcache
->cooked_read (tdep
->ppc_gp0_regnum
+ 3, regval
);
366 regcache
->cooked_read (tdep
->ppc_gp0_regnum
+ 4, regval
+ 4);
367 memcpy (readbuf
, regval
, 8);
371 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3, writebuf
);
372 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 4, writebuf
+ 4);
375 return RETURN_VALUE_REGISTER_CONVENTION
;
378 return RETURN_VALUE_STRUCT_CONVENTION
;
381 /* PowerPC Lynx178 OSABI sniffer. */
383 static enum gdb_osabi
384 rs6000_lynx178_osabi_sniffer (bfd
*abfd
)
386 if (bfd_get_flavour (abfd
) != bfd_target_xcoff_flavour
)
387 return GDB_OSABI_UNKNOWN
;
389 /* The only noticeable difference between Lynx178 XCOFF files and
390 AIX XCOFF files comes from the fact that there are no shared
391 libraries on Lynx178. So if the number of import files is
392 different from zero, it cannot be a Lynx178 binary. */
393 if (xcoff_get_n_import_files (abfd
) != 0)
394 return GDB_OSABI_UNKNOWN
;
396 return GDB_OSABI_LYNXOS178
;
399 /* Callback for powerpc-lynx178 initialization. */
402 rs6000_lynx178_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
404 set_gdbarch_push_dummy_call (gdbarch
, rs6000_lynx178_push_dummy_call
);
405 set_gdbarch_return_value (gdbarch
, rs6000_lynx178_return_value
);
406 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
409 void _initialize_rs6000_lynx178_tdep ();
411 _initialize_rs6000_lynx178_tdep ()
413 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
414 bfd_target_xcoff_flavour
,
415 rs6000_lynx178_osabi_sniffer
);
416 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_LYNXOS178
,
417 rs6000_lynx178_init_osabi
);