1 /* Native-dependent code for LynxOS.
2 Copyright 1993, 1994 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. */
27 #include <sys/ptrace.h>
31 static unsigned long registers_addr
PARAMS ((int pid
));
32 static void fetch_core_registers
PARAMS ((char *, unsigned, int, CORE_ADDR
));
34 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
37 /* Mappings from tm-i386v.h */
55 X (ecode
), /* Lynx doesn't give us either fs or gs, so */
56 X (fault
), /* we just substitute these two in the hopes
57 that they are useful. */
62 /* Mappings from tm-m68k.h */
76 X (regs
[10]), /* a2 */
77 X (regs
[11]), /* a3 */
78 X (regs
[12]), /* a4 */
79 X (regs
[13]), /* a5 */
80 X (regs
[14]), /* fp */
81 offsetof (st_t
, usp
) - offsetof (st_t
, ec
), /* sp */
85 X (fregs
[0 * 3]), /* fp0 */
86 X (fregs
[1 * 3]), /* fp1 */
87 X (fregs
[2 * 3]), /* fp2 */
88 X (fregs
[3 * 3]), /* fp3 */
89 X (fregs
[4 * 3]), /* fp4 */
90 X (fregs
[5 * 3]), /* fp5 */
91 X (fregs
[6 * 3]), /* fp6 */
92 X (fregs
[7 * 3]), /* fp7 */
94 X (fcregs
[0]), /* fpcontrol */
95 X (fcregs
[1]), /* fpstatus */
96 X (fcregs
[2]), /* fpiaddr */
98 X (fault
), /* fpflags */
103 /* Mappings from tm-sparc.h */
105 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
107 static int regmap
[] =
114 -1, /* g5->g7 aren't saved by Lynx */
127 -1, -1, -1, -1, -1, -1, -1, -1, /* l0 -> l7 */
129 -1, -1, -1, -1, -1, -1, -1, -1, /* i0 -> i7 */
131 FX (f
.fregs
[0]), /* f0 */
177 static int regmap
[] =
179 X (iregs
[0]), /* r0 */
212 X (fregs
[0]), /* f0 */
245 X (srr0
), /* IAR (PC) */
246 X (srr1
), /* MSR (PS) */
258 /* This routine handles some oddball cases for Sparc registers and LynxOS.
259 In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
260 It also handles knows where to find the I & L regs on the stack. */
263 fetch_inferior_registers (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 (regno
)
370 whatregs
= WHATREGS_FLOAT
| WHATREGS_GEN
| WHATREGS_STACK
;
371 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
372 whatregs
= WHATREGS_STACK
;
373 else if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
374 whatregs
= WHATREGS_FLOAT
;
375 else if (regno
== SP_REGNUM
)
376 whatregs
= WHATREGS_STACK
| WHATREGS_GEN
;
378 whatregs
= WHATREGS_GEN
;
380 if (whatregs
& WHATREGS_GEN
)
382 struct econtext ec
; /* general regs */
385 ec
.tbr
= read_register (TBR_REGNUM
);
386 memcpy (&ec
.g1
, ®isters
[REGISTER_BYTE (G1_REGNUM
)],
387 4 * REGISTER_RAW_SIZE (G1_REGNUM
));
389 ec
.psr
= read_register (PS_REGNUM
);
390 ec
.y
= read_register (Y_REGNUM
);
391 ec
.pc
= read_register (PC_REGNUM
);
392 ec
.npc
= read_register (NPC_REGNUM
);
393 ec
.wim
= read_register (WIM_REGNUM
);
395 memcpy (ec
.o
, ®isters
[REGISTER_BYTE (O0_REGNUM
)],
396 8 * REGISTER_RAW_SIZE (O0_REGNUM
));
399 retval
= ptrace (PTRACE_SETREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & ec
,
402 perror_with_name ("ptrace(PTRACE_SETREGS)");
405 if (whatregs
& WHATREGS_STACK
)
410 sp
= read_register (SP_REGNUM
);
412 if (regno
== -1 || regno
== SP_REGNUM
)
414 if (!register_valid
[L0_REGNUM
+ 5])
416 target_write_memory (sp
+ FRAME_SAVED_I0
,
417 ®isters
[REGISTER_BYTE (I0_REGNUM
)],
418 8 * REGISTER_RAW_SIZE (I0_REGNUM
));
420 target_write_memory (sp
+ FRAME_SAVED_L0
,
421 ®isters
[REGISTER_BYTE (L0_REGNUM
)],
422 8 * REGISTER_RAW_SIZE (L0_REGNUM
));
424 else if (regno
>= L0_REGNUM
&& regno
<= I7_REGNUM
)
426 if (!register_valid
[regno
])
428 if (regno
>= L0_REGNUM
&& regno
<= L0_REGNUM
+ 7)
429 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (L0_REGNUM
)
432 regoffset
= REGISTER_BYTE (regno
) - REGISTER_BYTE (I0_REGNUM
)
434 target_write_memory (sp
+ regoffset
,
435 ®isters
[REGISTER_BYTE (regno
)],
436 REGISTER_RAW_SIZE (regno
));
440 if (whatregs
& WHATREGS_FLOAT
)
442 struct fcontext fc
; /* fp regs */
445 /* We read fcontext first so that we can get good values for fq_t... */
447 retval
= ptrace (PTRACE_GETFPREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & fc
,
450 perror_with_name ("ptrace(PTRACE_GETFPREGS)");
452 memcpy (fc
.f
.fregs
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)],
453 32 * REGISTER_RAW_SIZE (FP0_REGNUM
));
455 fc
.fsr
= read_register (FPS_REGNUM
);
458 retval
= ptrace (PTRACE_SETFPREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & fc
,
461 perror_with_name ("ptrace(PTRACE_SETFPREGS)");
466 #if defined (I386) || defined (M68K) || defined (rs6000)
468 /* Return the offset relative to the start of the per-thread data to the
469 saved context block. */
476 int ecpoff
= offsetof (st_t
, ecp
);
480 stblock
= (CORE_ADDR
) ptrace (PTRACE_THREADUSER
, pid
, (PTRACE_ARG3_TYPE
) 0,
483 perror_with_name ("ptrace(PTRACE_THREADUSER)");
485 ecp
= (CORE_ADDR
) ptrace (PTRACE_PEEKTHREAD
, pid
, (PTRACE_ARG3_TYPE
) ecpoff
,
488 perror_with_name ("ptrace(PTRACE_PEEKTHREAD)");
490 return ecp
- stblock
;
493 /* Fetch one or more registers from the inferior. REGNO == -1 to get
494 them all. We actually fetch more than requested, when convenient,
495 marking them as valid so we won't fetch them again. */
498 fetch_inferior_registers (regno
)
508 reghi
= NUM_REGS
- 1;
511 reglo
= reghi
= regno
;
513 ecp
= registers_addr (inferior_pid
);
515 for (regno
= reglo
; regno
<= reghi
; regno
++)
517 char buf
[MAX_REGISTER_RAW_SIZE
];
518 int ptrace_fun
= PTRACE_PEEKTHREAD
;
521 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_PEEKUSP
: PTRACE_PEEKTHREAD
;
524 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
529 reg
= ptrace (ptrace_fun
, inferior_pid
,
530 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
] + i
), 0);
532 perror_with_name ("ptrace(PTRACE_PEEKUSP)");
534 *(int *) &buf
[i
] = reg
;
536 supply_register (regno
, buf
);
540 /* Store our register values back into the inferior.
541 If REGNO is -1, do this for all registers.
542 Otherwise, REGNO specifies which register (so we can save time). */
544 /* Registers we shouldn't try to store. */
545 #if !defined (CANNOT_STORE_REGISTER)
546 #define CANNOT_STORE_REGISTER(regno) 0
550 store_inferior_registers (regno
)
560 reghi
= NUM_REGS
- 1;
563 reglo
= reghi
= regno
;
565 ecp
= registers_addr (inferior_pid
);
567 for (regno
= reglo
; regno
<= reghi
; regno
++)
569 int ptrace_fun
= PTRACE_POKEUSER
;
571 if (CANNOT_STORE_REGISTER (regno
))
575 ptrace_fun
= regno
== SP_REGNUM
? PTRACE_POKEUSP
: PTRACE_POKEUSER
;
578 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
582 reg
= *(unsigned int *) ®isters
[REGISTER_BYTE (regno
) + i
];
585 ptrace (ptrace_fun
, inferior_pid
,
586 (PTRACE_ARG3_TYPE
) (ecp
+ regmap
[regno
] + i
), reg
);
588 perror_with_name ("ptrace(PTRACE_POKEUSP)");
592 #endif /* defined (I386) || defined (M68K) || defined (rs6000) */
594 /* Wait for child to do something. Return pid of child, or -1 in case
595 of error; store status through argument pointer OURSTATUS. */
598 child_wait (pid
, ourstatus
)
600 struct target_waitstatus
*ourstatus
;
610 set_sigint_trap (); /* Causes SIGINT to be passed on to the
612 pid
= wait (&status
);
616 clear_sigint_trap ();
620 if (save_errno
== EINTR
)
622 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
623 safe_strerror (save_errno
));
624 /* Claim it exited with unknown signal. */
625 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
626 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
630 if (pid
!= PIDGET (inferior_pid
)) /* Some other process?!? */
633 thread
= status
.w_tid
; /* Get thread id from status */
635 /* Initial thread value can only be acquired via wait, so we have to
636 resort to this hack. */
638 if (TIDGET (inferior_pid
) == 0 && thread
!= 0)
640 inferior_pid
= BUILDPID (inferior_pid
, thread
);
641 add_thread (inferior_pid
);
644 pid
= BUILDPID (pid
, thread
);
646 /* We've become a single threaded process again. */
650 /* Check for thread creation. */
651 if (WIFSTOPPED (status
)
652 && WSTOPSIG (status
) == SIGTRAP
653 && !in_thread_list (pid
))
657 realsig
= ptrace (PTRACE_GETTRACESIG
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
659 if (realsig
== SIGNEWTHREAD
)
661 /* It's a new thread notification. We don't want to much with
662 realsig -- the code in wait_for_inferior expects SIGTRAP. */
663 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
664 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
668 error ("Signal for unknown thread was not SIGNEWTHREAD");
671 /* Check for thread termination. */
672 else if (WIFSTOPPED (status
)
673 && WSTOPSIG (status
) == SIGTRAP
674 && in_thread_list (pid
))
678 realsig
= ptrace (PTRACE_GETTRACESIG
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
680 if (realsig
== SIGTHREADEXIT
)
682 ptrace (PTRACE_CONT
, PIDGET (pid
), (PTRACE_ARG3_TYPE
) 0, 0);
688 /* SPARC Lynx uses an byte reversed wait status; we must use the
689 host macros to access it. These lines just a copy of
690 store_waitstatus. We can't use CHILD_SPECIAL_WAITSTATUS
691 because target.c can't include the Lynx <sys/wait.h>. */
692 if (WIFEXITED (status
))
694 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
695 ourstatus
->value
.integer
= WEXITSTATUS (status
);
697 else if (!WIFSTOPPED (status
))
699 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
700 ourstatus
->value
.sig
=
701 target_signal_from_host (WTERMSIG (status
));
705 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
706 ourstatus
->value
.sig
=
707 target_signal_from_host (WSTOPSIG (status
));
710 store_waitstatus (ourstatus
, status
.w_status
);
717 /* Return nonzero if the given thread is still alive. */
719 child_thread_alive (pid
)
722 /* Arggh. Apparently pthread_kill only works for threads within
723 the process that calls pthread_kill.
725 We want to avoid the lynx signal extensions as they simply don't
726 map well to the generic gdb interface we want to keep.
728 All we want to do is determine if a particular thread is alive;
729 it appears as if we can just make a harmless thread specific
730 ptrace call to do that. */
731 return (ptrace (PTRACE_THREADUSER
, pid
, 0, 0) != -1);
734 /* Resume execution of the inferior process.
735 If STEP is nonzero, single-step it.
736 If SIGNAL is nonzero, give it that signal. */
739 child_resume (pid
, step
, signal
)
742 enum target_signal signal
;
748 /* If pid == -1, then we want to step/continue all threads, else
749 we only want to step/continue a single thread. */
753 func
= step
? PTRACE_SINGLESTEP
: PTRACE_CONT
;
756 func
= step
? PTRACE_SINGLESTEP_ONE
: PTRACE_CONT_ONE
;
759 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
760 it was. (If GDB wanted it to start some other way, we have already
761 written a new PC value to the child.)
763 If this system does not support PT_STEP, a higher level function will
764 have called single_step() to transmute the step request into a
765 continue request (by setting breakpoints on all possible successor
766 instructions), so we don't have to worry about that here. */
768 ptrace (func
, pid
, (PTRACE_ARG3_TYPE
) 1, target_signal_to_host (signal
));
771 perror_with_name ("ptrace");
774 /* Convert a Lynx process ID to a string. Returns the string in a static
778 child_pid_to_str (pid
)
783 sprintf (buf
, "process %d thread %d", PIDGET (pid
), TIDGET (pid
));
788 /* Extract the register values out of the core file and store
789 them where `read_register' will find them.
791 CORE_REG_SECT points to the register values themselves, read into memory.
792 CORE_REG_SIZE is the size of that area.
793 WHICH says which set of registers we are handling (0 = int, 2 = float
794 on machines where they are discontiguous).
795 REG_ADDR is the offset from u.u_ar0 to the register values relative to
796 core_reg_sect. This is used with old-fashioned core files to
797 locate the registers in a large upage-plus-stack ".reg" section.
798 Original upage address X is at location core_reg_sect+x+reg_addr.
802 fetch_core_registers (core_reg_sect
, core_reg_size
, which
, reg_addr
)
804 unsigned core_reg_size
;
811 for (regno
= 0; regno
< NUM_REGS
; regno
++)
812 if (regmap
[regno
] != -1)
813 supply_register (regno
, core_reg_sect
+ offsetof (st_t
, ec
)
817 /* Fetching this register causes all of the I & L regs to be read from the
818 stack and validated. */
820 fetch_inferior_registers (I0_REGNUM
);
825 /* Register that we are able to handle lynx core file formats.
826 FIXME: is this really bfd_target_unknown_flavour? */
828 static struct core_fns lynx_core_fns
=
830 bfd_target_unknown_flavour
, /* core_flavour */
831 default_check_format
, /* check_format */
832 default_core_sniffer
, /* core_sniffer */
833 fetch_core_registers
, /* core_read_registers */
838 _initialize_core_lynx ()
840 add_core_fns (&lynx_core_fns
);