1 /* Native-dependent code for LynxOS.
2 Copyright 1993, 1994, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
28 #include <sys/ptrace.h>
32 static unsigned long registers_addr (int pid
);
33 static void fetch_core_registers (char *, unsigned, int, CORE_ADDR
);
35 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
38 /* Mappings from tm-i386v.h */
56 X (ecode
), /* Lynx doesn't give us either fs or gs, so */
57 X (fault
), /* we just substitute these two in the hopes
58 that they are useful. */
63 /* Mappings from tm-m68k.h */
77 X (regs
[10]), /* a2 */
78 X (regs
[11]), /* a3 */
79 X (regs
[12]), /* a4 */
80 X (regs
[13]), /* a5 */
81 X (regs
[14]), /* fp */
82 offsetof (st_t
, usp
) - offsetof (st_t
, ec
), /* sp */
86 X (fregs
[0 * 3]), /* fp0 */
87 X (fregs
[1 * 3]), /* fp1 */
88 X (fregs
[2 * 3]), /* fp2 */
89 X (fregs
[3 * 3]), /* fp3 */
90 X (fregs
[4 * 3]), /* fp4 */
91 X (fregs
[5 * 3]), /* fp5 */
92 X (fregs
[6 * 3]), /* fp6 */
93 X (fregs
[7 * 3]), /* fp7 */
95 X (fcregs
[0]), /* fpcontrol */
96 X (fcregs
[1]), /* fpstatus */
97 X (fcregs
[2]), /* fpiaddr */
99 X (fault
), /* fpflags */
104 /* Mappings from tm-sparc.h */
106 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
108 static int regmap
[] =
115 -1, /* g5->g7 aren't saved by Lynx */
128 -1, -1, -1, -1, -1, -1, -1, -1, /* l0 -> l7 */
130 -1, -1, -1, -1, -1, -1, -1, -1, /* i0 -> i7 */
132 FX (f
.fregs
[0]), /* f0 */
178 static int regmap
[] =
180 X (iregs
[0]), /* r0 */
213 X (fregs
[0]), /* f0 */
246 X (srr0
), /* IAR (PC) */
247 X (srr1
), /* MSR (PS) */
259 /* This routine handles some oddball cases for Sparc registers and LynxOS.
260 In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
261 It also handles knows where to find the I & L regs on the stack. */
264 fetch_inferior_registers (int regno
)
268 #define WHATREGS_FLOAT 1
269 #define WHATREGS_GEN 2
270 #define WHATREGS_STACK 4
273 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
274 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
275 whatregs
= WHATREGS_STACK
;
276 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
277 whatregs
= WHATREGS_FLOAT
;
279 whatregs
= WHATREGS_GEN
;
281 if (whatregs
& WHATREGS_GEN
)
283 struct econtext ec
; /* general regs */
284 char buf
[MAX_REGISTER_RAW_SIZE
];
289 retval
= ptrace (PTRACE_GETREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & ec
,
292 perror_with_name ("ptrace(PTRACE_GETREGS)");
294 memset (buf
, 0, REGISTER_RAW_SIZE (G0_REGNUM
));
295 supply_register (G0_REGNUM
, buf
);
296 supply_register (TBR_REGNUM
, (char *) &ec
.tbr
);
298 memcpy (®isters
[REGISTER_BYTE (G1_REGNUM
)], &ec
.g1
,
299 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
300 for (i
= G1_REGNUM
; i
<= G1_REGNUM
+ 3; i
++)
301 register_valid
[i
] = 1;
303 supply_register (PS_REGNUM
, (char *) &ec
.psr
);
304 supply_register (Y_REGNUM
, (char *) &ec
.y
);
305 supply_register (PC_REGNUM
, (char *) &ec
.pc
);
306 supply_register (NPC_REGNUM
, (char *) &ec
.npc
);
307 supply_register (WIM_REGNUM
, (char *) &ec
.wim
);
309 memcpy (®isters
[REGISTER_BYTE (O0_REGNUM
)], ec
.o
,
310 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
311 for (i
= O0_REGNUM
; i
<= O0_REGNUM
+ 7; i
++)
312 register_valid
[i
] = 1;
315 if (whatregs
& WHATREGS_STACK
)
320 sp
= read_register (SP_REGNUM
);
322 target_read_memory (sp
+ FRAME_SAVED_I0
,
323 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
324 8 * REGISTER_RAW_SIZE (I0_REGNUM
));
325 for (i
= I0_REGNUM
; i
<= I7_REGNUM
; i
++)
326 register_valid
[i
] = 1;
328 target_read_memory (sp
+ FRAME_SAVED_L0
,
329 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
330 8 * REGISTER_RAW_SIZE (L0_REGNUM
));
331 for (i
= L0_REGNUM
; i
<= L0_REGNUM
+ 7; i
++)
332 register_valid
[i
] = 1;
335 if (whatregs
& WHATREGS_FLOAT
)
337 struct fcontext fc
; /* fp regs */
342 retval
= ptrace (PTRACE_GETFPREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & fc
,
345 perror_with_name ("ptrace(PTRACE_GETFPREGS)");
347 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], fc
.f
.fregs
,
348 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
349 for (i
= FP0_REGNUM
; i
<= FP0_REGNUM
+ 31; i
++)
350 register_valid
[i
] = 1;
352 supply_register (FPS_REGNUM
, (char *) &fc
.fsr
);
356 /* This routine handles storing of the I & L regs for the Sparc. The trick
357 here is that they actually live on the stack. The really tricky part is
358 that when changing the stack pointer, the I & L regs must be written to
359 where the new SP points, otherwise the regs will be incorrect when the
360 process is started up again. We assume that the I & L regs are valid at
364 store_inferior_registers (int regno
)
369 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
370 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
371 whatregs
= WHATREGS_STACK
;
372 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
373 whatregs
= WHATREGS_FLOAT
;
374 else if (regno
== SP_REGNUM
)
375 whatregs
= WHATREGS_STACK
| WHATREGS_GEN
;
377 whatregs
= WHATREGS_GEN
;
379 if (whatregs
& WHATREGS_GEN
)
381 struct econtext ec
; /* general regs */
384 ec
.tbr
= read_register (TBR_REGNUM
);
385 memcpy (&ec
.g1
, ®isters
[REGISTER_BYTE (G1_REGNUM
)],
386 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
388 ec
.psr
= read_register (PS_REGNUM
);
389 ec
.y
= read_register (Y_REGNUM
);
390 ec
.pc
= read_register (PC_REGNUM
);
391 ec
.npc
= read_register (NPC_REGNUM
);
392 ec
.wim
= read_register (WIM_REGNUM
);
394 memcpy (ec
.o
, ®isters
[REGISTER_BYTE (O0_REGNUM
)],
395 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
398 retval
= ptrace (PTRACE_SETREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & ec
,
401 perror_with_name ("ptrace(PTRACE_SETREGS)");
404 if (whatregs
& WHATREGS_STACK
)
409 sp
= read_register (SP_REGNUM
);
411 if (regno
== -1 || regno
== SP_REGNUM
)
413 if (!register_valid
[L0_REGNUM
+ 5])
414 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
415 target_write_memory (sp
+ FRAME_SAVED_I0
,
416 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
417 8 * REGISTER_RAW_SIZE (I0_REGNUM
));
419 target_write_memory (sp
+ FRAME_SAVED_L0
,
420 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
421 8 * REGISTER_RAW_SIZE (L0_REGNUM
));
423 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
425 if (!register_valid
[regno
])
426 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
427 if (regno
>= L0_REGNUM
&& regno
<= L0_REGNUM
+ 7)
428 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (L0_REGNUM
)
431 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (I0_REGNUM
)
433 target_write_memory (sp
+ regoffset
,
434 ®isters
[REGISTER_BYTE (regno
)],
435 REGISTER_RAW_SIZE (regno
));
439 if (whatregs
& WHATREGS_FLOAT
)
441 struct fcontext fc
; /* fp regs */
444 /* We read fcontext first so that we can get good values for fq_t... */
446 retval
= ptrace (PTRACE_GETFPREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & fc
,
449 perror_with_name ("ptrace(PTRACE_GETFPREGS)");
451 memcpy (fc
.f
.fregs
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
452 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
454 fc
.fsr
= read_register (FPS_REGNUM
);
457 retval
= ptrace (PTRACE_SETFPREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & fc
,
460 perror_with_name ("ptrace(PTRACE_SETFPREGS)");
465 #if defined (I386) || defined (M68K) || defined (rs6000)
467 /* Return the offset relative to the start of the per-thread data to the
468 saved context block. */
471 registers_addr (int pid
)
474 int ecpoff
= offsetof (st_t
, ecp
);
478 stblock
= (CORE_ADDR
) ptrace (PTRACE_THREADUSER
, pid
, (PTRACE_ARG3_TYPE
) 0,
481 perror_with_name ("ptrace(PTRACE_THREADUSER)");
483 ecp
= (CORE_ADDR
) ptrace (PTRACE_PEEKTHREAD
, pid
, (PTRACE_ARG3_TYPE
) ecpoff
,
486 perror_with_name ("ptrace(PTRACE_PEEKTHREAD)");
488 return ecp
- stblock
;
491 /* Fetch one or more registers from the inferior. REGNO == -1 to get
492 them all. We actually fetch more than requested, when convenient,
493 marking them as valid so we won't fetch them again. */
496 fetch_inferior_registers (int regno
)
505 reghi
= NUM_REGS
- 1;
508 reglo
= reghi
= regno
;
510 ecp
= registers_addr (inferior_pid
);
512 for (regno
= reglo
; regno
<= reghi
; regno
++)
514 char buf
[MAX_REGISTER_RAW_SIZE
];
515 int ptrace_fun
= PTRACE_PEEKTHREAD
;
518 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_PEEKUSP
: PTRACE_PEEKTHREAD
;
521 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
526 reg
= ptrace (ptrace_fun
, inferior_pid
,
527 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
] + i
), 0);
529 perror_with_name ("ptrace(PTRACE_PEEKUSP)");
531 *(int *) &buf
[i
] = reg
;
533 supply_register (regno
, buf
);
537 /* Store our register values back into the inferior.
538 If REGNO is -1, do this for all registers.
539 Otherwise, REGNO specifies which register (so we can save time). */
541 /* Registers we shouldn't try to store. */
542 #if !defined (CANNOT_STORE_REGISTER)
543 #define CANNOT_STORE_REGISTER(regno) 0
547 store_inferior_registers (int regno
)
556 reghi
= NUM_REGS
- 1;
559 reglo
= reghi
= regno
;
561 ecp
= registers_addr (inferior_pid
);
563 for (regno
= reglo
; regno
<= reghi
; regno
++)
565 int ptrace_fun
= PTRACE_POKEUSER
;
567 if (CANNOT_STORE_REGISTER (regno
))
571 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_POKEUSP
: PTRACE_POKEUSER
;
574 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
578 reg
= *(unsigned int *) ®isters
[REGISTER_BYTE (regno
) + i
];
581 ptrace (ptrace_fun
, inferior_pid
,
582 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
] + i
), reg
);
584 perror_with_name ("ptrace(PTRACE_POKEUSP)");
588 #endif /* defined (I386) || defined (M68K) || defined (rs6000) */
590 /* Wait for child to do something. Return pid of child, or -1 in case
591 of error; store status through argument pointer OURSTATUS. */
594 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
604 set_sigint_trap (); /* Causes SIGINT to be passed on to the
606 pid
= wait (&status
);
610 clear_sigint_trap ();
614 if (save_errno
== EINTR
)
616 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
617 safe_strerror (save_errno
));
618 /* Claim it exited with unknown signal. */
619 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
620 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
624 if (pid
!= PIDGET (inferior_pid
)) /* Some other process?!? */
627 thread
= status
.w_tid
; /* Get thread id from status */
629 /* Initial thread value can only be acquired via wait, so we have to
630 resort to this hack. */
632 if (TIDGET (inferior_pid
) == 0 && thread
!= 0)
634 inferior_pid
= BUILDPID (inferior_pid
, thread
);
635 add_thread (inferior_pid
);
638 pid
= BUILDPID (pid
, thread
);
640 /* We've become a single threaded process again. */
644 /* Check for thread creation. */
645 if (WIFSTOPPED (status
)
646 && WSTOPSIG (status
) == SIGTRAP
647 && !in_thread_list (pid
))
651 realsig
= ptrace (PTRACE_GETTRACESIG
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
653 if (realsig
== SIGNEWTHREAD
)
655 /* It's a new thread notification. We don't want to much with
656 realsig -- the code in wait_for_inferior expects SIGTRAP. */
657 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
658 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
662 error ("Signal for unknown thread was not SIGNEWTHREAD");
665 /* Check for thread termination. */
666 else if (WIFSTOPPED (status
)
667 && WSTOPSIG (status
) == SIGTRAP
668 && in_thread_list (pid
))
672 realsig
= ptrace (PTRACE_GETTRACESIG
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
674 if (realsig
== SIGTHREADEXIT
)
676 ptrace (PTRACE_CONT
, PIDGET (pid
), (PTRACE_ARG3_TYPE
) 0, 0);
682 /* SPARC Lynx uses an byte reversed wait status; we must use the
683 host macros to access it. These lines just a copy of
684 store_waitstatus. We can't use CHILD_SPECIAL_WAITSTATUS
685 because target.c can't include the Lynx <sys/wait.h>. */
686 if (WIFEXITED (status
))
688 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
689 ourstatus
->value
.integer
= WEXITSTATUS (status
);
691 else if (!WIFSTOPPED (status
))
693 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
694 ourstatus
->value
.sig
=
695 target_signal_from_host (WTERMSIG (status
));
699 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
700 ourstatus
->value
.sig
=
701 target_signal_from_host (WSTOPSIG (status
));
704 store_waitstatus (ourstatus
, status
.w_status
);
711 /* Return nonzero if the given thread is still alive. */
713 child_thread_alive (int pid
)
715 /* Arggh. Apparently pthread_kill only works for threads within
716 the process that calls pthread_kill.
718 We want to avoid the lynx signal extensions as they simply don't
719 map well to the generic gdb interface we want to keep.
721 All we want to do is determine if a particular thread is alive;
722 it appears as if we can just make a harmless thread specific
723 ptrace call to do that. */
724 return (ptrace (PTRACE_THREADUSER
, pid
, 0, 0) != -1);
727 /* Resume execution of the inferior process.
728 If STEP is nonzero, single-step it.
729 If SIGNAL is nonzero, give it that signal. */
732 child_resume (int pid
, int step
, enum target_signal signal
)
738 /* If pid == -1, then we want to step/continue all threads, else
739 we only want to step/continue a single thread. */
743 func
= step
? PTRACE_SINGLESTEP
: PTRACE_CONT
;
746 func
= step
? PTRACE_SINGLESTEP_ONE
: PTRACE_CONT_ONE
;
749 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
750 it was. (If GDB wanted it to start some other way, we have already
751 written a new PC value to the child.)
753 If this system does not support PT_STEP, a higher level function will
754 have called single_step() to transmute the step request into a
755 continue request (by setting breakpoints on all possible successor
756 instructions), so we don't have to worry about that here. */
758 ptrace (func
, pid
, (PTRACE_ARG3_TYPE
) 1, target_signal_to_host (signal
));
761 perror_with_name ("ptrace");
764 /* Convert a Lynx process ID to a string. Returns the string in a static
768 child_pid_to_str (int pid
)
772 sprintf (buf
, "process %d thread %d", PIDGET (pid
), TIDGET (pid
));
777 /* Extract the register values out of the core file and store
778 them where `read_register' will find them.
780 CORE_REG_SECT points to the register values themselves, read into memory.
781 CORE_REG_SIZE is the size of that area.
782 WHICH says which set of registers we are handling (0 = int, 2 = float
783 on machines where they are discontiguous).
784 REG_ADDR is the offset from u.u_ar0 to the register values relative to
785 core_reg_sect. This is used with old-fashioned core files to
786 locate the registers in a large upage-plus-stack ".reg" section.
787 Original upage address X is at location core_reg_sect+x+reg_addr.
791 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
, int which
,
797 for (regno
= 0; regno
< NUM_REGS
; regno
++)
798 if (regmap
[regno
] != -1)
799 supply_register (regno
, core_reg_sect
+ offsetof (st_t
, ec
)
803 /* Fetching this register causes all of the I & L regs to be read from the
804 stack and validated. */
806 fetch_inferior_registers (I0_REGNUM
);
811 /* Register that we are able to handle lynx core file formats.
812 FIXME: is this really bfd_target_unknown_flavour? */
814 static struct core_fns lynx_core_fns
=
816 bfd_target_unknown_flavour
, /* core_flavour */
817 default_check_format
, /* check_format */
818 default_core_sniffer
, /* core_sniffer */
819 fetch_core_registers
, /* core_read_registers */
824 _initialize_core_lynx (void)
826 add_core_fns (&lynx_core_fns
);