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 (FP0_REGNUM
<= regno
&& regno
< FP0_REGNUM
+ ppc_num_fprs
)
165 return regno
- FP0_REGNUM
+ FPR0
;
167 else if (regno
== PC_REGNUM
)
169 else if (regno
== tdep
->ppc_ps_regnum
)
171 else if (regno
== tdep
->ppc_cr_regnum
)
173 else if (regno
== tdep
->ppc_lr_regnum
)
175 else if (regno
== tdep
->ppc_ctr_regnum
)
177 else if (regno
== tdep
->ppc_xer_regnum
)
179 else if (regno
== tdep
->ppc_fpscr_regnum
)
181 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
187 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
190 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
192 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
194 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
195 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
200 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
203 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, int *buf
)
206 int ret
= ptracex (req
, id
, addr
, data
, buf
);
211 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
212 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
217 /* Fetch register REGNO from the inferior. */
220 fetch_register (int regno
)
222 int addr
[MAX_REGISTER_SIZE
];
225 /* Retrieved values may be -1, so infer errors from errno. */
228 nr
= regmap (regno
, &isfloat
);
230 /* Floating-point registers. */
232 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
234 /* Bogus register number. */
237 if (regno
>= NUM_REGS
)
238 fprintf_unfiltered (gdb_stderr
,
239 "gdb error: register no %d not implemented.\n",
244 /* Fixed-point registers. */
248 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
), (int *)nr
, 0, 0);
251 /* PT_READ_GPR requires the buffer parameter to point to long long,
252 even if the register is really only 32 bits. */
254 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
255 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) == 8)
256 memcpy (addr
, &buf
, 8);
263 supply_register (regno
, (char *) addr
);
267 /* FIXME: this happens 3 times at the start of each 64-bit program. */
268 perror ("ptrace read");
274 /* Store register REGNO back into the inferior. */
277 store_register (int regno
)
279 int addr
[MAX_REGISTER_SIZE
];
282 /* Fetch the register's value from the register cache. */
283 regcache_collect (regno
, addr
);
285 /* -1 can be a successful return value, so infer errors from errno. */
288 nr
= regmap (regno
, &isfloat
);
290 /* Floating-point registers. */
292 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
294 /* Bogus register number. */
297 if (regno
>= NUM_REGS
)
298 fprintf_unfiltered (gdb_stderr
,
299 "gdb error: register no %d not implemented.\n",
303 /* Fixed-point registers. */
306 if (regno
== SP_REGNUM
)
307 /* Execute one dummy instruction (which is a breakpoint) in inferior
308 process to give kernel a chance to do internal housekeeping.
309 Otherwise the following ptrace(2) calls will mess up user stack
310 since kernel will get confused about the bottom of the stack
312 exec_one_dummy_insn ();
314 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
315 the register's value is passed by value, but for 64-bit inferiors,
316 the address of a buffer containing the value is passed. */
318 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), (int *)nr
, *addr
, 0);
321 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
322 area, even if the register is really only 32 bits. */
324 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) == 8)
325 memcpy (&buf
, addr
, 8);
328 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
334 perror ("ptrace write");
339 /* Read from the inferior all registers if REGNO == -1 and just register
343 fetch_inferior_registers (int regno
)
346 fetch_register (regno
);
350 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
352 /* Read 32 general purpose registers. */
353 for (regno
= tdep
->ppc_gp0_regnum
;
354 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
357 fetch_register (regno
);
360 /* Read general purpose floating point registers. */
361 for (regno
= FP0_REGNUM
; regno
< FP0_REGNUM
+ ppc_num_fprs
; regno
++)
362 fetch_register (regno
);
364 /* Read special registers. */
365 fetch_register (PC_REGNUM
);
366 fetch_register (tdep
->ppc_ps_regnum
);
367 fetch_register (tdep
->ppc_cr_regnum
);
368 fetch_register (tdep
->ppc_lr_regnum
);
369 fetch_register (tdep
->ppc_ctr_regnum
);
370 fetch_register (tdep
->ppc_xer_regnum
);
371 fetch_register (tdep
->ppc_fpscr_regnum
);
372 if (tdep
->ppc_mq_regnum
>= 0)
373 fetch_register (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 store_inferior_registers (int regno
)
385 store_register (regno
);
389 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
391 /* Write general purpose registers first. */
392 for (regno
= tdep
->ppc_gp0_regnum
;
393 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
396 store_register (regno
);
399 /* Write floating point registers. */
400 for (regno
= FP0_REGNUM
; regno
< FP0_REGNUM
+ ppc_num_fprs
; regno
++)
401 store_register (regno
);
403 /* Write special registers. */
404 store_register (PC_REGNUM
);
405 store_register (tdep
->ppc_ps_regnum
);
406 store_register (tdep
->ppc_cr_regnum
);
407 store_register (tdep
->ppc_lr_regnum
);
408 store_register (tdep
->ppc_ctr_regnum
);
409 store_register (tdep
->ppc_xer_regnum
);
410 store_register (tdep
->ppc_fpscr_regnum
);
411 if (tdep
->ppc_mq_regnum
>= 0)
412 store_register (tdep
->ppc_mq_regnum
);
416 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
417 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
421 read_word (CORE_ADDR from
, int *to
, int arch64
)
423 /* Retrieved values may be -1, so infer errors from errno. */
427 *to
= rs6000_ptrace64 (PT_READ_I
, PIDGET (inferior_ptid
), from
, 0, NULL
);
429 *to
= rs6000_ptrace32 (PT_READ_I
, PIDGET (inferior_ptid
), (int *)(long) from
,
435 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
436 to debugger memory starting at MYADDR. Copy to inferior if
439 Returns the length copied, which is either the LEN argument or zero.
440 This xfer function does not do partial moves, since child_ops
441 doesn't allow memory operations to cross below us in the target stack
445 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
446 int write
, struct mem_attrib
*attrib
,
447 struct target_ops
*target
)
449 /* Round starting address down to 32-bit word boundary. */
450 int mask
= sizeof (int) - 1;
451 CORE_ADDR addr
= memaddr
& ~(CORE_ADDR
)mask
;
453 /* Round ending address up to 32-bit word boundary. */
454 int count
= ((memaddr
+ len
- addr
+ mask
) & ~(CORE_ADDR
)mask
)
457 /* Allocate word transfer buffer. */
458 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
459 because it uses alloca to allocate a buffer of arbitrary size.
460 For very large xfers, this could crash GDB's stack. */
461 int *buf
= (int *) alloca (count
* sizeof (int));
463 int arch64
= ARCH64 ();
468 /* Retrieve memory a word at a time. */
469 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
471 if (!read_word (addr
, buf
+ i
, arch64
))
476 /* Copy memory to supplied buffer. */
477 addr
-= count
* sizeof (int);
478 memcpy (myaddr
, (char *)buf
+ (memaddr
- addr
), len
);
482 /* Fetch leading memory needed for alignment. */
484 if (!read_word (addr
, buf
, arch64
))
487 /* Fetch trailing memory needed for alignment. */
488 if (addr
+ count
* sizeof (int) > memaddr
+ len
)
489 if (!read_word (addr
+ (count
- 1) * sizeof (int),
490 buf
+ count
- 1, arch64
))
493 /* Copy supplied data into memory buffer. */
494 memcpy ((char *)buf
+ (memaddr
- addr
), myaddr
, len
);
496 /* Store memory one word at a time. */
497 for (i
= 0, errno
= 0; i
< count
; i
++, addr
+= sizeof (int))
500 rs6000_ptrace64 (PT_WRITE_D
, PIDGET (inferior_ptid
), addr
, buf
[i
], NULL
);
502 rs6000_ptrace32 (PT_WRITE_D
, PIDGET (inferior_ptid
), (int *)(long) addr
,
514 /* Execute one dummy breakpoint instruction. This way we give the kernel
515 a chance to do some housekeeping and update inferior's internal data,
519 exec_one_dummy_insn (void)
521 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
523 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
524 int ret
, status
, pid
;
527 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
528 assume that this address will never be executed again by the real
531 target_insert_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
533 /* You might think this could be done with a single ptrace call, and
534 you'd be correct for just about every platform I've ever worked
535 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
536 the inferior never hits the breakpoint (it's also worth noting
537 powerpc-ibm-aix4.1.3 works correctly). */
538 prev_pc
= read_pc ();
539 write_pc (DUMMY_INSN_ADDR
);
541 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
543 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
), (int *)1, 0, NULL
);
546 perror ("pt_continue");
550 pid
= wait (&status
);
552 while (pid
!= PIDGET (inferior_ptid
));
555 target_remove_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
558 /* Fetch registers from the register section in core bfd. */
561 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
562 int which
, CORE_ADDR reg_addr
)
566 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
572 "Gdb error: unknown parameter to fetch_core_registers().\n");
576 regs
= (CoreRegs
*) core_reg_sect
;
578 /* Put the register values from the core file section in the regcache. */
582 for (regi
= 0; regi
< 32; regi
++)
583 supply_register (regi
, (char *) ®s
->r64
.gpr
[regi
]);
585 for (regi
= 0; regi
< 32; regi
++)
586 supply_register (FP0_REGNUM
+ regi
, (char *) ®s
->r64
.fpr
[regi
]);
588 supply_register (PC_REGNUM
, (char *) ®s
->r64
.iar
);
589 supply_register (tdep
->ppc_ps_regnum
, (char *) ®s
->r64
.msr
);
590 supply_register (tdep
->ppc_cr_regnum
, (char *) ®s
->r64
.cr
);
591 supply_register (tdep
->ppc_lr_regnum
, (char *) ®s
->r64
.lr
);
592 supply_register (tdep
->ppc_ctr_regnum
, (char *) ®s
->r64
.ctr
);
593 supply_register (tdep
->ppc_xer_regnum
, (char *) ®s
->r64
.xer
);
594 supply_register (tdep
->ppc_fpscr_regnum
, (char *) ®s
->r64
.fpscr
);
598 for (regi
= 0; regi
< 32; regi
++)
599 supply_register (regi
, (char *) ®s
->r32
.gpr
[regi
]);
601 for (regi
= 0; regi
< 32; regi
++)
602 supply_register (FP0_REGNUM
+ regi
, (char *) ®s
->r32
.fpr
[regi
]);
604 supply_register (PC_REGNUM
, (char *) ®s
->r32
.iar
);
605 supply_register (tdep
->ppc_ps_regnum
, (char *) ®s
->r32
.msr
);
606 supply_register (tdep
->ppc_cr_regnum
, (char *) ®s
->r32
.cr
);
607 supply_register (tdep
->ppc_lr_regnum
, (char *) ®s
->r32
.lr
);
608 supply_register (tdep
->ppc_ctr_regnum
, (char *) ®s
->r32
.ctr
);
609 supply_register (tdep
->ppc_xer_regnum
, (char *) ®s
->r32
.xer
);
610 supply_register (tdep
->ppc_fpscr_regnum
, (char *) ®s
->r32
.fpscr
);
611 if (tdep
->ppc_mq_regnum
>= 0)
612 supply_register (tdep
->ppc_mq_regnum
, (char *) ®s
->r32
.mq
);
617 /* Copy information about text and data sections from LDI to VP for a 64-bit
618 process if ARCH64 and for a 32-bit process otherwise. */
621 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
625 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
626 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
627 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
628 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
632 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
633 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
634 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
635 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
638 /* The run time loader maps the file header in addition to the text
639 section and returns a pointer to the header in ldinfo_textorg.
640 Adjust the text start address to point to the real start address
641 of the text section. */
642 vp
->tstart
+= vp
->toffs
;
645 /* handle symbol translation on vmapping */
648 vmap_symtab (struct vmap
*vp
)
650 struct objfile
*objfile
;
651 struct section_offsets
*new_offsets
;
654 objfile
= vp
->objfile
;
657 /* OK, it's not an objfile we opened ourselves.
658 Currently, that can only happen with the exec file, so
659 relocate the symbols for the symfile. */
660 if (symfile_objfile
== NULL
)
662 objfile
= symfile_objfile
;
664 else if (!vp
->loaded
)
665 /* If symbols are not yet loaded, offsets are not yet valid. */
669 (struct section_offsets
*)
670 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
672 for (i
= 0; i
< objfile
->num_sections
; ++i
)
673 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
675 /* The symbols in the object file are linked to the VMA of the section,
676 relocate them VMA relative. */
677 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
678 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
679 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
681 objfile_relocate (objfile
, new_offsets
);
684 /* Add symbols for an objfile. */
687 objfile_symbol_add (void *arg
)
689 struct objfile
*obj
= (struct objfile
*) arg
;
691 syms_from_objfile (obj
, NULL
, 0, 0, 0, 0);
692 new_symfile_objfile (obj
, 0, 0);
696 /* Add symbols for a vmap. Return zero upon error. */
699 vmap_add_symbols (struct vmap
*vp
)
701 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
702 "Error while reading shared library symbols:\n",
705 /* Note this is only done if symbol reading was successful. */
713 /* Add a new vmap entry based on ldinfo() information.
715 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
716 core file), the caller should set it to -1, and we will open the file.
718 Return the vmap new entry. */
721 add_vmap (LdInfo
*ldi
)
724 char *mem
, *objname
, *filename
;
728 ARCH64_DECL (arch64
);
730 /* This ldi structure was allocated using alloca() in
731 xcoff_relocate_symtab(). Now we need to have persistent object
732 and member names, so we should save them. */
734 filename
= LDI_FILENAME (ldi
, arch64
);
735 mem
= filename
+ strlen (filename
) + 1;
736 mem
= savestring (mem
, strlen (mem
));
737 objname
= savestring (filename
, strlen (filename
));
739 fd
= LDI_FD (ldi
, arch64
);
741 /* Note that this opens it once for every member; a possible
742 enhancement would be to only open it once for every object. */
743 abfd
= bfd_openr (objname
, gnutarget
);
745 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
748 warning ("Could not open `%s' as an executable file: %s",
749 objname
, bfd_errmsg (bfd_get_error ()));
753 /* make sure we have an object file */
755 if (bfd_check_format (abfd
, bfd_object
))
756 vp
= map_vmap (abfd
, 0);
758 else if (bfd_check_format (abfd
, bfd_archive
))
761 /* FIXME??? am I tossing BFDs? bfd? */
762 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
763 if (DEPRECATED_STREQ (mem
, last
->filename
))
768 warning ("\"%s\": member \"%s\" missing.", objname
, mem
);
773 if (!bfd_check_format (last
, bfd_object
))
775 warning ("\"%s\": member \"%s\" not in executable format: %s.",
776 objname
, mem
, bfd_errmsg (bfd_get_error ()));
782 vp
= map_vmap (last
, abfd
);
786 warning ("\"%s\": not in executable format: %s.",
787 objname
, bfd_errmsg (bfd_get_error ()));
791 obj
= allocate_objfile (vp
->bfd
, 0);
794 /* Always add symbols for the main objfile. */
795 if (vp
== vmap
|| auto_solib_add
)
796 vmap_add_symbols (vp
);
800 /* update VMAP info with ldinfo() information
801 Input is ptr to ldinfo() results. */
804 vmap_ldinfo (LdInfo
*ldi
)
808 int got_one
, retried
;
809 int got_exec_file
= 0;
811 int arch64
= ARCH64 ();
813 /* For each *ldi, see if we have a corresponding *vp.
814 If so, update the mapping, and symbol table.
815 If not, add an entry and symbol table. */
819 char *name
= LDI_FILENAME (ldi
, arch64
);
820 char *memb
= name
+ strlen (name
) + 1;
821 int fd
= LDI_FD (ldi
, arch64
);
825 if (fstat (fd
, &ii
) < 0)
827 /* The kernel sets ld_info to -1, if the process is still using the
828 object, and the object is removed. Keep the symbol info for the
829 removed object and issue a warning. */
830 warning ("%s (fd=%d) has disappeared, keeping its symbols",
835 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
837 struct objfile
*objfile
;
839 /* First try to find a `vp', which is the same as in ldinfo.
840 If not the same, just continue and grep the next `vp'. If same,
841 relocate its tstart, tend, dstart, dend values. If no such `vp'
842 found, get out of this for loop, add this ldi entry as a new vmap
843 (add_vmap) and come back, find its `vp' and so on... */
845 /* The filenames are not always sufficient to match on. */
847 if ((name
[0] == '/' && !DEPRECATED_STREQ (name
, vp
->name
))
848 || (memb
[0] && !DEPRECATED_STREQ (memb
, vp
->member
)))
851 /* See if we are referring to the same file.
852 We have to check objfile->obfd, symfile.c:reread_symbols might
853 have updated the obfd after a change. */
854 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
856 || objfile
->obfd
== NULL
857 || bfd_stat (objfile
->obfd
, &vi
) < 0)
859 warning ("Unable to stat %s, keeping its symbols", name
);
863 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
871 /* Found a corresponding VMAP. Remap! */
873 vmap_secs (vp
, ldi
, arch64
);
875 /* The objfile is only NULL for the exec file. */
876 if (vp
->objfile
== NULL
)
879 /* relocate symbol table(s). */
882 /* Announce new object files. Doing this after symbol relocation
883 makes aix-thread.c's job easier. */
884 if (deprecated_target_new_objfile_hook
&& vp
->objfile
)
885 deprecated_target_new_objfile_hook (vp
->objfile
);
887 /* There may be more, so we don't break out of the loop. */
890 /* if there was no matching *vp, we must perforce create the sucker(s) */
891 if (!got_one
&& !retried
)
898 while ((next
= LDI_NEXT (ldi
, arch64
))
899 && (ldi
= (void *) (next
+ (char *) ldi
)));
901 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
902 is unlikely that the symbol file is relocated to the proper
903 address. And we might have attached to a process which is
904 running a different copy of the same executable. */
905 if (symfile_objfile
!= NULL
&& !got_exec_file
)
907 warning ("Symbol file %s\nis not mapped; discarding it.\n\
908 If in fact that file has symbols which the mapped files listed by\n\
909 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
910 \"add-symbol-file\" commands (note that you must take care of relocating\n\
911 symbols to the proper address).",
912 symfile_objfile
->name
);
913 free_objfile (symfile_objfile
);
914 symfile_objfile
= NULL
;
916 breakpoint_re_set ();
919 /* As well as symbol tables, exec_sections need relocation. After
920 the inferior process' termination, there will be a relocated symbol
921 table exist with no corresponding inferior process. At that time, we
922 need to use `exec' bfd, rather than the inferior process's memory space
925 `exec_sections' need to be relocated only once, as long as the exec
926 file remains unchanged.
935 if (execbfd
== exec_bfd
)
940 if (!vmap
|| !exec_ops
.to_sections
)
941 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
943 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
945 if (DEPRECATED_STREQ (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
947 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
948 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
950 else if (DEPRECATED_STREQ (".data", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
952 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
953 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
955 else if (DEPRECATED_STREQ (".bss", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
957 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
958 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
963 /* Set the current architecture from the host running GDB. Called when
964 starting a child process. */
967 set_host_arch (int pid
)
969 enum bfd_architecture arch
;
972 struct gdbarch_info info
;
976 arch
= bfd_arch_rs6000
;
977 mach
= bfd_mach_rs6k
;
981 arch
= bfd_arch_powerpc
;
985 /* FIXME: schauer/2002-02-25:
986 We don't know if we are executing a 32 or 64 bit executable,
987 and have no way to pass the proper word size to rs6000_gdbarch_init.
988 So we have to avoid switching to a new architecture, if the architecture
990 Blindly calling rs6000_gdbarch_init used to work in older versions of
991 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
992 determine the wordsize. */
995 const struct bfd_arch_info
*exec_bfd_arch_info
;
997 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
998 if (arch
== exec_bfd_arch_info
->arch
)
1002 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1004 gdbarch_info_init (&info
);
1005 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1006 info
.abfd
= exec_bfd
;
1008 if (!gdbarch_update_p (info
))
1010 internal_error (__FILE__
, __LINE__
,
1011 "set_host_arch: failed to select architecture");
1016 /* xcoff_relocate_symtab - hook for symbol table relocation.
1017 also reads shared libraries.. */
1020 xcoff_relocate_symtab (unsigned int pid
)
1022 int load_segs
= 64; /* number of load segments */
1025 int arch64
= ARCH64 ();
1026 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1031 size
= load_segs
* ldisize
;
1032 ldi
= (void *) xrealloc (ldi
, size
);
1035 /* According to my humble theory, AIX has some timing problems and
1036 when the user stack grows, kernel doesn't update stack info in time
1037 and ptrace calls step on user stack. That is why we sleep here a
1038 little, and give kernel to update its internals. */
1043 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1045 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1049 if (errno
== ENOMEM
)
1052 perror_with_name ("ptrace ldinfo");
1057 vmap_exec (); /* relocate the exec and core sections as well. */
1064 /* Core file stuff. */
1066 /* Relocate symtabs and read in shared library info, based on symbols
1067 from the core file. */
1070 xcoff_relocate_core (struct target_ops
*target
)
1072 struct bfd_section
*ldinfo_sec
;
1076 int arch64
= ARCH64 ();
1078 /* Size of a struct ld_info except for the variable-length filename. */
1079 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1081 /* Allocated size of buffer. */
1082 int buffer_size
= nonfilesz
;
1083 char *buffer
= xmalloc (buffer_size
);
1084 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1086 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1087 if (ldinfo_sec
== NULL
)
1090 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1091 bfd_errmsg (bfd_get_error ()));
1098 int names_found
= 0;
1100 /* Read in everything but the name. */
1101 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1102 offset
, nonfilesz
) == 0)
1109 if (i
== buffer_size
)
1112 buffer
= xrealloc (buffer
, buffer_size
);
1114 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1115 offset
+ i
, 1) == 0)
1117 if (buffer
[i
++] == '\0')
1120 while (names_found
< 2);
1122 ldi
= (LdInfo
*) buffer
;
1124 /* Can't use a file descriptor from the core file; need to open it. */
1126 ldi
->l64
.ldinfo_fd
= -1;
1128 ldi
->l32
.ldinfo_fd
= -1;
1130 /* The first ldinfo is for the exec file, allocated elsewhere. */
1131 if (offset
== 0 && vmap
!= NULL
)
1134 vp
= add_vmap (ldi
);
1136 /* Process next shared library upon error. */
1137 offset
+= LDI_NEXT (ldi
, arch64
);
1141 vmap_secs (vp
, ldi
, arch64
);
1143 /* Unless this is the exec file,
1144 add our sections to the section table for the core target. */
1147 struct section_table
*stp
;
1149 target_resize_to_sections (target
, 2);
1150 stp
= target
->to_sections_end
- 2;
1153 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1154 stp
->addr
= vp
->tstart
;
1155 stp
->endaddr
= vp
->tend
;
1159 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1160 stp
->addr
= vp
->dstart
;
1161 stp
->endaddr
= vp
->dend
;
1166 if (deprecated_target_new_objfile_hook
&& vp
!= vmap
&& vp
->objfile
)
1167 deprecated_target_new_objfile_hook (vp
->objfile
);
1169 while (LDI_NEXT (ldi
, arch64
) != 0);
1171 breakpoint_re_set ();
1176 kernel_u_size (void)
1178 return (sizeof (struct user
));
1181 /* Under AIX, we have to pass the correct TOC pointer to a function
1182 when calling functions in the inferior.
1183 We try to find the relative toc offset of the objfile containing PC
1184 and add the current load address of the data segment from the vmap. */
1187 find_toc_address (CORE_ADDR pc
)
1190 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1192 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1194 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1196 /* vp->objfile is only NULL for the exec file. */
1197 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1202 error ("Unable to find TOC entry for pc %s\n", local_hex_string (pc
));
1205 /* Register that we are able to handle rs6000 core file formats. */
1207 static struct core_fns rs6000_core_fns
=
1209 bfd_target_xcoff_flavour
, /* core_flavour */
1210 default_check_format
, /* check_format */
1211 default_core_sniffer
, /* core_sniffer */
1212 fetch_core_registers
, /* core_read_registers */
1217 _initialize_core_rs6000 (void)
1219 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1220 calling functions in the inferior. */
1221 rs6000_find_toc_address_hook
= find_toc_address
;
1223 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1224 starting a child process. */
1225 rs6000_set_host_arch_hook
= set_host_arch
;
1227 deprecated_add_core_fns (&rs6000_core_fns
);