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