Rename TARGET_OBJECT_AIX_LIBRARIES to TARGET_OBJECT_LIBRARIES_AIX
[external/binutils.git] / gdb / rs6000-nat.c
1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "inferior.h"
22 #include "target.h"
23 #include "gdbcore.h"
24 #include "symfile.h"
25 #include "objfiles.h"
26 #include "libbfd.h"             /* For bfd_default_set_arch_mach (FIXME) */
27 #include "bfd.h"
28 #include "exceptions.h"
29 #include "gdb-stabs.h"
30 #include "regcache.h"
31 #include "arch-utils.h"
32 #include "inf-child.h"
33 #include "inf-ptrace.h"
34 #include "ppc-tdep.h"
35 #include "rs6000-tdep.h"
36 #include "exec.h"
37 #include "observer.h"
38 #include "xcoffread.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 "gdb_bfd.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 #include "xml-utils.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 static void exec_one_dummy_insn (struct regcache *);
122
123 static LONGEST rs6000_xfer_shared_libraries
124   (struct target_ops *ops, enum target_object object,
125    const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
126    ULONGEST offset, LONGEST len);
127
128 /* Given REGNO, a gdb register number, return the corresponding
129    number suitable for use as a ptrace() parameter.  Return -1 if
130    there's no suitable mapping.  Also, set the int pointed to by
131    ISFLOAT to indicate whether REGNO is a floating point register.  */
132
133 static int
134 regmap (struct gdbarch *gdbarch, int regno, int *isfloat)
135 {
136   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
137
138   *isfloat = 0;
139   if (tdep->ppc_gp0_regnum <= regno
140       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
141     return regno;
142   else if (tdep->ppc_fp0_regnum >= 0
143            && tdep->ppc_fp0_regnum <= regno
144            && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
145     {
146       *isfloat = 1;
147       return regno - tdep->ppc_fp0_regnum + FPR0;
148     }
149   else if (regno == gdbarch_pc_regnum (gdbarch))
150     return IAR;
151   else if (regno == tdep->ppc_ps_regnum)
152     return MSR;
153   else if (regno == tdep->ppc_cr_regnum)
154     return CR;
155   else if (regno == tdep->ppc_lr_regnum)
156     return LR;
157   else if (regno == tdep->ppc_ctr_regnum)
158     return CTR;
159   else if (regno == tdep->ppc_xer_regnum)
160     return XER;
161   else if (tdep->ppc_fpscr_regnum >= 0
162            && regno == tdep->ppc_fpscr_regnum)
163     return FPSCR;
164   else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
165     return MQ;
166   else
167     return -1;
168 }
169
170 /* Call ptrace(REQ, ID, ADDR, DATA, BUF).  */
171
172 static int
173 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
174 {
175   int ret = ptrace (req, id, (int *)addr, data, buf);
176 #if 0
177   printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
178           req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
179 #endif
180   return ret;
181 }
182
183 /* Call ptracex(REQ, ID, ADDR, DATA, BUF).  */
184
185 static int
186 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
187 {
188 #ifdef ARCH3264
189   int ret = ptracex (req, id, addr, data, buf);
190 #else
191   int ret = 0;
192 #endif
193 #if 0
194   printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
195           req, id, hex_string (addr), data, (unsigned int)buf, ret);
196 #endif
197   return ret;
198 }
199
200 /* Fetch register REGNO from the inferior.  */
201
202 static void
203 fetch_register (struct regcache *regcache, int regno)
204 {
205   struct gdbarch *gdbarch = get_regcache_arch (regcache);
206   int addr[MAX_REGISTER_SIZE];
207   int nr, isfloat;
208
209   /* Retrieved values may be -1, so infer errors from errno.  */
210   errno = 0;
211
212   nr = regmap (gdbarch, regno, &isfloat);
213
214   /* Floating-point registers.  */
215   if (isfloat)
216     rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
217
218   /* Bogus register number.  */
219   else if (nr < 0)
220     {
221       if (regno >= gdbarch_num_regs (gdbarch))
222         fprintf_unfiltered (gdb_stderr,
223                             "gdb error: register no %d not implemented.\n",
224                             regno);
225       return;
226     }
227
228   /* Fixed-point registers.  */
229   else
230     {
231       if (!ARCH64 ())
232         *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid),
233                                  (int *) nr, 0, 0);
234       else
235         {
236           /* PT_READ_GPR requires the buffer parameter to point to long long,
237              even if the register is really only 32 bits.  */
238           long long buf;
239           rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
240           if (register_size (gdbarch, regno) == 8)
241             memcpy (addr, &buf, 8);
242           else
243             *addr = buf;
244         }
245     }
246
247   if (!errno)
248     regcache_raw_supply (regcache, regno, (char *) addr);
249   else
250     {
251 #if 0
252       /* FIXME: this happens 3 times at the start of each 64-bit program.  */
253       perror (_("ptrace read"));
254 #endif
255       errno = 0;
256     }
257 }
258
259 /* Store register REGNO back into the inferior.  */
260
261 static void
262 store_register (struct regcache *regcache, int regno)
263 {
264   struct gdbarch *gdbarch = get_regcache_arch (regcache);
265   int addr[MAX_REGISTER_SIZE];
266   int nr, isfloat;
267
268   /* Fetch the register's value from the register cache.  */
269   regcache_raw_collect (regcache, regno, addr);
270
271   /* -1 can be a successful return value, so infer errors from errno.  */
272   errno = 0;
273
274   nr = regmap (gdbarch, regno, &isfloat);
275
276   /* Floating-point registers.  */
277   if (isfloat)
278     rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
279
280   /* Bogus register number.  */
281   else if (nr < 0)
282     {
283       if (regno >= gdbarch_num_regs (gdbarch))
284         fprintf_unfiltered (gdb_stderr,
285                             "gdb error: register no %d not implemented.\n",
286                             regno);
287     }
288
289   /* Fixed-point registers.  */
290   else
291     {
292       if (regno == gdbarch_sp_regnum (gdbarch))
293         /* Execute one dummy instruction (which is a breakpoint) in inferior
294            process to give kernel a chance to do internal housekeeping.
295            Otherwise the following ptrace(2) calls will mess up user stack
296            since kernel will get confused about the bottom of the stack
297            (%sp).  */
298         exec_one_dummy_insn (regcache);
299
300       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
301          the register's value is passed by value, but for 64-bit inferiors,
302          the address of a buffer containing the value is passed.  */
303       if (!ARCH64 ())
304         rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid),
305                          (int *) nr, *addr, 0);
306       else
307         {
308           /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
309              area, even if the register is really only 32 bits.  */
310           long long buf;
311           if (register_size (gdbarch, regno) == 8)
312             memcpy (&buf, addr, 8);
313           else
314             buf = *addr;
315           rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
316         }
317     }
318
319   if (errno)
320     {
321       perror (_("ptrace write"));
322       errno = 0;
323     }
324 }
325
326 /* Read from the inferior all registers if REGNO == -1 and just register
327    REGNO otherwise.  */
328
329 static void
330 rs6000_fetch_inferior_registers (struct target_ops *ops,
331                                  struct regcache *regcache, int regno)
332 {
333   struct gdbarch *gdbarch = get_regcache_arch (regcache);
334   if (regno != -1)
335     fetch_register (regcache, regno);
336
337   else
338     {
339       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
340
341       /* Read 32 general purpose registers.  */
342       for (regno = tdep->ppc_gp0_regnum;
343            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
344            regno++)
345         {
346           fetch_register (regcache, regno);
347         }
348
349       /* Read general purpose floating point registers.  */
350       if (tdep->ppc_fp0_regnum >= 0)
351         for (regno = 0; regno < ppc_num_fprs; regno++)
352           fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
353
354       /* Read special registers.  */
355       fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
356       fetch_register (regcache, tdep->ppc_ps_regnum);
357       fetch_register (regcache, tdep->ppc_cr_regnum);
358       fetch_register (regcache, tdep->ppc_lr_regnum);
359       fetch_register (regcache, tdep->ppc_ctr_regnum);
360       fetch_register (regcache, tdep->ppc_xer_regnum);
361       if (tdep->ppc_fpscr_regnum >= 0)
362         fetch_register (regcache, tdep->ppc_fpscr_regnum);
363       if (tdep->ppc_mq_regnum >= 0)
364         fetch_register (regcache, tdep->ppc_mq_regnum);
365     }
366 }
367
368 /* Store our register values back into the inferior.
369    If REGNO is -1, do this for all registers.
370    Otherwise, REGNO specifies which register (so we can save time).  */
371
372 static void
373 rs6000_store_inferior_registers (struct target_ops *ops,
374                                  struct regcache *regcache, int regno)
375 {
376   struct gdbarch *gdbarch = get_regcache_arch (regcache);
377   if (regno != -1)
378     store_register (regcache, regno);
379
380   else
381     {
382       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
383
384       /* Write general purpose registers first.  */
385       for (regno = tdep->ppc_gp0_regnum;
386            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
387            regno++)
388         {
389           store_register (regcache, regno);
390         }
391
392       /* Write floating point registers.  */
393       if (tdep->ppc_fp0_regnum >= 0)
394         for (regno = 0; regno < ppc_num_fprs; regno++)
395           store_register (regcache, tdep->ppc_fp0_regnum + regno);
396
397       /* Write special registers.  */
398       store_register (regcache, gdbarch_pc_regnum (gdbarch));
399       store_register (regcache, tdep->ppc_ps_regnum);
400       store_register (regcache, tdep->ppc_cr_regnum);
401       store_register (regcache, tdep->ppc_lr_regnum);
402       store_register (regcache, tdep->ppc_ctr_regnum);
403       store_register (regcache, tdep->ppc_xer_regnum);
404       if (tdep->ppc_fpscr_regnum >= 0)
405         store_register (regcache, tdep->ppc_fpscr_regnum);
406       if (tdep->ppc_mq_regnum >= 0)
407         store_register (regcache, tdep->ppc_mq_regnum);
408     }
409 }
410
411
412 /* Attempt a transfer all LEN bytes starting at OFFSET between the
413    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
414    Return the number of bytes actually transferred.  */
415
416 static LONGEST
417 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
418                      const char *annex, gdb_byte *readbuf,
419                      const gdb_byte *writebuf,
420                      ULONGEST offset, LONGEST len)
421 {
422   pid_t pid = ptid_get_pid (inferior_ptid);
423   int arch64 = ARCH64 ();
424
425   switch (object)
426     {
427     case TARGET_OBJECT_LIBRARIES_AIX:
428       return rs6000_xfer_shared_libraries (ops, object, annex,
429                                            readbuf, writebuf,
430                                            offset, len);
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)
470                                                  rounded_offset,
471                                                  0, NULL);
472               }
473
474             /* Copy data to be written over corresponding part of
475                buffer.  */
476             memcpy (buffer.byte + (offset - rounded_offset),
477                     writebuf, partial_len);
478
479             errno = 0;
480             if (arch64)
481               rs6000_ptrace64 (PT_WRITE_D, pid,
482                                rounded_offset, buffer.word, NULL);
483             else
484               rs6000_ptrace32 (PT_WRITE_D, pid,
485                                (int *) (uintptr_t) rounded_offset,
486                                buffer.word, NULL);
487             if (errno)
488               return 0;
489           }
490
491         if (readbuf)
492           {
493             errno = 0;
494             if (arch64)
495               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
496                                              rounded_offset, 0, NULL);
497             else
498               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
499                                              (int *)(uintptr_t)rounded_offset,
500                                              0, NULL);
501             if (errno)
502               return 0;
503
504             /* Copy appropriate bytes out of the buffer.  */
505             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
506                     partial_len);
507           }
508
509         return partial_len;
510       }
511
512     default:
513       return -1;
514     }
515 }
516
517 /* Wait for the child specified by PTID to do something.  Return the
518    process ID of the child, or MINUS_ONE_PTID in case of error; store
519    the status in *OURSTATUS.  */
520
521 static ptid_t
522 rs6000_wait (struct target_ops *ops,
523              ptid_t ptid, struct target_waitstatus *ourstatus, int options)
524 {
525   pid_t pid;
526   int status, save_errno;
527
528   do
529     {
530       set_sigint_trap ();
531
532       do
533         {
534           pid = waitpid (ptid_get_pid (ptid), &status, 0);
535           save_errno = errno;
536         }
537       while (pid == -1 && errno == EINTR);
538
539       clear_sigint_trap ();
540
541       if (pid == -1)
542         {
543           fprintf_unfiltered (gdb_stderr,
544                               _("Child process unexpectedly missing: %s.\n"),
545                               safe_strerror (save_errno));
546
547           /* Claim it exited with unknown signal.  */
548           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
549           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
550           return inferior_ptid;
551         }
552
553       /* Ignore terminated detached child processes.  */
554       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
555         pid = -1;
556     }
557   while (pid == -1);
558
559   /* AIX has a couple of strange returns from wait().  */
560
561   /* stop after load" status.  */
562   if (status == 0x57c)
563     ourstatus->kind = TARGET_WAITKIND_LOADED;
564   /* signal 0.  I have no idea why wait(2) returns with this status word.  */
565   else if (status == 0x7f)
566     ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
567   /* A normal waitstatus.  Let the usual macros deal with it.  */
568   else
569     store_waitstatus (ourstatus, status);
570
571   return pid_to_ptid (pid);
572 }
573
574 /* Execute one dummy breakpoint instruction.  This way we give the kernel
575    a chance to do some housekeeping and update inferior's internal data,
576    including u_area.  */
577
578 static void
579 exec_one_dummy_insn (struct regcache *regcache)
580 {
581 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
582
583   struct gdbarch *gdbarch = get_regcache_arch (regcache);
584   int ret, status, pid;
585   CORE_ADDR prev_pc;
586   void *bp;
587
588   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address.  We
589      assume that this address will never be executed again by the real
590      code.  */
591
592   bp = deprecated_insert_raw_breakpoint (gdbarch, NULL, DUMMY_INSN_ADDR);
593
594   /* You might think this could be done with a single ptrace call, and
595      you'd be correct for just about every platform I've ever worked
596      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
597      the inferior never hits the breakpoint (it's also worth noting
598      powerpc-ibm-aix4.1.3 works correctly).  */
599   prev_pc = regcache_read_pc (regcache);
600   regcache_write_pc (regcache, DUMMY_INSN_ADDR);
601   if (ARCH64 ())
602     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
603   else
604     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid),
605                            (int *) 1, 0, NULL);
606
607   if (ret != 0)
608     perror (_("pt_continue"));
609
610   do
611     {
612       pid = waitpid (PIDGET (inferior_ptid), &status, 0);
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 /* Set the current architecture from the host running GDB.  Called when
622    starting a child process.  */
623
624 static void (*super_create_inferior) (struct target_ops *,char *exec_file, 
625                                       char *allargs, char **env, int from_tty);
626 static void
627 rs6000_create_inferior (struct target_ops * ops, char *exec_file,
628                         char *allargs, char **env, int from_tty)
629 {
630   enum bfd_architecture arch;
631   unsigned long mach;
632   bfd abfd;
633   struct gdbarch_info info;
634
635   super_create_inferior (ops, exec_file, allargs, env, from_tty);
636
637   if (__power_rs ())
638     {
639       arch = bfd_arch_rs6000;
640       mach = bfd_mach_rs6k;
641     }
642   else
643     {
644       arch = bfd_arch_powerpc;
645       mach = bfd_mach_ppc;
646     }
647
648   /* FIXME: schauer/2002-02-25:
649      We don't know if we are executing a 32 or 64 bit executable,
650      and have no way to pass the proper word size to rs6000_gdbarch_init.
651      So we have to avoid switching to a new architecture, if the architecture
652      matches already.
653      Blindly calling rs6000_gdbarch_init used to work in older versions of
654      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
655      determine the wordsize.  */
656   if (exec_bfd)
657     {
658       const struct bfd_arch_info *exec_bfd_arch_info;
659
660       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
661       if (arch == exec_bfd_arch_info->arch)
662         return;
663     }
664
665   bfd_default_set_arch_mach (&abfd, arch, mach);
666
667   gdbarch_info_init (&info);
668   info.bfd_arch_info = bfd_get_arch_info (&abfd);
669   info.abfd = exec_bfd;
670
671   if (!gdbarch_update_p (info))
672     internal_error (__FILE__, __LINE__,
673                     _("rs6000_create_inferior: failed "
674                       "to select architecture"));
675 }
676 \f
677
678 /* Shared Object support.  */
679
680 /* Return the LdInfo data for the given process.  Raises an error
681    if the data could not be obtained.
682
683    The returned value must be deallocated after use.  */
684
685 static LdInfo *
686 rs6000_ptrace_ldinfo (ptid_t ptid)
687 {
688   const int pid = ptid_get_pid (ptid);
689   int ldi_size = 1024;
690   LdInfo *ldi = xmalloc (ldi_size);
691   int rc = -1;
692
693   while (1)
694     {
695       if (ARCH64 ())
696         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, ldi_size,
697                               NULL);
698       else
699         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, ldi_size, NULL);
700
701       if (rc != -1)
702         break; /* Success, we got the entire ld_info data.  */
703
704       if (errno != ENOMEM)
705         perror_with_name (_("ptrace ldinfo"));
706
707       /* ldi is not big enough.  Double it and try again.  */
708       ldi_size *= 2;
709       ldi = xrealloc (ldi, ldi_size);
710     }
711
712   return ldi;
713 }
714
715 /* Assuming ABFD refers to a core file, return the LdInfo data
716    stored in that core file.  Raises an error if the data could
717    not be read or extracted.
718
719    The returned value much be deallocated after use.  */
720
721 static LdInfo *
722 rs6000_core_ldinfo (bfd *abfd)
723 {
724   struct bfd_section *ldinfo_sec;
725   int ldinfo_size;
726   gdb_byte *ldinfo_buf;
727   struct cleanup *cleanup;
728
729   ldinfo_sec = bfd_get_section_by_name (abfd, ".ldinfo");
730   if (ldinfo_sec == NULL)
731     error (_("cannot find .ldinfo section from core file: %s\n"),
732            bfd_errmsg (bfd_get_error ()));
733   ldinfo_size = bfd_get_section_size (ldinfo_sec);
734
735   ldinfo_buf = xmalloc (ldinfo_size);
736   cleanup = make_cleanup (xfree, ldinfo_buf);
737
738   if (! bfd_get_section_contents (abfd, ldinfo_sec,
739                                   ldinfo_buf, 0, ldinfo_size))
740     error (_("unable to read .ldinfo section from core file: %s\n"),
741            bfd_errmsg (bfd_get_error ()));
742
743   discard_cleanups (cleanup);
744   return (LdInfo *) ldinfo_buf;
745 }
746
747 /* Append to OBJSTACK an XML string description of the shared library
748    corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
749    format.  */
750
751 static void
752 rs6000_xfer_shared_library (LdInfo *ldi, struct obstack *obstack)
753 {
754   const int arch64 = ARCH64 ();
755   const char *archive_name = LDI_FILENAME (ldi, arch64);
756   const char *member_name = archive_name + strlen (archive_name) + 1;
757   CORE_ADDR text_addr, data_addr;
758   ULONGEST text_size, data_size;
759   char *p;
760
761   if (arch64)
762     {
763       text_addr = ldi->l64.ldinfo_textorg;
764       text_size = ldi->l64.ldinfo_textsize;
765       data_addr = ldi->l64.ldinfo_dataorg;
766       data_size = ldi->l64.ldinfo_datasize;
767     }
768   else
769     {
770       /* The text and data addresses are defined as pointers.
771          To avoid sign-extending their value in the assignments
772          below, we cast their value to unsigned long first.  */
773       text_addr = (unsigned long) ldi->l32.ldinfo_textorg;
774       text_size = ldi->l32.ldinfo_textsize;
775       data_addr = (unsigned long) ldi->l32.ldinfo_dataorg;
776       data_size = ldi->l32.ldinfo_datasize;
777     }
778
779   obstack_grow_str (obstack, "<library name=\"");
780   p = xml_escape_text (archive_name);
781   obstack_grow_str (obstack, p);
782   xfree (p);
783   obstack_grow_str (obstack, "\"");
784
785   if (member_name[0] != '\0')
786     {
787       obstack_grow_str (obstack, " member=\"");
788       p = xml_escape_text (member_name);
789       obstack_grow_str (obstack, p);
790       xfree (p);
791       obstack_grow_str (obstack, "\"");
792     }
793
794   obstack_grow_str (obstack, " text_addr=\"");
795   obstack_grow_str (obstack, core_addr_to_string (text_addr));
796   obstack_grow_str (obstack, "\"");
797
798   obstack_grow_str (obstack, " text_size=\"");
799   obstack_grow_str (obstack, pulongest (text_size));
800   obstack_grow_str (obstack, "\"");
801
802   obstack_grow_str (obstack, " data_addr=\"");
803   obstack_grow_str (obstack, core_addr_to_string (data_addr));
804   obstack_grow_str (obstack, "\"");
805
806   obstack_grow_str (obstack, " data_size=\"");
807   obstack_grow_str (obstack, pulongest (data_size));
808   obstack_grow_str (obstack, "\"");
809
810   obstack_grow_str (obstack, "></library>");
811 }
812
813 /* Implement the to_xfer_partial target_ops method for
814    TARGET_OBJECT_LIBRARIES_AIX objects.  */
815
816 static LONGEST
817 rs6000_xfer_shared_libraries
818   (struct target_ops *ops, enum target_object object,
819    const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
820    ULONGEST offset, LONGEST len)
821 {
822   const int arch64 = ARCH64 ();
823   LdInfo *ldi_data;
824   LdInfo *ldi;
825   struct obstack obstack;
826   const char *buf;
827   LONGEST len_avail;
828
829   if (writebuf)
830     return -1;
831
832   /* Get the ldinfo raw data: If debugging a live process, we get it
833      using ptrace.  Otherwise, the info is stored in the .ldinfo
834      section of the core file.  */
835
836   if (target_has_execution)
837     ldi_data = rs6000_ptrace_ldinfo (inferior_ptid);
838   else
839     ldi_data = rs6000_core_ldinfo (core_bfd);
840
841   /* Convert the raw data into an XML representation.  */
842
843   obstack_init (&obstack);
844   obstack_grow_str (&obstack, "<library-list version=\"1.0\">\n");
845
846   ldi = ldi_data;
847   while (1)
848     {
849       /* Close the fd.  We cannot use it, because we cannot assume
850          that the user of this descriptor will be in the same
851          process.  */
852       close (LDI_FD (ldi, arch64));
853
854       rs6000_xfer_shared_library (ldi, &obstack);
855
856       if (!LDI_NEXT (ldi, arch64))
857         break;
858       ldi = (LdInfo *) ((char *) ldi + LDI_NEXT (ldi, arch64));
859     }
860
861   xfree (ldi_data);
862
863   obstack_grow_str0 (&obstack, "</library-list>\n");
864
865   buf = obstack_finish (&obstack);
866   len_avail = strlen (buf);
867   if (offset >= len_avail)
868     len= 0;
869   else
870     {
871       if (len > len_avail - offset)
872         len = len_avail - offset;
873       memcpy (readbuf, buf + offset, len);
874     }
875
876   obstack_free (&obstack, NULL);
877   return len;
878 }
879
880 void _initialize_rs6000_nat (void);
881
882 void
883 _initialize_rs6000_nat (void)
884 {
885   struct target_ops *t;
886
887   t = inf_ptrace_target ();
888   t->to_fetch_registers = rs6000_fetch_inferior_registers;
889   t->to_store_registers = rs6000_store_inferior_registers;
890   t->to_xfer_partial = rs6000_xfer_partial;
891
892   super_create_inferior = t->to_create_inferior;
893   t->to_create_inferior = rs6000_create_inferior;
894
895   t->to_wait = rs6000_wait;
896
897   add_target (t);
898 }