[PowerPC] Consolidate linux vector regset sizes
[deliverable/binutils-gdb.git] / gdb / rs6000-aix-tdep.c
CommitLineData
1f82754b
JB
1/* Native support code for PPC AIX, for GDB the GNU debugger.
2
e2882c85 3 Copyright (C) 2006-2018 Free Software Foundation, Inc.
1f82754b
JB
4
5 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
1f82754b
JB
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
1f82754b
JB
21
22#include "defs.h"
23#include "osabi.h"
7a61a01c
UW
24#include "regcache.h"
25#include "regset.h"
4a7622d1
UW
26#include "gdbtypes.h"
27#include "gdbcore.h"
28#include "target.h"
29#include "value.h"
30#include "infcall.h"
31#include "objfiles.h"
32#include "breakpoint.h"
1f82754b 33#include "rs6000-tdep.h"
6f7f3f0d 34#include "ppc-tdep.h"
356a5233 35#include "rs6000-aix-tdep.h"
d5367fe1 36#include "xcoffread.h"
4d1eb6b4
JB
37#include "solib.h"
38#include "solib-aix.h"
3b2ca824 39#include "target-float.h"
356a5233 40#include "xml-utils.h"
4a7622d1
UW
41
42/* If the kernel has to deliver a signal, it pushes a sigcontext
43 structure on the stack and then calls the signal handler, passing
0df8b418 44 the address of the sigcontext in an argument register. Usually
4a7622d1
UW
45 the signal handler doesn't save this register, so we have to
46 access the sigcontext structure via an offset from the signal handler
47 frame.
48 The following constants were determined by experimentation on AIX 3.2. */
49#define SIG_FRAME_PC_OFFSET 96
50#define SIG_FRAME_LR_OFFSET 108
51#define SIG_FRAME_FP_OFFSET 284
52
7a61a01c
UW
53
54/* Core file support. */
55
56static struct ppc_reg_offsets rs6000_aix32_reg_offsets =
57{
58 /* General-purpose registers. */
59 208, /* r0_offset */
f2db237a
AM
60 4, /* gpr_size */
61 4, /* xr_size */
7a61a01c
UW
62 24, /* pc_offset */
63 28, /* ps_offset */
64 32, /* cr_offset */
65 36, /* lr_offset */
66 40, /* ctr_offset */
67 44, /* xer_offset */
68 48, /* mq_offset */
69
70 /* Floating-point registers. */
71 336, /* f0_offset */
72 56, /* fpscr_offset */
f2db237a 73 4, /* fpscr_size */
7a61a01c
UW
74
75 /* AltiVec registers. */
76 -1, /* vr0_offset */
77 -1, /* vscr_offset */
78 -1 /* vrsave_offset */
79};
80
81static struct ppc_reg_offsets rs6000_aix64_reg_offsets =
82{
83 /* General-purpose registers. */
84 0, /* r0_offset */
f2db237a
AM
85 8, /* gpr_size */
86 4, /* xr_size */
7a61a01c
UW
87 264, /* pc_offset */
88 256, /* ps_offset */
89 288, /* cr_offset */
90 272, /* lr_offset */
91 280, /* ctr_offset */
92 292, /* xer_offset */
93 -1, /* mq_offset */
94
95 /* Floating-point registers. */
96 312, /* f0_offset */
97 296, /* fpscr_offset */
f2db237a 98 4, /* fpscr_size */
7a61a01c
UW
99
100 /* AltiVec registers. */
101 -1, /* vr0_offset */
102 -1, /* vscr_offset */
103 -1 /* vrsave_offset */
104};
105
106
107/* Supply register REGNUM in the general-purpose register set REGSET
108 from the buffer specified by GREGS and LEN to register cache
109 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
110
111static void
112rs6000_aix_supply_regset (const struct regset *regset,
113 struct regcache *regcache, int regnum,
114 const void *gregs, size_t len)
115{
116 ppc_supply_gregset (regset, regcache, regnum, gregs, len);
f2db237a 117 ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
7a61a01c
UW
118}
119
120/* Collect register REGNUM in the general-purpose register set
0df8b418 121 REGSET, from register cache REGCACHE into the buffer specified by
7a61a01c
UW
122 GREGS and LEN. If REGNUM is -1, do this for all registers in
123 REGSET. */
124
125static void
126rs6000_aix_collect_regset (const struct regset *regset,
127 const struct regcache *regcache, int regnum,
128 void *gregs, size_t len)
129{
130 ppc_collect_gregset (regset, regcache, regnum, gregs, len);
f2db237a 131 ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
7a61a01c
UW
132}
133
134/* AIX register set. */
135
3ca7dae4 136static const struct regset rs6000_aix32_regset =
7a61a01c
UW
137{
138 &rs6000_aix32_reg_offsets,
139 rs6000_aix_supply_regset,
140 rs6000_aix_collect_regset,
141};
142
3ca7dae4 143static const struct regset rs6000_aix64_regset =
7a61a01c
UW
144{
145 &rs6000_aix64_reg_offsets,
146 rs6000_aix_supply_regset,
147 rs6000_aix_collect_regset,
148};
149
23ea9aeb 150/* Iterate over core file register note sections. */
7a61a01c 151
23ea9aeb
AA
152static void
153rs6000_aix_iterate_over_regset_sections (struct gdbarch *gdbarch,
154 iterate_over_regset_sections_cb *cb,
155 void *cb_data,
156 const struct regcache *regcache)
7a61a01c
UW
157{
158 if (gdbarch_tdep (gdbarch)->wordsize == 4)
23ea9aeb 159 cb (".reg", 592, &rs6000_aix32_regset, NULL, cb_data);
7a61a01c 160 else
23ea9aeb 161 cb (".reg", 576, &rs6000_aix64_regset, NULL, cb_data);
7a61a01c
UW
162}
163
164
0df8b418 165/* Pass the arguments in either registers, or in the stack. In RS/6000,
4a7622d1
UW
166 the first eight words of the argument list (that might be less than
167 eight parameters if some parameters occupy more than one word) are
0df8b418 168 passed in r3..r10 registers. Float and double parameters are
4a7622d1
UW
169 passed in fpr's, in addition to that. Rest of the parameters if any
170 are passed in user stack. There might be cases in which half of the
171 parameter is copied into registers, the other half is pushed into
172 stack.
173
174 Stack must be aligned on 64-bit boundaries when synthesizing
175 function calls.
176
177 If the function is returning a structure, then the return address is passed
178 in r3, then the first 7 words of the parameters can be passed in registers,
179 starting from r4. */
180
181static CORE_ADDR
182rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
183 struct regcache *regcache, CORE_ADDR bp_addr,
184 int nargs, struct value **args, CORE_ADDR sp,
185 int struct_return, CORE_ADDR struct_addr)
186{
187 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
e17a4113 188 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4a7622d1
UW
189 int ii;
190 int len = 0;
191 int argno; /* current argument number */
192 int argbytes; /* current argument byte */
193 gdb_byte tmp_buffer[50];
194 int f_argno = 0; /* current floating point argno */
195 int wordsize = gdbarch_tdep (gdbarch)->wordsize;
196 CORE_ADDR func_addr = find_function_addr (function, NULL);
197
198 struct value *arg = 0;
199 struct type *type;
200
201 ULONGEST saved_sp;
202
203 /* The calling convention this function implements assumes the
204 processor has floating-point registers. We shouldn't be using it
205 on PPC variants that lack them. */
206 gdb_assert (ppc_floating_point_unit_p (gdbarch));
207
208 /* The first eight words of ther arguments are passed in registers.
209 Copy them appropriately. */
210 ii = 0;
211
212 /* If the function is returning a `struct', then the first word
213 (which will be passed in r3) is used for struct return address.
214 In that case we should advance one word and start from r4
215 register to copy parameters. */
216 if (struct_return)
217 {
218 regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
219 struct_addr);
220 ii++;
221 }
222
0df8b418 223/* effectively indirect call... gcc does...
4a7622d1
UW
224
225 return_val example( float, int);
226
227 eabi:
228 float in fp0, int in r3
229 offset of stack on overflow 8/16
230 for varargs, must go by type.
231 power open:
232 float in r3&r4, int in r5
233 offset of stack on overflow different
234 both:
235 return in r3 or f0. If no float, must study how gcc emulates floats;
0df8b418 236 pay attention to arg promotion.
4a7622d1 237 User may have to cast\args to handle promotion correctly
0df8b418 238 since gdb won't know if prototype supplied or not. */
4a7622d1
UW
239
240 for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
241 {
242 int reg_size = register_size (gdbarch, ii + 3);
243
244 arg = args[argno];
245 type = check_typedef (value_type (arg));
246 len = TYPE_LENGTH (type);
247
248 if (TYPE_CODE (type) == TYPE_CODE_FLT)
249 {
4a7622d1 250 /* Floating point arguments are passed in fpr's, as well as gpr's.
0df8b418 251 There are 13 fpr's reserved for passing parameters. At this point
36d1c68c
JB
252 there is no way we would run out of them.
253
254 Always store the floating point value using the register's
255 floating-point format. */
256 const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
0f068fb5 257 gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
36d1c68c 258 struct type *reg_type = register_type (gdbarch, fp_regnum);
4a7622d1
UW
259
260 gdb_assert (len <= 8);
261
3b2ca824 262 target_float_convert (value_contents (arg), type, reg_val, reg_type);
36d1c68c 263 regcache_cooked_write (regcache, fp_regnum, reg_val);
4a7622d1
UW
264 ++f_argno;
265 }
266
267 if (len > reg_size)
268 {
269
270 /* Argument takes more than one register. */
271 while (argbytes < len)
272 {
0f068fb5 273 gdb_byte word[PPC_MAX_REGISTER_SIZE];
4a7622d1
UW
274 memset (word, 0, reg_size);
275 memcpy (word,
276 ((char *) value_contents (arg)) + argbytes,
277 (len - argbytes) > reg_size
278 ? reg_size : len - argbytes);
279 regcache_cooked_write (regcache,
280 tdep->ppc_gp0_regnum + 3 + ii,
281 word);
282 ++ii, argbytes += reg_size;
283
284 if (ii >= 8)
285 goto ran_out_of_registers_for_arguments;
286 }
287 argbytes = 0;
288 --ii;
289 }
290 else
291 {
292 /* Argument can fit in one register. No problem. */
0f068fb5 293 gdb_byte word[PPC_MAX_REGISTER_SIZE];
4a7622d1
UW
294
295 memset (word, 0, reg_size);
296 memcpy (word, value_contents (arg), len);
297 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
298 }
299 ++argno;
300 }
301
302ran_out_of_registers_for_arguments:
303
304 regcache_cooked_read_unsigned (regcache,
305 gdbarch_sp_regnum (gdbarch),
306 &saved_sp);
307
308 /* Location for 8 parameters are always reserved. */
309 sp -= wordsize * 8;
310
311 /* Another six words for back chain, TOC register, link register, etc. */
312 sp -= wordsize * 6;
313
314 /* Stack pointer must be quadword aligned. */
315 sp &= -16;
316
317 /* If there are more arguments, allocate space for them in
318 the stack, then push them starting from the ninth one. */
319
320 if ((argno < nargs) || argbytes)
321 {
322 int space = 0, jj;
323
324 if (argbytes)
325 {
326 space += ((len - argbytes + 3) & -4);
327 jj = argno + 1;
328 }
329 else
330 jj = argno;
331
332 for (; jj < nargs; ++jj)
333 {
334 struct value *val = args[jj];
335 space += ((TYPE_LENGTH (value_type (val))) + 3) & -4;
336 }
337
338 /* Add location required for the rest of the parameters. */
339 space = (space + 15) & -16;
340 sp -= space;
341
342 /* This is another instance we need to be concerned about
0df8b418 343 securing our stack space. If we write anything underneath %sp
4a7622d1
UW
344 (r1), we might conflict with the kernel who thinks he is free
345 to use this area. So, update %sp first before doing anything
346 else. */
347
348 regcache_raw_write_signed (regcache,
349 gdbarch_sp_regnum (gdbarch), sp);
350
351 /* If the last argument copied into the registers didn't fit there
352 completely, push the rest of it into stack. */
353
354 if (argbytes)
355 {
356 write_memory (sp + 24 + (ii * 4),
357 value_contents (arg) + argbytes,
358 len - argbytes);
359 ++argno;
360 ii += ((len - argbytes + 3) & -4) / 4;
361 }
362
363 /* Push the rest of the arguments into stack. */
364 for (; argno < nargs; ++argno)
365 {
366
367 arg = args[argno];
368 type = check_typedef (value_type (arg));
369 len = TYPE_LENGTH (type);
370
371
372 /* Float types should be passed in fpr's, as well as in the
373 stack. */
374 if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
375 {
376
377 gdb_assert (len <= 8);
378
379 regcache_cooked_write (regcache,
380 tdep->ppc_fp0_regnum + 1 + f_argno,
381 value_contents (arg));
382 ++f_argno;
383 }
384
385 write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
386 ii += ((len + 3) & -4) / 4;
387 }
388 }
389
390 /* Set the stack pointer. According to the ABI, the SP is meant to
391 be set _before_ the corresponding stack space is used. On AIX,
392 this even applies when the target has been completely stopped!
393 Not doing this can lead to conflicts with the kernel which thinks
394 that it still has control over this not-yet-allocated stack
395 region. */
396 regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
397
398 /* Set back chain properly. */
e17a4113 399 store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
4a7622d1
UW
400 write_memory (sp, tmp_buffer, wordsize);
401
402 /* Point the inferior function call's return address at the dummy's
403 breakpoint. */
404 regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
405
4d1eb6b4
JB
406 /* Set the TOC register value. */
407 regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum,
408 solib_aix_get_toc_value (func_addr));
4a7622d1
UW
409
410 target_store_registers (regcache, -1);
411 return sp;
412}
413
414static enum return_value_convention
6a3a010b 415rs6000_return_value (struct gdbarch *gdbarch, struct value *function,
4a7622d1
UW
416 struct type *valtype, struct regcache *regcache,
417 gdb_byte *readbuf, const gdb_byte *writebuf)
418{
419 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
e17a4113 420 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4a7622d1
UW
421
422 /* The calling convention this function implements assumes the
423 processor has floating-point registers. We shouldn't be using it
424 on PowerPC variants that lack them. */
425 gdb_assert (ppc_floating_point_unit_p (gdbarch));
426
427 /* AltiVec extension: Functions that declare a vector data type as a
428 return value place that return value in VR2. */
429 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
430 && TYPE_LENGTH (valtype) == 16)
431 {
432 if (readbuf)
433 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
434 if (writebuf)
435 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
436
437 return RETURN_VALUE_REGISTER_CONVENTION;
438 }
439
440 /* If the called subprogram returns an aggregate, there exists an
441 implicit first argument, whose value is the address of a caller-
442 allocated buffer into which the callee is assumed to store its
0df8b418 443 return value. All explicit parameters are appropriately
4a7622d1
UW
444 relabeled. */
445 if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
446 || TYPE_CODE (valtype) == TYPE_CODE_UNION
447 || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
448 return RETURN_VALUE_STRUCT_CONVENTION;
449
450 /* Scalar floating-point values are returned in FPR1 for float or
451 double, and in FPR1:FPR2 for quadword precision. Fortran
452 complex*8 and complex*16 are returned in FPR1:FPR2, and
453 complex*32 is returned in FPR1:FPR4. */
454 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
455 && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
456 {
457 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
458 gdb_byte regval[8];
459
460 /* FIXME: kettenis/2007-01-01: Add support for quadword
461 precision and complex. */
462
463 if (readbuf)
464 {
465 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
3b2ca824 466 target_float_convert (regval, regtype, readbuf, valtype);
4a7622d1
UW
467 }
468 if (writebuf)
469 {
3b2ca824 470 target_float_convert (writebuf, valtype, regval, regtype);
4a7622d1
UW
471 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
472 }
473
474 return RETURN_VALUE_REGISTER_CONVENTION;
475 }
476
477 /* Values of the types int, long, short, pointer, and char (length
478 is less than or equal to four bytes), as well as bit values of
479 lengths less than or equal to 32 bits, must be returned right
480 justified in GPR3 with signed values sign extended and unsigned
481 values zero extended, as necessary. */
482 if (TYPE_LENGTH (valtype) <= tdep->wordsize)
483 {
484 if (readbuf)
485 {
486 ULONGEST regval;
487
488 /* For reading we don't have to worry about sign extension. */
489 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
490 &regval);
e17a4113
UW
491 store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
492 regval);
4a7622d1
UW
493 }
494 if (writebuf)
495 {
496 /* For writing, use unpack_long since that should handle any
497 required sign extension. */
498 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
499 unpack_long (valtype, writebuf));
500 }
501
502 return RETURN_VALUE_REGISTER_CONVENTION;
503 }
504
505 /* Eight-byte non-floating-point scalar values must be returned in
506 GPR3:GPR4. */
507
508 if (TYPE_LENGTH (valtype) == 8)
509 {
510 gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
511 gdb_assert (tdep->wordsize == 4);
512
513 if (readbuf)
514 {
515 gdb_byte regval[8];
516
517 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
518 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
519 regval + 4);
520 memcpy (readbuf, regval, 8);
521 }
522 if (writebuf)
523 {
524 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
525 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
526 writebuf + 4);
527 }
528
529 return RETURN_VALUE_REGISTER_CONVENTION;
530 }
531
532 return RETURN_VALUE_STRUCT_CONVENTION;
533}
534
535/* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
536
537 Usually a function pointer's representation is simply the address
0df8b418
MS
538 of the function. On the RS/6000 however, a function pointer is
539 represented by a pointer to an OPD entry. This OPD entry contains
4a7622d1
UW
540 three words, the first word is the address of the function, the
541 second word is the TOC pointer (r2), and the third word is the
542 static chain value. Throughout GDB it is currently assumed that a
543 function pointer contains the address of the function, which is not
544 easy to fix. In addition, the conversion of a function address to
545 a function pointer would require allocation of an OPD entry in the
546 inferior's memory space, with all its drawbacks. To be able to
547 call C++ virtual methods in the inferior (which are called via
548 function pointers), find_function_addr uses this function to get the
549 function address from a function pointer. */
550
551/* Return real function address if ADDR (a function pointer) is in the data
552 space and is therefore a special function pointer. */
553
554static CORE_ADDR
555rs6000_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
556 CORE_ADDR addr,
557 struct target_ops *targ)
558{
e17a4113
UW
559 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
560 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4a7622d1
UW
561 struct obj_section *s;
562
563 s = find_pc_section (addr);
4a7622d1 564
40adab56
JB
565 /* Normally, functions live inside a section that is executable.
566 So, if ADDR points to a non-executable section, then treat it
567 as a function descriptor and return the target address iff
568 the target address itself points to a section that is executable. */
569 if (s && (s->the_bfd_section->flags & SEC_CODE) == 0)
570 {
57174f31 571 CORE_ADDR pc = 0;
2971b56b 572 struct obj_section *pc_section;
2971b56b 573
492d29ea 574 TRY
2971b56b
JB
575 {
576 pc = read_memory_unsigned_integer (addr, tdep->wordsize, byte_order);
577 }
492d29ea 578 CATCH (e, RETURN_MASK_ERROR)
2971b56b
JB
579 {
580 /* An error occured during reading. Probably a memory error
581 due to the section not being loaded yet. This address
582 cannot be a function descriptor. */
583 return addr;
584 }
492d29ea
PA
585 END_CATCH
586
2971b56b 587 pc_section = find_pc_section (pc);
40adab56
JB
588
589 if (pc_section && (pc_section->the_bfd_section->flags & SEC_CODE))
590 return pc;
591 }
592
593 return addr;
4a7622d1
UW
594}
595
596
597/* Calculate the destination of a branch/jump. Return -1 if not a branch. */
598
599static CORE_ADDR
41e26ad3 600branch_dest (struct regcache *regcache, int opcode, int instr,
4a7622d1
UW
601 CORE_ADDR pc, CORE_ADDR safety)
602{
ac7936df 603 struct gdbarch *gdbarch = regcache->arch ();
e17a4113
UW
604 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
605 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4a7622d1
UW
606 CORE_ADDR dest;
607 int immediate;
608 int absolute;
609 int ext_op;
610
611 absolute = (int) ((instr >> 1) & 1);
612
613 switch (opcode)
614 {
615 case 18:
616 immediate = ((instr & ~3) << 6) >> 6; /* br unconditional */
617 if (absolute)
618 dest = immediate;
619 else
620 dest = pc + immediate;
621 break;
622
623 case 16:
624 immediate = ((instr & ~3) << 16) >> 16; /* br conditional */
625 if (absolute)
626 dest = immediate;
627 else
628 dest = pc + immediate;
629 break;
630
631 case 19:
632 ext_op = (instr >> 1) & 0x3ff;
633
634 if (ext_op == 16) /* br conditional register */
635 {
41e26ad3 636 dest = regcache_raw_get_unsigned (regcache, tdep->ppc_lr_regnum) & ~3;
4a7622d1
UW
637
638 /* If we are about to return from a signal handler, dest is
639 something like 0x3c90. The current frame is a signal handler
640 caller frame, upon completion of the sigreturn system call
641 execution will return to the saved PC in the frame. */
642 if (dest < AIX_TEXT_SEGMENT_BASE)
41e26ad3
YQ
643 {
644 struct frame_info *frame = get_current_frame ();
645
646 dest = read_memory_unsigned_integer
647 (get_frame_base (frame) + SIG_FRAME_PC_OFFSET,
648 tdep->wordsize, byte_order);
649 }
4a7622d1
UW
650 }
651
652 else if (ext_op == 528) /* br cond to count reg */
653 {
41e26ad3
YQ
654 dest = regcache_raw_get_unsigned (regcache,
655 tdep->ppc_ctr_regnum) & ~3;
4a7622d1
UW
656
657 /* If we are about to execute a system call, dest is something
658 like 0x22fc or 0x3b00. Upon completion the system call
659 will return to the address in the link register. */
660 if (dest < AIX_TEXT_SEGMENT_BASE)
41e26ad3
YQ
661 dest = regcache_raw_get_unsigned (regcache,
662 tdep->ppc_lr_regnum) & ~3;
4a7622d1
UW
663 }
664 else
665 return -1;
666 break;
667
668 default:
669 return -1;
670 }
671 return (dest < AIX_TEXT_SEGMENT_BASE) ? safety : dest;
672}
673
674/* AIX does not support PT_STEP. Simulate it. */
675
a0ff9e1a 676static std::vector<CORE_ADDR>
f5ea389a 677rs6000_software_single_step (struct regcache *regcache)
4a7622d1 678{
ac7936df 679 struct gdbarch *gdbarch = regcache->arch ();
e17a4113 680 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4a7622d1
UW
681 int ii, insn;
682 CORE_ADDR loc;
683 CORE_ADDR breaks[2];
684 int opcode;
685
41e26ad3 686 loc = regcache_read_pc (regcache);
4a7622d1 687
e17a4113 688 insn = read_memory_integer (loc, 4, byte_order);
4a7622d1 689
a0ff9e1a
SM
690 std::vector<CORE_ADDR> next_pcs = ppc_deal_with_atomic_sequence (regcache);
691 if (!next_pcs.empty ())
93f9a11f 692 return next_pcs;
4a7622d1
UW
693
694 breaks[0] = loc + PPC_INSN_SIZE;
695 opcode = insn >> 26;
41e26ad3 696 breaks[1] = branch_dest (regcache, opcode, insn, loc, breaks[0]);
4a7622d1 697
0df8b418 698 /* Don't put two breakpoints on the same address. */
4a7622d1
UW
699 if (breaks[1] == breaks[0])
700 breaks[1] = -1;
701
702 for (ii = 0; ii < 2; ++ii)
703 {
0df8b418 704 /* ignore invalid breakpoint. */
4a7622d1
UW
705 if (breaks[ii] == -1)
706 continue;
a0ff9e1a
SM
707
708 next_pcs.push_back (breaks[ii]);
4a7622d1
UW
709 }
710
0df8b418 711 errno = 0; /* FIXME, don't ignore errors! */
4a7622d1 712 /* What errors? {read,write}_memory call error(). */
93f9a11f 713 return next_pcs;
4a7622d1
UW
714}
715
38a69d0a
JB
716/* Implement the "auto_wide_charset" gdbarch method for this platform. */
717
718static const char *
719rs6000_aix_auto_wide_charset (void)
720{
721 return "UTF-16";
722}
723
beb4b03c
JB
724/* Implement an osabi sniffer for RS6000/AIX.
725
726 This function assumes that ABFD's flavour is XCOFF. In other words,
727 it should be registered as a sniffer for bfd_target_xcoff_flavour
728 objfiles only. A failed assertion will be raised if this condition
729 is not met. */
730
1f82754b
JB
731static enum gdb_osabi
732rs6000_aix_osabi_sniffer (bfd *abfd)
733{
beb4b03c 734 gdb_assert (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
1f82754b 735
d5367fe1
JB
736 /* The only noticeable difference between Lynx178 XCOFF files and
737 AIX XCOFF files comes from the fact that there are no shared
738 libraries on Lynx178. On AIX, we are betting that an executable
739 linked with no shared library will never exist. */
740 if (xcoff_get_n_import_files (abfd) <= 0)
741 return GDB_OSABI_UNKNOWN;
742
beb4b03c 743 return GDB_OSABI_AIX;
1f82754b
JB
744}
745
356a5233
JB
746/* A structure encoding the offset and size of a field within
747 a struct. */
748
749struct field_info
750{
751 int offset;
752 int size;
753};
754
755/* A structure describing the layout of all the fields of interest
756 in AIX's struct ld_info. Each field in this struct corresponds
757 to the field of the same name in struct ld_info. */
758
759struct ld_info_desc
760{
761 struct field_info ldinfo_next;
762 struct field_info ldinfo_fd;
763 struct field_info ldinfo_textorg;
764 struct field_info ldinfo_textsize;
765 struct field_info ldinfo_dataorg;
766 struct field_info ldinfo_datasize;
767 struct field_info ldinfo_filename;
768};
769
770/* The following data has been generated by compiling and running
771 the following program on AIX 5.3. */
772
773#if 0
1c432e72
JB
774#include <stddef.h>
775#include <stdio.h>
776#define __LDINFO_PTRACE32__
777#define __LDINFO_PTRACE64__
778#include <sys/ldr.h>
779
780#define pinfo(type,member) \
781 { \
782 struct type ldi = {0}; \
783 \
784 printf (" {%d, %d},\t/* %s */\n", \
785 offsetof (struct type, member), \
786 sizeof (ldi.member), \
787 #member); \
788 } \
789 while (0)
790
791int
792main (void)
793{
794 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
795 pinfo (__ld_info32, ldinfo_next);
796 pinfo (__ld_info32, ldinfo_fd);
797 pinfo (__ld_info32, ldinfo_textorg);
798 pinfo (__ld_info32, ldinfo_textsize);
799 pinfo (__ld_info32, ldinfo_dataorg);
800 pinfo (__ld_info32, ldinfo_datasize);
801 pinfo (__ld_info32, ldinfo_filename);
802 printf ("};\n");
803
804 printf ("\n");
805
806 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
807 pinfo (__ld_info64, ldinfo_next);
808 pinfo (__ld_info64, ldinfo_fd);
809 pinfo (__ld_info64, ldinfo_textorg);
810 pinfo (__ld_info64, ldinfo_textsize);
811 pinfo (__ld_info64, ldinfo_dataorg);
812 pinfo (__ld_info64, ldinfo_datasize);
813 pinfo (__ld_info64, ldinfo_filename);
814 printf ("};\n");
815
816 return 0;
817}
356a5233
JB
818#endif /* 0 */
819
820/* Layout of the 32bit version of struct ld_info. */
821
822static const struct ld_info_desc ld_info32_desc =
823{
824 {0, 4}, /* ldinfo_next */
825 {4, 4}, /* ldinfo_fd */
826 {8, 4}, /* ldinfo_textorg */
827 {12, 4}, /* ldinfo_textsize */
828 {16, 4}, /* ldinfo_dataorg */
829 {20, 4}, /* ldinfo_datasize */
830 {24, 2}, /* ldinfo_filename */
831};
832
833/* Layout of the 64bit version of struct ld_info. */
834
835static const struct ld_info_desc ld_info64_desc =
836{
837 {0, 4}, /* ldinfo_next */
838 {8, 4}, /* ldinfo_fd */
839 {16, 8}, /* ldinfo_textorg */
840 {24, 8}, /* ldinfo_textsize */
841 {32, 8}, /* ldinfo_dataorg */
842 {40, 8}, /* ldinfo_datasize */
843 {48, 2}, /* ldinfo_filename */
844};
845
846/* A structured representation of one entry read from the ld_info
847 binary data provided by the AIX loader. */
848
849struct ld_info
850{
851 ULONGEST next;
852 int fd;
853 CORE_ADDR textorg;
854 ULONGEST textsize;
855 CORE_ADDR dataorg;
856 ULONGEST datasize;
857 char *filename;
858 char *member_name;
859};
860
861/* Return a struct ld_info object corresponding to the entry at
862 LDI_BUF.
863
864 Note that the filename and member_name strings still point
865 to the data in LDI_BUF. So LDI_BUF must not be deallocated
866 while the struct ld_info object returned is in use. */
867
868static struct ld_info
869rs6000_aix_extract_ld_info (struct gdbarch *gdbarch,
870 const gdb_byte *ldi_buf)
871{
872 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
873 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
874 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
875 const struct ld_info_desc desc
876 = tdep->wordsize == 8 ? ld_info64_desc : ld_info32_desc;
877 struct ld_info info;
878
879 info.next = extract_unsigned_integer (ldi_buf + desc.ldinfo_next.offset,
880 desc.ldinfo_next.size,
881 byte_order);
882 info.fd = extract_signed_integer (ldi_buf + desc.ldinfo_fd.offset,
883 desc.ldinfo_fd.size,
884 byte_order);
885 info.textorg = extract_typed_address (ldi_buf + desc.ldinfo_textorg.offset,
886 ptr_type);
887 info.textsize
888 = extract_unsigned_integer (ldi_buf + desc.ldinfo_textsize.offset,
889 desc.ldinfo_textsize.size,
890 byte_order);
891 info.dataorg = extract_typed_address (ldi_buf + desc.ldinfo_dataorg.offset,
892 ptr_type);
893 info.datasize
894 = extract_unsigned_integer (ldi_buf + desc.ldinfo_datasize.offset,
895 desc.ldinfo_datasize.size,
896 byte_order);
897 info.filename = (char *) ldi_buf + desc.ldinfo_filename.offset;
898 info.member_name = info.filename + strlen (info.filename) + 1;
899
900 return info;
901}
902
903/* Append to OBJSTACK an XML string description of the shared library
904 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
905 format. */
906
907static void
908rs6000_aix_shared_library_to_xml (struct ld_info *ldi,
909 struct obstack *obstack)
910{
356a5233 911 obstack_grow_str (obstack, "<library name=\"");
5e187554
SM
912 std::string p = xml_escape_text (ldi->filename);
913 obstack_grow_str (obstack, p.c_str ());
356a5233
JB
914 obstack_grow_str (obstack, "\"");
915
916 if (ldi->member_name[0] != '\0')
917 {
918 obstack_grow_str (obstack, " member=\"");
919 p = xml_escape_text (ldi->member_name);
5e187554 920 obstack_grow_str (obstack, p.c_str ());
356a5233
JB
921 obstack_grow_str (obstack, "\"");
922 }
923
924 obstack_grow_str (obstack, " text_addr=\"");
925 obstack_grow_str (obstack, core_addr_to_string (ldi->textorg));
926 obstack_grow_str (obstack, "\"");
927
928 obstack_grow_str (obstack, " text_size=\"");
929 obstack_grow_str (obstack, pulongest (ldi->textsize));
930 obstack_grow_str (obstack, "\"");
931
932 obstack_grow_str (obstack, " data_addr=\"");
933 obstack_grow_str (obstack, core_addr_to_string (ldi->dataorg));
934 obstack_grow_str (obstack, "\"");
935
936 obstack_grow_str (obstack, " data_size=\"");
937 obstack_grow_str (obstack, pulongest (ldi->datasize));
938 obstack_grow_str (obstack, "\"");
939
940 obstack_grow_str (obstack, "></library>");
941}
942
943/* Convert the ld_info binary data provided by the AIX loader into
944 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
945 format.
946
947 LDI_BUF is a buffer containing the ld_info data.
948 READBUF, OFFSET and LEN follow the same semantics as target_ops'
949 to_xfer_partial target_ops method.
950
951 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
952 the ldinfo_fd file descriptor. This is useful when the ldinfo
953 data is obtained via ptrace, as ptrace opens a file descriptor
954 for each and every entry; but we cannot use this descriptor
955 as the consumer of the XML library list might live in a different
956 process. */
957
c09f20e4 958ULONGEST
356a5233 959rs6000_aix_ld_info_to_xml (struct gdbarch *gdbarch, const gdb_byte *ldi_buf,
b55e14c7 960 gdb_byte *readbuf, ULONGEST offset, ULONGEST len,
356a5233
JB
961 int close_ldinfo_fd)
962{
963 struct obstack obstack;
964 const char *buf;
c09f20e4 965 ULONGEST len_avail;
356a5233
JB
966
967 obstack_init (&obstack);
968 obstack_grow_str (&obstack, "<library-list-aix version=\"1.0\">\n");
969
970 while (1)
971 {
972 struct ld_info ldi = rs6000_aix_extract_ld_info (gdbarch, ldi_buf);
973
974 rs6000_aix_shared_library_to_xml (&ldi, &obstack);
975 if (close_ldinfo_fd)
976 close (ldi.fd);
977
978 if (!ldi.next)
979 break;
980 ldi_buf = ldi_buf + ldi.next;
981 }
982
983 obstack_grow_str0 (&obstack, "</library-list-aix>\n");
984
224c3ddb 985 buf = (const char *) obstack_finish (&obstack);
356a5233
JB
986 len_avail = strlen (buf);
987 if (offset >= len_avail)
988 len= 0;
989 else
990 {
991 if (len > len_avail - offset)
992 len = len_avail - offset;
993 memcpy (readbuf, buf + offset, len);
994 }
995
996 obstack_free (&obstack, NULL);
997 return len;
998}
999
1000/* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1001
c09f20e4 1002static ULONGEST
356a5233
JB
1003rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch,
1004 gdb_byte *readbuf,
1005 ULONGEST offset,
7ec1862d 1006 ULONGEST len)
356a5233
JB
1007{
1008 struct bfd_section *ldinfo_sec;
1009 int ldinfo_size;
356a5233
JB
1010
1011 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1012 if (ldinfo_sec == NULL)
1013 error (_("cannot find .ldinfo section from core file: %s"),
1014 bfd_errmsg (bfd_get_error ()));
1015 ldinfo_size = bfd_get_section_size (ldinfo_sec);
1016
984c7238 1017 gdb::byte_vector ldinfo_buf (ldinfo_size);
356a5233
JB
1018
1019 if (! bfd_get_section_contents (core_bfd, ldinfo_sec,
984c7238 1020 ldinfo_buf.data (), 0, ldinfo_size))
356a5233
JB
1021 error (_("unable to read .ldinfo section from core file: %s"),
1022 bfd_errmsg (bfd_get_error ()));
1023
984c7238
TT
1024 return rs6000_aix_ld_info_to_xml (gdbarch, ldinfo_buf.data (), readbuf,
1025 offset, len, 0);
356a5233
JB
1026}
1027
1f82754b
JB
1028static void
1029rs6000_aix_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
1030{
4a7622d1
UW
1031 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1032
1f82754b
JB
1033 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1034 set_gdbarch_software_single_step (gdbarch, rs6000_software_single_step);
6f7f3f0d 1035
2454a024
UW
1036 /* Displaced stepping is currently not supported in combination with
1037 software single-stepping. */
1038 set_gdbarch_displaced_step_copy_insn (gdbarch, NULL);
1039 set_gdbarch_displaced_step_fixup (gdbarch, NULL);
2454a024
UW
1040 set_gdbarch_displaced_step_location (gdbarch, NULL);
1041
4a7622d1
UW
1042 set_gdbarch_push_dummy_call (gdbarch, rs6000_push_dummy_call);
1043 set_gdbarch_return_value (gdbarch, rs6000_return_value);
1044 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1045
1046 /* Handle RS/6000 function pointers (which are really function
1047 descriptors). */
1048 set_gdbarch_convert_from_func_ptr_addr
1049 (gdbarch, rs6000_convert_from_func_ptr_addr);
1050
7a61a01c 1051 /* Core file support. */
23ea9aeb
AA
1052 set_gdbarch_iterate_over_regset_sections
1053 (gdbarch, rs6000_aix_iterate_over_regset_sections);
356a5233
JB
1054 set_gdbarch_core_xfer_shared_libraries_aix
1055 (gdbarch, rs6000_aix_core_xfer_shared_libraries_aix);
7a61a01c 1056
4a7622d1
UW
1057 if (tdep->wordsize == 8)
1058 tdep->lr_frame_offset = 16;
1059 else
1060 tdep->lr_frame_offset = 8;
1061
1062 if (tdep->wordsize == 4)
1063 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1064 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1065 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1066 224. */
1067 set_gdbarch_frame_red_zone_size (gdbarch, 224);
1068 else
1069 set_gdbarch_frame_red_zone_size (gdbarch, 0);
38a69d0a 1070
53375380
PA
1071 if (tdep->wordsize == 8)
1072 set_gdbarch_wchar_bit (gdbarch, 32);
1073 else
1074 set_gdbarch_wchar_bit (gdbarch, 16);
1075 set_gdbarch_wchar_signed (gdbarch, 0);
38a69d0a 1076 set_gdbarch_auto_wide_charset (gdbarch, rs6000_aix_auto_wide_charset);
4d1eb6b4
JB
1077
1078 set_solib_ops (gdbarch, &solib_aix_so_ops);
1f82754b
JB
1079}
1080
1081void
1082_initialize_rs6000_aix_tdep (void)
1083{
1084 gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
1085 bfd_target_xcoff_flavour,
1086 rs6000_aix_osabi_sniffer);
7a61a01c
UW
1087 gdbarch_register_osabi_sniffer (bfd_arch_powerpc,
1088 bfd_target_xcoff_flavour,
1089 rs6000_aix_osabi_sniffer);
1f82754b
JB
1090
1091 gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_AIX,
1092 rs6000_aix_init_osabi);
7a61a01c
UW
1093 gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_AIX,
1094 rs6000_aix_init_osabi);
1f82754b
JB
1095}
1096
This page took 1.332162 seconds and 4 git commands to generate.