OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [rs6000-nat.c] - Blame information for rev 280

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* 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, 2010
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, NULL, 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
 
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
 
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
 
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
      gdb_assert (symfile_objfile == NULL);
919
    }
920
  breakpoint_re_set ();
921
}
922
 
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
  struct target_section_table *table = target_get_section_table (&exec_ops);
939
 
940
  if (execbfd == exec_bfd)
941
    return;
942
 
943
  execbfd = exec_bfd;
944
 
945
  if (!vmap || !table->sections)
946
    error (_("vmap_exec: vmap or table->sections == 0."));
947
 
948
  for (i = 0; &table->sections[i] < table->sections_end; i++)
949
    {
950
      if (strcmp (".text", table->sections[i].the_bfd_section->name) == 0)
951
        {
952
          table->sections[i].addr += vmap->tstart - vmap->tvma;
953
          table->sections[i].endaddr += vmap->tstart - vmap->tvma;
954
        }
955
      else if (strcmp (".data", table->sections[i].the_bfd_section->name) == 0)
956
        {
957
          table->sections[i].addr += vmap->dstart - vmap->dvma;
958
          table->sections[i].endaddr += vmap->dstart - vmap->dvma;
959
        }
960
      else if (strcmp (".bss", table->sections[i].the_bfd_section->name) == 0)
961
        {
962
          table->sections[i].addr += vmap->dstart - vmap->dvma;
963
          table->sections[i].endaddr += vmap->dstart - vmap->dvma;
964
        }
965
    }
966
}
967
 
968
/* Set the current architecture from the host running GDB.  Called when
969
   starting a child process. */
970
 
971
static void (*super_create_inferior) (struct target_ops *,char *exec_file,
972
                                      char *allargs, char **env, int from_tty);
973
static void
974
rs6000_create_inferior (struct target_ops * ops, char *exec_file,
975
                        char *allargs, char **env, int from_tty)
976
{
977
  enum bfd_architecture arch;
978
  unsigned long mach;
979
  bfd abfd;
980
  struct gdbarch_info info;
981
 
982
  super_create_inferior (ops, exec_file, allargs, env, from_tty);
983
 
984
  if (__power_rs ())
985
    {
986
      arch = bfd_arch_rs6000;
987
      mach = bfd_mach_rs6k;
988
    }
989
  else
990
    {
991
      arch = bfd_arch_powerpc;
992
      mach = bfd_mach_ppc;
993
    }
994
 
995
  /* FIXME: schauer/2002-02-25:
996
     We don't know if we are executing a 32 or 64 bit executable,
997
     and have no way to pass the proper word size to rs6000_gdbarch_init.
998
     So we have to avoid switching to a new architecture, if the architecture
999
     matches already.
1000
     Blindly calling rs6000_gdbarch_init used to work in older versions of
1001
     GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1002
     determine the wordsize.  */
1003
  if (exec_bfd)
1004
    {
1005
      const struct bfd_arch_info *exec_bfd_arch_info;
1006
 
1007
      exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1008
      if (arch == exec_bfd_arch_info->arch)
1009
        return;
1010
    }
1011
 
1012
  bfd_default_set_arch_mach (&abfd, arch, mach);
1013
 
1014
  gdbarch_info_init (&info);
1015
  info.bfd_arch_info = bfd_get_arch_info (&abfd);
1016
  info.abfd = exec_bfd;
1017
 
1018
  if (!gdbarch_update_p (info))
1019
    internal_error (__FILE__, __LINE__,
1020
                    _("rs6000_create_inferior: failed to select architecture"));
1021
}
1022
 
1023
 
1024
/* xcoff_relocate_symtab -      hook for symbol table relocation.
1025
 
1026
   This is only applicable to live processes, and is a no-op when
1027
   debugging a core file.  */
1028
 
1029
void
1030
xcoff_relocate_symtab (unsigned int pid)
1031
{
1032
  int load_segs = 64; /* number of load segments */
1033
  int rc;
1034
  LdInfo *ldi = NULL;
1035
  int arch64 = ARCH64 ();
1036
  int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1037
  int size;
1038
 
1039
  /* Nothing to do if we are debugging a core file.  */
1040
  if (!target_has_execution)
1041
    return;
1042
 
1043
  do
1044
    {
1045
      size = load_segs * ldisize;
1046
      ldi = (void *) xrealloc (ldi, size);
1047
 
1048
#if 0
1049
      /* According to my humble theory, AIX has some timing problems and
1050
         when the user stack grows, kernel doesn't update stack info in time
1051
         and ptrace calls step on user stack. That is why we sleep here a
1052
         little, and give kernel to update its internals. */
1053
      usleep (36000);
1054
#endif
1055
 
1056
      if (arch64)
1057
        rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1058
      else
1059
        rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1060
 
1061
      if (rc == -1)
1062
        {
1063
          if (errno == ENOMEM)
1064
            load_segs *= 2;
1065
          else
1066
            perror_with_name (_("ptrace ldinfo"));
1067
        }
1068
      else
1069
        {
1070
          vmap_ldinfo (ldi);
1071
          vmap_exec (); /* relocate the exec and core sections as well. */
1072
        }
1073
    } while (rc == -1);
1074
  if (ldi)
1075
    xfree (ldi);
1076
}
1077
 
