![[BACK]](/icons/back.gif){kind=icon}
Return to db_run.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ddb|
Return to db_run.c CVS log | Up to [local] / sys / ddb |
1.1 nbrk 1: /* $OpenBSD: db_run.c,v 1.19 2006/03/13 06:23:20 jsg Exp $ */
2: /* $NetBSD: db_run.c,v 1.8 1996/02/05 01:57:12 christos Exp $ */
3:
4: /*
5: * Mach Operating System
6: * Copyright (c) 1993,1992,1991,1990 Carnegie Mellon University
7: * All Rights Reserved.
8: *
9: * Permission to use, copy, modify and distribute this software and its
10: * documentation is hereby granted, provided that both the copyright
11: * notice and this permission notice appear in all copies of the
12: * software, derivative works or modified versions, and any portions
13: * thereof, and that both notices appear in supporting documentation.
14: *
15: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
16: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
17: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
18: *
19: * Carnegie Mellon requests users of this software to return to
20: *
21: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
22: * School of Computer Science
23: * Carnegie Mellon University
24: * Pittsburgh PA 15213-3890
25: *
26: * any improvements or extensions that they make and grant Carnegie Mellon
27: * the rights to redistribute these changes.
28: *
29: * Author: David B. Golub, Carnegie Mellon University
30: * Date: 7/90
31: */
32:
33: /*
34: * Commands to run process.
35: */
36: #include <sys/param.h>
37: #include <sys/proc.h>
38:
39: #include <uvm/uvm_extern.h>
40:
41: #include <machine/db_machdep.h>
42:
43: #include <ddb/db_run.h>
44: #include <ddb/db_break.h>
45: #include <ddb/db_access.h>
46:
47: #ifdef SOFTWARE_SSTEP
48: db_breakpoint_t db_not_taken_bkpt = 0;
49: db_breakpoint_t db_taken_bkpt = 0;
50: #endif
51:
52: int db_inst_count;
53: int db_load_count;
54: int db_store_count;
55:
56: #ifndef KGDB
57:
58: #include <ddb/db_lex.h>
59: #include <ddb/db_watch.h>
60: #include <ddb/db_output.h>
61: #include <ddb/db_sym.h>
62: #include <ddb/db_extern.h>
63:
64: int db_run_mode;
65: #define STEP_NONE 0
66: #define STEP_ONCE 1
67: #define STEP_RETURN 2
68: #define STEP_CALLT 3
69: #define STEP_CONTINUE 4
70: #define STEP_INVISIBLE 5
71: #define STEP_COUNT 6
72:
73: boolean_t db_sstep_print;
74: int db_loop_count;
75: int db_call_depth;
76:
77: boolean_t
78: db_stop_at_pc(db_regs_t *regs, boolean_t *is_breakpoint)
79: {
80: db_addr_t pc, old_pc;
81: db_breakpoint_t bkpt;
82:
83: db_clear_breakpoints();
84: db_clear_watchpoints();
85: old_pc = pc = PC_REGS(regs);
86:
87: #ifdef FIXUP_PC_AFTER_BREAK
88: if (*is_breakpoint) {
89: /*
90: * Breakpoint trap. Fix up the PC if the
91: * machine requires it.
92: */
93: FIXUP_PC_AFTER_BREAK(regs);
94: pc = PC_REGS(regs);
95: }
96: #endif
97:
98: /*
99: * Now check for a breakpoint at this address.
100: */
101: bkpt = db_find_breakpoint_here(pc);
102: if (bkpt) {
103: if (--bkpt->count == 0) {
104: db_clear_single_step(regs);
105: bkpt->count = bkpt->init_count;
106: *is_breakpoint = TRUE;
107: return (TRUE); /* stop here */
108: }
109: } else if (*is_breakpoint
110: #ifdef SOFTWARE_SSTEP
111: && !((db_taken_bkpt && db_taken_bkpt->address == pc) ||
112: (db_not_taken_bkpt && db_not_taken_bkpt->address == pc))
113: #endif
114: ) {
115: #ifdef PC_ADVANCE
116: PC_ADVANCE(regs);
117: #else
118: # ifdef SET_PC_REGS
119: SET_PC_REGS(regs, old_pc);
120: # else
121: PC_REGS(regs) = old_pc;
122: # endif
123: #endif
124: }
125: db_clear_single_step(regs);
126:
127: *is_breakpoint = FALSE;
128:
129: if (db_run_mode == STEP_INVISIBLE) {
130: db_run_mode = STEP_CONTINUE;
131: return (FALSE); /* continue */
132: }
133: if (db_run_mode == STEP_COUNT) {
134: return (FALSE); /* continue */
135: }
136: if (db_run_mode == STEP_ONCE) {
137: if (--db_loop_count > 0) {
138: if (db_sstep_print) {
139: db_printf("\t\t");
140: db_print_loc_and_inst(pc);
141: db_printf("\n");
142: }
143: return (FALSE); /* continue */
144: }
145: }
146: if (db_run_mode == STEP_RETURN) {
147: db_expr_t ins = db_get_value(pc, sizeof(int), FALSE);
148:
149: /* continue until matching return */
150:
151: if (!inst_trap_return(ins) &&
152: (!inst_return(ins) || --db_call_depth != 0)) {
153: if (db_sstep_print) {
154: if (inst_call(ins) || inst_return(ins)) {
155: int i;
156:
157: db_printf("[after %6d] ", db_inst_count);
158: for (i = db_call_depth; --i > 0; )
159: db_printf(" ");
160: db_print_loc_and_inst(pc);
161: db_printf("\n");
162: }
163: }
164: if (inst_call(ins))
165: db_call_depth++;
166: return (FALSE); /* continue */
167: }
168: }
169: if (db_run_mode == STEP_CALLT) {
170: db_expr_t ins = db_get_value(pc, sizeof(int), FALSE);
171:
172: /* continue until call or return */
173:
174: if (!inst_call(ins) && !inst_return(ins) &&
175: !inst_trap_return(ins)) {
176: return (FALSE); /* continue */
177: }
178: }
179: db_run_mode = STEP_NONE;
180: return (TRUE);
181: }
182:
183: void
184: db_restart_at_pc(db_regs_t *regs, boolean_t watchpt)
185: {
186: db_addr_t pc = PC_REGS(regs);
187:
188: if ((db_run_mode == STEP_COUNT) || (db_run_mode == STEP_RETURN) ||
189: (db_run_mode == STEP_CALLT)) {
190: db_expr_t ins;
191:
192: /*
193: * We are about to execute this instruction,
194: * so count it now.
195: */
196: ins = db_get_value(pc, sizeof(int), FALSE);
197: db_inst_count++;
198: db_load_count += inst_load(ins);
199: db_store_count += inst_store(ins);
200: #ifdef SOFTWARE_SSTEP
201: /* XXX works on mips, but... */
202: if (inst_branch(ins) || inst_call(ins)) {
203: ins = db_get_value(next_instr_address(pc, 1),
204: sizeof(int), FALSE);
205: db_inst_count++;
206: db_load_count += inst_load(ins);
207: db_store_count += inst_store(ins);
208: }
209: #endif /* SOFTWARE_SSTEP */
210: }
211:
212: if (db_run_mode == STEP_CONTINUE) {
213: if (watchpt || db_find_breakpoint_here(pc)) {
214: /*
215: * Step over breakpoint/watchpoint.
216: */
217: db_run_mode = STEP_INVISIBLE;
218: db_set_single_step(regs);
219: } else {
220: db_set_breakpoints();
221: db_set_watchpoints();
222: }
223: } else {
224: db_set_single_step(regs);
225: }
226: }
227:
228: void
229: db_single_step(db_regs_t *regs)
230: {
231: if (db_run_mode == STEP_CONTINUE) {
232: db_run_mode = STEP_INVISIBLE;
233: db_set_single_step(regs);
234: }
235: }
236:
237: extern int db_cmd_loop_done;
238:
239: /* single-step */
240: /*ARGSUSED*/
241: void
242: db_single_step_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
243: {
244: boolean_t print = FALSE;
245:
246: if (count == -1)
247: count = 1;
248:
249: if (modif[0] == 'p')
250: print = TRUE;
251:
252: db_run_mode = STEP_ONCE;
253: db_loop_count = count;
254: db_sstep_print = print;
255: db_inst_count = 0;
256: db_load_count = 0;
257: db_store_count = 0;
258:
259: db_cmd_loop_done = 1;
260: }
261:
262: /* trace and print until call/return */
263: /*ARGSUSED*/
264: void
265: db_trace_until_call_cmd(db_expr_t addr, int have_addr, db_expr_t count,
266: char *modif)
267: {
268: boolean_t print = FALSE;
269:
270: if (modif[0] == 'p')
271: print = TRUE;
272:
273: db_run_mode = STEP_CALLT;
274: db_sstep_print = print;
275: db_inst_count = 0;
276: db_load_count = 0;
277: db_store_count = 0;
278:
279: db_cmd_loop_done = 1;
280: }
281:
282: /*ARGSUSED*/
283: void
284: db_trace_until_matching_cmd(db_expr_t addr, int have_addr, db_expr_t count,
285: char *modif)
286: {
287: boolean_t print = FALSE;
288:
289: if (modif[0] == 'p')
290: print = TRUE;
291:
292: db_run_mode = STEP_RETURN;
293: db_call_depth = 1;
294: db_sstep_print = print;
295: db_inst_count = 0;
296: db_load_count = 0;
297: db_store_count = 0;
298:
299: db_cmd_loop_done = 1;
300: }
301:
302: /* continue */
303: /*ARGSUSED*/
304: void
305: db_continue_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
306: {
307: if (modif[0] == 'c')
308: db_run_mode = STEP_COUNT;
309: else
310: db_run_mode = STEP_CONTINUE;
311: db_inst_count = 0;
312: db_load_count = 0;
313: db_store_count = 0;
314:
315: db_cmd_loop_done = 1;
316: }
317: #endif /* NO KGDB */
318:
319: #ifdef SOFTWARE_SSTEP
320: /*
321: * Software implementation of single-stepping.
322: * If your machine does not have a trace mode
323: * similar to the vax or sun ones you can use
324: * this implementation, done for the mips.
325: * Just define the above conditional and provide
326: * the functions/macros defined below.
327: *
328: * extern boolean_t
329: * inst_branch(ins), returns true if the instruction might branch
330: * extern unsigned
331: * branch_taken(ins, pc, getreg_val, regs),
332: * return the address the instruction might
333: * branch to
334: * getreg_val(regs, reg), return the value of a user register,
335: * as indicated in the hardware instruction
336: * encoding, e.g. 8 for r8
337: *
338: * next_instr_address(pc, bd) returns the address of the first
339: * instruction following the one at "pc",
340: * which is either in the taken path of
341: * the branch (bd==1) or not. This is
342: * for machines (mips) with branch delays.
343: *
344: * A single-step may involve at most 2 breakpoints -
345: * one for branch-not-taken and one for branch taken.
346: * If one of these addresses does not already have a breakpoint,
347: * we allocate a breakpoint and save it here.
348: * These breakpoints are deleted on return.
349: */
350:
351: void
352: db_set_single_step(db_regs_t *regs)
353: {
354: db_addr_t pc = PC_REGS(regs);
355: #ifndef SOFTWARE_SSTEP_EMUL
356: db_addr_t brpc;
357: u_int inst;
358:
359: /*
360: * User was stopped at pc, e.g. the instruction
361: * at pc was not executed.
362: */
363: inst = db_get_value(pc, sizeof(int), FALSE);
364: if (inst_branch(inst) || inst_call(inst) || inst_return(inst)) {
365: brpc = branch_taken(inst, pc, getreg_val, regs);
366: if (brpc != pc) { /* self-branches are hopeless */
367: db_taken_bkpt = db_set_temp_breakpoint(brpc);
368: }
369: #if 0
370: /* XXX this seems like a true bug, no? */
371: pc = next_instr_address(pc, 1);
372: #endif
373: }
374: #endif /*SOFTWARE_SSTEP_EMUL*/
375: pc = next_instr_address(pc, 0);
376: db_not_taken_bkpt = db_set_temp_breakpoint(pc);
377: }
378:
379: void
380: db_clear_single_step(db_regs_t *regs)
381: {
382: if (db_taken_bkpt != 0) {
383: db_delete_temp_breakpoint(db_taken_bkpt);
384: db_taken_bkpt = 0;
385: }
386: if (db_not_taken_bkpt != 0) {
387: db_delete_temp_breakpoint(db_not_taken_bkpt);
388: db_not_taken_bkpt = 0;
389: }
390: }
391:
392: #endif /* SOFTWARE_SSTEP */