1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
5 Free Software Foundation, Inc.
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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "xcoffsolib.h"
31 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
33 #include "exceptions.h"
34 #include "gdb-stabs.h"
36 #include "arch-utils.h"
38 #include "rs6000-tdep.h"
41 #include <sys/ptrace.h>
44 #include <sys/param.h>
48 #include <sys/ioctl.h>
56 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
57 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
59 #include <sys/systemcfg.h>
61 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
62 debugging 32-bit and 64-bit processes. Define a typedef and macros for
63 accessing fields in the appropriate structures. */
65 /* In 32-bit compilation mode (which is the only mode from which ptrace()
66 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
72 /* Return whether the current architecture is 64-bit. */
77 # define ARCH64() (register_size (current_gdbarch, 0) == 8)
80 /* Union of 32-bit and 64-bit ".reg" core file sections. */
84 struct __context64 r64
;
91 /* Union of 32-bit and 64-bit versions of ld_info. */
98 struct __ld_info32 l32
;
99 struct __ld_info64 l64
;
103 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
104 declare and initialize a variable named VAR suitable for use as the arch64
105 parameter to the various LDI_*() macros. */
108 # define ARCH64_DECL(var)
110 # define ARCH64_DECL(var) int var = ARCH64 ()
113 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
114 otherwise. This technique only works for FIELDs with the same data type in
115 32-bit and 64-bit versions of ld_info. */
118 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
120 # define LDI_FIELD(ldi, arch64, field) \
121 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
124 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
125 process otherwise. */
127 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
128 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
129 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
131 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
133 static void vmap_exec (void);
135 static void vmap_ldinfo (LdInfo
*);
137 static struct vmap
*add_vmap (LdInfo
*);
139 static int objfile_symbol_add (void *);
141 static void vmap_symtab (struct vmap
*);
143 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR
);
145 static void exec_one_dummy_insn (void);
147 extern void fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
149 /* Given REGNO, a gdb register number, return the corresponding
150 number suitable for use as a ptrace() parameter. Return -1 if
151 there's no suitable mapping. Also, set the int pointed to by
152 ISFLOAT to indicate whether REGNO is a floating point register. */
155 regmap (int regno
, int *isfloat
)
157 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
160 if (tdep
->ppc_gp0_regnum
<= regno
161 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
163 else if (tdep
->ppc_fp0_regnum
>= 0
164 && tdep
->ppc_fp0_regnum
<= regno
165 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
168 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
170 else if (regno
== PC_REGNUM
)
172 else if (regno
== tdep
->ppc_ps_regnum
)
174 else if (regno
== tdep
->ppc_cr_regnum
)
176 else if (regno
== tdep
->ppc_lr_regnum
)
178 else if (regno
== tdep
->ppc_ctr_regnum
)
180 else if (regno
== tdep
->ppc_xer_regnum
)
182 else if (tdep
->ppc_fpscr_regnum
>= 0
183 && regno
== tdep
->ppc_fpscr_regnum
)
185 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
191 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
194 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
196 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
198 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
199 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
204 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
207 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, int *buf
)
210 int ret
= ptracex (req
, id
, addr
, data
, buf
);
215 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
216 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
221 /* Fetch register REGNO from the inferior. */
224 fetch_register (int regno
)
226 int addr
[MAX_REGISTER_SIZE
];
229 /* Retrieved values may be -1, so infer errors from errno. */
232 nr
= regmap (regno
, &isfloat
);
234 /* Floating-point registers. */
236 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
238 /* Bogus register number. */
241 if (regno
>= NUM_REGS
)
242 fprintf_unfiltered (gdb_stderr
,
243 "gdb error: register no %d not implemented.\n",
248 /* Fixed-point registers. */
252 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
), (int *)nr
, 0, 0);
255 /* PT_READ_GPR requires the buffer parameter to point to long long,
256 even if the register is really only 32 bits. */
258 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
259 if (register_size (current_gdbarch
, regno
) == 8)
260 memcpy (addr
, &buf
, 8);
267 regcache_raw_supply (current_regcache
, regno
, (char *) addr
);
271 /* FIXME: this happens 3 times at the start of each 64-bit program. */
272 perror ("ptrace read");
278 /* Store register REGNO back into the inferior. */
281 store_register (int regno
)
283 int addr
[MAX_REGISTER_SIZE
];
286 /* Fetch the register's value from the register cache. */
287 regcache_raw_collect (current_regcache
, regno
, addr
);
289 /* -1 can be a successful return value, so infer errors from errno. */
292 nr
= regmap (regno
, &isfloat
);
294 /* Floating-point registers. */
296 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
298 /* Bogus register number. */
301 if (regno
>= NUM_REGS
)
302 fprintf_unfiltered (gdb_stderr
,
303 "gdb error: register no %d not implemented.\n",
307 /* Fixed-point registers. */
310 if (regno
== SP_REGNUM
)
311 /* Execute one dummy instruction (which is a breakpoint) in inferior
312 process to give kernel a chance to do internal housekeeping.
313 Otherwise the following ptrace(2) calls will mess up user stack
314 since kernel will get confused about the bottom of the stack
316 exec_one_dummy_insn ();
318 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
319 the register's value is passed by value, but for 64-bit inferiors,
320 the address of a buffer containing the value is passed. */
322 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), (int *)nr
, *addr
, 0);
325 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
326 area, even if the register is really only 32 bits. */
328 if (register_size (current_gdbarch
, regno
) == 8)
329 memcpy (&buf
, addr
, 8);
332 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, (int *)&buf
);
338 perror ("ptrace write");
343 /* Read from the inferior all registers if REGNO == -1 and just register
347 fetch_inferior_registers (int regno
)
350 fetch_register (regno
);
354 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
356 /* Read 32 general purpose registers. */
357 for (regno
= tdep
->ppc_gp0_regnum
;
358 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
361 fetch_register (regno
);
364 /* Read general purpose floating point registers. */
365 if (tdep
->ppc_fp0_regnum
>= 0)
366 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
367 fetch_register (tdep
->ppc_fp0_regnum
+ regno
);
369 /* Read special registers. */
370 fetch_register (PC_REGNUM
);
371 fetch_register (tdep
->ppc_ps_regnum
);
372 fetch_register (tdep
->ppc_cr_regnum
);
373 fetch_register (tdep
->ppc_lr_regnum
);
374 fetch_register (tdep
->ppc_ctr_regnum
);
375 fetch_register (tdep
->ppc_xer_regnum
);
376 if (tdep
->ppc_fpscr_regnum
>= 0)
377 fetch_register (tdep
->ppc_fpscr_regnum
);
378 if (tdep
->ppc_mq_regnum
>= 0)
379 fetch_register (tdep
->ppc_mq_regnum
);
383 /* Store our register values back into the inferior.
384 If REGNO is -1, do this for all registers.
385 Otherwise, REGNO specifies which register (so we can save time). */
388 store_inferior_registers (int regno
)
391 store_register (regno
);
395 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
397 /* Write general purpose registers first. */
398 for (regno
= tdep
->ppc_gp0_regnum
;
399 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
402 store_register (regno
);
405 /* Write floating point registers. */
406 if (tdep
->ppc_fp0_regnum
>= 0)
407 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
408 store_register (tdep
->ppc_fp0_regnum
+ regno
);
410 /* Write special registers. */
411 store_register (PC_REGNUM
);
412 store_register (tdep
->ppc_ps_regnum
);
413 store_register (tdep
->ppc_cr_regnum
);
414 store_register (tdep
->ppc_lr_regnum
);
415 store_register (tdep
->ppc_ctr_regnum
);
416 store_register (tdep
->ppc_xer_regnum
);
417 if (tdep
->ppc_fpscr_regnum
>= 0)
418 store_register (tdep
->ppc_fpscr_regnum
);
419 if (tdep
->ppc_mq_regnum
>= 0)
420 store_register (tdep
->ppc_mq_regnum
);
424 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
425 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
429 read_word (CORE_ADDR from
, int *to
, int arch64
)
431 /* Retrieved values may be -1, so infer errors from errno. */
435 *to
= rs6000_ptrace64 (PT_READ_I
, PIDGET (inferior_ptid
), from
, 0, NULL
);
437 *to
= rs6000_ptrace32 (PT_READ_I
, PIDGET (inferior_ptid
), (int *)(long) from
,
443 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
444 to debugger memory starting at MYADDR. Copy to inferior if
447 Returns the length copied, which is either the LEN argument or
448 zero. This xfer function does not do partial moves, since
449 deprecated_child_ops doesn't allow memory operations to cross below
450 us in the target stack anyway. */
453 child_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
454 int write
, struct mem_attrib
*attrib
,
455 struct target_ops
*target
)
457 /* Round starting address down to 32-bit word boundary. */
458 int mask
= sizeof (int) - 1;
459 CORE_ADDR addr
= memaddr
& ~(CORE_ADDR
)mask
;
461 /* Round ending address up to 32-bit word boundary. */
462 int count
= ((memaddr
+ len
- addr
+ mask
) & ~(CORE_ADDR
)mask
)
465 /* Allocate word transfer buffer. */
466 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
467 because it uses alloca to allocate a buffer of arbitrary size.
468 For very large xfers, this could crash GDB's stack. */
469 int *buf
= (int *) alloca (count
* sizeof (int));
471 int arch64
= ARCH64 ();
476 /* Retrieve memory a word at a time. */
477 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
479 if (!read_word (addr
, buf
+ i
, arch64
))
484 /* Copy memory to supplied buffer. */
485 addr
-= count
* sizeof (int);
486 memcpy (myaddr
, (char *)buf
+ (memaddr
- addr
), len
);
490 /* Fetch leading memory needed for alignment. */
492 if (!read_word (addr
, buf
, arch64
))
495 /* Fetch trailing memory needed for alignment. */
496 if (addr
+ count
* sizeof (int) > memaddr
+ len
)
497 if (!read_word (addr
+ (count
- 1) * sizeof (int),
498 buf
+ count
- 1, arch64
))
501 /* Copy supplied data into memory buffer. */
502 memcpy ((char *)buf
+ (memaddr
- addr
), myaddr
, len
);
504 /* Store memory one word at a time. */
505 for (i
= 0, errno
= 0; i
< count
; i
++, addr
+= sizeof (int))
508 rs6000_ptrace64 (PT_WRITE_D
, PIDGET (inferior_ptid
), addr
, buf
[i
], NULL
);
510 rs6000_ptrace32 (PT_WRITE_D
, PIDGET (inferior_ptid
), (int *)(long) addr
,
522 /* Execute one dummy breakpoint instruction. This way we give the kernel
523 a chance to do some housekeeping and update inferior's internal data,
527 exec_one_dummy_insn (void)
529 #define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
531 int ret
, status
, pid
;
535 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
536 assume that this address will never be executed again by the real
539 bp
= deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR
);
541 /* You might think this could be done with a single ptrace call, and
542 you'd be correct for just about every platform I've ever worked
543 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
544 the inferior never hits the breakpoint (it's also worth noting
545 powerpc-ibm-aix4.1.3 works correctly). */
546 prev_pc
= read_pc ();
547 write_pc (DUMMY_INSN_ADDR
);
549 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
551 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
), (int *)1, 0, NULL
);
554 perror ("pt_continue");
558 pid
= wait (&status
);
560 while (pid
!= PIDGET (inferior_ptid
));
563 deprecated_remove_raw_breakpoint (bp
);
566 /* Fetch registers from the register section in core bfd. */
569 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
570 int which
, CORE_ADDR reg_addr
)
574 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
580 "Gdb error: unknown parameter to fetch_core_registers().\n");
584 regs
= (CoreRegs
*) core_reg_sect
;
586 /* Put the register values from the core file section in the regcache. */
590 for (regi
= 0; regi
< ppc_num_gprs
; regi
++)
591 regcache_raw_supply (current_regcache
, tdep
->ppc_gp0_regnum
+ regi
,
592 (char *) ®s
->r64
.gpr
[regi
]);
594 if (tdep
->ppc_fp0_regnum
>= 0)
595 for (regi
= 0; regi
< ppc_num_fprs
; regi
++)
596 regcache_raw_supply (current_regcache
, tdep
->ppc_fp0_regnum
+ regi
,
597 (char *) ®s
->r64
.fpr
[regi
]);
599 regcache_raw_supply (current_regcache
, PC_REGNUM
,
600 (char *) ®s
->r64
.iar
);
601 regcache_raw_supply (current_regcache
, tdep
->ppc_ps_regnum
,
602 (char *) ®s
->r64
.msr
);
603 regcache_raw_supply (current_regcache
, tdep
->ppc_cr_regnum
,
604 (char *) ®s
->r64
.cr
);
605 regcache_raw_supply (current_regcache
, tdep
->ppc_lr_regnum
,
606 (char *) ®s
->r64
.lr
);
607 regcache_raw_supply (current_regcache
, tdep
->ppc_ctr_regnum
,
608 (char *) ®s
->r64
.ctr
);
609 regcache_raw_supply (current_regcache
, tdep
->ppc_xer_regnum
,
610 (char *) ®s
->r64
.xer
);
611 if (tdep
->ppc_fpscr_regnum
>= 0)
612 regcache_raw_supply (current_regcache
, tdep
->ppc_fpscr_regnum
,
613 (char *) ®s
->r64
.fpscr
);
617 for (regi
= 0; regi
< ppc_num_gprs
; regi
++)
618 regcache_raw_supply (current_regcache
, tdep
->ppc_gp0_regnum
+ regi
,
619 (char *) ®s
->r32
.gpr
[regi
]);
621 if (tdep
->ppc_fp0_regnum
>= 0)
622 for (regi
= 0; regi
< ppc_num_fprs
; regi
++)
623 regcache_raw_supply (current_regcache
, tdep
->ppc_fp0_regnum
+ regi
,
624 (char *) ®s
->r32
.fpr
[regi
]);
626 regcache_raw_supply (current_regcache
, PC_REGNUM
,
627 (char *) ®s
->r32
.iar
);
628 regcache_raw_supply (current_regcache
, tdep
->ppc_ps_regnum
,
629 (char *) ®s
->r32
.msr
);
630 regcache_raw_supply (current_regcache
, tdep
->ppc_cr_regnum
,
631 (char *) ®s
->r32
.cr
);
632 regcache_raw_supply (current_regcache
, tdep
->ppc_lr_regnum
,
633 (char *) ®s
->r32
.lr
);
634 regcache_raw_supply (current_regcache
, tdep
->ppc_ctr_regnum
,
635 (char *) ®s
->r32
.ctr
);
636 regcache_raw_supply (current_regcache
, tdep
->ppc_xer_regnum
,
637 (char *) ®s
->r32
.xer
);
638 if (tdep
->ppc_fpscr_regnum
>= 0)
639 regcache_raw_supply (current_regcache
, tdep
->ppc_fpscr_regnum
,
640 (char *) ®s
->r32
.fpscr
);
641 if (tdep
->ppc_mq_regnum
>= 0)
642 regcache_raw_supply (current_regcache
, tdep
->ppc_mq_regnum
,
643 (char *) ®s
->r32
.mq
);
648 /* Copy information about text and data sections from LDI to VP for a 64-bit
649 process if ARCH64 and for a 32-bit process otherwise. */
652 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
656 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
657 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
658 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
659 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
663 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
664 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
665 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
666 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
669 /* The run time loader maps the file header in addition to the text
670 section and returns a pointer to the header in ldinfo_textorg.
671 Adjust the text start address to point to the real start address
672 of the text section. */
673 vp
->tstart
+= vp
->toffs
;
676 /* handle symbol translation on vmapping */
679 vmap_symtab (struct vmap
*vp
)
681 struct objfile
*objfile
;
682 struct section_offsets
*new_offsets
;
685 objfile
= vp
->objfile
;
688 /* OK, it's not an objfile we opened ourselves.
689 Currently, that can only happen with the exec file, so
690 relocate the symbols for the symfile. */
691 if (symfile_objfile
== NULL
)
693 objfile
= symfile_objfile
;
695 else if (!vp
->loaded
)
696 /* If symbols are not yet loaded, offsets are not yet valid. */
700 (struct section_offsets
*)
701 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
703 for (i
= 0; i
< objfile
->num_sections
; ++i
)
704 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
706 /* The symbols in the object file are linked to the VMA of the section,
707 relocate them VMA relative. */
708 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
709 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
710 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
712 objfile_relocate (objfile
, new_offsets
);
715 /* Add symbols for an objfile. */
718 objfile_symbol_add (void *arg
)
720 struct objfile
*obj
= (struct objfile
*) arg
;
722 syms_from_objfile (obj
, NULL
, 0, 0, 0, 0);
723 new_symfile_objfile (obj
, 0, 0);
727 /* Add symbols for a vmap. Return zero upon error. */
730 vmap_add_symbols (struct vmap
*vp
)
732 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
733 "Error while reading shared library symbols:\n",
736 /* Note this is only done if symbol reading was successful. */
744 /* Add a new vmap entry based on ldinfo() information.
746 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
747 core file), the caller should set it to -1, and we will open the file.
749 Return the vmap new entry. */
752 add_vmap (LdInfo
*ldi
)
755 char *mem
, *objname
, *filename
;
759 ARCH64_DECL (arch64
);
761 /* This ldi structure was allocated using alloca() in
762 xcoff_relocate_symtab(). Now we need to have persistent object
763 and member names, so we should save them. */
765 filename
= LDI_FILENAME (ldi
, arch64
);
766 mem
= filename
+ strlen (filename
) + 1;
767 mem
= savestring (mem
, strlen (mem
));
768 objname
= savestring (filename
, strlen (filename
));
770 fd
= LDI_FD (ldi
, arch64
);
772 /* Note that this opens it once for every member; a possible
773 enhancement would be to only open it once for every object. */
774 abfd
= bfd_openr (objname
, gnutarget
);
776 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
779 warning (_("Could not open `%s' as an executable file: %s"),
780 objname
, bfd_errmsg (bfd_get_error ()));
784 /* make sure we have an object file */
786 if (bfd_check_format (abfd
, bfd_object
))
787 vp
= map_vmap (abfd
, 0);
789 else if (bfd_check_format (abfd
, bfd_archive
))
792 /* FIXME??? am I tossing BFDs? bfd? */
793 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
794 if (DEPRECATED_STREQ (mem
, last
->filename
))
799 warning (_("\"%s\": member \"%s\" missing."), objname
, mem
);
804 if (!bfd_check_format (last
, bfd_object
))
806 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
807 objname
, mem
, bfd_errmsg (bfd_get_error ()));
813 vp
= map_vmap (last
, abfd
);
817 warning (_("\"%s\": not in executable format: %s."),
818 objname
, bfd_errmsg (bfd_get_error ()));
822 obj
= allocate_objfile (vp
->bfd
, 0);
825 /* Always add symbols for the main objfile. */
826 if (vp
== vmap
|| auto_solib_add
)
827 vmap_add_symbols (vp
);
831 /* update VMAP info with ldinfo() information
832 Input is ptr to ldinfo() results. */
835 vmap_ldinfo (LdInfo
*ldi
)
839 int got_one
, retried
;
840 int got_exec_file
= 0;
842 int arch64
= ARCH64 ();
844 /* For each *ldi, see if we have a corresponding *vp.
845 If so, update the mapping, and symbol table.
846 If not, add an entry and symbol table. */
850 char *name
= LDI_FILENAME (ldi
, arch64
);
851 char *memb
= name
+ strlen (name
) + 1;
852 int fd
= LDI_FD (ldi
, arch64
);
856 if (fstat (fd
, &ii
) < 0)
858 /* The kernel sets ld_info to -1, if the process is still using the
859 object, and the object is removed. Keep the symbol info for the
860 removed object and issue a warning. */
861 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
866 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
868 struct objfile
*objfile
;
870 /* First try to find a `vp', which is the same as in ldinfo.
871 If not the same, just continue and grep the next `vp'. If same,
872 relocate its tstart, tend, dstart, dend values. If no such `vp'
873 found, get out of this for loop, add this ldi entry as a new vmap
874 (add_vmap) and come back, find its `vp' and so on... */
876 /* The filenames are not always sufficient to match on. */
878 if ((name
[0] == '/' && !DEPRECATED_STREQ (name
, vp
->name
))
879 || (memb
[0] && !DEPRECATED_STREQ (memb
, vp
->member
)))
882 /* See if we are referring to the same file.
883 We have to check objfile->obfd, symfile.c:reread_symbols might
884 have updated the obfd after a change. */
885 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
887 || objfile
->obfd
== NULL
888 || bfd_stat (objfile
->obfd
, &vi
) < 0)
890 warning (_("Unable to stat %s, keeping its symbols"), name
);
894 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
902 /* Found a corresponding VMAP. Remap! */
904 vmap_secs (vp
, ldi
, arch64
);
906 /* The objfile is only NULL for the exec file. */
907 if (vp
->objfile
== NULL
)
910 /* relocate symbol table(s). */
913 /* Announce new object files. Doing this after symbol relocation
914 makes aix-thread.c's job easier. */
915 if (deprecated_target_new_objfile_hook
&& vp
->objfile
)
916 deprecated_target_new_objfile_hook (vp
->objfile
);
918 /* There may be more, so we don't break out of the loop. */
921 /* if there was no matching *vp, we must perforce create the sucker(s) */
922 if (!got_one
&& !retried
)
929 while ((next
= LDI_NEXT (ldi
, arch64
))
930 && (ldi
= (void *) (next
+ (char *) ldi
)));
932 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
933 is unlikely that the symbol file is relocated to the proper
934 address. And we might have attached to a process which is
935 running a different copy of the same executable. */
936 if (symfile_objfile
!= NULL
&& !got_exec_file
)
938 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
939 If in fact that file has symbols which the mapped files listed by\n\
940 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
941 \"add-symbol-file\" commands (note that you must take care of relocating\n\
942 symbols to the proper address)."),
943 symfile_objfile
->name
);
944 free_objfile (symfile_objfile
);
945 symfile_objfile
= NULL
;
947 breakpoint_re_set ();
950 /* As well as symbol tables, exec_sections need relocation. After
951 the inferior process' termination, there will be a relocated symbol
952 table exist with no corresponding inferior process. At that time, we
953 need to use `exec' bfd, rather than the inferior process's memory space
956 `exec_sections' need to be relocated only once, as long as the exec
957 file remains unchanged.
966 if (execbfd
== exec_bfd
)
971 if (!vmap
|| !exec_ops
.to_sections
)
972 error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
974 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
976 if (DEPRECATED_STREQ (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
978 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
979 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
981 else if (DEPRECATED_STREQ (".data", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
983 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
984 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
986 else if (DEPRECATED_STREQ (".bss", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
988 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
989 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
994 /* Set the current architecture from the host running GDB. Called when
995 starting a child process. */
998 rs6000_create_inferior (int pid
)
1000 enum bfd_architecture arch
;
1003 struct gdbarch_info info
;
1007 arch
= bfd_arch_rs6000
;
1008 mach
= bfd_mach_rs6k
;
1012 arch
= bfd_arch_powerpc
;
1013 mach
= bfd_mach_ppc
;
1016 /* FIXME: schauer/2002-02-25:
1017 We don't know if we are executing a 32 or 64 bit executable,
1018 and have no way to pass the proper word size to rs6000_gdbarch_init.
1019 So we have to avoid switching to a new architecture, if the architecture
1021 Blindly calling rs6000_gdbarch_init used to work in older versions of
1022 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1023 determine the wordsize. */
1026 const struct bfd_arch_info
*exec_bfd_arch_info
;
1028 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1029 if (arch
== exec_bfd_arch_info
->arch
)
1033 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1035 gdbarch_info_init (&info
);
1036 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1037 info
.abfd
= exec_bfd
;
1039 if (!gdbarch_update_p (info
))
1040 internal_error (__FILE__
, __LINE__
,
1041 _("rs6000_create_inferior: failed to select architecture"));
1045 /* xcoff_relocate_symtab - hook for symbol table relocation.
1046 also reads shared libraries. */
1049 xcoff_relocate_symtab (unsigned int pid
)
1051 int load_segs
= 64; /* number of load segments */
1054 int arch64
= ARCH64 ();
1055 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
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 section_table
*stp
;
1178 target_resize_to_sections (target
, 2);
1179 stp
= target
->to_sections_end
- 2;
1182 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1183 stp
->addr
= vp
->tstart
;
1184 stp
->endaddr
= vp
->tend
;
1188 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1189 stp
->addr
= vp
->dstart
;
1190 stp
->endaddr
= vp
->dend
;
1195 if (deprecated_target_new_objfile_hook
&& vp
!= vmap
&& vp
->objfile
)
1196 deprecated_target_new_objfile_hook (vp
->objfile
);
1198 while (LDI_NEXT (ldi
, arch64
) != 0);
1200 breakpoint_re_set ();
1205 kernel_u_size (void)
1207 return (sizeof (struct user
));
1210 /* Under AIX, we have to pass the correct TOC pointer to a function
1211 when calling functions in the inferior.
1212 We try to find the relative toc offset of the objfile containing PC
1213 and add the current load address of the data segment from the vmap. */
1216 find_toc_address (CORE_ADDR pc
)
1219 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1221 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1223 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1225 /* vp->objfile is only NULL for the exec file. */
1226 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1231 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1234 /* Register that we are able to handle rs6000 core file formats. */
1236 static struct core_fns rs6000_core_fns
=
1238 bfd_target_xcoff_flavour
, /* core_flavour */
1239 default_check_format
, /* check_format */
1240 default_core_sniffer
, /* core_sniffer */
1241 fetch_core_registers
, /* core_read_registers */
1246 _initialize_core_rs6000 (void)
1248 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1249 when calling functions in the inferior. */
1250 rs6000_find_toc_address_hook
= find_toc_address
;
1252 deprecated_add_core_fns (&rs6000_core_fns
);