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