1 /* Low level Pyramid interface to ptrace, for GDB when running under Unix.
2 Copyright (C) 1988, 1989, 1991 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include <sys/param.h>
27 #include <sys/ioctl.h>
28 /* #include <fcntl.h> Can we live without this? */
31 #include <sys/user.h> /* After a.out.h */
37 fetch_inferior_registers (regno
)
41 register unsigned int regaddr
;
42 int reg_buf
[NUM_REGS
+1];
44 register int skipped_frames
= 0;
48 for (regno
= 0; regno
< 64; regno
++) {
49 reg_buf
[regno
] = ptrace (3, inferior_pid
, regno
, 0);
51 #if defined(PYRAMID_CONTROL_FRAME_DEBUGGING)
52 printf ("Fetching %s from inferior, got %0x\n",
55 #endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
57 if (reg_buf
[regno
] == -1 && errno
== EIO
) {
58 printf("fetch_interior_registers: fetching %s from inferior\n",
62 supply_register (regno
, reg_buf
+regno
);
64 /* that leaves regs 64, 65, and 66 */
65 datum
= ptrace (3, inferior_pid
,
66 ((char *)&u
.u_pcb
.pcb_csp
) -
71 /* FIXME: Find the Current Frame Pointer (CFP). CFP is a global
72 register (ie, NOT windowed), that gets saved in a frame iff
73 the code for that frame has a prologue (ie, "adsf N"). If
74 there is a prologue, the adsf insn saves the old cfp in
75 pr13, cfp is set to sp, and N bytes of locals are allocated
76 (sp is decremented by n).
77 This makes finding CFP hard. I guess the right way to do it
79 - If this is the innermost frame, believe ptrace() or
82 Find the first insn of the current frame.
84 - find the call insn that saved it;
85 - figure out where the call is to;
86 - if the first insn is an adsf, we got a frame
90 /* Normal processors have separate stack pointers for user and
91 kernel mode. Getting the last user mode frame on such
92 machines is easy: the kernel context of the ptrace()'d
93 process is on the kernel stack, and the USP points to what
94 we want. But Pyramids only have a single cfp for both user and
95 kernel mode. And processes being ptrace()'d have some
96 kernel-context control frames on their stack.
97 To avoid tracing back into the kernel context of an inferior,
98 we skip 0 or more contiguous control frames where the pc is
102 register int inferior_saved_pc
;
103 inferior_saved_pc
= ptrace (1, inferior_pid
, datum
+((32+15)*4), 0);
104 if (inferior_saved_pc
> 0) break;
105 #if defined(PYRAMID_CONTROL_FRAME_DEBUGGING)
106 printf("skipping kernel frame %08x, pc=%08x\n", datum
,
108 #endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
110 datum
-= CONTROL_STACK_FRAME_SIZE
;
113 reg_buf
[CSP_REGNUM
] = datum
;
114 supply_register(CSP_REGNUM
, reg_buf
+CSP_REGNUM
);
115 #ifdef PYRAMID_CONTROL_FRAME_DEBUGGING
116 if (skipped_frames
) {
118 "skipped %d frames from %x to %x; cfp was %x, now %x\n",
119 skipped_frames
, reg_buf
[CSP_REGNUM
]);
121 #endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
124 /* Store our register values back into the inferior.
125 If REGNO is -1, do this for all registers.
126 Otherwise, REGNO specifies which register (so we can save time). */
129 store_inferior_registers (regno
)
132 register unsigned int regaddr
;
137 if ((0 <= regno
) && (regno
< 64)) {
138 /*regaddr = register_addr (regno, offset);*/
141 ptrace (6, inferior_pid
, regaddr
, read_register (regno
));
144 sprintf (buf
, "writing register number %d", regno
);
145 perror_with_name (buf
);
151 for (regno
= 0; regno
< NUM_REGS
; regno
++)
153 /*regaddr = register_addr (regno, offset);*/
156 ptrace (6, inferior_pid
, regaddr
, read_register (regno
));
159 sprintf (buf
, "writing all regs, number %d", regno
);
160 perror_with_name (buf
);
165 /*** Extensions to core and dump files, for GDB. */
167 extern unsigned int last_frame_offset
;
171 /* Can't make definitions here static, since core.c needs them
172 to do bounds checking on the core-file areas. O well. */
174 /* have two stacks: one for data, one for register windows. */
175 extern CORE_ADDR reg_stack_start
;
176 extern CORE_ADDR reg_stack_end
;
178 /* need this so we can find the global registers: they never get saved. */
179 CORE_ADDR global_reg_offset
;
180 static CORE_ADDR last_frame_address
;
181 CORE_ADDR last_frame_offset
;
184 /* Address in core file of start of register window stack area.
185 Don't know if is this any of meaningful, useful or necessary. */
186 extern int reg_stack_offset
;
188 #endif /* PYRAMID_CORE */
191 /* Work with core dump and executable files, for GDB.
192 This code would be in core.c if it weren't machine-dependent. */
195 core_file_command (filename
, from_tty
)
200 extern char registers
[];
202 /* Discard all vestiges of any previous core file
203 and mark data and stack spaces as empty. */
215 stack_start
= STACK_END_ADDR
;
216 stack_end
= STACK_END_ADDR
;
219 reg_stack_start
= CONTROL_STACK_ADDR
;
220 reg_stack_end
= CONTROL_STACK_ADDR
; /* this isn't strictly true...*/
221 #endif /* PYRAMID_CORE */
223 /* Now, if a new core file was specified, open it and digest it. */
227 filename
= tilde_expand (filename
);
228 make_cleanup (free
, filename
);
230 if (have_inferior_p ())
231 error ("To look at a core file, you must kill the inferior with \"kill\".");
232 corechan
= open (filename
, O_RDONLY
, 0);
234 perror_with_name (filename
);
235 /* 4.2-style (and perhaps also sysV-style) core dump file. */
239 unsigned int reg_offset
;
241 val
= myread (corechan
, &u
, sizeof u
);
243 perror_with_name ("Not a core file: reading upage");
245 error ("Not a core file: could only read %d bytes", val
);
246 data_start
= exec_data_start
;
248 data_end
= data_start
+ NBPG
* u
.u_dsize
;
249 data_offset
= NBPG
* UPAGES
;
250 stack_offset
= NBPG
* (UPAGES
+ u
.u_dsize
);
252 /* find registers in core file */
253 #ifdef PYRAMID_PTRACE
254 stack_start
= stack_end
- NBPG
* u
.u_ussize
;
255 reg_stack_offset
= stack_offset
+ (NBPG
*u
.u_ussize
);
256 reg_stack_end
= reg_stack_start
+ NBPG
* u
.u_cssize
;
258 last_frame_address
= ((int) u
.u_pcb
.pcb_csp
);
259 last_frame_offset
= reg_stack_offset
+ last_frame_address
260 - CONTROL_STACK_ADDR
;
261 global_reg_offset
= (char *)&u
- (char *)&u
.u_pcb
.pcb_gr0
;
263 /* skip any control-stack frames that were executed in the
268 val
= lseek (corechan
, last_frame_offset
+(47*4), 0);
270 perror_with_name (filename
);
271 val
= myread (corechan
, buf
, sizeof buf
);
273 perror_with_name (filename
);
275 if (*(int *)buf
>= 0)
277 printf ("skipping frame %s\n", local_hex_string (last_frame_address
));
278 last_frame_offset
-= CONTROL_STACK_FRAME_SIZE
;
279 last_frame_address
-= CONTROL_STACK_FRAME_SIZE
;
281 reg_offset
= last_frame_offset
;
283 #if 1 || defined(PYRAMID_CONTROL_FRAME_DEBUGGING)
284 printf ("Control stack pointer = %s\n",
285 local_hex_string (u
.u_pcb
.pcb_csp
));
286 printf ("offset to control stack %d outermost frame %d (%s)\n",
287 reg_stack_offset
, reg_offset
, local_hex_string (last_frame_address
));
288 #endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
290 #else /* not PYRAMID_CORE */
291 stack_start
= stack_end
- NBPG
* u
.u_ssize
;
292 reg_offset
= (int) u
.u_ar0
- KERNEL_U_ADDR
;
293 #endif /* not PYRAMID_CORE */
295 #ifdef __not_on_pyr_yet
296 /* Some machines put an absolute address in here and some put
297 the offset in the upage of the regs. */
298 reg_offset
= (int) u
.u_ar0
;
299 if (reg_offset
> NBPG
* UPAGES
)
300 reg_offset
-= KERNEL_U_ADDR
;
303 /* I don't know where to find this info.
304 So, for now, mark it as not available. */
305 N_SET_MAGIC (core_aouthdr
, 0);
307 /* Read the register values out of the core file and store
308 them where `read_register' will find them. */
313 for (regno
= 0; regno
< 64; regno
++)
315 char buf
[MAX_REGISTER_RAW_SIZE
];
317 val
= lseek (corechan
, register_addr (regno
, reg_offset
), 0);
319 || (val
= myread (corechan
, buf
, sizeof buf
)) < 0)
321 char * buffer
= (char *) alloca (strlen (reg_names
[regno
])
323 strcpy (buffer
, "Reading register ");
324 strcat (buffer
, reg_names
[regno
]);
326 perror_with_name (buffer
);
330 perror_with_name (filename
);
331 #ifdef PYRAMID_CONTROL_FRAME_DEBUGGING
332 printf ("[reg %s(%d), offset in file %s=0x%0x, addr =0x%0x, =%0x]\n",
333 reg_names
[regno
], regno
, filename
,
334 register_addr(regno
, reg_offset
),
335 regno
* 4 + last_frame_address
,
337 #endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */
338 supply_register (regno
, buf
);
342 if (filename
[0] == '/')
343 corefile
= savestring (filename
, strlen (filename
));
346 corefile
= concat (current_directory
, "/", filename
, NULL
);
349 #if 1 || defined(PYRAMID_CONTROL_FRAME_DEBUGGING)
350 printf ("Providing CSP (%s) as nominal address of current frame.\n",
351 local_hex_string(last_frame_address
));
352 #endif PYRAMID_CONTROL_FRAME_DEBUGGING
353 /* FIXME: Which of the following is correct? */
355 set_current_frame ( create_new_frame (read_register (FP_REGNUM
),
358 set_current_frame ( create_new_frame (last_frame_address
,
362 select_frame (get_current_frame (), 0);
366 printf ("No core file now.\n");