]> Git Repo - binutils.git/blob - gdb/rs6000-aix-nat.c
Automatic date update in version.in
[binutils.git] / gdb / rs6000-aix-nat.c
1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2022 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 "bfd.h"
27 #include "gdb-stabs.h"
28 #include "regcache.h"
29 #include "arch-utils.h"
30 #include "inf-child.h"
31 #include "inf-ptrace.h"
32 #include "ppc-tdep.h"
33 #include "rs6000-aix-tdep.h"
34 #include "exec.h"
35 #include "observable.h"
36 #include "xcoffread.h"
37
38 #include <sys/ptrace.h>
39 #include <sys/reg.h>
40
41 #include <sys/dir.h>
42 #include <sys/user.h>
43 #include <signal.h>
44 #include <sys/ioctl.h>
45 #include <fcntl.h>
46
47 #include <a.out.h>
48 #include <sys/file.h>
49 #include <sys/stat.h>
50 #include "gdb_bfd.h"
51 #include <sys/core.h>
52 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
53 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
54 #include <sys/ldr.h>
55 #include <sys/systemcfg.h>
56
57 /* Header files for getting ppid in AIX of a child process.  */
58 #include <procinfo.h>
59 #include <sys/types.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 #if defined (__ld_info32) || defined (__ld_info64)
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 (target_gdbarch (), 0) == 8)
78 #endif
79
80 class rs6000_nat_target final : public inf_ptrace_target
81 {
82 public:
83   void fetch_registers (struct regcache *, int) override;
84   void store_registers (struct regcache *, int) override;
85
86   enum target_xfer_status xfer_partial (enum target_object object,
87                                         const char *annex,
88                                         gdb_byte *readbuf,
89                                         const gdb_byte *writebuf,
90                                         ULONGEST offset, ULONGEST len,
91                                         ULONGEST *xfered_len) override;
92
93   void create_inferior (const char *, const std::string &,
94                         char **, int) override;
95
96   ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
97
98   /* Fork detection related functions, For adding multi process debugging
99      support.  */
100   void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
101
102 protected:
103
104   void post_startup_inferior (ptid_t ptid) override;
105
106 private:
107   enum target_xfer_status
108     xfer_shared_libraries (enum target_object object,
109                            const char *annex, gdb_byte *readbuf,
110                            const gdb_byte *writebuf,
111                            ULONGEST offset, ULONGEST len,
112                            ULONGEST *xfered_len);
113 };
114
115 static rs6000_nat_target the_rs6000_nat_target;
116
117 /* The below declaration is to track number of times, parent has
118    reported fork event before its children.  */
119
120 static std::list<pid_t> aix_pending_parent;
121
122 /* The below declaration is for a child process event that
123    is reported before its corresponding parent process in
124    the event of a fork ().  */
125
126 static std::list<pid_t> aix_pending_children;
127
128 static void
129 aix_remember_child (pid_t pid)
130 {
131   aix_pending_children.push_front (pid);
132 }
133
134 static void
135 aix_remember_parent (pid_t pid)
136 {
137   aix_pending_parent.push_front (pid);
138 }
139
140 /* This function returns a parent of a child process.  */
141
142 static pid_t
143 find_my_aix_parent (pid_t child_pid)
144 {
145   struct procsinfo ProcessBuffer1;
146
147   if (getprocs (&ProcessBuffer1, sizeof (ProcessBuffer1),
148                 NULL, 0, &child_pid, 1) != 1)
149     return 0;
150   else
151     return ProcessBuffer1.pi_ppid;
152 }
153
154 /* In the below function we check if there was any child
155    process pending.  If it exists we return it from the
156    list, otherwise we return a null.  */
157
158 static pid_t
159 has_my_aix_child_reported (pid_t parent_pid)
160 {
161   pid_t child = 0;
162   auto it = std::find_if (aix_pending_children.begin (),
163                           aix_pending_children.end (),
164                           [=] (pid_t child_pid)
165                           {
166                             return find_my_aix_parent (child_pid) == parent_pid;
167                           });
168   if (it != aix_pending_children.end ())
169     {
170       child = *it;
171       aix_pending_children.erase (it);
172     }
173   return child;
174 }
175
176 /* In the below function we check if there was any parent
177    process pending.  If it exists we return it from the
178    list, otherwise we return a null.  */
179
180 static pid_t
181 has_my_aix_parent_reported (pid_t child_pid)
182 {
183   pid_t my_parent = find_my_aix_parent (child_pid);
184   auto it = std::find (aix_pending_parent.begin (),
185                        aix_pending_parent.end (),
186                        my_parent);
187   if (it != aix_pending_parent.end ())
188     {
189       aix_pending_parent.erase (it);
190       return my_parent;
191     }
192   return 0;
193 }
194
195 /* Given REGNO, a gdb register number, return the corresponding
196    number suitable for use as a ptrace() parameter.  Return -1 if
197    there's no suitable mapping.  Also, set the int pointed to by
198    ISFLOAT to indicate whether REGNO is a floating point register.  */
199
200 static int
201 regmap (struct gdbarch *gdbarch, int regno, int *isfloat)
202 {
203   ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
204
205   *isfloat = 0;
206   if (tdep->ppc_gp0_regnum <= regno
207       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
208     return regno;
209   else if (tdep->ppc_fp0_regnum >= 0
210            && tdep->ppc_fp0_regnum <= regno
211            && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
212     {
213       *isfloat = 1;
214       return regno - tdep->ppc_fp0_regnum + FPR0;
215     }
216   else if (regno == gdbarch_pc_regnum (gdbarch))
217     return IAR;
218   else if (regno == tdep->ppc_ps_regnum)
219     return MSR;
220   else if (regno == tdep->ppc_cr_regnum)
221     return CR;
222   else if (regno == tdep->ppc_lr_regnum)
223     return LR;
224   else if (regno == tdep->ppc_ctr_regnum)
225     return CTR;
226   else if (regno == tdep->ppc_xer_regnum)
227     return XER;
228   else if (tdep->ppc_fpscr_regnum >= 0
229            && regno == tdep->ppc_fpscr_regnum)
230     return FPSCR;
231   else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
232     return MQ;
233   else
234     return -1;
235 }
236
237 /* Call ptrace(REQ, ID, ADDR, DATA, BUF).  */
238
239 static int
240 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
241 {
242 #ifdef HAVE_PTRACE64
243   int ret = ptrace64 (req, id, (uintptr_t) addr, data, buf);
244 #else
245   int ret = ptrace (req, id, (int *)addr, data, buf);
246 #endif
247 #if 0
248   printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
249           req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
250 #endif
251   return ret;
252 }
253
254 /* Call ptracex(REQ, ID, ADDR, DATA, BUF).  */
255
256 static int
257 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
258 {
259 #ifdef ARCH3264
260 #  ifdef HAVE_PTRACE64
261   int ret = ptrace64 (req, id, addr, data, (PTRACE_TYPE_ARG5) buf);
262 #  else
263   int ret = ptracex (req, id, addr, data, (PTRACE_TYPE_ARG5) buf);
264 #  endif
265 #else
266   int ret = 0;
267 #endif
268 #if 0
269   printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
270           req, id, hex_string (addr), data, (unsigned int)buf, ret);
271 #endif
272   return ret;
273 }
274
275 void rs6000_nat_target::post_startup_inferior (ptid_t ptid)
276 {
277
278   /* In AIX to turn on multi process debugging in ptrace
279      PT_MULTI is the option to be passed,
280      with the process ID which can fork () and
281      the data parameter [fourth parameter] must be 1.  */
282
283   if (!ARCH64 ())
284     rs6000_ptrace32 (PT_MULTI, ptid.pid(), 0, 1, 0);
285   else
286     rs6000_ptrace64 (PT_MULTI, ptid.pid(), 0, 1, 0);
287 }
288
289 void
290 rs6000_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
291                                 target_waitkind fork_kind, bool follow_child,
292                                 bool detach_fork)
293 {
294
295   /* Once the fork event is detected the infrun.c code
296      calls the target_follow_fork to take care of
297      follow child and detach the child activity which is
298      done using the function below.  */
299
300   inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind,
301                                   follow_child, detach_fork);
302
303   /* If we detach fork and follow child we do not want the child
304      process to geneate events that ptrace can trace.  Hence we
305      detach it.  */
306
307   if (detach_fork && !follow_child)
308   {
309     if (ARCH64 ())
310       rs6000_ptrace64 (PT_DETACH, child_ptid.pid (), 0, 0, 0);
311     else
312       rs6000_ptrace32 (PT_DETACH, child_ptid.pid (), 0, 0, 0);
313   }
314 }
315
316 /* Fetch register REGNO from the inferior.  */
317
318 static void
319 fetch_register (struct regcache *regcache, int regno)
320 {
321   struct gdbarch *gdbarch = regcache->arch ();
322   int addr[PPC_MAX_REGISTER_SIZE];
323   int nr, isfloat;
324   pid_t pid = regcache->ptid ().pid ();
325
326   /* Retrieved values may be -1, so infer errors from errno.  */
327   errno = 0;
328
329   nr = regmap (gdbarch, regno, &isfloat);
330
331   /* Floating-point registers.  */
332   if (isfloat)
333     rs6000_ptrace32 (PT_READ_FPR, pid, addr, nr, 0);
334
335   /* Bogus register number.  */
336   else if (nr < 0)
337     {
338       if (regno >= gdbarch_num_regs (gdbarch))
339         gdb_printf (gdb_stderr,
340                     "gdb error: register no %d not implemented.\n",
341                     regno);
342       return;
343     }
344
345   /* Fixed-point registers.  */
346   else
347     {
348       if (!ARCH64 ())
349         *addr = rs6000_ptrace32 (PT_READ_GPR, pid, (int *) nr, 0, 0);
350       else
351         {
352           /* PT_READ_GPR requires the buffer parameter to point to long long,
353              even if the register is really only 32 bits.  */
354           long long buf;
355           rs6000_ptrace64 (PT_READ_GPR, pid, nr, 0, &buf);
356           if (register_size (gdbarch, regno) == 8)
357             memcpy (addr, &buf, 8);
358           else
359             *addr = buf;
360         }
361     }
362
363   if (!errno)
364     regcache->raw_supply (regno, (char *) addr);
365   else
366     {
367 #if 0
368       /* FIXME: this happens 3 times at the start of each 64-bit program.  */
369       perror (_("ptrace read"));
370 #endif
371       errno = 0;
372     }
373 }
374
375 /* Store register REGNO back into the inferior.  */
376
377 static void
378 store_register (struct regcache *regcache, int regno)
379 {
380   struct gdbarch *gdbarch = regcache->arch ();
381   int addr[PPC_MAX_REGISTER_SIZE];
382   int nr, isfloat;
383   pid_t pid = regcache->ptid ().pid ();
384
385   /* Fetch the register's value from the register cache.  */
386   regcache->raw_collect (regno, addr);
387
388   /* -1 can be a successful return value, so infer errors from errno.  */
389   errno = 0;
390
391   nr = regmap (gdbarch, regno, &isfloat);
392
393   /* Floating-point registers.  */
394   if (isfloat)
395     rs6000_ptrace32 (PT_WRITE_FPR, pid, addr, nr, 0);
396
397   /* Bogus register number.  */
398   else if (nr < 0)
399     {
400       if (regno >= gdbarch_num_regs (gdbarch))
401         gdb_printf (gdb_stderr,
402                     "gdb error: register no %d not implemented.\n",
403                     regno);
404     }
405
406   /* Fixed-point registers.  */
407   else
408     {
409       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
410          the register's value is passed by value, but for 64-bit inferiors,
411          the address of a buffer containing the value is passed.  */
412       if (!ARCH64 ())
413         rs6000_ptrace32 (PT_WRITE_GPR, pid, (int *) nr, *addr, 0);
414       else
415         {
416           /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
417              area, even if the register is really only 32 bits.  */
418           long long buf;
419           if (register_size (gdbarch, regno) == 8)
420             memcpy (&buf, addr, 8);
421           else
422             buf = *addr;
423           rs6000_ptrace64 (PT_WRITE_GPR, pid, nr, 0, &buf);
424         }
425     }
426
427   if (errno)
428     {
429       perror (_("ptrace write"));
430       errno = 0;
431     }
432 }
433
434 /* Read from the inferior all registers if REGNO == -1 and just register
435    REGNO otherwise.  */
436
437 void
438 rs6000_nat_target::fetch_registers (struct regcache *regcache, int regno)
439 {
440   struct gdbarch *gdbarch = regcache->arch ();
441   if (regno != -1)
442     fetch_register (regcache, regno);
443
444   else
445     {
446       ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
447
448       /* Read 32 general purpose registers.  */
449       for (regno = tdep->ppc_gp0_regnum;
450            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
451            regno++)
452         {
453           fetch_register (regcache, regno);
454         }
455
456       /* Read general purpose floating point registers.  */
457       if (tdep->ppc_fp0_regnum >= 0)
458         for (regno = 0; regno < ppc_num_fprs; regno++)
459           fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
460
461       /* Read special registers.  */
462       fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
463       fetch_register (regcache, tdep->ppc_ps_regnum);
464       fetch_register (regcache, tdep->ppc_cr_regnum);
465       fetch_register (regcache, tdep->ppc_lr_regnum);
466       fetch_register (regcache, tdep->ppc_ctr_regnum);
467       fetch_register (regcache, tdep->ppc_xer_regnum);
468       if (tdep->ppc_fpscr_regnum >= 0)
469         fetch_register (regcache, tdep->ppc_fpscr_regnum);
470       if (tdep->ppc_mq_regnum >= 0)
471         fetch_register (regcache, tdep->ppc_mq_regnum);
472     }
473 }
474
475 /* Store our register values back into the inferior.
476    If REGNO is -1, do this for all registers.
477    Otherwise, REGNO specifies which register (so we can save time).  */
478
479 void
480 rs6000_nat_target::store_registers (struct regcache *regcache, int regno)
481 {
482   struct gdbarch *gdbarch = regcache->arch ();
483   if (regno != -1)
484     store_register (regcache, regno);
485
486   else
487     {
488       ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
489
490       /* Write general purpose registers first.  */
491       for (regno = tdep->ppc_gp0_regnum;
492            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
493            regno++)
494         {
495           store_register (regcache, regno);
496         }
497
498       /* Write floating point registers.  */
499       if (tdep->ppc_fp0_regnum >= 0)
500         for (regno = 0; regno < ppc_num_fprs; regno++)
501           store_register (regcache, tdep->ppc_fp0_regnum + regno);
502
503       /* Write special registers.  */
504       store_register (regcache, gdbarch_pc_regnum (gdbarch));
505       store_register (regcache, tdep->ppc_ps_regnum);
506       store_register (regcache, tdep->ppc_cr_regnum);
507       store_register (regcache, tdep->ppc_lr_regnum);
508       store_register (regcache, tdep->ppc_ctr_regnum);
509       store_register (regcache, tdep->ppc_xer_regnum);
510       if (tdep->ppc_fpscr_regnum >= 0)
511         store_register (regcache, tdep->ppc_fpscr_regnum);
512       if (tdep->ppc_mq_regnum >= 0)
513         store_register (regcache, tdep->ppc_mq_regnum);
514     }
515 }
516
517 /* Implement the to_xfer_partial target_ops method.  */
518
519 enum target_xfer_status
520 rs6000_nat_target::xfer_partial (enum target_object object,
521                                  const char *annex, gdb_byte *readbuf,
522                                  const gdb_byte *writebuf,
523                                  ULONGEST offset, ULONGEST len,
524                                  ULONGEST *xfered_len)
525 {
526   pid_t pid = inferior_ptid.pid ();
527   int arch64 = ARCH64 ();
528
529   switch (object)
530     {
531     case TARGET_OBJECT_LIBRARIES_AIX:
532       return xfer_shared_libraries (object, annex,
533                                     readbuf, writebuf,
534                                     offset, len, xfered_len);
535     case TARGET_OBJECT_MEMORY:
536       {
537         union
538         {
539           PTRACE_TYPE_RET word;
540           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
541         } buffer;
542         ULONGEST rounded_offset;
543         LONGEST partial_len;
544
545         /* Round the start offset down to the next long word
546            boundary.  */
547         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
548
549         /* Since ptrace will transfer a single word starting at that
550            rounded_offset the partial_len needs to be adjusted down to
551            that (remember this function only does a single transfer).
552            Should the required length be even less, adjust it down
553            again.  */
554         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
555         if (partial_len > len)
556           partial_len = len;
557
558         if (writebuf)
559           {
560             /* If OFFSET:PARTIAL_LEN is smaller than
561                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
562                be needed.  Read in the entire word.  */
563             if (rounded_offset < offset
564                 || (offset + partial_len
565                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
566               {
567                 /* Need part of initial word -- fetch it.  */
568                 if (arch64)
569                   buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
570                                                  rounded_offset, 0, NULL);
571                 else
572                   buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
573                                                  (int *) (uintptr_t)
574                                                  rounded_offset,
575                                                  0, NULL);
576               }
577
578             /* Copy data to be written over corresponding part of
579                buffer.  */
580             memcpy (buffer.byte + (offset - rounded_offset),
581                     writebuf, partial_len);
582
583             errno = 0;
584             if (arch64)
585               rs6000_ptrace64 (PT_WRITE_D, pid,
586                                rounded_offset, buffer.word, NULL);
587             else
588               rs6000_ptrace32 (PT_WRITE_D, pid,
589                                (int *) (uintptr_t) rounded_offset,
590                                buffer.word, NULL);
591             if (errno)
592               return TARGET_XFER_EOF;
593           }
594
595         if (readbuf)
596           {
597             errno = 0;
598             if (arch64)
599               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
600                                              rounded_offset, 0, NULL);
601             else
602               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
603                                              (int *)(uintptr_t)rounded_offset,
604                                              0, NULL);
605             if (errno)
606               return TARGET_XFER_EOF;
607
608             /* Copy appropriate bytes out of the buffer.  */
609             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
610                     partial_len);
611           }
612
613         *xfered_len = (ULONGEST) partial_len;
614         return TARGET_XFER_OK;
615       }
616
617     default:
618       return TARGET_XFER_E_IO;
619     }
620 }
621
622 /* Wait for the child specified by PTID to do something.  Return the
623    process ID of the child, or MINUS_ONE_PTID in case of error; store
624    the status in *OURSTATUS.  */
625
626 ptid_t
627 rs6000_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
628                          target_wait_flags options)
629 {
630   pid_t pid;
631   int status, save_errno;
632
633   while (1)
634     {
635       set_sigint_trap ();
636
637       do
638         {
639           pid = waitpid (ptid.pid (), &status, 0);
640           save_errno = errno;
641         }
642       while (pid == -1 && errno == EINTR);
643
644       clear_sigint_trap ();
645
646       if (pid == -1)
647         {
648           gdb_printf (gdb_stderr,
649                       _("Child process unexpectedly missing: %s.\n"),
650                       safe_strerror (save_errno));
651
652           ourstatus->set_ignore ();
653           return minus_one_ptid;
654         }
655
656       /* Ignore terminated detached child processes.  */
657       if (!WIFSTOPPED (status) && find_inferior_pid (this, pid) == nullptr)
658         continue;
659
660       /* Check for a fork () event.  */
661       if ((status & 0xff) == W_SFWTED)
662         {
663           /* Checking whether it is a parent or a child event.  */
664
665           /* If the event is a child we check if there was a parent
666              event recorded before.  If yes we got the parent child
667              relationship.  If not we push this child and wait for
668              the next fork () event.  */
669           if (find_inferior_pid (this, pid) == nullptr)
670             {
671               pid_t parent_pid = has_my_aix_parent_reported (pid);
672               if (parent_pid > 0)
673                 {
674                   ourstatus->set_forked (ptid_t (pid));
675                   return ptid_t (parent_pid);
676                 }
677               aix_remember_child (pid);
678             }
679
680           /* If the event is a parent we check if there was a child
681              event recorded before.  If yes we got the parent child
682              relationship.  If not we push this parent and wait for
683              the next fork () event.  */
684           else
685             {
686               pid_t child_pid = has_my_aix_child_reported (pid);
687               if (child_pid > 0)
688                 {
689                   ourstatus->set_forked (ptid_t (child_pid));
690                   return ptid_t (pid);
691                 }
692               aix_remember_parent (pid);
693             }
694           continue;
695         }
696
697       break;
698     }
699
700   /* AIX has a couple of strange returns from wait().  */
701
702   /* stop after load" status.  */
703   if (status == 0x57c)
704     ourstatus->set_loaded ();
705   /* 0x7f is signal 0.  0x17f and 0x137f are status returned
706      if we follow parent, a switch is made to a child post parent
707      execution and child continues its execution [user switches
708      to child and presses continue].  */
709   else if (status == 0x7f || status == 0x17f || status == 0x137f)
710     ourstatus->set_spurious ();
711   /* A normal waitstatus.  Let the usual macros deal with it.  */
712   else
713     *ourstatus = host_status_to_waitstatus (status);
714
715   return ptid_t (pid);
716 }
717 \f
718
719 /* Set the current architecture from the host running GDB.  Called when
720    starting a child process.  */
721
722 void
723 rs6000_nat_target::create_inferior (const char *exec_file,
724                                     const std::string &allargs,
725                                     char **env, int from_tty)
726 {
727   enum bfd_architecture arch;
728   unsigned long mach;
729   bfd abfd;
730
731   inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
732
733   if (__power_rs ())
734     {
735       arch = bfd_arch_rs6000;
736       mach = bfd_mach_rs6k;
737     }
738   else
739     {
740       arch = bfd_arch_powerpc;
741       mach = bfd_mach_ppc;
742     }
743
744   /* FIXME: schauer/2002-02-25:
745      We don't know if we are executing a 32 or 64 bit executable,
746      and have no way to pass the proper word size to rs6000_gdbarch_init.
747      So we have to avoid switching to a new architecture, if the architecture
748      matches already.
749      Blindly calling rs6000_gdbarch_init used to work in older versions of
750      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
751      determine the wordsize.  */
752   if (current_program_space->exec_bfd ())
753     {
754       const struct bfd_arch_info *exec_bfd_arch_info;
755
756       exec_bfd_arch_info
757         = bfd_get_arch_info (current_program_space->exec_bfd ());
758       if (arch == exec_bfd_arch_info->arch)
759         return;
760     }
761
762   bfd_default_set_arch_mach (&abfd, arch, mach);
763
764   gdbarch_info info;
765   info.bfd_arch_info = bfd_get_arch_info (&abfd);
766   info.abfd = current_program_space->exec_bfd ();
767
768   if (!gdbarch_update_p (info))
769     internal_error (_("rs6000_create_inferior: failed "
770                       "to select architecture"));
771 }
772 \f
773
774 /* Shared Object support.  */
775
776 /* Return the LdInfo data for the given process.  Raises an error
777    if the data could not be obtained.  */
778
779 static gdb::byte_vector
780 rs6000_ptrace_ldinfo (ptid_t ptid)
781 {
782   const int pid = ptid.pid ();
783   gdb::byte_vector ldi (1024);
784   int rc = -1;
785
786   while (1)
787     {
788       if (ARCH64 ())
789         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi.data (),
790                               ldi.size (), NULL);
791       else
792         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi.data (),
793                               ldi.size (), NULL);
794
795       if (rc != -1)
796         break; /* Success, we got the entire ld_info data.  */
797
798       if (errno != ENOMEM)
799         perror_with_name (_("ptrace ldinfo"));
800
801       /* ldi is not big enough.  Double it and try again.  */
802       ldi.resize (ldi.size () * 2);
803     }
804
805   return ldi;
806 }
807
808 /* Implement the to_xfer_partial target_ops method for
809    TARGET_OBJECT_LIBRARIES_AIX objects.  */
810
811 enum target_xfer_status
812 rs6000_nat_target::xfer_shared_libraries
813   (enum target_object object,
814    const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
815    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
816 {
817   ULONGEST result;
818
819   /* This function assumes that it is being run with a live process.
820      Core files are handled via gdbarch.  */
821   gdb_assert (target_has_execution ());
822
823   if (writebuf)
824     return TARGET_XFER_E_IO;
825
826   gdb::byte_vector ldi_buf = rs6000_ptrace_ldinfo (inferior_ptid);
827   result = rs6000_aix_ld_info_to_xml (target_gdbarch (), ldi_buf.data (),
828                                       readbuf, offset, len, 1);
829
830   if (result == 0)
831     return TARGET_XFER_EOF;
832   else
833     {
834       *xfered_len = result;
835       return TARGET_XFER_OK;
836     }
837 }
838
839 void _initialize_rs6000_nat ();
840 void
841 _initialize_rs6000_nat ()
842 {
843   add_inf_child_target (&the_rs6000_nat_target);
844 }
This page took 0.0702 seconds and 4 git commands to generate.