2002-08-14 Michael Snyder <msnyder@redhat.com>
[deliverable/binutils-gdb.git] / gdb / rs6000-nat.c
1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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.
12
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.
17
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. */
22
23 #include "defs.h"
24 #include "inferior.h"
25 #include "target.h"
26 #include "gdbcore.h"
27 #include "xcoffsolib.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
31 #include "bfd.h"
32 #include "gdb-stabs.h"
33 #include "regcache.h"
34 #include "arch-utils.h"
35 #include "language.h" /* for local_hex_string(). */
36 #include "ppc-tdep.h"
37
38 #include <sys/ptrace.h>
39 #include <sys/reg.h>
40
41 #include <sys/param.h>
42 #include <sys/dir.h>
43 #include <sys/user.h>
44 #include <signal.h>
45 #include <sys/ioctl.h>
46 #include <fcntl.h>
47 #include <errno.h>
48
49 #include <a.out.h>
50 #include <sys/file.h>
51 #include "gdb_stat.h"
52 #include <sys/core.h>
53 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
54 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
55 #include <sys/ldr.h>
56 #include <sys/systemcfg.h>
57
58 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
59 debugging 32-bit and 64-bit processes. Define a typedef and macros for
60 accessing fields in the appropriate structures. */
61
62 /* In 32-bit compilation mode (which is the only mode from which ptrace()
63 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
64
65 #ifdef __ld_info32
66 # define ARCH3264
67 #endif
68
69 /* Return whether the current architecture is 64-bit. */
70
71 #ifndef ARCH3264
72 # define ARCH64() 0
73 #else
74 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
75 #endif
76
77 /* Union of 32-bit and 64-bit ".reg" core file sections. */
78
79 typedef union {
80 #ifdef ARCH3264
81 struct __context64 r64;
82 #else
83 struct mstsave r64;
84 #endif
85 struct mstsave r32;
86 } CoreRegs;
87
88 /* Union of 32-bit and 64-bit versions of ld_info. */
89
90 typedef union {
91 #ifndef ARCH3264
92 struct ld_info l32;
93 struct ld_info l64;
94 #else
95 struct __ld_info32 l32;
96 struct __ld_info64 l64;
97 #endif
98 } LdInfo;
99
100 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
101 declare and initialize a variable named VAR suitable for use as the arch64
102 parameter to the various LDI_*() macros. */
103
104 #ifndef ARCH3264
105 # define ARCH64_DECL(var)
106 #else
107 # define ARCH64_DECL(var) int var = ARCH64 ()
108 #endif
109
110 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
111 otherwise. This technique only works for FIELDs with the same data type in
112 32-bit and 64-bit versions of ld_info. */
113
114 #ifndef ARCH3264
115 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
116 #else
117 # define LDI_FIELD(ldi, arch64, field) \
118 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
119 #endif
120
121 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
122 process otherwise. */
123
124 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
125 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
126 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
127
128 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
129
130 extern struct target_ops exec_ops;
131
132 static void vmap_exec (void);
133
134 static void vmap_ldinfo (LdInfo *);
135
136 static struct vmap *add_vmap (LdInfo *);
137
138 static int objfile_symbol_add (void *);
139
140 static void vmap_symtab (struct vmap *);
141
142 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
143
144 static void exec_one_dummy_insn (void);
145
146 extern void
147 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
148
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. */
153
154 static int
155 regmap (int regno, int *isfloat)
156 {
157 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
158
159 *isfloat = 0;
160 if (tdep->ppc_gp0_regnum <= regno && regno <= tdep->ppc_gplast_regnum)
161 return regno;
162 else if (FP0_REGNUM <= regno && regno <= FPLAST_REGNUM)
163 {
164 *isfloat = 1;
165 return regno - FP0_REGNUM + FPR0;
166 }
167 else if (regno == PC_REGNUM)
168 return IAR;
169 else if (regno == tdep->ppc_ps_regnum)
170 return MSR;
171 else if (regno == tdep->ppc_cr_regnum)
172 return CR;
173 else if (regno == tdep->ppc_lr_regnum)
174 return LR;
175 else if (regno == tdep->ppc_ctr_regnum)
176 return CTR;
177 else if (regno == tdep->ppc_xer_regnum)
178 return XER;
179 else if (regno == tdep->ppc_fpscr_regnum)
180 return FPSCR;
181 else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
182 return MQ;
183 else
184 return -1;
185 }
186
187 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
188
189 static int
190 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
191 {
192 int ret = ptrace (req, id, (int *)addr, data, buf);
193 #if 0
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);
196 #endif
197 return ret;
198 }
199
200 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
201
202 static int
203 rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
204 {
205 #ifdef ARCH3264
206 int ret = ptracex (req, id, addr, data, buf);
207 #else
208 int ret = 0;
209 #endif
210 #if 0
211 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
212 req, id, addr, data, (unsigned int)buf, ret);
213 #endif
214 return ret;
215 }
216
217 /* Fetch register REGNO from the inferior. */
218
219 static void
220 fetch_register (int regno)
221 {
222 int *addr = alloca (MAX_REGISTER_RAW_SIZE);
223 int nr, isfloat;
224
225 /* Retrieved values may be -1, so infer errors from errno. */
226 errno = 0;
227
228 nr = regmap (regno, &isfloat);
229
230 /* Floating-point registers. */
231 if (isfloat)
232 rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
233
234 /* Bogus register number. */
235 else if (nr < 0)
236 {
237 if (regno >= NUM_REGS)
238 fprintf_unfiltered (gdb_stderr,
239 "gdb error: register no %d not implemented.\n",
240 regno);
241 return;
242 }
243
244 /* Fixed-point registers. */
245 else
246 {
247 if (!ARCH64 ())
248 *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
249 else
250 {
251 /* PT_READ_GPR requires the buffer parameter to point to long long,
252 even if the register is really only 32 bits. */
253 long long buf;
254 rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
255 if (REGISTER_RAW_SIZE (regno) == 8)
256 memcpy (addr, &buf, 8);
257 else
258 *addr = buf;
259 }
260 }
261
262 if (!errno)
263 supply_register (regno, (char *) addr);
264 else
265 {
266 #if 0
267 /* FIXME: this happens 3 times at the start of each 64-bit program. */
268 perror ("ptrace read");
269 #endif
270 errno = 0;
271 }
272 }
273
274 /* Store register REGNO back into the inferior. */
275
276 static void
277 store_register (int regno)
278 {
279 int *addr = alloca (MAX_REGISTER_RAW_SIZE);
280 int nr, isfloat;
281
282 /* Fetch the register's value from the register cache. */
283 regcache_collect (regno, addr);
284
285 /* -1 can be a successful return value, so infer errors from errno. */
286 errno = 0;
287
288 nr = regmap (regno, &isfloat);
289
290 /* Floating-point registers. */
291 if (isfloat)
292 rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
293
294 /* Bogus register number. */
295 else if (nr < 0)
296 {
297 if (regno >= NUM_REGS)
298 fprintf_unfiltered (gdb_stderr,
299 "gdb error: register no %d not implemented.\n",
300 regno);
301 }
302
303 /* Fixed-point registers. */
304 else
305 {
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
311 (%sp). */
312 exec_one_dummy_insn ();
313
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. */
317 if (!ARCH64 ())
318 rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
319 else
320 {
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. */
323 long long buf;
324 if (REGISTER_RAW_SIZE (regno) == 8)
325 memcpy (&buf, addr, 8);
326 else
327 buf = *addr;
328 rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
329 }
330 }
331
332 if (errno)
333 {
334 perror ("ptrace write");
335 errno = 0;
336 }
337 }
338
339 /* Read from the inferior all registers if REGNO == -1 and just register
340 REGNO otherwise. */
341
342 void
343 fetch_inferior_registers (int regno)
344 {
345 if (regno != -1)
346 fetch_register (regno);
347
348 else
349 {
350 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
351
352 /* Read 32 general purpose registers. */
353 for (regno = tdep->ppc_gp0_regnum;
354 regno <= tdep->ppc_gplast_regnum;
355 regno++)
356 {
357 fetch_register (regno);
358 }
359
360 /* Read general purpose floating point registers. */
361 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
362 fetch_register (regno);
363
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);
374 }
375 }
376
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). */
380
381 void
382 store_inferior_registers (int regno)
383 {
384 if (regno != -1)
385 store_register (regno);
386
387 else
388 {
389 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
390
391 /* Write general purpose registers first. */
392 for (regno = tdep->ppc_gp0_regnum;
393 regno <= tdep->ppc_gplast_regnum;
394 regno++)
395 {
396 store_register (regno);
397 }
398
399 /* Write floating point registers. */
400 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
401 store_register (regno);
402
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);
413 }
414 }
415
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
418 success. */
419
420 static int
421 read_word (CORE_ADDR from, int *to, int arch64)
422 {
423 /* Retrieved values may be -1, so infer errors from errno. */
424 errno = 0;
425
426 if (arch64)
427 *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
428 else
429 *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
430 0, NULL);
431
432 return !errno;
433 }
434
435 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
436 to debugger memory starting at MYADDR. Copy to inferior if
437 WRITE is nonzero.
438
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
442 anyway. */
443
444 int
445 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
446 int write, struct mem_attrib *attrib,
447 struct target_ops *target)
448 {
449 /* Round starting address down to 32-bit word boundary. */
450 int mask = sizeof (int) - 1;
451 CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
452
453 /* Round ending address up to 32-bit word boundary. */
454 int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
455 / sizeof (int);
456
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));
462
463 int arch64 = ARCH64 ();
464 int i;
465
466 if (!write)
467 {
468 /* Retrieve memory a word at a time. */
469 for (i = 0; i < count; i++, addr += sizeof (int))
470 {
471 if (!read_word (addr, buf + i, arch64))
472 return 0;
473 QUIT;
474 }
475
476 /* Copy memory to supplied buffer. */
477 addr -= count * sizeof (int);
478 memcpy (myaddr, (char *)buf + (memaddr - addr), len);
479 }
480 else
481 {
482 /* Fetch leading memory needed for alignment. */
483 if (addr < memaddr)
484 if (!read_word (addr, buf, arch64))
485 return 0;
486
487 /* Fetch trailing memory needed for alignment. */
488 if (addr + count * sizeof (int) > memaddr + len)
489 if (!read_word (addr, buf + count - 1, arch64))
490 return 0;
491
492 /* Copy supplied data into memory buffer. */
493 memcpy ((char *)buf + (memaddr - addr), myaddr, len);
494
495 /* Store memory one word at a time. */
496 for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
497 {
498 if (arch64)
499 rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
500 else
501 rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
502 buf[i], NULL);
503
504 if (errno)
505 return 0;
506 QUIT;
507 }
508 }
509
510 return len;
511 }
512
513 /* Execute one dummy breakpoint instruction. This way we give the kernel
514 a chance to do some housekeeping and update inferior's internal data,
515 including u_area. */
516
517 static void
518 exec_one_dummy_insn (void)
519 {
520 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
521
522 char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
523 int ret, status, pid;
524 CORE_ADDR prev_pc;
525
526 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
527 assume that this address will never be executed again by the real
528 code. */
529
530 target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
531
532 /* You might think this could be done with a single ptrace call, and
533 you'd be correct for just about every platform I've ever worked
534 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
535 the inferior never hits the breakpoint (it's also worth noting
536 powerpc-ibm-aix4.1.3 works correctly). */
537 prev_pc = read_pc ();
538 write_pc (DUMMY_INSN_ADDR);
539 if (ARCH64 ())
540 ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
541 else
542 ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
543
544 if (ret != 0)
545 perror ("pt_continue");
546
547 do
548 {
549 pid = wait (&status);
550 }
551 while (pid != PIDGET (inferior_ptid));
552
553 write_pc (prev_pc);
554 target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
555 }
556
557 /* Fetch registers from the register section in core bfd. */
558
559 static void
560 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
561 int which, CORE_ADDR reg_addr)
562 {
563 CoreRegs *regs;
564 int regi;
565 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
566
567 if (which != 0)
568 {
569 fprintf_unfiltered
570 (gdb_stderr,
571 "Gdb error: unknown parameter to fetch_core_registers().\n");
572 return;
573 }
574
575 regs = (CoreRegs *) core_reg_sect;
576
577 /* Put the register values from the core file section in the regcache. */
578
579 if (ARCH64 ())
580 {
581 for (regi = 0; regi < 32; regi++)
582 supply_register (regi, (char *) &regs->r64.gpr[regi]);
583
584 for (regi = 0; regi < 32; regi++)
585 supply_register (FP0_REGNUM + regi, (char *) &regs->r64.fpr[regi]);
586
587 supply_register (PC_REGNUM, (char *) &regs->r64.iar);
588 supply_register (tdep->ppc_ps_regnum, (char *) &regs->r64.msr);
589 supply_register (tdep->ppc_cr_regnum, (char *) &regs->r64.cr);
590 supply_register (tdep->ppc_lr_regnum, (char *) &regs->r64.lr);
591 supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r64.ctr);
592 supply_register (tdep->ppc_xer_regnum, (char *) &regs->r64.xer);
593 supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r64.fpscr);
594 }
595 else
596 {
597 for (regi = 0; regi < 32; regi++)
598 supply_register (regi, (char *) &regs->r32.gpr[regi]);
599
600 for (regi = 0; regi < 32; regi++)
601 supply_register (FP0_REGNUM + regi, (char *) &regs->r32.fpr[regi]);
602
603 supply_register (PC_REGNUM, (char *) &regs->r32.iar);
604 supply_register (tdep->ppc_ps_regnum, (char *) &regs->r32.msr);
605 supply_register (tdep->ppc_cr_regnum, (char *) &regs->r32.cr);
606 supply_register (tdep->ppc_lr_regnum, (char *) &regs->r32.lr);
607 supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r32.ctr);
608 supply_register (tdep->ppc_xer_regnum, (char *) &regs->r32.xer);
609 supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r32.fpscr);
610 if (tdep->ppc_mq_regnum >= 0)
611 supply_register (tdep->ppc_mq_regnum, (char *) &regs->r32.mq);
612 }
613 }
614 \f
615
616 /* Copy information about text and data sections from LDI to VP for a 64-bit
617 process if ARCH64 and for a 32-bit process otherwise. */
618
619 static void
620 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
621 {
622 if (arch64)
623 {
624 vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
625 vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
626 vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
627 vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
628 }
629 else
630 {
631 vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
632 vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
633 vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
634 vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
635 }
636
637 /* The run time loader maps the file header in addition to the text
638 section and returns a pointer to the header in ldinfo_textorg.
639 Adjust the text start address to point to the real start address
640 of the text section. */
641 vp->tstart += vp->toffs;
642 }
643
644 /* handle symbol translation on vmapping */
645
646 static void
647 vmap_symtab (struct vmap *vp)
648 {
649 register struct objfile *objfile;
650 struct section_offsets *new_offsets;
651 int i;
652
653 objfile = vp->objfile;
654 if (objfile == NULL)
655 {
656 /* OK, it's not an objfile we opened ourselves.
657 Currently, that can only happen with the exec file, so
658 relocate the symbols for the symfile. */
659 if (symfile_objfile == NULL)
660 return;
661 objfile = symfile_objfile;
662 }
663 else if (!vp->loaded)
664 /* If symbols are not yet loaded, offsets are not yet valid. */
665 return;
666
667 new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
668
669 for (i = 0; i < objfile->num_sections; ++i)
670 new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
671
672 /* The symbols in the object file are linked to the VMA of the section,
673 relocate them VMA relative. */
674 new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
675 new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
676 new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
677
678 objfile_relocate (objfile, new_offsets);
679 }
680 \f
681 /* Add symbols for an objfile. */
682
683 static int
684 objfile_symbol_add (void *arg)
685 {
686 struct objfile *obj = (struct objfile *) arg;
687
688 syms_from_objfile (obj, NULL, 0, 0);
689 new_symfile_objfile (obj, 0, 0);
690 return 1;
691 }
692
693 /* Add symbols for a vmap. Return zero upon error. */
694
695 int
696 vmap_add_symbols (struct vmap *vp)
697 {
698 if (catch_errors (objfile_symbol_add, vp->objfile,
699 "Error while reading shared library symbols:\n",
700 RETURN_MASK_ALL))
701 {
702 /* Note this is only done if symbol reading was successful. */
703 vp->loaded = 1;
704 vmap_symtab (vp);
705 return 1;
706 }
707 return 0;
708 }
709
710 /* Add a new vmap entry based on ldinfo() information.
711
712 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
713 core file), the caller should set it to -1, and we will open the file.
714
715 Return the vmap new entry. */
716
717 static struct vmap *
718 add_vmap (LdInfo *ldi)
719 {
720 bfd *abfd, *last;
721 register char *mem, *objname, *filename;
722 struct objfile *obj;
723 struct vmap *vp;
724 int fd;
725 ARCH64_DECL (arch64);
726
727 /* This ldi structure was allocated using alloca() in
728 xcoff_relocate_symtab(). Now we need to have persistent object
729 and member names, so we should save them. */
730
731 filename = LDI_FILENAME (ldi, arch64);
732 mem = filename + strlen (filename) + 1;
733 mem = savestring (mem, strlen (mem));
734 objname = savestring (filename, strlen (filename));
735
736 fd = LDI_FD (ldi, arch64);
737 if (fd < 0)
738 /* Note that this opens it once for every member; a possible
739 enhancement would be to only open it once for every object. */
740 abfd = bfd_openr (objname, gnutarget);
741 else
742 abfd = bfd_fdopenr (objname, gnutarget, fd);
743 if (!abfd)
744 {
745 warning ("Could not open `%s' as an executable file: %s",
746 objname, bfd_errmsg (bfd_get_error ()));
747 return NULL;
748 }
749
750 /* make sure we have an object file */
751
752 if (bfd_check_format (abfd, bfd_object))
753 vp = map_vmap (abfd, 0);
754
755 else if (bfd_check_format (abfd, bfd_archive))
756 {
757 last = 0;
758 /* FIXME??? am I tossing BFDs? bfd? */
759 while ((last = bfd_openr_next_archived_file (abfd, last)))
760 if (STREQ (mem, last->filename))
761 break;
762
763 if (!last)
764 {
765 warning ("\"%s\": member \"%s\" missing.", objname, mem);
766 bfd_close (abfd);
767 return NULL;
768 }
769
770 if (!bfd_check_format (last, bfd_object))
771 {
772 warning ("\"%s\": member \"%s\" not in executable format: %s.",
773 objname, mem, bfd_errmsg (bfd_get_error ()));
774 bfd_close (last);
775 bfd_close (abfd);
776 return NULL;
777 }
778
779 vp = map_vmap (last, abfd);
780 }
781 else
782 {
783 warning ("\"%s\": not in executable format: %s.",
784 objname, bfd_errmsg (bfd_get_error ()));
785 bfd_close (abfd);
786 return NULL;
787 }
788 obj = allocate_objfile (vp->bfd, 0);
789 vp->objfile = obj;
790
791 /* Always add symbols for the main objfile. */
792 if (vp == vmap || auto_solib_add)
793 vmap_add_symbols (vp);
794 return vp;
795 }
796 \f
797 /* update VMAP info with ldinfo() information
798 Input is ptr to ldinfo() results. */
799
800 static void
801 vmap_ldinfo (LdInfo *ldi)
802 {
803 struct stat ii, vi;
804 register struct vmap *vp;
805 int got_one, retried;
806 int got_exec_file = 0;
807 uint next;
808 int arch64 = ARCH64 ();
809
810 /* For each *ldi, see if we have a corresponding *vp.
811 If so, update the mapping, and symbol table.
812 If not, add an entry and symbol table. */
813
814 do
815 {
816 char *name = LDI_FILENAME (ldi, arch64);
817 char *memb = name + strlen (name) + 1;
818 int fd = LDI_FD (ldi, arch64);
819
820 retried = 0;
821
822 if (fstat (fd, &ii) < 0)
823 {
824 /* The kernel sets ld_info to -1, if the process is still using the
825 object, and the object is removed. Keep the symbol info for the
826 removed object and issue a warning. */
827 warning ("%s (fd=%d) has disappeared, keeping its symbols",
828 name, fd);
829 continue;
830 }
831 retry:
832 for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
833 {
834 struct objfile *objfile;
835
836 /* First try to find a `vp', which is the same as in ldinfo.
837 If not the same, just continue and grep the next `vp'. If same,
838 relocate its tstart, tend, dstart, dend values. If no such `vp'
839 found, get out of this for loop, add this ldi entry as a new vmap
840 (add_vmap) and come back, find its `vp' and so on... */
841
842 /* The filenames are not always sufficient to match on. */
843
844 if ((name[0] == '/' && !STREQ (name, vp->name))
845 || (memb[0] && !STREQ (memb, vp->member)))
846 continue;
847
848 /* See if we are referring to the same file.
849 We have to check objfile->obfd, symfile.c:reread_symbols might
850 have updated the obfd after a change. */
851 objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
852 if (objfile == NULL
853 || objfile->obfd == NULL
854 || bfd_stat (objfile->obfd, &vi) < 0)
855 {
856 warning ("Unable to stat %s, keeping its symbols", name);
857 continue;
858 }
859
860 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
861 continue;
862
863 if (!retried)
864 close (fd);
865
866 ++got_one;
867
868 /* Found a corresponding VMAP. Remap! */
869
870 vmap_secs (vp, ldi, arch64);
871
872 /* The objfile is only NULL for the exec file. */
873 if (vp->objfile == NULL)
874 got_exec_file = 1;
875
876 /* relocate symbol table(s). */
877 vmap_symtab (vp);
878
879 /* Announce new object files. Doing this after symbol relocation
880 makes aix-thread.c's job easier. */
881 if (target_new_objfile_hook && vp->objfile)
882 target_new_objfile_hook (vp->objfile);
883
884 /* There may be more, so we don't break out of the loop. */
885 }
886
887 /* if there was no matching *vp, we must perforce create the sucker(s) */
888 if (!got_one && !retried)
889 {
890 add_vmap (ldi);
891 ++retried;
892 goto retry;
893 }
894 }
895 while ((next = LDI_NEXT (ldi, arch64))
896 && (ldi = (void *) (next + (char *) ldi)));
897
898 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
899 is unlikely that the symbol file is relocated to the proper
900 address. And we might have attached to a process which is
901 running a different copy of the same executable. */
902 if (symfile_objfile != NULL && !got_exec_file)
903 {
904 warning ("Symbol file %s\nis not mapped; discarding it.\n\
905 If in fact that file has symbols which the mapped files listed by\n\
906 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
907 \"add-symbol-file\" commands (note that you must take care of relocating\n\
908 symbols to the proper address).",
909 symfile_objfile->name);
910 free_objfile (symfile_objfile);
911 symfile_objfile = NULL;
912 }
913 breakpoint_re_set ();
914 }
915 \f
916 /* As well as symbol tables, exec_sections need relocation. After
917 the inferior process' termination, there will be a relocated symbol
918 table exist with no corresponding inferior process. At that time, we
919 need to use `exec' bfd, rather than the inferior process's memory space
920 to look up symbols.
921
922 `exec_sections' need to be relocated only once, as long as the exec
923 file remains unchanged.
924 */
925
926 static void
927 vmap_exec (void)
928 {
929 static bfd *execbfd;
930 int i;
931
932 if (execbfd == exec_bfd)
933 return;
934
935 execbfd = exec_bfd;
936
937 if (!vmap || !exec_ops.to_sections)
938 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
939
940 for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
941 {
942 if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
943 {
944 exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
945 exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
946 }
947 else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
948 {
949 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
950 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
951 }
952 else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
953 {
954 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
955 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
956 }
957 }
958 }
959
960 /* Set the current architecture from the host running GDB. Called when
961 starting a child process. */
962
963 static void
964 set_host_arch (int pid)
965 {
966 enum bfd_architecture arch;
967 unsigned long mach;
968 bfd abfd;
969 struct gdbarch_info info;
970
971 if (__power_rs ())
972 {
973 arch = bfd_arch_rs6000;
974 mach = bfd_mach_rs6k;
975 }
976 else
977 {
978 arch = bfd_arch_powerpc;
979 mach = bfd_mach_ppc;
980 }
981
982 /* FIXME: schauer/2002-02-25:
983 We don't know if we are executing a 32 or 64 bit executable,
984 and have no way to pass the proper word size to rs6000_gdbarch_init.
985 So we have to avoid switching to a new architecture, if the architecture
986 matches already.
987 Blindly calling rs6000_gdbarch_init used to work in older versions of
988 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
989 determine the wordsize. */
990 if (exec_bfd)
991 {
992 const struct bfd_arch_info *exec_bfd_arch_info;
993
994 exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
995 if (arch == exec_bfd_arch_info->arch)
996 return;
997 }
998
999 bfd_default_set_arch_mach (&abfd, arch, mach);
1000
1001 gdbarch_info_init (&info);
1002 info.bfd_arch_info = bfd_get_arch_info (&abfd);
1003
1004 if (!gdbarch_update_p (info))
1005 {
1006 internal_error (__FILE__, __LINE__,
1007 "set_host_arch: failed to select architecture");
1008 }
1009 }
1010
1011 \f
1012 /* xcoff_relocate_symtab - hook for symbol table relocation.
1013 also reads shared libraries.. */
1014
1015 void
1016 xcoff_relocate_symtab (unsigned int pid)
1017 {
1018 int load_segs = 64; /* number of load segments */
1019 int rc;
1020 LdInfo *ldi = NULL;
1021 int arch64 = ARCH64 ();
1022 int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1023 int size;
1024
1025 do
1026 {
1027 size = load_segs * ldisize;
1028 ldi = (void *) xrealloc (ldi, size);
1029
1030 #if 0
1031 /* According to my humble theory, AIX has some timing problems and
1032 when the user stack grows, kernel doesn't update stack info in time
1033 and ptrace calls step on user stack. That is why we sleep here a
1034 little, and give kernel to update its internals. */
1035 usleep (36000);
1036 #endif
1037
1038 if (arch64)
1039 rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1040 else
1041 rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1042
1043 if (rc == -1)
1044 {
1045 if (errno == ENOMEM)
1046 load_segs *= 2;
1047 else
1048 perror_with_name ("ptrace ldinfo");
1049 }
1050 else
1051 {
1052 vmap_ldinfo (ldi);
1053 vmap_exec (); /* relocate the exec and core sections as well. */
1054 }
1055 } while (rc == -1);
1056 if (ldi)
1057 xfree (ldi);
1058 }
1059 \f
1060 /* Core file stuff. */
1061
1062 /* Relocate symtabs and read in shared library info, based on symbols
1063 from the core file. */
1064
1065 void
1066 xcoff_relocate_core (struct target_ops *target)
1067 {
1068 sec_ptr ldinfo_sec;
1069 int offset = 0;
1070 LdInfo *ldi;
1071 struct vmap *vp;
1072 int arch64 = ARCH64 ();
1073
1074 /* Size of a struct ld_info except for the variable-length filename. */
1075 int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1076
1077 /* Allocated size of buffer. */
1078 int buffer_size = nonfilesz;
1079 char *buffer = xmalloc (buffer_size);
1080 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1081
1082 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1083 if (ldinfo_sec == NULL)
1084 {
1085 bfd_err:
1086 fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1087 bfd_errmsg (bfd_get_error ()));
1088 do_cleanups (old);
1089 return;
1090 }
1091 do
1092 {
1093 int i;
1094 int names_found = 0;
1095
1096 /* Read in everything but the name. */
1097 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1098 offset, nonfilesz) == 0)
1099 goto bfd_err;
1100
1101 /* Now the name. */
1102 i = nonfilesz;
1103 do
1104 {
1105 if (i == buffer_size)
1106 {
1107 buffer_size *= 2;
1108 buffer = xrealloc (buffer, buffer_size);
1109 }
1110 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1111 offset + i, 1) == 0)
1112 goto bfd_err;
1113 if (buffer[i++] == '\0')
1114 ++names_found;
1115 }
1116 while (names_found < 2);
1117
1118 ldi = (LdInfo *) buffer;
1119
1120 /* Can't use a file descriptor from the core file; need to open it. */
1121 if (arch64)
1122 ldi->l64.ldinfo_fd = -1;
1123 else
1124 ldi->l32.ldinfo_fd = -1;
1125
1126 /* The first ldinfo is for the exec file, allocated elsewhere. */
1127 if (offset == 0 && vmap != NULL)
1128 vp = vmap;
1129 else
1130 vp = add_vmap (ldi);
1131
1132 /* Process next shared library upon error. */
1133 offset += LDI_NEXT (ldi, arch64);
1134 if (vp == NULL)
1135 continue;
1136
1137 vmap_secs (vp, ldi, arch64);
1138
1139 /* Unless this is the exec file,
1140 add our sections to the section table for the core target. */
1141 if (vp != vmap)
1142 {
1143 struct section_table *stp;
1144
1145 target_resize_to_sections (target, 2);
1146 stp = target->to_sections_end - 2;
1147
1148 stp->bfd = vp->bfd;
1149 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1150 stp->addr = vp->tstart;
1151 stp->endaddr = vp->tend;
1152 stp++;
1153
1154 stp->bfd = vp->bfd;
1155 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1156 stp->addr = vp->dstart;
1157 stp->endaddr = vp->dend;
1158 }
1159
1160 vmap_symtab (vp);
1161
1162 if (target_new_objfile_hook && vp != vmap && vp->objfile)
1163 target_new_objfile_hook (vp->objfile);
1164 }
1165 while (LDI_NEXT (ldi, arch64) != 0);
1166 vmap_exec ();
1167 breakpoint_re_set ();
1168 do_cleanups (old);
1169 }
1170
1171 int
1172 kernel_u_size (void)
1173 {
1174 return (sizeof (struct user));
1175 }
1176 \f
1177 /* Under AIX, we have to pass the correct TOC pointer to a function
1178 when calling functions in the inferior.
1179 We try to find the relative toc offset of the objfile containing PC
1180 and add the current load address of the data segment from the vmap. */
1181
1182 static CORE_ADDR
1183 find_toc_address (CORE_ADDR pc)
1184 {
1185 struct vmap *vp;
1186 extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
1187
1188 for (vp = vmap; vp; vp = vp->nxt)
1189 {
1190 if (pc >= vp->tstart && pc < vp->tend)
1191 {
1192 /* vp->objfile is only NULL for the exec file. */
1193 return vp->dstart + get_toc_offset (vp->objfile == NULL
1194 ? symfile_objfile
1195 : vp->objfile);
1196 }
1197 }
1198 error ("Unable to find TOC entry for pc %s\n", local_hex_string (pc));
1199 }
1200 \f
1201 /* Register that we are able to handle rs6000 core file formats. */
1202
1203 static struct core_fns rs6000_core_fns =
1204 {
1205 bfd_target_xcoff_flavour, /* core_flavour */
1206 default_check_format, /* check_format */
1207 default_core_sniffer, /* core_sniffer */
1208 fetch_core_registers, /* core_read_registers */
1209 NULL /* next */
1210 };
1211
1212 void
1213 _initialize_core_rs6000 (void)
1214 {
1215 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1216 calling functions in the inferior. */
1217 rs6000_find_toc_address_hook = find_toc_address;
1218
1219 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1220 starting a child process. */
1221 rs6000_set_host_arch_hook = set_host_arch;
1222
1223 add_core_fns (&rs6000_core_fns);
1224 }
This page took 0.064737 seconds and 4 git commands to generate.