1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
7 This file is part of GDB.
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 2 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
28 #include "xcoffsolib.h"
31 #include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
33 #include "gdb-stabs.h"
35 #include "arch-utils.h"
36 #include "language.h" /* for local_hex_string(). */
40 #include <sys/ptrace.h>
43 #include <sys/param.h>
47 #include <sys/ioctl.h>
55 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
56 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
58 #include <sys/systemcfg.h>
60 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
61 debugging 32-bit and 64-bit processes. Define a typedef and macros for
62 accessing fields in the appropriate structures. */
64 /* In 32-bit compilation mode (which is the only mode from which ptrace()
65 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
71 /* Return whether the current architecture is 64-bit. */
76 # define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8)
79 /* Union of 32-bit and 64-bit ".reg" core file sections. */
83 struct __context64 r64
;
90 /* Union of 32-bit and 64-bit versions of ld_info. */
97 struct __ld_info32 l32
;
98 struct __ld_info64 l64
;
102 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
103 declare and initialize a variable named VAR suitable for use as the arch64
104 parameter to the various LDI_*() macros. */
107 # define ARCH64_DECL(var)
109 # define ARCH64_DECL(var) int var = ARCH64 ()
112 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
113 otherwise. This technique only works for FIELDs with the same data type in
114 32-bit and 64-bit versions of ld_info. */
117 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
119 # define LDI_FIELD(ldi, arch64, field) \
120 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
123 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
124 process otherwise. */
126 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
127 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
128 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
130 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
132 static void vmap_exec (void);
134 static void vmap_ldinfo (LdInfo
*);
136 static struct vmap
*add_vmap (LdInfo
*);
138 static int objfile_symbol_add (void *);
140 static void vmap_symtab (struct vmap
*);
142 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR
);
144 static void exec_one_dummy_insn (void);
146 extern void fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
148 /* Given REGNO, a gdb register number, return the corresponding
149 number suitable for use as a ptrace() parameter. Return -1 if
150 there's no suitable mapping. Also, set the int pointed to by
151 ISFLOAT to indicate whether REGNO is a floating point register. */
154 regmap (int regno
, int *isfloat
)
156 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
159 if (tdep
->ppc_gp0_regnum
<= regno
160 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
162 else if (tdep
->ppc_fp0_regnum
<= regno
163 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
166 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
168 else if (regno
== PC_REGNUM
)
170 else if (regno
== tdep
->ppc_ps_regnum
)
172 else if (regno
== tdep
->ppc_cr_regnum
)
174 else if (regno
== tdep
->ppc_lr_regnum
)
176 else if (regno
== tdep
->ppc_ctr_regnum
)
178 else if (regno
== tdep
->ppc_xer_regnum
)
180 else if (regno
== tdep
->ppc_fpscr_regnum
)
182 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
188 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
191 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
193 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
195 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
196 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
201 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
204 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, int *buf
)
207 int ret
= ptracex (req
, id
, addr
, data
, buf
);
212 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
213 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
218 /* Fetch register REGNO from the inferior. */
221 fetch_register (int regno
)
223 int addr
[MAX_REGISTER_SIZE
];
226 /* Retrieved values may be -1, so infer errors from errno. */
229 nr
= regmap (regno
, &isfloat
);
231 /* Floating-point registers. */
233 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
235 /* Bogus register number. */
238 if (regno
>= NUM_REGS
)
239 fprintf_unfiltered (gdb_stderr
,
240 "gdb error: register no %d not implemented.\n",
245 /* Fixed-point registers. */
249 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
), (int *)nr
, 0, 0);
252 /* PT_READ_GPR requires the buffer parameter to point to long long,
253 even if the register is really only 32 bits. */
255 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
256 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) == 8)
257 memcpy (addr
, &buf
, 8);
264 supply_register (regno
, (char *) addr
);
268 /* FIXME: this happens 3 times at the start of each 64-bit program. */
269 perror ("ptrace read");
275 /* Store register REGNO back into the inferior. */
278 store_register (int regno
)
280 int addr
[MAX_REGISTER_SIZE
];
283 /* Fetch the register's value from the register cache. */
284 regcache_collect (regno
, addr
);
286 /* -1 can be a successful return value, so infer errors from errno. */
289 nr
= regmap (regno
, &isfloat
);
291 /* Floating-point registers. */
293 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
295 /* Bogus register number. */
298 if (regno
>= NUM_REGS
)
299 fprintf_unfiltered (gdb_stderr
,
300 "gdb error: register no %d not implemented.\n",
304 /* Fixed-point registers. */
307 if (regno
== SP_REGNUM
)
308 /* Execute one dummy instruction (which is a breakpoint) in inferior
309 process to give kernel a chance to do internal housekeeping.
310 Otherwise the following ptrace(2) calls will mess up user stack
311 since kernel will get confused about the bottom of the stack
313 exec_one_dummy_insn ();
315 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
316 the register's value is passed by value, but for 64-bit inferiors,
317 the address of a buffer containing the value is passed. */
319 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), (int *)nr
, *addr
, 0);
322 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
323 area, even if the register is really only 32 bits. */
325 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) == 8)
326 memcpy (&buf
, addr
, 8);
329 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
335 perror ("ptrace write");
340 /* Read from the inferior all registers if REGNO == -1 and just register
344 fetch_inferior_registers (int regno
)
347 fetch_register (regno
);
351 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
353 /* Read 32 general purpose registers. */
354 for (regno
= tdep
->ppc_gp0_regnum
;
355 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
358 fetch_register (regno
);
361 /* Read general purpose floating point registers. */
362 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
363 fetch_register (tdep
->ppc_fp0_regnum
+ regno
);
365 /* Read special registers. */
366 fetch_register (PC_REGNUM
);
367 fetch_register (tdep
->ppc_ps_regnum
);
368 fetch_register (tdep
->ppc_cr_regnum
);
369 fetch_register (tdep
->ppc_lr_regnum
);
370 fetch_register (tdep
->ppc_ctr_regnum
);
371 fetch_register (tdep
->ppc_xer_regnum
);
372 fetch_register (tdep
->ppc_fpscr_regnum
);
373 if (tdep
->ppc_mq_regnum
>= 0)
374 fetch_register (tdep
->ppc_mq_regnum
);
378 /* Store our register values back into the inferior.
379 If REGNO is -1, do this for all registers.
380 Otherwise, REGNO specifies which register (so we can save time). */
383 store_inferior_registers (int regno
)
386 store_register (regno
);
390 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
392 /* Write general purpose registers first. */
393 for (regno
= tdep
->ppc_gp0_regnum
;
394 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
397 store_register (regno
);
400 /* Write floating point registers. */
401 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
402 store_register (tdep
->ppc_fp0_regnum
+ regno
);
404 /* Write special registers. */
405 store_register (PC_REGNUM
);
406 store_register (tdep
->ppc_ps_regnum
);
407 store_register (tdep
->ppc_cr_regnum
);
408 store_register (tdep
->ppc_lr_regnum
);
409 store_register (tdep
->ppc_ctr_regnum
);
410 store_register (tdep
->ppc_xer_regnum
);
411 store_register (tdep
->ppc_fpscr_regnum
);
412 if (tdep
->ppc_mq_regnum
>= 0)
413 store_register (tdep
->ppc_mq_regnum
);
417 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
418 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
422 read_word (CORE_ADDR from
, int *to
, int arch64
)
424 /* Retrieved values may be -1, so infer errors from errno. */
428 *to
= rs6000_ptrace64 (PT_READ_I
, PIDGET (inferior_ptid
), from
, 0, NULL
);
430 *to
= rs6000_ptrace32 (PT_READ_I
, PIDGET (inferior_ptid
), (int *)(long) from
,
436 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
437 to debugger memory starting at MYADDR. Copy to inferior if
440 Returns the length copied, which is either the LEN argument or zero.
441 This xfer function does not do partial moves, since child_ops
442 doesn't allow memory operations to cross below us in the target stack
446 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
447 int write
, struct mem_attrib
*attrib
,
448 struct target_ops
*target
)
450 /* Round starting address down to 32-bit word boundary. */
451 int mask
= sizeof (int) - 1;
452 CORE_ADDR addr
= memaddr
& ~(CORE_ADDR
)mask
;
454 /* Round ending address up to 32-bit word boundary. */
455 int count
= ((memaddr
+ len
- addr
+ mask
) & ~(CORE_ADDR
)mask
)
458 /* Allocate word transfer buffer. */
459 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
460 because it uses alloca to allocate a buffer of arbitrary size.
461 For very large xfers, this could crash GDB's stack. */
462 int *buf
= (int *) alloca (count
* sizeof (int));
464 int arch64
= ARCH64 ();
469 /* Retrieve memory a word at a time. */
470 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
472 if (!read_word (addr
, buf
+ i
, arch64
))
477 /* Copy memory to supplied buffer. */
478 addr
-= count
* sizeof (int);
479 memcpy (myaddr
, (char *)buf
+ (memaddr
- addr
), len
);
483 /* Fetch leading memory needed for alignment. */
485 if (!read_word (addr
, buf
, arch64
))
488 /* Fetch trailing memory needed for alignment. */
489 if (addr
+ count
* sizeof (int) > memaddr
+ len
)
490 if (!read_word (addr
+ (count
- 1) * sizeof (int),
491 buf
+ count
- 1, arch64
))
494 /* Copy supplied data into memory buffer. */
495 memcpy ((char *)buf
+ (memaddr
- addr
), myaddr
, len
);
497 /* Store memory one word at a time. */
498 for (i
= 0, errno
= 0; i
< count
; i
++, addr
+= sizeof (int))
501 rs6000_ptrace64 (PT_WRITE_D
, PIDGET (inferior_ptid
), addr
, buf
[i
], NULL
);
503 rs6000_ptrace32 (PT_WRITE_D
, PIDGET (inferior_ptid
), (int *)(long) addr
,
515 /* Execute one dummy breakpoint instruction. This way we give the kernel
516 a chance to do some housekeeping and update inferior's internal data,
520 exec_one_dummy_insn (void)
522 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
524 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
525 int ret
, status
, pid
;
528 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
529 assume that this address will never be executed again by the real
532 target_insert_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
534 /* You might think this could be done with a single ptrace call, and
535 you'd be correct for just about every platform I've ever worked
536 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
537 the inferior never hits the breakpoint (it's also worth noting
538 powerpc-ibm-aix4.1.3 works correctly). */
539 prev_pc
= read_pc ();
540 write_pc (DUMMY_INSN_ADDR
);
542 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
544 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
), (int *)1, 0, NULL
);
547 perror ("pt_continue");
551 pid
= wait (&status
);
553 while (pid
!= PIDGET (inferior_ptid
));
556 target_remove_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
559 /* Fetch registers from the register section in core bfd. */
562 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
563 int which
, CORE_ADDR reg_addr
)
567 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
573 "Gdb error: unknown parameter to fetch_core_registers().\n");
577 regs
= (CoreRegs
*) core_reg_sect
;
579 /* Put the register values from the core file section in the regcache. */
583 for (regi
= 0; regi
< 32; regi
++)
584 supply_register (regi
, (char *) ®s
->r64
.gpr
[regi
]);
586 for (regi
= 0; regi
< 32; regi
++)
587 supply_register (tdep
->ppc_fp0_regnum
+ regi
,
588 (char *) ®s
->r64
.fpr
[regi
]);
590 supply_register (PC_REGNUM
, (char *) ®s
->r64
.iar
);
591 supply_register (tdep
->ppc_ps_regnum
, (char *) ®s
->r64
.msr
);
592 supply_register (tdep
->ppc_cr_regnum
, (char *) ®s
->r64
.cr
);
593 supply_register (tdep
->ppc_lr_regnum
, (char *) ®s
->r64
.lr
);
594 supply_register (tdep
->ppc_ctr_regnum
, (char *) ®s
->r64
.ctr
);
595 supply_register (tdep
->ppc_xer_regnum
, (char *) ®s
->r64
.xer
);
596 supply_register (tdep
->ppc_fpscr_regnum
, (char *) ®s
->r64
.fpscr
);
600 for (regi
= 0; regi
< 32; regi
++)
601 supply_register (regi
, (char *) ®s
->r32
.gpr
[regi
]);
603 for (regi
= 0; regi
< 32; regi
++)
604 supply_register (tdep
->ppc_fp0_regnum
+ regi
,
605 (char *) ®s
->r32
.fpr
[regi
]);
607 supply_register (PC_REGNUM
, (char *) ®s
->r32
.iar
);
608 supply_register (tdep
->ppc_ps_regnum
, (char *) ®s
->r32
.msr
);
609 supply_register (tdep
->ppc_cr_regnum
, (char *) ®s
->r32
.cr
);
610 supply_register (tdep
->ppc_lr_regnum
, (char *) ®s
->r32
.lr
);
611 supply_register (tdep
->ppc_ctr_regnum
, (char *) ®s
->r32
.ctr
);
612 supply_register (tdep
->ppc_xer_regnum
, (char *) ®s
->r32
.xer
);
613 supply_register (tdep
->ppc_fpscr_regnum
, (char *) ®s
->r32
.fpscr
);
614 if (tdep
->ppc_mq_regnum
>= 0)
615 supply_register (tdep
->ppc_mq_regnum
, (char *) ®s
->r32
.mq
);
620 /* Copy information about text and data sections from LDI to VP for a 64-bit
621 process if ARCH64 and for a 32-bit process otherwise. */
624 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
628 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
629 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
630 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
631 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
635 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
636 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
637 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
638 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
641 /* The run time loader maps the file header in addition to the text
642 section and returns a pointer to the header in ldinfo_textorg.
643 Adjust the text start address to point to the real start address
644 of the text section. */
645 vp
->tstart
+= vp
->toffs
;
648 /* handle symbol translation on vmapping */
651 vmap_symtab (struct vmap
*vp
)
653 struct objfile
*objfile
;
654 struct section_offsets
*new_offsets
;
657 objfile
= vp
->objfile
;
660 /* OK, it's not an objfile we opened ourselves.
661 Currently, that can only happen with the exec file, so
662 relocate the symbols for the symfile. */
663 if (symfile_objfile
== NULL
)
665 objfile
= symfile_objfile
;
667 else if (!vp
->loaded
)
668 /* If symbols are not yet loaded, offsets are not yet valid. */
672 (struct section_offsets
*)
673 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
675 for (i
= 0; i
< objfile
->num_sections
; ++i
)
676 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
678 /* The symbols in the object file are linked to the VMA of the section,
679 relocate them VMA relative. */
680 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
681 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
682 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
684 objfile_relocate (objfile
, new_offsets
);
687 /* Add symbols for an objfile. */
690 objfile_symbol_add (void *arg
)
692 struct objfile
*obj
= (struct objfile
*) arg
;
694 syms_from_objfile (obj
, NULL
, 0, 0, 0, 0);
695 new_symfile_objfile (obj
, 0, 0);
699 /* Add symbols for a vmap. Return zero upon error. */
702 vmap_add_symbols (struct vmap
*vp
)
704 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
705 "Error while reading shared library symbols:\n",
708 /* Note this is only done if symbol reading was successful. */
716 /* Add a new vmap entry based on ldinfo() information.
718 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
719 core file), the caller should set it to -1, and we will open the file.
721 Return the vmap new entry. */
724 add_vmap (LdInfo
*ldi
)
727 char *mem
, *objname
, *filename
;
731 ARCH64_DECL (arch64
);
733 /* This ldi structure was allocated using alloca() in
734 xcoff_relocate_symtab(). Now we need to have persistent object
735 and member names, so we should save them. */
737 filename
= LDI_FILENAME (ldi
, arch64
);
738 mem
= filename
+ strlen (filename
) + 1;
739 mem
= savestring (mem
, strlen (mem
));
740 objname
= savestring (filename
, strlen (filename
));
742 fd
= LDI_FD (ldi
, arch64
);
744 /* Note that this opens it once for every member; a possible
745 enhancement would be to only open it once for every object. */
746 abfd
= bfd_openr (objname
, gnutarget
);
748 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
751 warning ("Could not open `%s' as an executable file: %s",
752 objname
, bfd_errmsg (bfd_get_error ()));
756 /* make sure we have an object file */
758 if (bfd_check_format (abfd
, bfd_object
))
759 vp
= map_vmap (abfd
, 0);
761 else if (bfd_check_format (abfd
, bfd_archive
))
764 /* FIXME??? am I tossing BFDs? bfd? */
765 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
766 if (DEPRECATED_STREQ (mem
, last
->filename
))
771 warning ("\"%s\": member \"%s\" missing.", objname
, mem
);
776 if (!bfd_check_format (last
, bfd_object
))
778 warning ("\"%s\": member \"%s\" not in executable format: %s.",
779 objname
, mem
, bfd_errmsg (bfd_get_error ()));
785 vp
= map_vmap (last
, abfd
);
789 warning ("\"%s\": not in executable format: %s.",
790 objname
, bfd_errmsg (bfd_get_error ()));
794 obj
= allocate_objfile (vp
->bfd
, 0);
797 /* Always add symbols for the main objfile. */
798 if (vp
== vmap
|| auto_solib_add
)
799 vmap_add_symbols (vp
);
803 /* update VMAP info with ldinfo() information
804 Input is ptr to ldinfo() results. */
807 vmap_ldinfo (LdInfo
*ldi
)
811 int got_one
, retried
;
812 int got_exec_file
= 0;
814 int arch64
= ARCH64 ();
816 /* For each *ldi, see if we have a corresponding *vp.
817 If so, update the mapping, and symbol table.
818 If not, add an entry and symbol table. */
822 char *name
= LDI_FILENAME (ldi
, arch64
);
823 char *memb
= name
+ strlen (name
) + 1;
824 int fd
= LDI_FD (ldi
, arch64
);
828 if (fstat (fd
, &ii
) < 0)
830 /* The kernel sets ld_info to -1, if the process is still using the
831 object, and the object is removed. Keep the symbol info for the
832 removed object and issue a warning. */
833 warning ("%s (fd=%d) has disappeared, keeping its symbols",
838 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
840 struct objfile
*objfile
;
842 /* First try to find a `vp', which is the same as in ldinfo.
843 If not the same, just continue and grep the next `vp'. If same,
844 relocate its tstart, tend, dstart, dend values. If no such `vp'
845 found, get out of this for loop, add this ldi entry as a new vmap
846 (add_vmap) and come back, find its `vp' and so on... */
848 /* The filenames are not always sufficient to match on. */
850 if ((name
[0] == '/' && !DEPRECATED_STREQ (name
, vp
->name
))
851 || (memb
[0] && !DEPRECATED_STREQ (memb
, vp
->member
)))
854 /* See if we are referring to the same file.
855 We have to check objfile->obfd, symfile.c:reread_symbols might
856 have updated the obfd after a change. */
857 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
859 || objfile
->obfd
== NULL
860 || bfd_stat (objfile
->obfd
, &vi
) < 0)
862 warning ("Unable to stat %s, keeping its symbols", name
);
866 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
874 /* Found a corresponding VMAP. Remap! */
876 vmap_secs (vp
, ldi
, arch64
);
878 /* The objfile is only NULL for the exec file. */
879 if (vp
->objfile
== NULL
)
882 /* relocate symbol table(s). */
885 /* Announce new object files. Doing this after symbol relocation
886 makes aix-thread.c's job easier. */
887 if (deprecated_target_new_objfile_hook
&& vp
->objfile
)
888 deprecated_target_new_objfile_hook (vp
->objfile
);
890 /* There may be more, so we don't break out of the loop. */
893 /* if there was no matching *vp, we must perforce create the sucker(s) */
894 if (!got_one
&& !retried
)
901 while ((next
= LDI_NEXT (ldi
, arch64
))
902 && (ldi
= (void *) (next
+ (char *) ldi
)));
904 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
905 is unlikely that the symbol file is relocated to the proper
906 address. And we might have attached to a process which is
907 running a different copy of the same executable. */
908 if (symfile_objfile
!= NULL
&& !got_exec_file
)
910 warning ("Symbol file %s\nis not mapped; discarding it.\n\
911 If in fact that file has symbols which the mapped files listed by\n\
912 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
913 \"add-symbol-file\" commands (note that you must take care of relocating\n\
914 symbols to the proper address).",
915 symfile_objfile
->name
);
916 free_objfile (symfile_objfile
);
917 symfile_objfile
= NULL
;
919 breakpoint_re_set ();
922 /* As well as symbol tables, exec_sections need relocation. After
923 the inferior process' termination, there will be a relocated symbol
924 table exist with no corresponding inferior process. At that time, we
925 need to use `exec' bfd, rather than the inferior process's memory space
928 `exec_sections' need to be relocated only once, as long as the exec
929 file remains unchanged.
938 if (execbfd
== exec_bfd
)
943 if (!vmap
|| !exec_ops
.to_sections
)
944 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
946 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
948 if (DEPRECATED_STREQ (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
950 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
951 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
953 else if (DEPRECATED_STREQ (".data", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
955 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
956 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
958 else if (DEPRECATED_STREQ (".bss", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
960 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
961 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
966 /* Set the current architecture from the host running GDB. Called when
967 starting a child process. */
970 set_host_arch (int pid
)
972 enum bfd_architecture arch
;
975 struct gdbarch_info info
;
979 arch
= bfd_arch_rs6000
;
980 mach
= bfd_mach_rs6k
;
984 arch
= bfd_arch_powerpc
;
988 /* FIXME: schauer/2002-02-25:
989 We don't know if we are executing a 32 or 64 bit executable,
990 and have no way to pass the proper word size to rs6000_gdbarch_init.
991 So we have to avoid switching to a new architecture, if the architecture
993 Blindly calling rs6000_gdbarch_init used to work in older versions of
994 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
995 determine the wordsize. */
998 const struct bfd_arch_info
*exec_bfd_arch_info
;
1000 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1001 if (arch
== exec_bfd_arch_info
->arch
)
1005 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1007 gdbarch_info_init (&info
);
1008 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1009 info
.abfd
= exec_bfd
;
1011 if (!gdbarch_update_p (info
))
1013 internal_error (__FILE__
, __LINE__
,
1014 "set_host_arch: failed to select architecture");
1019 /* xcoff_relocate_symtab - hook for symbol table relocation.
1020 also reads shared libraries.. */
1023 xcoff_relocate_symtab (unsigned int pid
)
1025 int load_segs
= 64; /* number of load segments */
1028 int arch64
= ARCH64 ();
1029 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1034 size
= load_segs
* ldisize
;
1035 ldi
= (void *) xrealloc (ldi
, size
);
1038 /* According to my humble theory, AIX has some timing problems and
1039 when the user stack grows, kernel doesn't update stack info in time
1040 and ptrace calls step on user stack. That is why we sleep here a
1041 little, and give kernel to update its internals. */
1046 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1048 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1052 if (errno
== ENOMEM
)
1055 perror_with_name ("ptrace ldinfo");
1060 vmap_exec (); /* relocate the exec and core sections as well. */
1067 /* Core file stuff. */
1069 /* Relocate symtabs and read in shared library info, based on symbols
1070 from the core file. */
1073 xcoff_relocate_core (struct target_ops
*target
)
1075 struct bfd_section
*ldinfo_sec
;
1079 int arch64
= ARCH64 ();
1081 /* Size of a struct ld_info except for the variable-length filename. */
1082 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1084 /* Allocated size of buffer. */
1085 int buffer_size
= nonfilesz
;
1086 char *buffer
= xmalloc (buffer_size
);
1087 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1089 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1090 if (ldinfo_sec
== NULL
)
1093 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1094 bfd_errmsg (bfd_get_error ()));
1101 int names_found
= 0;
1103 /* Read in everything but the name. */
1104 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1105 offset
, nonfilesz
) == 0)
1112 if (i
== buffer_size
)
1115 buffer
= xrealloc (buffer
, buffer_size
);
1117 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1118 offset
+ i
, 1) == 0)
1120 if (buffer
[i
++] == '\0')
1123 while (names_found
< 2);
1125 ldi
= (LdInfo
*) buffer
;
1127 /* Can't use a file descriptor from the core file; need to open it. */
1129 ldi
->l64
.ldinfo_fd
= -1;
1131 ldi
->l32
.ldinfo_fd
= -1;
1133 /* The first ldinfo is for the exec file, allocated elsewhere. */
1134 if (offset
== 0 && vmap
!= NULL
)
1137 vp
= add_vmap (ldi
);
1139 /* Process next shared library upon error. */
1140 offset
+= LDI_NEXT (ldi
, arch64
);
1144 vmap_secs (vp
, ldi
, arch64
);
1146 /* Unless this is the exec file,
1147 add our sections to the section table for the core target. */
1150 struct section_table
*stp
;
1152 target_resize_to_sections (target
, 2);
1153 stp
= target
->to_sections_end
- 2;
1156 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1157 stp
->addr
= vp
->tstart
;
1158 stp
->endaddr
= vp
->tend
;
1162 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1163 stp
->addr
= vp
->dstart
;
1164 stp
->endaddr
= vp
->dend
;
1169 if (deprecated_target_new_objfile_hook
&& vp
!= vmap
&& vp
->objfile
)
1170 deprecated_target_new_objfile_hook (vp
->objfile
);
1172 while (LDI_NEXT (ldi
, arch64
) != 0);
1174 breakpoint_re_set ();
1179 kernel_u_size (void)
1181 return (sizeof (struct user
));
1184 /* Under AIX, we have to pass the correct TOC pointer to a function
1185 when calling functions in the inferior.
1186 We try to find the relative toc offset of the objfile containing PC
1187 and add the current load address of the data segment from the vmap. */
1190 find_toc_address (CORE_ADDR pc
)
1193 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1195 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1197 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1199 /* vp->objfile is only NULL for the exec file. */
1200 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1205 error ("Unable to find TOC entry for pc %s\n", local_hex_string (pc
));
1208 /* Register that we are able to handle rs6000 core file formats. */
1210 static struct core_fns rs6000_core_fns
=
1212 bfd_target_xcoff_flavour
, /* core_flavour */
1213 default_check_format
, /* check_format */
1214 default_core_sniffer
, /* core_sniffer */
1215 fetch_core_registers
, /* core_read_registers */
1220 _initialize_core_rs6000 (void)
1222 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1223 calling functions in the inferior. */
1224 rs6000_find_toc_address_hook
= find_toc_address
;
1226 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1227 starting a child process. */
1228 rs6000_set_host_arch_hook
= set_host_arch
;
1230 deprecated_add_core_fns (&rs6000_core_fns
);