1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996, 1997,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "xcoffsolib.h"
30 #include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
32 #include "gdb-stabs.h"
34 #include <sys/ptrace.h>
37 #include <sys/param.h>
41 #include <sys/ioctl.h>
49 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
50 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
52 #include <sys/systemcfg.h>
54 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
55 debugging 32-bit and 64-bit processes. Define a typedef and macros for
56 accessing fields in the appropriate structures. */
58 /* In 32-bit compilation mode (which is the only mode from which ptrace()
59 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
65 /* Return whether the current architecture is 64-bit. */
70 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
73 /* Union of 32-bit and 64-bit ".reg" core file sections. */
77 struct __context64 r64
;
84 /* Union of 32-bit and 64-bit versions of ld_info. */
91 struct __ld_info32 l32
;
92 struct __ld_info64 l64
;
96 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
97 declare and initialize a variable named VAR suitable for use as the arch64
98 parameter to the various LDI_*() macros. */
101 # define ARCH64_DECL(var)
103 # define ARCH64_DECL(var) int var = ARCH64 ()
106 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
107 otherwise. This technique only works for FIELDs with the same data type in
108 32-bit and 64-bit versions of ld_info. */
111 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
113 # define LDI_FIELD(ldi, arch64, field) \
114 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
117 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
118 process otherwise. */
120 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
121 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
122 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
124 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
126 extern struct target_ops exec_ops
;
128 static void vmap_exec (void);
130 static void vmap_ldinfo (LdInfo
*);
132 static struct vmap
*add_vmap (LdInfo
*);
134 static int objfile_symbol_add (void *);
136 static void vmap_symtab (struct vmap
*);
138 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR
);
140 static void exec_one_dummy_insn (void);
143 fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
145 /* Conversion from gdb-to-system special purpose register numbers. */
147 static int special_regs
[] =
153 CTR
, /* CTR_REGNUM */
154 XER
, /* XER_REGNUM */
158 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
161 ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
163 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
165 printf ("ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
166 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
171 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
174 ptrace64 (int req
, int id
, long long addr
, int data
, int *buf
)
177 int ret
= ptracex (req
, id
, addr
, data
, buf
);
182 printf ("ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
183 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
188 /* Fetch register REGNO from the inferior. */
191 fetch_register (int regno
)
193 int *addr
= (int *) ®isters
[REGISTER_BYTE (regno
)];
196 /* Retrieved values may be -1, so infer errors from errno. */
199 /* Floating-point registers. */
200 if (regno
>= FP0_REGNUM
&& regno
<= FPLAST_REGNUM
)
202 nr
= regno
- FP0_REGNUM
+ FPR0
;
203 ptrace32 (PT_READ_FPR
, inferior_pid
, addr
, nr
, 0);
206 /* Bogus register number. */
207 else if (regno
> LAST_UISA_SP_REGNUM
)
208 fprintf_unfiltered (gdb_stderr
,
209 "gdb error: register no %d not implemented.\n",
212 /* Fixed-point registers. */
215 if (regno
>= FIRST_UISA_SP_REGNUM
)
216 nr
= special_regs
[regno
- FIRST_UISA_SP_REGNUM
];
221 *addr
= ptrace32 (PT_READ_GPR
, inferior_pid
, (int *)nr
, 0, 0);
224 /* PT_READ_GPR requires the buffer parameter to point to long long,
225 even if the register is really only 32 bits. */
227 ptrace64 (PT_READ_GPR
, inferior_pid
, nr
, 0, (int *)&buf
);
228 if (REGISTER_RAW_SIZE (regno
) == 8)
229 memcpy (addr
, &buf
, 8);
236 register_valid
[regno
] = 1;
240 /* FIXME: this happens 3 times at the start of each 64-bit program. */
241 perror ("ptrace read");
247 /* Store register REGNO back into the inferior. */
250 store_register (int regno
)
252 int *addr
= (int *) ®isters
[REGISTER_BYTE (regno
)];
255 /* -1 can be a successful return value, so infer errors from errno. */
258 /* Floating-point registers. */
259 if (regno
>= FP0_REGNUM
&& regno
<= FPLAST_REGNUM
)
261 nr
= regno
- FP0_REGNUM
+ FPR0
;
262 ptrace32 (PT_WRITE_FPR
, inferior_pid
, addr
, nr
, 0);
265 /* Bogus register number. */
266 else if (regno
> LAST_UISA_SP_REGNUM
)
268 if (regno
>= NUM_REGS
)
269 fprintf_unfiltered (gdb_stderr
,
270 "gdb error: register no %d not implemented.\n",
274 /* Fixed-point registers. */
277 if (regno
== SP_REGNUM
)
278 /* Execute one dummy instruction (which is a breakpoint) in inferior
279 process to give kernel a chance to do internal housekeeping.
280 Otherwise the following ptrace(2) calls will mess up user stack
281 since kernel will get confused about the bottom of the stack
283 exec_one_dummy_insn ();
285 if (regno
>= FIRST_UISA_SP_REGNUM
)
286 nr
= special_regs
[regno
- FIRST_UISA_SP_REGNUM
];
291 ptrace32 (PT_WRITE_GPR
, inferior_pid
, (int *)nr
, *addr
, 0);
294 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
295 area, even if the register is really only 32 bits. */
297 if (REGISTER_RAW_SIZE (regno
) == 8)
298 memcpy (&buf
, addr
, 8);
301 ptrace64 (PT_WRITE_GPR
, inferior_pid
, nr
, 0, (int *)&buf
);
307 perror ("ptrace write");
312 /* Read from the inferior all registers if REGNO == -1 and just register
316 fetch_inferior_registers (int regno
)
319 fetch_register (regno
);
323 /* read 32 general purpose registers. */
324 for (regno
= 0; regno
< 32; regno
++)
325 fetch_register (regno
);
327 /* read general purpose floating point registers. */
328 for (regno
= FP0_REGNUM
; regno
<= FPLAST_REGNUM
; regno
++)
329 fetch_register (regno
);
331 /* read special registers. */
332 for (regno
= FIRST_UISA_SP_REGNUM
; regno
<= LAST_UISA_SP_REGNUM
; regno
++)
333 fetch_register (regno
);
337 /* Store our register values back into the inferior.
338 If REGNO is -1, do this for all registers.
339 Otherwise, REGNO specifies which register (so we can save time). */
342 store_inferior_registers (int regno
)
345 store_register (regno
);
349 /* write general purpose registers first! */
350 for (regno
= GPR0
; regno
<= GPR31
; regno
++)
351 store_register (regno
);
353 /* write floating point registers now. */
354 for (regno
= FP0_REGNUM
; regno
<= FPLAST_REGNUM
; regno
++)
355 store_register (regno
);
357 /* write special registers. */
359 for (regno
= FIRST_UISA_SP_REGNUM
; regno
<= LAST_UISA_SP_REGNUM
; regno
++)
360 store_register (regno
);
364 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
365 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
369 read_word (CORE_ADDR from
, int *to
, int arch64
)
371 /* Retrieved values may be -1, so infer errors from errno. */
375 *to
= ptrace64 (PT_READ_I
, inferior_pid
, from
, 0, NULL
);
377 *to
= ptrace32 (PT_READ_I
, inferior_pid
, (int *)(long) from
, 0, NULL
);
382 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
383 to debugger memory starting at MYADDR. Copy to inferior if
386 Returns the length copied, which is either the LEN argument or zero.
387 This xfer function does not do partial moves, since child_ops
388 doesn't allow memory operations to cross below us in the target stack
392 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
393 int write
, struct mem_attrib
*attrib
,
394 struct target_ops
*target
)
396 /* Round starting address down to 32-bit word boundary. */
397 int mask
= sizeof (int) - 1;
398 CORE_ADDR addr
= memaddr
& ~(CORE_ADDR
)mask
;
400 /* Round ending address up to 32-bit word boundary. */
401 int count
= ((memaddr
+ len
- addr
+ mask
) & ~(CORE_ADDR
)mask
)
404 /* Allocate word transfer buffer. */
405 int *buf
= (int *) alloca (count
* sizeof (int));
407 int arch64
= ARCH64 ();
412 /* Retrieve memory a word at a time. */
413 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
415 if (!read_word (addr
, buf
+ i
, arch64
))
420 /* Copy memory to supplied buffer. */
421 addr
-= count
* sizeof (int);
422 memcpy (myaddr
, (char *)buf
+ (memaddr
- addr
), len
);
426 /* Fetch leading memory needed for alignment. */
428 if (!read_word (addr
, buf
, arch64
))
431 /* Fetch trailing memory needed for alignment. */
432 if (addr
+ count
* sizeof (int) > memaddr
+ len
)
433 if (!read_word (addr
, buf
+ count
- 1, arch64
))
436 /* Copy supplied data into memory buffer. */
437 memcpy ((char *)buf
+ (memaddr
- addr
), myaddr
, len
);
439 /* Store memory one word at a time. */
440 for (i
= 0, errno
= 0; i
< count
; i
++, addr
+= sizeof (int))
443 ptrace64 (PT_WRITE_D
, inferior_pid
, addr
, buf
[i
], NULL
);
445 ptrace32 (PT_WRITE_D
, inferior_pid
, (int *)(long) addr
,
457 /* Execute one dummy breakpoint instruction. This way we give the kernel
458 a chance to do some housekeeping and update inferior's internal data,
462 exec_one_dummy_insn (void)
464 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
466 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
467 int ret
, status
, pid
;
470 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
471 assume that this address will never be executed again by the real
474 target_insert_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
476 /* You might think this could be done with a single ptrace call, and
477 you'd be correct for just about every platform I've ever worked
478 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
479 the inferior never hits the breakpoint (it's also worth noting
480 powerpc-ibm-aix4.1.3 works correctly). */
481 prev_pc
= read_pc ();
482 write_pc (DUMMY_INSN_ADDR
);
484 ret
= ptrace64 (PT_CONTINUE
, inferior_pid
, 1, 0, NULL
);
486 ret
= ptrace32 (PT_CONTINUE
, inferior_pid
, (int *)1, 0, NULL
);
489 perror ("pt_continue");
493 pid
= wait (&status
);
495 while (pid
!= inferior_pid
);
498 target_remove_breakpoint (DUMMY_INSN_ADDR
, shadow_contents
);
501 /* Fetch registers from the register section in core bfd. */
504 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
505 int which
, CORE_ADDR reg_addr
)
510 void *gprs
, *sprs
[7];
516 "Gdb error: unknown parameter to fetch_core_registers().\n");
521 regs
= (CoreRegs
*) core_reg_sect
;
523 /* Retrieve register pointers. */
527 gprs
= regs
->r64
.gpr
;
528 fprs
= regs
->r64
.fpr
;
529 sprs
[0] = ®s
->r64
.iar
;
530 sprs
[1] = ®s
->r64
.msr
;
531 sprs
[2] = ®s
->r64
.cr
;
532 sprs
[3] = ®s
->r64
.lr
;
533 sprs
[4] = ®s
->r64
.ctr
;
534 sprs
[5] = ®s
->r64
.xer
;
538 gprs
= regs
->r32
.gpr
;
539 fprs
= regs
->r32
.fpr
;
540 sprs
[0] = ®s
->r32
.iar
;
541 sprs
[1] = ®s
->r32
.msr
;
542 sprs
[2] = ®s
->r32
.cr
;
543 sprs
[3] = ®s
->r32
.lr
;
544 sprs
[4] = ®s
->r32
.ctr
;
545 sprs
[5] = ®s
->r32
.xer
;
546 sprs
[6] = ®s
->r32
.mq
;
549 /* Copy from pointers to registers[]. */
551 memcpy (registers
, gprs
, 32 * (arch64
? 8 : 4));
552 memcpy (registers
+ REGISTER_BYTE (FP0_REGNUM
), fprs
, 32 * 8);
553 for (i
= FIRST_UISA_SP_REGNUM
; i
<= LAST_UISA_SP_REGNUM
; i
++)
555 size
= REGISTER_RAW_SIZE (i
);
557 memcpy (registers
+ REGISTER_BYTE (i
),
558 sprs
[i
- FIRST_UISA_SP_REGNUM
], size
);
563 /* Copy information about text and data sections from LDI to VP for a 64-bit
564 process if ARCH64 and for a 32-bit process otherwise. */
567 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
571 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
572 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
573 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
574 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
578 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
579 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
580 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
581 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
584 /* The run time loader maps the file header in addition to the text
585 section and returns a pointer to the header in ldinfo_textorg.
586 Adjust the text start address to point to the real start address
587 of the text section. */
588 vp
->tstart
+= vp
->toffs
;
591 /* handle symbol translation on vmapping */
594 vmap_symtab (struct vmap
*vp
)
596 register struct objfile
*objfile
;
597 struct section_offsets
*new_offsets
;
600 objfile
= vp
->objfile
;
603 /* OK, it's not an objfile we opened ourselves.
604 Currently, that can only happen with the exec file, so
605 relocate the symbols for the symfile. */
606 if (symfile_objfile
== NULL
)
608 objfile
= symfile_objfile
;
610 else if (!vp
->loaded
)
611 /* If symbols are not yet loaded, offsets are not yet valid. */
614 new_offsets
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
616 for (i
= 0; i
< objfile
->num_sections
; ++i
)
617 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
619 /* The symbols in the object file are linked to the VMA of the section,
620 relocate them VMA relative. */
621 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
622 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
623 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
625 objfile_relocate (objfile
, new_offsets
);
628 /* Add symbols for an objfile. */
631 objfile_symbol_add (void *arg
)
633 struct objfile
*obj
= (struct objfile
*) arg
;
635 syms_from_objfile (obj
, NULL
, 0, 0);
636 new_symfile_objfile (obj
, 0, 0);
640 /* Add symbols for a vmap. Return zero upon error. */
643 vmap_add_symbols (struct vmap
*vp
)
645 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
646 "Error while reading shared library symbols:\n",
649 /* Note this is only done if symbol reading was successful. */
657 /* Add a new vmap entry based on ldinfo() information.
659 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
660 core file), the caller should set it to -1, and we will open the file.
662 Return the vmap new entry. */
665 add_vmap (LdInfo
*ldi
)
668 register char *mem
, *objname
, *filename
;
672 ARCH64_DECL (arch64
);
674 /* This ldi structure was allocated using alloca() in
675 xcoff_relocate_symtab(). Now we need to have persistent object
676 and member names, so we should save them. */
678 filename
= LDI_FILENAME (ldi
, arch64
);
679 mem
= filename
+ strlen (filename
) + 1;
680 mem
= savestring (mem
, strlen (mem
));
681 objname
= savestring (filename
, strlen (filename
));
683 fd
= LDI_FD (ldi
, arch64
);
685 /* Note that this opens it once for every member; a possible
686 enhancement would be to only open it once for every object. */
687 abfd
= bfd_openr (objname
, gnutarget
);
689 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
692 warning ("Could not open `%s' as an executable file: %s",
693 objname
, bfd_errmsg (bfd_get_error ()));
697 /* make sure we have an object file */
699 if (bfd_check_format (abfd
, bfd_object
))
700 vp
= map_vmap (abfd
, 0);
702 else if (bfd_check_format (abfd
, bfd_archive
))
705 /* FIXME??? am I tossing BFDs? bfd? */
706 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
707 if (STREQ (mem
, last
->filename
))
712 warning ("\"%s\": member \"%s\" missing.", objname
, mem
);
717 if (!bfd_check_format (last
, bfd_object
))
719 warning ("\"%s\": member \"%s\" not in executable format: %s.",
720 objname
, mem
, bfd_errmsg (bfd_get_error ()));
726 vp
= map_vmap (last
, abfd
);
730 warning ("\"%s\": not in executable format: %s.",
731 objname
, bfd_errmsg (bfd_get_error ()));
735 obj
= allocate_objfile (vp
->bfd
, 0);
738 /* Always add symbols for the main objfile. */
739 if (vp
== vmap
|| auto_solib_add
)
740 vmap_add_symbols (vp
);
744 /* update VMAP info with ldinfo() information
745 Input is ptr to ldinfo() results. */
748 vmap_ldinfo (LdInfo
*ldi
)
751 register struct vmap
*vp
;
752 int got_one
, retried
;
753 int got_exec_file
= 0;
755 int arch64
= ARCH64 ();
757 /* For each *ldi, see if we have a corresponding *vp.
758 If so, update the mapping, and symbol table.
759 If not, add an entry and symbol table. */
763 char *name
= LDI_FILENAME (ldi
, arch64
);
764 char *memb
= name
+ strlen (name
) + 1;
765 int fd
= LDI_FD (ldi
, arch64
);
769 if (fstat (fd
, &ii
) < 0)
771 /* The kernel sets ld_info to -1, if the process is still using the
772 object, and the object is removed. Keep the symbol info for the
773 removed object and issue a warning. */
774 warning ("%s (fd=%d) has disappeared, keeping its symbols",
779 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
781 struct objfile
*objfile
;
783 /* First try to find a `vp', which is the same as in ldinfo.
784 If not the same, just continue and grep the next `vp'. If same,
785 relocate its tstart, tend, dstart, dend values. If no such `vp'
786 found, get out of this for loop, add this ldi entry as a new vmap
787 (add_vmap) and come back, find its `vp' and so on... */
789 /* The filenames are not always sufficient to match on. */
791 if ((name
[0] == '/' && !STREQ (name
, vp
->name
))
792 || (memb
[0] && !STREQ (memb
, vp
->member
)))
795 /* See if we are referring to the same file.
796 We have to check objfile->obfd, symfile.c:reread_symbols might
797 have updated the obfd after a change. */
798 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
800 || objfile
->obfd
== NULL
801 || bfd_stat (objfile
->obfd
, &vi
) < 0)
803 warning ("Unable to stat %s, keeping its symbols", name
);
807 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
815 /* Found a corresponding VMAP. Remap! */
817 vmap_secs (vp
, ldi
, arch64
);
819 /* The objfile is only NULL for the exec file. */
820 if (vp
->objfile
== NULL
)
823 /* relocate symbol table(s). */
826 /* There may be more, so we don't break out of the loop. */
829 /* if there was no matching *vp, we must perforce create the sucker(s) */
830 if (!got_one
&& !retried
)
837 while ((next
= LDI_NEXT (ldi
, arch64
))
838 && (ldi
= (void *) (next
+ (char *) ldi
)));
840 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
841 is unlikely that the symbol file is relocated to the proper
842 address. And we might have attached to a process which is
843 running a different copy of the same executable. */
844 if (symfile_objfile
!= NULL
&& !got_exec_file
)
847 fputs_unfiltered ("Symbol file ", gdb_stderr
);
848 fputs_unfiltered (symfile_objfile
->name
, gdb_stderr
);
849 fputs_unfiltered ("\nis not mapped; discarding it.\n\
850 If in fact that file has symbols which the mapped files listed by\n\
851 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
852 \"add-symbol-file\" commands (note that you must take care of relocating\n\
853 symbols to the proper address).\n", gdb_stderr
);
854 free_objfile (symfile_objfile
);
855 symfile_objfile
= NULL
;
857 breakpoint_re_set ();
860 /* As well as symbol tables, exec_sections need relocation. After
861 the inferior process' termination, there will be a relocated symbol
862 table exist with no corresponding inferior process. At that time, we
863 need to use `exec' bfd, rather than the inferior process's memory space
866 `exec_sections' need to be relocated only once, as long as the exec
867 file remains unchanged.
876 if (execbfd
== exec_bfd
)
881 if (!vmap
|| !exec_ops
.to_sections
)
882 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
884 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
886 if (STREQ (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
888 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
889 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
891 else if (STREQ (".data", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
893 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
894 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
896 else if (STREQ (".bss", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
898 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
899 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
904 /* Set the current architecture from the host running GDB. Called when
905 starting a child process. */
908 set_host_arch (int pid
)
910 enum bfd_architecture arch
;
913 struct gdbarch_info info
;
917 arch
= bfd_arch_rs6000
;
918 mach
= bfd_mach_rs6k
;
922 arch
= bfd_arch_powerpc
;
925 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
927 memset (&info
, 0, sizeof info
);
928 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
930 if (!gdbarch_update_p (info
))
932 internal_error (__FILE__
, __LINE__
,
933 "set_host_arch: failed to select architecture");
938 /* xcoff_relocate_symtab - hook for symbol table relocation.
939 also reads shared libraries.. */
942 xcoff_relocate_symtab (unsigned int pid
)
944 int load_segs
= 64; /* number of load segments */
947 int arch64
= ARCH64 ();
948 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
953 size
= load_segs
* ldisize
;
954 ldi
= (void *) xrealloc (ldi
, size
);
957 /* According to my humble theory, AIX has some timing problems and
958 when the user stack grows, kernel doesn't update stack info in time
959 and ptrace calls step on user stack. That is why we sleep here a
960 little, and give kernel to update its internals. */
965 rc
= ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
967 rc
= ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
974 perror_with_name ("ptrace ldinfo");
979 vmap_exec (); /* relocate the exec and core sections as well. */
986 /* Core file stuff. */
988 /* Relocate symtabs and read in shared library info, based on symbols
989 from the core file. */
992 xcoff_relocate_core (struct target_ops
*target
)
998 int arch64
= ARCH64 ();
1000 /* Size of a struct ld_info except for the variable-length filename. */
1001 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1003 /* Allocated size of buffer. */
1004 int buffer_size
= nonfilesz
;
1005 char *buffer
= xmalloc (buffer_size
);
1006 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1008 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1009 if (ldinfo_sec
== NULL
)
1012 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1013 bfd_errmsg (bfd_get_error ()));
1020 int names_found
= 0;
1022 /* Read in everything but the name. */
1023 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1024 offset
, nonfilesz
) == 0)
1031 if (i
== buffer_size
)
1034 buffer
= xrealloc (buffer
, buffer_size
);
1036 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1037 offset
+ i
, 1) == 0)
1039 if (buffer
[i
++] == '\0')
1042 while (names_found
< 2);
1044 ldi
= (LdInfo
*) buffer
;
1046 /* Can't use a file descriptor from the core file; need to open it. */
1048 ldi
->l64
.ldinfo_fd
= -1;
1050 ldi
->l32
.ldinfo_fd
= -1;
1052 /* The first ldinfo is for the exec file, allocated elsewhere. */
1053 if (offset
== 0 && vmap
!= NULL
)
1056 vp
= add_vmap (ldi
);
1058 /* Process next shared library upon error. */
1059 offset
+= LDI_NEXT (ldi
, arch64
);
1063 vmap_secs (vp
, ldi
, arch64
);
1065 /* Unless this is the exec file,
1066 add our sections to the section table for the core target. */
1069 struct section_table
*stp
;
1071 target_resize_to_sections (target
, 2);
1072 stp
= target
->to_sections_end
- 2;
1075 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1076 stp
->addr
= vp
->tstart
;
1077 stp
->endaddr
= vp
->tend
;
1081 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1082 stp
->addr
= vp
->dstart
;
1083 stp
->endaddr
= vp
->dend
;
1088 while (LDI_NEXT (ldi
, arch64
) != 0);
1090 breakpoint_re_set ();
1095 kernel_u_size (void)
1097 return (sizeof (struct user
));
1100 /* Under AIX, we have to pass the correct TOC pointer to a function
1101 when calling functions in the inferior.
1102 We try to find the relative toc offset of the objfile containing PC
1103 and add the current load address of the data segment from the vmap. */
1106 find_toc_address (CORE_ADDR pc
)
1109 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1111 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1113 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1115 /* vp->objfile is only NULL for the exec file. */
1116 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1121 error ("Unable to find TOC entry for pc 0x%x\n", pc
);
1124 /* Register that we are able to handle rs6000 core file formats. */
1126 static struct core_fns rs6000_core_fns
=
1128 bfd_target_xcoff_flavour
, /* core_flavour */
1129 default_check_format
, /* check_format */
1130 default_core_sniffer
, /* core_sniffer */
1131 fetch_core_registers
, /* core_read_registers */
1136 _initialize_core_rs6000 (void)
1138 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1139 calling functions in the inferior. */
1140 rs6000_find_toc_address_hook
= find_toc_address
;
1142 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1143 starting a child process. */
1144 rs6000_set_host_arch_hook
= set_host_arch
;
1146 add_core_fns (&rs6000_core_fns
);