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