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