1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "xcoffsolib.h"
27 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
29 #include "exceptions.h"
30 #include "gdb-stabs.h"
32 #include "arch-utils.h"
33 #include "inf-child.h"
34 #include "inf-ptrace.h"
36 #include "rs6000-tdep.h"
39 #include "xcoffread.h"
41 #include <sys/ptrace.h>
44 #include <sys/param.h>
48 #include <sys/ioctl.h>
57 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
58 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
60 #include <sys/systemcfg.h>
62 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
63 debugging 32-bit and 64-bit processes. Define a typedef and macros for
64 accessing fields in the appropriate structures. */
66 /* In 32-bit compilation mode (which is the only mode from which ptrace()
67 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
73 /* Return whether the current architecture is 64-bit. */
78 # define ARCH64() (register_size (target_gdbarch (), 0) == 8)
81 /* Union of 32-bit and 64-bit versions of ld_info. */
88 struct __ld_info32 l32
;
89 struct __ld_info64 l64
;
93 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
94 declare and initialize a variable named VAR suitable for use as the arch64
95 parameter to the various LDI_*() macros. */
98 # define ARCH64_DECL(var)
100 # define ARCH64_DECL(var) int var = ARCH64 ()
103 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
104 otherwise. This technique only works for FIELDs with the same data type in
105 32-bit and 64-bit versions of ld_info. */
108 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
110 # define LDI_FIELD(ldi, arch64, field) \
111 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
114 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
115 process otherwise. */
117 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
118 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
119 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
121 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
123 static void vmap_exec (void);
125 static void vmap_ldinfo (LdInfo
*);
127 static struct vmap
*add_vmap (LdInfo
*);
129 static int objfile_symbol_add (void *);
131 static void vmap_symtab (struct vmap
*);
133 static void exec_one_dummy_insn (struct regcache
*);
135 extern void fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
137 /* Given REGNO, a gdb register number, return the corresponding
138 number suitable for use as a ptrace() parameter. Return -1 if
139 there's no suitable mapping. Also, set the int pointed to by
140 ISFLOAT to indicate whether REGNO is a floating point register. */
143 regmap (struct gdbarch
*gdbarch
, int regno
, int *isfloat
)
145 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
148 if (tdep
->ppc_gp0_regnum
<= regno
149 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
151 else if (tdep
->ppc_fp0_regnum
>= 0
152 && tdep
->ppc_fp0_regnum
<= regno
153 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
156 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
158 else if (regno
== gdbarch_pc_regnum (gdbarch
))
160 else if (regno
== tdep
->ppc_ps_regnum
)
162 else if (regno
== tdep
->ppc_cr_regnum
)
164 else if (regno
== tdep
->ppc_lr_regnum
)
166 else if (regno
== tdep
->ppc_ctr_regnum
)
168 else if (regno
== tdep
->ppc_xer_regnum
)
170 else if (tdep
->ppc_fpscr_regnum
>= 0
171 && regno
== tdep
->ppc_fpscr_regnum
)
173 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
179 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
182 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
184 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
186 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
187 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
192 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
195 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, void *buf
)
198 int ret
= ptracex (req
, id
, addr
, data
, buf
);
203 printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
204 req
, id
, hex_string (addr
), data
, (unsigned int)buf
, ret
);
209 /* Fetch register REGNO from the inferior. */
212 fetch_register (struct regcache
*regcache
, int regno
)
214 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
215 int addr
[MAX_REGISTER_SIZE
];
218 /* Retrieved values may be -1, so infer errors from errno. */
221 nr
= regmap (gdbarch
, regno
, &isfloat
);
223 /* Floating-point registers. */
225 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
227 /* Bogus register number. */
230 if (regno
>= gdbarch_num_regs (gdbarch
))
231 fprintf_unfiltered (gdb_stderr
,
232 "gdb error: register no %d not implemented.\n",
237 /* Fixed-point registers. */
241 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
),
245 /* PT_READ_GPR requires the buffer parameter to point to long long,
246 even if the register is really only 32 bits. */
248 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
249 if (register_size (gdbarch
, regno
) == 8)
250 memcpy (addr
, &buf
, 8);
257 regcache_raw_supply (regcache
, regno
, (char *) addr
);
261 /* FIXME: this happens 3 times at the start of each 64-bit program. */
262 perror (_("ptrace read"));
268 /* Store register REGNO back into the inferior. */
271 store_register (struct regcache
*regcache
, int regno
)
273 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
274 int addr
[MAX_REGISTER_SIZE
];
277 /* Fetch the register's value from the register cache. */
278 regcache_raw_collect (regcache
, regno
, addr
);
280 /* -1 can be a successful return value, so infer errors from errno. */
283 nr
= regmap (gdbarch
, regno
, &isfloat
);
285 /* Floating-point registers. */
287 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
289 /* Bogus register number. */
292 if (regno
>= gdbarch_num_regs (gdbarch
))
293 fprintf_unfiltered (gdb_stderr
,
294 "gdb error: register no %d not implemented.\n",
298 /* Fixed-point registers. */
301 if (regno
== gdbarch_sp_regnum (gdbarch
))
302 /* Execute one dummy instruction (which is a breakpoint) in inferior
303 process to give kernel a chance to do internal housekeeping.
304 Otherwise the following ptrace(2) calls will mess up user stack
305 since kernel will get confused about the bottom of the stack
307 exec_one_dummy_insn (regcache
);
309 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
310 the register's value is passed by value, but for 64-bit inferiors,
311 the address of a buffer containing the value is passed. */
313 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
),
314 (int *) nr
, *addr
, 0);
317 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
318 area, even if the register is really only 32 bits. */
320 if (register_size (gdbarch
, regno
) == 8)
321 memcpy (&buf
, addr
, 8);
324 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
330 perror (_("ptrace write"));
335 /* Read from the inferior all registers if REGNO == -1 and just register
339 rs6000_fetch_inferior_registers (struct target_ops
*ops
,
340 struct regcache
*regcache
, int regno
)
342 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
344 fetch_register (regcache
, regno
);
348 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
350 /* Read 32 general purpose registers. */
351 for (regno
= tdep
->ppc_gp0_regnum
;
352 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
355 fetch_register (regcache
, regno
);
358 /* Read general purpose floating point registers. */
359 if (tdep
->ppc_fp0_regnum
>= 0)
360 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
361 fetch_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
363 /* Read special registers. */
364 fetch_register (regcache
, gdbarch_pc_regnum (gdbarch
));
365 fetch_register (regcache
, tdep
->ppc_ps_regnum
);
366 fetch_register (regcache
, tdep
->ppc_cr_regnum
);
367 fetch_register (regcache
, tdep
->ppc_lr_regnum
);
368 fetch_register (regcache
, tdep
->ppc_ctr_regnum
);
369 fetch_register (regcache
, tdep
->ppc_xer_regnum
);
370 if (tdep
->ppc_fpscr_regnum
>= 0)
371 fetch_register (regcache
, tdep
->ppc_fpscr_regnum
);
372 if (tdep
->ppc_mq_regnum
>= 0)
373 fetch_register (regcache
, tdep
->ppc_mq_regnum
);
377 /* Store our register values back into the inferior.
378 If REGNO is -1, do this for all registers.
379 Otherwise, REGNO specifies which register (so we can save time). */
382 rs6000_store_inferior_registers (struct target_ops
*ops
,
383 struct regcache
*regcache
, int regno
)
385 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
387 store_register (regcache
, regno
);
391 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
393 /* Write general purpose registers first. */
394 for (regno
= tdep
->ppc_gp0_regnum
;
395 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
398 store_register (regcache
, regno
);
401 /* Write floating point registers. */
402 if (tdep
->ppc_fp0_regnum
>= 0)
403 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
404 store_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
406 /* Write special registers. */
407 store_register (regcache
, gdbarch_pc_regnum (gdbarch
));
408 store_register (regcache
, tdep
->ppc_ps_regnum
);
409 store_register (regcache
, tdep
->ppc_cr_regnum
);
410 store_register (regcache
, tdep
->ppc_lr_regnum
);
411 store_register (regcache
, tdep
->ppc_ctr_regnum
);
412 store_register (regcache
, tdep
->ppc_xer_regnum
);
413 if (tdep
->ppc_fpscr_regnum
>= 0)
414 store_register (regcache
, tdep
->ppc_fpscr_regnum
);
415 if (tdep
->ppc_mq_regnum
>= 0)
416 store_register (regcache
, tdep
->ppc_mq_regnum
);
421 /* Attempt a transfer all LEN bytes starting at OFFSET between the
422 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
423 Return the number of bytes actually transferred. */
426 rs6000_xfer_partial (struct target_ops
*ops
, enum target_object object
,
427 const char *annex
, gdb_byte
*readbuf
,
428 const gdb_byte
*writebuf
,
429 ULONGEST offset
, LONGEST len
)
431 pid_t pid
= ptid_get_pid (inferior_ptid
);
432 int arch64
= ARCH64 ();
436 case TARGET_OBJECT_MEMORY
:
440 PTRACE_TYPE_RET word
;
441 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
443 ULONGEST rounded_offset
;
446 /* Round the start offset down to the next long word
448 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
450 /* Since ptrace will transfer a single word starting at that
451 rounded_offset the partial_len needs to be adjusted down to
452 that (remember this function only does a single transfer).
453 Should the required length be even less, adjust it down
455 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
456 if (partial_len
> len
)
461 /* If OFFSET:PARTIAL_LEN is smaller than
462 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
463 be needed. Read in the entire word. */
464 if (rounded_offset
< offset
465 || (offset
+ partial_len
466 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
468 /* Need part of initial word -- fetch it. */
470 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
471 rounded_offset
, 0, NULL
);
473 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
479 /* Copy data to be written over corresponding part of
481 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
482 writebuf
, partial_len
);
486 rs6000_ptrace64 (PT_WRITE_D
, pid
,
487 rounded_offset
, buffer
.word
, NULL
);
489 rs6000_ptrace32 (PT_WRITE_D
, pid
,
490 (int *) (uintptr_t) rounded_offset
,
500 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
501 rounded_offset
, 0, NULL
);
503 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
504 (int *)(uintptr_t)rounded_offset
,
509 /* Copy appropriate bytes out of the buffer. */
510 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
522 /* Wait for the child specified by PTID to do something. Return the
523 process ID of the child, or MINUS_ONE_PTID in case of error; store
524 the status in *OURSTATUS. */
527 rs6000_wait (struct target_ops
*ops
,
528 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
531 int status
, save_errno
;
539 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
542 while (pid
== -1 && errno
== EINTR
);
544 clear_sigint_trap ();
548 fprintf_unfiltered (gdb_stderr
,
549 _("Child process unexpectedly missing: %s.\n"),
550 safe_strerror (save_errno
));
552 /* Claim it exited with unknown signal. */
553 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
554 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
555 return inferior_ptid
;
558 /* Ignore terminated detached child processes. */
559 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
564 /* AIX has a couple of strange returns from wait(). */
566 /* stop after load" status. */
568 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
569 /* signal 0. I have no idea why wait(2) returns with this status word. */
570 else if (status
== 0x7f)
571 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
572 /* A normal waitstatus. Let the usual macros deal with it. */
574 store_waitstatus (ourstatus
, status
);
576 return pid_to_ptid (pid
);
579 /* Execute one dummy breakpoint instruction. This way we give the kernel
580 a chance to do some housekeeping and update inferior's internal data,
584 exec_one_dummy_insn (struct regcache
*regcache
)
586 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
588 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
589 int ret
, status
, pid
;
593 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
594 assume that this address will never be executed again by the real
597 bp
= deprecated_insert_raw_breakpoint (gdbarch
, NULL
, DUMMY_INSN_ADDR
);
599 /* You might think this could be done with a single ptrace call, and
600 you'd be correct for just about every platform I've ever worked
601 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
602 the inferior never hits the breakpoint (it's also worth noting
603 powerpc-ibm-aix4.1.3 works correctly). */
604 prev_pc
= regcache_read_pc (regcache
);
605 regcache_write_pc (regcache
, DUMMY_INSN_ADDR
);
607 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
609 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
),
613 perror (_("pt_continue"));
617 pid
= waitpid (PIDGET (inferior_ptid
), &status
, 0);
619 while (pid
!= PIDGET (inferior_ptid
));
621 regcache_write_pc (regcache
, prev_pc
);
622 deprecated_remove_raw_breakpoint (gdbarch
, bp
);
626 /* Copy information about text and data sections from LDI to VP for a 64-bit
627 process if ARCH64 and for a 32-bit process otherwise. */
630 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
634 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
635 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
636 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
637 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
641 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
642 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
643 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
644 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
647 /* The run time loader maps the file header in addition to the text
648 section and returns a pointer to the header in ldinfo_textorg.
649 Adjust the text start address to point to the real start address
650 of the text section. */
651 vp
->tstart
+= vp
->toffs
;
654 /* Handle symbol translation on vmapping. */
657 vmap_symtab (struct vmap
*vp
)
659 struct objfile
*objfile
;
660 struct section_offsets
*new_offsets
;
663 objfile
= vp
->objfile
;
666 /* OK, it's not an objfile we opened ourselves.
667 Currently, that can only happen with the exec file, so
668 relocate the symbols for the symfile. */
669 if (symfile_objfile
== NULL
)
671 objfile
= symfile_objfile
;
673 else if (!vp
->loaded
)
674 /* If symbols are not yet loaded, offsets are not yet valid. */
678 (struct section_offsets
*)
679 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
681 for (i
= 0; i
< objfile
->num_sections
; ++i
)
682 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
684 /* The symbols in the object file are linked to the VMA of the section,
685 relocate them VMA relative. */
686 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
687 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
688 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
690 objfile_relocate (objfile
, new_offsets
);
693 /* Add symbols for an objfile. */
696 objfile_symbol_add (void *arg
)
698 struct objfile
*obj
= (struct objfile
*) arg
;
700 syms_from_objfile (obj
, NULL
, 0, 0, 0);
701 new_symfile_objfile (obj
, 0);
705 /* Add symbols for a vmap. Return zero upon error. */
708 vmap_add_symbols (struct vmap
*vp
)
710 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
711 "Error while reading shared library symbols:\n",
714 /* Note this is only done if symbol reading was successful. */
722 /* Add a new vmap entry based on ldinfo() information.
724 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
725 core file), the caller should set it to -1, and we will open the file.
727 Return the vmap new entry. */
730 add_vmap (LdInfo
*ldi
)
733 char *mem
, *filename
;
737 ARCH64_DECL (arch64
);
739 /* This ldi structure was allocated using alloca() in
740 xcoff_relocate_symtab(). Now we need to have persistent object
741 and member names, so we should save them. */
743 filename
= LDI_FILENAME (ldi
, arch64
);
744 mem
= filename
+ strlen (filename
) + 1;
747 fd
= LDI_FD (ldi
, arch64
);
748 abfd
= gdb_bfd_open (filename
, gnutarget
, fd
< 0 ? -1 : fd
);
751 warning (_("Could not open `%s' as an executable file: %s"),
752 filename
, 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
))
763 last
= gdb_bfd_openr_next_archived_file (abfd
, NULL
);
768 if (strcmp (mem
, last
->filename
) == 0)
771 next
= gdb_bfd_openr_next_archived_file (abfd
, last
);
772 gdb_bfd_unref (last
);
778 warning (_("\"%s\": member \"%s\" missing."), filename
, mem
);
779 gdb_bfd_unref (abfd
);
783 if (!bfd_check_format (last
, bfd_object
))
785 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
786 filename
, mem
, bfd_errmsg (bfd_get_error ()));
787 gdb_bfd_unref (last
);
788 gdb_bfd_unref (abfd
);
792 vp
= map_vmap (last
, abfd
);
793 /* map_vmap acquired a reference to LAST, so we can release
795 gdb_bfd_unref (last
);
799 warning (_("\"%s\": not in executable format: %s."),
800 filename
, bfd_errmsg (bfd_get_error ()));
801 gdb_bfd_unref (abfd
);
804 obj
= allocate_objfile (vp
->bfd
, 0);
807 /* Always add symbols for the main objfile. */
808 if (vp
== vmap
|| auto_solib_add
)
809 vmap_add_symbols (vp
);
811 /* Anything needing a reference to ABFD has already acquired it, so
812 release our local reference. */
813 gdb_bfd_unref (abfd
);
818 /* update VMAP info with ldinfo() information
819 Input is ptr to ldinfo() results. */
822 vmap_ldinfo (LdInfo
*ldi
)
826 int got_one
, retried
;
827 int got_exec_file
= 0;
829 int arch64
= ARCH64 ();
831 /* For each *ldi, see if we have a corresponding *vp.
832 If so, update the mapping, and symbol table.
833 If not, add an entry and symbol table. */
837 char *name
= LDI_FILENAME (ldi
, arch64
);
838 char *memb
= name
+ strlen (name
) + 1;
839 int fd
= LDI_FD (ldi
, arch64
);
843 if (fstat (fd
, &ii
) < 0)
845 /* The kernel sets ld_info to -1, if the process is still using the
846 object, and the object is removed. Keep the symbol info for the
847 removed object and issue a warning. */
848 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
853 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
855 struct objfile
*objfile
;
857 /* First try to find a `vp', which is the same as in ldinfo.
858 If not the same, just continue and grep the next `vp'. If same,
859 relocate its tstart, tend, dstart, dend values. If no such `vp'
860 found, get out of this for loop, add this ldi entry as a new vmap
861 (add_vmap) and come back, find its `vp' and so on... */
863 /* The filenames are not always sufficient to match on. */
865 if ((name
[0] == '/' && strcmp (name
, vp
->name
) != 0)
866 || (memb
[0] && strcmp (memb
, vp
->member
) != 0))
869 /* See if we are referring to the same file.
870 We have to check objfile->obfd, symfile.c:reread_symbols might
871 have updated the obfd after a change. */
872 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
874 || objfile
->obfd
== NULL
875 || bfd_stat (objfile
->obfd
, &vi
) < 0)
877 warning (_("Unable to stat %s, keeping its symbols"), name
);
881 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
889 /* Found a corresponding VMAP. Remap! */
891 vmap_secs (vp
, ldi
, arch64
);
893 /* The objfile is only NULL for the exec file. */
894 if (vp
->objfile
== NULL
)
897 /* relocate symbol table(s). */
900 /* Announce new object files. Doing this after symbol relocation
901 makes aix-thread.c's job easier. */
903 observer_notify_new_objfile (vp
->objfile
);
905 /* There may be more, so we don't break out of the loop. */
908 /* If there was no matching *vp, we must perforce create the
910 if (!got_one
&& !retried
)
917 while ((next
= LDI_NEXT (ldi
, arch64
))
918 && (ldi
= (void *) (next
+ (char *) ldi
)));
920 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
921 is unlikely that the symbol file is relocated to the proper
922 address. And we might have attached to a process which is
923 running a different copy of the same executable. */
924 if (symfile_objfile
!= NULL
&& !got_exec_file
)
926 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
927 If in fact that file has symbols which the mapped files listed by\n\
928 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
929 \"add-symbol-file\" commands (note that you must take care of relocating\n\
930 symbols to the proper address)."),
931 symfile_objfile
->name
);
932 free_objfile (symfile_objfile
);
933 gdb_assert (symfile_objfile
== NULL
);
935 breakpoint_re_set ();
938 /* As well as symbol tables, exec_sections need relocation. After
939 the inferior process' termination, there will be a relocated symbol
940 table exist with no corresponding inferior process. At that time, we
941 need to use `exec' bfd, rather than the inferior process's memory space
944 `exec_sections' need to be relocated only once, as long as the exec
945 file remains unchanged. */
952 struct target_section_table
*table
= target_get_section_table (&exec_ops
);
954 if (execbfd
== exec_bfd
)
959 if (!vmap
|| !table
->sections
)
960 error (_("vmap_exec: vmap or table->sections == 0."));
962 for (i
= 0; &table
->sections
[i
] < table
->sections_end
; i
++)
964 if (strcmp (".text", table
->sections
[i
].the_bfd_section
->name
) == 0)
966 table
->sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
967 table
->sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
969 else if (strcmp (".data", table
->sections
[i
].the_bfd_section
->name
) == 0)
971 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
972 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
974 else if (strcmp (".bss", table
->sections
[i
].the_bfd_section
->name
) == 0)
976 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
977 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
982 /* Set the current architecture from the host running GDB. Called when
983 starting a child process. */
985 static void (*super_create_inferior
) (struct target_ops
*,char *exec_file
,
986 char *allargs
, char **env
, int from_tty
);
988 rs6000_create_inferior (struct target_ops
* ops
, char *exec_file
,
989 char *allargs
, char **env
, int from_tty
)
991 enum bfd_architecture arch
;
994 struct gdbarch_info info
;
996 super_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1000 arch
= bfd_arch_rs6000
;
1001 mach
= bfd_mach_rs6k
;
1005 arch
= bfd_arch_powerpc
;
1006 mach
= bfd_mach_ppc
;
1009 /* FIXME: schauer/2002-02-25:
1010 We don't know if we are executing a 32 or 64 bit executable,
1011 and have no way to pass the proper word size to rs6000_gdbarch_init.
1012 So we have to avoid switching to a new architecture, if the architecture
1014 Blindly calling rs6000_gdbarch_init used to work in older versions of
1015 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1016 determine the wordsize. */
1019 const struct bfd_arch_info
*exec_bfd_arch_info
;
1021 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1022 if (arch
== exec_bfd_arch_info
->arch
)
1026 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1028 gdbarch_info_init (&info
);
1029 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1030 info
.abfd
= exec_bfd
;
1032 if (!gdbarch_update_p (info
))
1033 internal_error (__FILE__
, __LINE__
,
1034 _("rs6000_create_inferior: failed "
1035 "to select architecture"));
1039 /* xcoff_relocate_symtab - hook for symbol table relocation.
1041 This is only applicable to live processes, and is a no-op when
1042 debugging a core file. */
1045 xcoff_relocate_symtab (unsigned int pid
)
1047 int load_segs
= 64; /* number of load segments */
1050 int arch64
= ARCH64 ();
1051 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1054 /* Nothing to do if we are debugging a core file. */
1055 if (!target_has_execution
)
1060 size
= load_segs
* ldisize
;
1061 ldi
= (void *) xrealloc (ldi
, size
);
1064 /* According to my humble theory, AIX has some timing problems and
1065 when the user stack grows, kernel doesn't update stack info in time
1066 and ptrace calls step on user stack. That is why we sleep here a
1067 little, and give kernel to update its internals. */
1072 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1074 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1078 if (errno
== ENOMEM
)
1081 perror_with_name (_("ptrace ldinfo"));
1086 vmap_exec (); /* relocate the exec and core sections as well. */
1093 /* Core file stuff. */
1095 /* Relocate symtabs and read in shared library info, based on symbols
1096 from the core file. */
1099 xcoff_relocate_core (struct target_ops
*target
)
1101 struct bfd_section
*ldinfo_sec
;
1105 int arch64
= ARCH64 ();
1107 /* Size of a struct ld_info except for the variable-length filename. */
1108 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1110 /* Allocated size of buffer. */
1111 int buffer_size
= nonfilesz
;
1112 char *buffer
= xmalloc (buffer_size
);
1113 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1115 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1116 if (ldinfo_sec
== NULL
)
1119 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1120 bfd_errmsg (bfd_get_error ()));
1127 int names_found
= 0;
1129 /* Read in everything but the name. */
1130 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1131 offset
, nonfilesz
) == 0)
1138 if (i
== buffer_size
)
1141 buffer
= xrealloc (buffer
, buffer_size
);
1143 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1144 offset
+ i
, 1) == 0)
1146 if (buffer
[i
++] == '\0')
1149 while (names_found
< 2);
1151 ldi
= (LdInfo
*) buffer
;
1153 /* Can't use a file descriptor from the core file; need to open it. */
1155 ldi
->l64
.ldinfo_fd
= -1;
1157 ldi
->l32
.ldinfo_fd
= -1;
1159 /* The first ldinfo is for the exec file, allocated elsewhere. */
1160 if (offset
== 0 && vmap
!= NULL
)
1163 vp
= add_vmap (ldi
);
1165 /* Process next shared library upon error. */
1166 offset
+= LDI_NEXT (ldi
, arch64
);
1170 vmap_secs (vp
, ldi
, arch64
);
1172 /* Unless this is the exec file,
1173 add our sections to the section table for the core target. */
1176 struct target_section
*stp
;
1178 stp
= deprecated_core_resize_section_table (2);
1181 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1182 stp
->addr
= vp
->tstart
;
1183 stp
->endaddr
= vp
->tend
;
1187 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1188 stp
->addr
= vp
->dstart
;
1189 stp
->endaddr
= vp
->dend
;
1194 if (vp
!= vmap
&& vp
->objfile
)
1195 observer_notify_new_objfile (vp
->objfile
);
1197 while (LDI_NEXT (ldi
, arch64
) != 0);
1199 breakpoint_re_set ();
1203 /* Under AIX, we have to pass the correct TOC pointer to a function
1204 when calling functions in the inferior.
1205 We try to find the relative toc offset of the objfile containing PC
1206 and add the current load address of the data segment from the vmap. */
1209 find_toc_address (CORE_ADDR pc
)
1213 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1215 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1217 /* vp->objfile is only NULL for the exec file. */
1218 return vp
->dstart
+ xcoff_get_toc_offset (vp
->objfile
== NULL
1223 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1227 void _initialize_rs6000_nat (void);
1230 _initialize_rs6000_nat (void)
1232 struct target_ops
*t
;
1234 t
= inf_ptrace_target ();
1235 t
->to_fetch_registers
= rs6000_fetch_inferior_registers
;
1236 t
->to_store_registers
= rs6000_store_inferior_registers
;
1237 t
->to_xfer_partial
= rs6000_xfer_partial
;
1239 super_create_inferior
= t
->to_create_inferior
;
1240 t
->to_create_inferior
= rs6000_create_inferior
;
1242 t
->to_wait
= rs6000_wait
;
1246 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1247 when calling functions in the inferior. */
1248 rs6000_find_toc_address_hook
= find_toc_address
;