2005-01-12 Andrew Cagney <cagney@gnu.org>
[external/binutils.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_default_set_arch_mach (FIXME) */
32 #include "bfd.h"
33 #include "exceptions.h"
34 #include "gdb-stabs.h"
35 #include "regcache.h"
36 #include "arch-utils.h"
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() (register_size (current_gdbarch, 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 (register_size (current_gdbarch, regno) == 8)
259             memcpy (addr, &buf, 8);
260           else
261             *addr = buf;
262         }
263     }
264
265   if (!errno)
266     regcache_raw_supply (current_regcache, 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_raw_collect (current_regcache, 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 (register_size (current_gdbarch, 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
447    zero.  This xfer function does not do partial moves, since
448    deprecated_child_ops doesn't allow memory operations to cross below
449    us in the target stack 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 < ppc_num_gprs; regi++)
590         regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
591                              (char *) &regs->r64.gpr[regi]);
592
593       if (tdep->ppc_fp0_regnum >= 0)
594         for (regi = 0; regi < ppc_num_fprs; regi++)
595           regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
596                                (char *) &regs->r64.fpr[regi]);
597
598       regcache_raw_supply (current_regcache, PC_REGNUM,
599                            (char *) &regs->r64.iar);
600       regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
601                            (char *) &regs->r64.msr);
602       regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
603                            (char *) &regs->r64.cr);
604       regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
605                            (char *) &regs->r64.lr);
606       regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
607                            (char *) &regs->r64.ctr);
608       regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
609                            (char *) &regs->r64.xer);
610       if (tdep->ppc_fpscr_regnum >= 0)
611         regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
612                              (char *) &regs->r64.fpscr);
613     }
614   else
615     {
616       for (regi = 0; regi < ppc_num_gprs; regi++)
617         regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
618                              (char *) &regs->r32.gpr[regi]);
619
620       if (tdep->ppc_fp0_regnum >= 0)
621         for (regi = 0; regi < ppc_num_fprs; regi++)
622           regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
623                                (char *) &regs->r32.fpr[regi]);
624
625       regcache_raw_supply (current_regcache, PC_REGNUM,
626                            (char *) &regs->r32.iar);
627       regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
628                            (char *) &regs->r32.msr);
629       regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
630                            (char *) &regs->r32.cr);
631       regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
632                            (char *) &regs->r32.lr);
633       regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
634                            (char *) &regs->r32.ctr);
635       regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
636                            (char *) &regs->r32.xer);
637       if (tdep->ppc_fpscr_regnum >= 0)
638         regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
639                              (char *) &regs->r32.fpscr);
640       if (tdep->ppc_mq_regnum >= 0)
641         regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
642                              (char *) &regs->r32.mq);
643     }
644 }
645 \f
646
647 /* Copy information about text and data sections from LDI to VP for a 64-bit
648    process if ARCH64 and for a 32-bit process otherwise. */
649
650 static void
651 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
652 {
653   if (arch64)
654     {
655       vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
656       vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
657       vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
658       vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
659     }
660   else
661     {
662       vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
663       vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
664       vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
665       vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
666     }
667
668   /* The run time loader maps the file header in addition to the text
669      section and returns a pointer to the header in ldinfo_textorg.
670      Adjust the text start address to point to the real start address
671      of the text section.  */
672   vp->tstart += vp->toffs;
673 }
674
675 /* handle symbol translation on vmapping */
676
677 static void
678 vmap_symtab (struct vmap *vp)
679 {
680   struct objfile *objfile;
681   struct section_offsets *new_offsets;
682   int i;
683
684   objfile = vp->objfile;
685   if (objfile == NULL)
686     {
687       /* OK, it's not an objfile we opened ourselves.
688          Currently, that can only happen with the exec file, so
689          relocate the symbols for the symfile.  */
690       if (symfile_objfile == NULL)
691         return;
692       objfile = symfile_objfile;
693     }
694   else if (!vp->loaded)
695     /* If symbols are not yet loaded, offsets are not yet valid. */
696     return;
697
698   new_offsets =
699     (struct section_offsets *)
700     alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
701
702   for (i = 0; i < objfile->num_sections; ++i)
703     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
704
705   /* The symbols in the object file are linked to the VMA of the section,
706      relocate them VMA relative.  */
707   new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
708   new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
709   new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
710
711   objfile_relocate (objfile, new_offsets);
712 }
713 \f
714 /* Add symbols for an objfile.  */
715
716 static int
717 objfile_symbol_add (void *arg)
718 {
719   struct objfile *obj = (struct objfile *) arg;
720
721   syms_from_objfile (obj, NULL, 0, 0, 0, 0);
722   new_symfile_objfile (obj, 0, 0);
723   return 1;
724 }
725
726 /* Add symbols for a vmap. Return zero upon error.  */
727
728 int
729 vmap_add_symbols (struct vmap *vp)
730 {
731   if (catch_errors (objfile_symbol_add, vp->objfile,
732                     "Error while reading shared library symbols:\n",
733                     RETURN_MASK_ALL))
734     {
735       /* Note this is only done if symbol reading was successful.  */
736       vp->loaded = 1;
737       vmap_symtab (vp);
738       return 1;
739     }
740   return 0;
741 }
742
743 /* Add a new vmap entry based on ldinfo() information.
744
745    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
746    core file), the caller should set it to -1, and we will open the file.
747
748    Return the vmap new entry.  */
749
750 static struct vmap *
751 add_vmap (LdInfo *ldi)
752 {
753   bfd *abfd, *last;
754   char *mem, *objname, *filename;
755   struct objfile *obj;
756   struct vmap *vp;
757   int fd;
758   ARCH64_DECL (arch64);
759
760   /* This ldi structure was allocated using alloca() in 
761      xcoff_relocate_symtab(). Now we need to have persistent object 
762      and member names, so we should save them. */
763
764   filename = LDI_FILENAME (ldi, arch64);
765   mem = filename + strlen (filename) + 1;
766   mem = savestring (mem, strlen (mem));
767   objname = savestring (filename, strlen (filename));
768
769   fd = LDI_FD (ldi, arch64);
770   if (fd < 0)
771     /* Note that this opens it once for every member; a possible
772        enhancement would be to only open it once for every object.  */
773     abfd = bfd_openr (objname, gnutarget);
774   else
775     abfd = bfd_fdopenr (objname, gnutarget, fd);
776   if (!abfd)
777     {
778       warning ("Could not open `%s' as an executable file: %s",
779                objname, bfd_errmsg (bfd_get_error ()));
780       return NULL;
781     }
782
783   /* make sure we have an object file */
784
785   if (bfd_check_format (abfd, bfd_object))
786     vp = map_vmap (abfd, 0);
787
788   else if (bfd_check_format (abfd, bfd_archive))
789     {
790       last = 0;
791       /* FIXME??? am I tossing BFDs?  bfd? */
792       while ((last = bfd_openr_next_archived_file (abfd, last)))
793         if (DEPRECATED_STREQ (mem, last->filename))
794           break;
795
796       if (!last)
797         {
798           warning ("\"%s\": member \"%s\" missing.", objname, mem);
799           bfd_close (abfd);
800           return NULL;
801         }
802
803       if (!bfd_check_format (last, bfd_object))
804         {
805           warning ("\"%s\": member \"%s\" not in executable format: %s.",
806                    objname, mem, bfd_errmsg (bfd_get_error ()));
807           bfd_close (last);
808           bfd_close (abfd);
809           return NULL;
810         }
811
812       vp = map_vmap (last, abfd);
813     }
814   else
815     {
816       warning ("\"%s\": not in executable format: %s.",
817                objname, bfd_errmsg (bfd_get_error ()));
818       bfd_close (abfd);
819       return NULL;
820     }
821   obj = allocate_objfile (vp->bfd, 0);
822   vp->objfile = obj;
823
824   /* Always add symbols for the main objfile.  */
825   if (vp == vmap || auto_solib_add)
826     vmap_add_symbols (vp);
827   return vp;
828 }
829 \f
830 /* update VMAP info with ldinfo() information
831    Input is ptr to ldinfo() results.  */
832
833 static void
834 vmap_ldinfo (LdInfo *ldi)
835 {
836   struct stat ii, vi;
837   struct vmap *vp;
838   int got_one, retried;
839   int got_exec_file = 0;
840   uint next;
841   int arch64 = ARCH64 ();
842
843   /* For each *ldi, see if we have a corresponding *vp.
844      If so, update the mapping, and symbol table.
845      If not, add an entry and symbol table.  */
846
847   do
848     {
849       char *name = LDI_FILENAME (ldi, arch64);
850       char *memb = name + strlen (name) + 1;
851       int fd = LDI_FD (ldi, arch64);
852
853       retried = 0;
854
855       if (fstat (fd, &ii) < 0)
856         {
857           /* The kernel sets ld_info to -1, if the process is still using the
858              object, and the object is removed. Keep the symbol info for the
859              removed object and issue a warning.  */
860           warning ("%s (fd=%d) has disappeared, keeping its symbols",
861                    name, fd);
862           continue;
863         }
864     retry:
865       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
866         {
867           struct objfile *objfile;
868
869           /* First try to find a `vp', which is the same as in ldinfo.
870              If not the same, just continue and grep the next `vp'. If same,
871              relocate its tstart, tend, dstart, dend values. If no such `vp'
872              found, get out of this for loop, add this ldi entry as a new vmap
873              (add_vmap) and come back, find its `vp' and so on... */
874
875           /* The filenames are not always sufficient to match on. */
876
877           if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
878               || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
879             continue;
880
881           /* See if we are referring to the same file.
882              We have to check objfile->obfd, symfile.c:reread_symbols might
883              have updated the obfd after a change.  */
884           objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
885           if (objfile == NULL
886               || objfile->obfd == NULL
887               || bfd_stat (objfile->obfd, &vi) < 0)
888             {
889               warning ("Unable to stat %s, keeping its symbols", name);
890               continue;
891             }
892
893           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
894             continue;
895
896           if (!retried)
897             close (fd);
898
899           ++got_one;
900
901           /* Found a corresponding VMAP.  Remap!  */
902
903           vmap_secs (vp, ldi, arch64);
904
905           /* The objfile is only NULL for the exec file.  */
906           if (vp->objfile == NULL)
907             got_exec_file = 1;
908
909           /* relocate symbol table(s). */
910           vmap_symtab (vp);
911
912           /* Announce new object files.  Doing this after symbol relocation
913              makes aix-thread.c's job easier. */
914           if (deprecated_target_new_objfile_hook && vp->objfile)
915             deprecated_target_new_objfile_hook (vp->objfile);
916
917           /* There may be more, so we don't break out of the loop.  */
918         }
919
920       /* if there was no matching *vp, we must perforce create the sucker(s) */
921       if (!got_one && !retried)
922         {
923           add_vmap (ldi);
924           ++retried;
925           goto retry;
926         }
927     }
928   while ((next = LDI_NEXT (ldi, arch64))
929          && (ldi = (void *) (next + (char *) ldi)));
930
931   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
932      is unlikely that the symbol file is relocated to the proper
933      address.  And we might have attached to a process which is
934      running a different copy of the same executable.  */
935   if (symfile_objfile != NULL && !got_exec_file)
936     {
937       warning ("Symbol file %s\nis not mapped; discarding it.\n\
938 If in fact that file has symbols which the mapped files listed by\n\
939 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
940 \"add-symbol-file\" commands (note that you must take care of relocating\n\
941 symbols to the proper address).",
942                symfile_objfile->name);
943       free_objfile (symfile_objfile);
944       symfile_objfile = NULL;
945     }
946   breakpoint_re_set ();
947 }
948 \f
949 /* As well as symbol tables, exec_sections need relocation. After
950    the inferior process' termination, there will be a relocated symbol
951    table exist with no corresponding inferior process. At that time, we
952    need to use `exec' bfd, rather than the inferior process's memory space
953    to look up symbols.
954
955    `exec_sections' need to be relocated only once, as long as the exec
956    file remains unchanged.
957  */
958
959 static void
960 vmap_exec (void)
961 {
962   static bfd *execbfd;
963   int i;
964
965   if (execbfd == exec_bfd)
966     return;
967
968   execbfd = exec_bfd;
969
970   if (!vmap || !exec_ops.to_sections)
971     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
972
973   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
974     {
975       if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
976         {
977           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
978           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
979         }
980       else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
981         {
982           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
983           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
984         }
985       else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
986         {
987           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
988           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
989         }
990     }
991 }
992
993 /* Set the current architecture from the host running GDB.  Called when
994    starting a child process. */
995
996 static void
997 set_host_arch (int pid)
998 {
999   enum bfd_architecture arch;
1000   unsigned long mach;
1001   bfd abfd;
1002   struct gdbarch_info info;
1003
1004   if (__power_rs ())
1005     {
1006       arch = bfd_arch_rs6000;
1007       mach = bfd_mach_rs6k;
1008     }
1009   else
1010     {
1011       arch = bfd_arch_powerpc;
1012       mach = bfd_mach_ppc;
1013     }
1014
1015   /* FIXME: schauer/2002-02-25:
1016      We don't know if we are executing a 32 or 64 bit executable,
1017      and have no way to pass the proper word size to rs6000_gdbarch_init.
1018      So we have to avoid switching to a new architecture, if the architecture
1019      matches already.
1020      Blindly calling rs6000_gdbarch_init used to work in older versions of
1021      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1022      determine the wordsize.  */
1023   if (exec_bfd)
1024     {
1025       const struct bfd_arch_info *exec_bfd_arch_info;
1026
1027       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1028       if (arch == exec_bfd_arch_info->arch)
1029         return;
1030     }
1031
1032   bfd_default_set_arch_mach (&abfd, arch, mach);
1033
1034   gdbarch_info_init (&info);
1035   info.bfd_arch_info = bfd_get_arch_info (&abfd);
1036   info.abfd = exec_bfd;
1037
1038   if (!gdbarch_update_p (info))
1039     {
1040       internal_error (__FILE__, __LINE__,
1041                       "set_host_arch: failed to select architecture");
1042     }
1043 }
1044
1045 \f
1046 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1047    also reads shared libraries.. */
1048
1049 void
1050 xcoff_relocate_symtab (unsigned int pid)
1051 {
1052   int load_segs = 64; /* number of load segments */
1053   int rc;
1054   LdInfo *ldi = NULL;
1055   int arch64 = ARCH64 ();
1056   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1057   int size;
1058
1059   do
1060     {
1061       size = load_segs * ldisize;
1062       ldi = (void *) xrealloc (ldi, size);
1063
1064 #if 0
1065       /* According to my humble theory, AIX has some timing problems and
1066          when the user stack grows, kernel doesn't update stack info in time
1067          and ptrace calls step on user stack. That is why we sleep here a
1068          little, and give kernel to update its internals. */
1069       usleep (36000);
1070 #endif
1071
1072       if (arch64)
1073         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1074       else
1075         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1076
1077       if (rc == -1)
1078         {
1079           if (errno == ENOMEM)
1080             load_segs *= 2;
1081           else
1082             perror_with_name ("ptrace ldinfo");
1083         }
1084       else
1085         {
1086           vmap_ldinfo (ldi);
1087           vmap_exec (); /* relocate the exec and core sections as well. */
1088         }
1089     } while (rc == -1);
1090   if (ldi)
1091     xfree (ldi);
1092 }
1093 \f
1094 /* Core file stuff.  */
1095
1096 /* Relocate symtabs and read in shared library info, based on symbols
1097    from the core file.  */
1098
1099 void
1100 xcoff_relocate_core (struct target_ops *target)
1101 {
1102   struct bfd_section *ldinfo_sec;
1103   int offset = 0;
1104   LdInfo *ldi;
1105   struct vmap *vp;
1106   int arch64 = ARCH64 ();
1107
1108   /* Size of a struct ld_info except for the variable-length filename. */
1109   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1110
1111   /* Allocated size of buffer.  */
1112   int buffer_size = nonfilesz;
1113   char *buffer = xmalloc (buffer_size);
1114   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1115
1116   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1117   if (ldinfo_sec == NULL)
1118     {
1119     bfd_err:
1120       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1121                         bfd_errmsg (bfd_get_error ()));
1122       do_cleanups (old);
1123       return;
1124     }
1125   do
1126     {
1127       int i;
1128       int names_found = 0;
1129
1130       /* Read in everything but the name.  */
1131       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1132                                     offset, nonfilesz) == 0)
1133         goto bfd_err;
1134
1135       /* Now the name.  */
1136       i = nonfilesz;
1137       do
1138         {
1139           if (i == buffer_size)
1140             {
1141               buffer_size *= 2;
1142               buffer = xrealloc (buffer, buffer_size);
1143             }
1144           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1145                                         offset + i, 1) == 0)
1146             goto bfd_err;
1147           if (buffer[i++] == '\0')
1148             ++names_found;
1149         }
1150       while (names_found < 2);
1151
1152       ldi = (LdInfo *) buffer;
1153
1154       /* Can't use a file descriptor from the core file; need to open it.  */
1155       if (arch64)
1156         ldi->l64.ldinfo_fd = -1;
1157       else
1158         ldi->l32.ldinfo_fd = -1;
1159
1160       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1161       if (offset == 0 && vmap != NULL)
1162         vp = vmap;
1163       else
1164         vp = add_vmap (ldi);
1165
1166       /* Process next shared library upon error. */
1167       offset += LDI_NEXT (ldi, arch64);
1168       if (vp == NULL)
1169         continue;
1170
1171       vmap_secs (vp, ldi, arch64);
1172
1173       /* Unless this is the exec file,
1174          add our sections to the section table for the core target.  */
1175       if (vp != vmap)
1176         {
1177           struct section_table *stp;
1178
1179           target_resize_to_sections (target, 2);
1180           stp = target->to_sections_end - 2;
1181
1182           stp->bfd = vp->bfd;
1183           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1184           stp->addr = vp->tstart;
1185           stp->endaddr = vp->tend;
1186           stp++;
1187
1188           stp->bfd = vp->bfd;
1189           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1190           stp->addr = vp->dstart;
1191           stp->endaddr = vp->dend;
1192         }
1193
1194       vmap_symtab (vp);
1195
1196       if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
1197         deprecated_target_new_objfile_hook (vp->objfile);
1198     }
1199   while (LDI_NEXT (ldi, arch64) != 0);
1200   vmap_exec ();
1201   breakpoint_re_set ();
1202   do_cleanups (old);
1203 }
1204
1205 int
1206 kernel_u_size (void)
1207 {
1208   return (sizeof (struct user));
1209 }
1210 \f
1211 /* Under AIX, we have to pass the correct TOC pointer to a function
1212    when calling functions in the inferior.
1213    We try to find the relative toc offset of the objfile containing PC
1214    and add the current load address of the data segment from the vmap.  */
1215
1216 static CORE_ADDR
1217 find_toc_address (CORE_ADDR pc)
1218 {
1219   struct vmap *vp;
1220   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1221
1222   for (vp = vmap; vp; vp = vp->nxt)
1223     {
1224       if (pc >= vp->tstart && pc < vp->tend)
1225         {
1226           /* vp->objfile is only NULL for the exec file.  */
1227           return vp->dstart + get_toc_offset (vp->objfile == NULL
1228                                               ? symfile_objfile
1229                                               : vp->objfile);
1230         }
1231     }
1232   error ("Unable to find TOC entry for pc %s\n", hex_string (pc));
1233 }
1234 \f
1235 /* Register that we are able to handle rs6000 core file formats. */
1236
1237 static struct core_fns rs6000_core_fns =
1238 {
1239   bfd_target_xcoff_flavour,             /* core_flavour */
1240   default_check_format,                 /* check_format */
1241   default_core_sniffer,                 /* core_sniffer */
1242   fetch_core_registers,                 /* core_read_registers */
1243   NULL                                  /* next */
1244 };
1245
1246 void
1247 _initialize_core_rs6000 (void)
1248 {
1249   /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1250      calling functions in the inferior.  */
1251   rs6000_find_toc_address_hook = find_toc_address;
1252
1253   /* Initialize hook in rs6000-tdep.c to set the current architecture when
1254      starting a child process. */
1255   rs6000_set_host_arch_hook = set_host_arch;
1256
1257   deprecated_add_core_fns (&rs6000_core_fns);
1258 }