1078
/* Core file stuff.  */
1079
 
1080
/* Relocate symtabs and read in shared library info, based on symbols
1081
   from the core file.  */
1082
 
1083
void
1084
xcoff_relocate_core (struct target_ops *target)
1085
{
1086
  struct bfd_section *ldinfo_sec;
1087
  int offset = 0;
1088
  LdInfo *ldi;
1089
  struct vmap *vp;
1090
  int arch64 = ARCH64 ();
1091
 
1092
  /* Size of a struct ld_info except for the variable-length filename. */
1093
  int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1094
 
1095
  /* Allocated size of buffer.  */
1096
  int buffer_size = nonfilesz;
1097
  char *buffer = xmalloc (buffer_size);
1098
  struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1099
 
1100
  ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1101
  if (ldinfo_sec == NULL)
1102
    {
1103
    bfd_err:
1104
      fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1105
                        bfd_errmsg (bfd_get_error ()));
1106
      do_cleanups (old);
1107
      return;
1108
    }
1109
  do
1110
    {
1111
      int i;
1112
      int names_found = 0;
1113
 
1114
      /* Read in everything but the name.  */
1115
      if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1116
                                    offset, nonfilesz) == 0)
1117
        goto bfd_err;
1118
 
1119
      /* Now the name.  */
1120
      i = nonfilesz;
1121
      do
1122
        {
1123
          if (i == buffer_size)
1124
            {
1125
              buffer_size *= 2;
1126
              buffer = xrealloc (buffer, buffer_size);
1127
            }
1128
          if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1129
                                        offset + i, 1) == 0)
1130
            goto bfd_err;
1131
          if (buffer[i++] == '\0')
1132
            ++names_found;
1133
        }
1134
      while (names_found < 2);
1135
 
1136
      ldi = (LdInfo *) buffer;
1137
 
1138
      /* Can't use a file descriptor from the core file; need to open it.  */
1139
      if (arch64)
1140
        ldi->l64.ldinfo_fd = -1;
1141
      else
1142
        ldi->l32.ldinfo_fd = -1;
1143
 
1144
      /* The first ldinfo is for the exec file, allocated elsewhere.  */
1145
      if (offset == 0 && vmap != NULL)
1146
        vp = vmap;
1147
      else
1148
        vp = add_vmap (ldi);
1149
 
1150
      /* Process next shared library upon error. */
1151
      offset += LDI_NEXT (ldi, arch64);
1152
      if (vp == NULL)
1153
        continue;
1154
 
1155
      vmap_secs (vp, ldi, arch64);
1156
 
1157
      /* Unless this is the exec file,
1158
         add our sections to the section table for the core target.  */
1159
      if (vp != vmap)
1160
        {
1161
          struct target_section *stp;
1162
 
1163
          stp = deprecated_core_resize_section_table (2);
1164
 
1165
          stp->bfd = vp->bfd;
1166
          stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1167
          stp->addr = vp->tstart;
1168
          stp->endaddr = vp->tend;
1169
          stp++;
1170
 
1171
          stp->bfd = vp->bfd;
1172
          stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1173
          stp->addr = vp->dstart;
1174
          stp->endaddr = vp->dend;
1175
        }
1176
 
1177
      vmap_symtab (vp);
1178
 
1179
      if (vp != vmap && vp->objfile)
1180
        observer_notify_new_objfile (vp->objfile);
1181
    }
1182
  while (LDI_NEXT (ldi, arch64) != 0);
1183
  vmap_exec ();
1184
  breakpoint_re_set ();
1185
  do_cleanups (old);
1186
}
1187
 
1188
/* Under AIX, we have to pass the correct TOC pointer to a function
1189
   when calling functions in the inferior.
1190
   We try to find the relative toc offset of the objfile containing PC
1191
   and add the current load address of the data segment from the vmap.  */
1192
 
1193
static CORE_ADDR
1194
find_toc_address (CORE_ADDR pc)
1195
{
1196
  struct vmap *vp;
1197
 
1198
  for (vp = vmap; vp; vp = vp->nxt)
1199
    {
1200
      if (pc >= vp->tstart && pc < vp->tend)
1201
        {
1202
          /* vp->objfile is only NULL for the exec file.  */
1203
          return vp->dstart + xcoff_get_toc_offset (vp->objfile == NULL
1204
                                                    ? symfile_objfile
1205
                                                    : vp->objfile);
1206
        }
1207
    }
1208
  error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1209
}
1210
 
1211
 
1212
void
1213
_initialize_rs6000_nat (void)
1214
{
1215
  struct target_ops *t;
1216
 
1217
  t = inf_ptrace_target ();
1218
  t->to_fetch_registers = rs6000_fetch_inferior_registers;
1219
  t->to_store_registers = rs6000_store_inferior_registers;
1220
  t->to_xfer_partial = rs6000_xfer_partial;
1221
 
1222
  super_create_inferior = t->to_create_inferior;
1223
  t->to_create_inferior = rs6000_create_inferior;
1224
 
1225
  t->to_wait = rs6000_wait;
1226
 
1227
  add_target (t);
1228
 
1229
  /* Initialize hook in rs6000-tdep.c for determining the TOC address
1230
     when calling functions in the inferior.  */
1231
  rs6000_find_toc_address_hook = find_toc_address;
1232
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.