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