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