[apple/xnu.git] / osfmk / ddb / db_run.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 * 	Author: David B. Golub, Carnegie Mellon University
 *	Date:	7/90
 */

/*
 * Commands to run process.
 */
#include <mach/boolean.h>
#include <machine/db_machdep.h>

#include <ddb/db_lex.h>
#include <ddb/db_break.h>
#include <ddb/db_access.h>
#include <ddb/db_run.h>
#include <ddb/db_cond.h>
#include <ddb/db_examine.h>
#include <ddb/db_output.h>		/* For db_printf() */
#include <ddb/db_watch.h>
#include <kern/misc_protos.h>
#include <kern/debug.h>

boolean_t	db_sstep_print;
int		db_loop_count;
int		db_call_depth;

int		db_inst_count;
int		db_last_inst_count;
int		db_load_count;
int		db_store_count;
int		db_max_inst_count = 1000;

#ifndef db_set_single_step
void db_set_task_single_step(
	register db_regs_t	*regs,
	task_t		   	task);
#else
#define	db_set_task_single_step(regs,task)	db_set_single_step(regs)
#endif
#ifndef db_clear_single_step
void db_clear_task_single_step(
	db_regs_t	*regs,
	task_t	  	task);
#else
#define db_clear_task_single_step(regs,task)	db_clear_single_step(regs)
#endif

extern jmp_buf_t *db_recover;
boolean_t db_step_again(void);

boolean_t
db_stop_at_pc(
	boolean_t	*is_breakpoint,
	task_t		task,
	task_t		space)
{
	register  db_addr_t	pc;
	register  db_thread_breakpoint_t bkpt;

	db_clear_task_single_step(DDB_REGS, space);
	db_clear_breakpoints();
	db_clear_watchpoints();
	pc = PC_REGS(DDB_REGS);

#ifdef	FIXUP_PC_AFTER_BREAK
	if (*is_breakpoint) {
	    /*
	     * Breakpoint trap.  Fix up the PC if the
	     * machine requires it.
	     */
	    FIXUP_PC_AFTER_BREAK
	    pc = PC_REGS(DDB_REGS);
	}
#endif

	/*
	 * Now check for a breakpoint at this address.
	 */
	bkpt = db_find_thread_breakpoint_here(space, pc);
	if (bkpt) {
	    if (db_cond_check(bkpt)) {
		*is_breakpoint = TRUE;
		return (TRUE);	/* stop here */
	    }
	}
	*is_breakpoint = FALSE;

	if (db_run_mode == STEP_INVISIBLE) {
	    db_run_mode = STEP_CONTINUE;
	    return (FALSE);	/* continue */
	}
	if (db_run_mode == STEP_COUNT) {
	    return (FALSE); /* continue */
	}
	if (db_run_mode == STEP_ONCE) {
	    if (--db_loop_count > 0) {
		if (db_sstep_print) {
		    db_print_loc_and_inst(pc, task);
		}
		return (FALSE);	/* continue */
	    }
	}
	if (db_run_mode == STEP_RETURN) {
	    jmp_buf_t *prev;
	    jmp_buf_t db_jmpbuf;
	    /* WARNING: the following assumes an instruction fits an int */
	    db_expr_t ins = db_get_task_value(pc, sizeof(int), FALSE, space);

	    /* continue until matching return */

	    prev = db_recover;
	    if (_setjmp(db_recover = &db_jmpbuf) == 0) {
	    	if (!inst_trap_return(ins) &&
		    (!inst_return(ins) || --db_call_depth != 0)) {
			if (db_sstep_print) {
		    	    if (inst_call(ins) || inst_return(ins)) {
				register int i;

				db_printf("[after %6d /%4d] ",
					  db_inst_count,
					  db_inst_count - db_last_inst_count);
				db_last_inst_count = db_inst_count;
				for (i = db_call_depth; --i > 0; )
				    db_printf("  ");
				db_print_loc_and_inst(pc, task);
				db_printf("\n");
		    	    }
		        }
			if (inst_call(ins))
			    db_call_depth++;
			db_recover = prev;
			if (db_step_again())
				return (FALSE);	/* continue */
	        }
	    }
	    db_recover = prev;
	}
	if (db_run_mode == STEP_CALLT) {
	    /* WARNING: the following assumes an instruction fits an int */
	    db_expr_t ins = db_get_task_value(pc, sizeof(int), FALSE, space);

	    /* continue until call or return */

	    if (!inst_call(ins) &&
		!inst_return(ins) &&
		!inst_trap_return(ins)) {
			if (db_step_again())
				return (FALSE);	/* continue */
	    }
	}
	if (db_find_breakpoint_here(space, pc))
		return(FALSE);
	db_run_mode = STEP_NONE;
	return (TRUE);
}

void
db_restart_at_pc(
	boolean_t	watchpt,
	task_t	  	task)
{
	register db_addr_t pc = PC_REGS(DDB_REGS), brpc;

	if ((db_run_mode == STEP_COUNT) ||
	    (db_run_mode == STEP_RETURN) ||
	    (db_run_mode == STEP_CALLT)) {
	    db_expr_t		ins;

	    /*
	     * We are about to execute this instruction,
	     * so count it now.
	     */

	    ins = db_get_task_value(pc, sizeof(int), FALSE, task);
	    db_inst_count++;
	    db_load_count += db_inst_load(ins);
	    db_store_count += db_inst_store(ins);
#ifdef	SOFTWARE_SSTEP
	    /* Account for instructions in delay slots */
	    brpc = next_instr_address(pc,1,task);
	    if ((brpc != pc) && (inst_branch(ins) || inst_call(ins))) {
		/* Note: this ~assumes an instruction <= sizeof(int) */
		ins = db_get_task_value(brpc, sizeof(int), FALSE, task);
		db_inst_count++;
		db_load_count += db_inst_load(ins);
		db_store_count += db_inst_store(ins);
	    }
#endif	/* SOFTWARE_SSTEP */
	}

	if (db_run_mode == STEP_CONTINUE) {
	    if (watchpt || db_find_breakpoint_here(task, pc)) {
		/*
		 * Step over breakpoint/watchpoint.
		 */
		db_run_mode = STEP_INVISIBLE;
		db_set_task_single_step(DDB_REGS, task);
	    } else {
		db_set_breakpoints();
		db_set_watchpoints();
	    }
	} else {
	    db_set_task_single_step(DDB_REGS, task);
	}
}

/*
 * 'n' and 'u' commands might never return.
 * Limit the maximum number of steps.
 */

boolean_t
db_step_again(void)
{
	if (db_inst_count && !(db_inst_count%db_max_inst_count)) {
		char c;
		db_printf("%d instructions, continue ? (y/n) ",
			  db_inst_count);
	        c = cngetc();
		db_printf("\n");
		if(c == 'n')
			return(FALSE);
	}
	return(TRUE);
}

void
db_single_step(
	db_regs_t	*regs,
	task_t	  	task)
{
	if (db_run_mode == STEP_CONTINUE) {
	    db_run_mode = STEP_INVISIBLE;
	    db_set_task_single_step(regs, task);
	}
}

#ifdef	SOFTWARE_SSTEP
/*
 *	Software implementation of single-stepping.
 *	If your machine does not have a trace mode
 *	similar to the vax or sun ones you can use
 *	this implementation, done for the mips.
 *	Just define the above conditional and provide
 *	the functions/macros defined below.
 *
 * extern boolean_t
 *	inst_branch(),		returns true if the instruction might branch
 * extern unsigned
 *	branch_taken(),		return the address the instruction might
 *				branch to
 *	db_getreg_val();	return the value of a user register,
 *				as indicated in the hardware instruction
 *				encoding, e.g. 8 for r8
 *			
 * next_instr_address(pc,bd,task) returns the address of the first
 *				instruction following the one at "pc",
 *				which is either in the taken path of
 *				the branch (bd==1) or not.  This is
 *				for machines (mips) with branch delays.
 *
 *	A single-step may involve at most 2 breakpoints -
 *	one for branch-not-taken and one for branch taken.
 *	If one of these addresses does not already have a breakpoint,
 *	we allocate a breakpoint and save it here.
 *	These breakpoints are deleted on return.
 */			
db_breakpoint_t	db_not_taken_bkpt = 0;
db_breakpoint_t	db_taken_bkpt = 0;

db_breakpoint_t
db_find_temp_breakpoint(
	task_t		   task,
	db_addr_t	   addr)
{
	if (db_taken_bkpt && (db_taken_bkpt->address == addr) &&
	    db_taken_bkpt->task == task)
		return db_taken_bkpt;
	if (db_not_taken_bkpt && (db_not_taken_bkpt->address == addr) &&
	    db_not_taken_bkpt->task == task)
		return db_not_taken_bkpt;
	return 0;
}

void
db_set_task_single_step(
	register db_regs_t	*regs,
	task_t		   	task)
{
	db_addr_t pc = PC_REGS(regs), brpc;
	register unsigned int	 inst;
	register boolean_t       unconditional;

	/*
	 *	User was stopped at pc, e.g. the instruction
	 *	at pc was not executed.
	 */
	inst = db_get_task_value(pc, sizeof(int), FALSE, task);
	if (inst_branch(inst) || inst_call(inst)) {
	    extern db_expr_t getreg_val();	/* XXX -- need prototype! */

	    brpc = branch_taken(inst, pc, getreg_val, (unsigned char*)regs);
	    if (brpc != pc) {	/* self-branches are hopeless */
		db_taken_bkpt = db_set_temp_breakpoint(task, brpc);
	    } else
	        db_taken_bkpt = 0;
	    pc = next_instr_address(pc,1,task);
	} else 
	    pc = next_instr_address(pc,0,task);
	
	/* 
	 * check if this control flow instruction is an
	 * unconditional transfer
	 */

	unconditional = inst_unconditional_flow_transfer(inst);

	/* 
	  We only set the sequential breakpoint if previous instruction was not
	  an unconditional change of flow of control. If the previous instruction
	  is an unconditional change of flow of control, setting a breakpoint in the
	  next sequential location may set a breakpoint in data or in another routine,
	  which could screw up either the program or the debugger. 
	  (Consider, for instance, that the next sequential instruction is the 
	  start of a routine needed by the debugger.)
	*/
	if (!unconditional && db_find_breakpoint_here(task, pc) == 0 &&
	    (db_taken_bkpt == 0 || db_taken_bkpt->address != pc)) {
	    	db_not_taken_bkpt = db_set_temp_breakpoint(task, pc);
	} else
	    	db_not_taken_bkpt = 0;
}

void
db_clear_task_single_step(
	db_regs_t	*regs,
	task_t	  	task)
{
	if (db_taken_bkpt != 0) {
	    db_delete_temp_breakpoint(task, db_taken_bkpt);
	    db_taken_bkpt = 0;
	}
	if (db_not_taken_bkpt != 0) {
	    db_delete_temp_breakpoint(task, db_not_taken_bkpt);
	    db_not_taken_bkpt = 0;
	}
}

#endif	/* SOFTWARE_SSTEP */

extern int	db_cmd_loop_done;

/* single-step */
void
db_single_step_cmd(
	db_expr_t	addr,
	int		have_addr,
	db_expr_t	count,
	char *		modif)
{
	boolean_t	print = FALSE;

	if (count == -1)
	    count = 1;

	if (modif[0] == 'p')
	    print = TRUE;

	db_run_mode = STEP_ONCE;
	db_loop_count = count;
	db_sstep_print = print;
	db_inst_count = 0;
	db_last_inst_count = 0;
	db_load_count = 0;
	db_store_count = 0;

	db_cmd_loop_done = 1;
}

/* trace and print until call/return */
void
db_trace_until_call_cmd(
	db_expr_t	addr,
	int		have_addr,
	db_expr_t	count,
	char *		modif)
{
	boolean_t	print = FALSE;

	if (modif[0] == 'p')
	    print = TRUE;

	db_run_mode = STEP_CALLT;
	db_sstep_print = print;
	db_inst_count = 0;
	db_last_inst_count = 0;
	db_load_count = 0;
	db_store_count = 0;

	db_cmd_loop_done = 1;
}

void
db_trace_until_matching_cmd(
	db_expr_t	addr,
	int		have_addr,
	db_expr_t	count,
	char *		modif)
{
	boolean_t	print = FALSE;

	if (modif[0] == 'p')
	    print = TRUE;

	db_run_mode = STEP_RETURN;
	db_call_depth = 1;
	db_sstep_print = print;
	db_inst_count = 0;
	db_last_inst_count = 0;
	db_load_count = 0;
	db_store_count = 0;

	db_cmd_loop_done = 1;
}

/* continue */
void
db_continue_cmd(
	db_expr_t	addr,
	int		have_addr,
	db_expr_t	count,
	char *		modif)
{
	/*
	 * Though "cont/c" works fairly well, it's not really robust
	 * enough to use in arbitrary situations, so disable it.
	 * (Doesn't seem cost-effective to debug and fix what ails
	 * it.)
	 */
#if 0
	if (modif[0] == 'c')
	    db_run_mode = STEP_COUNT;
	else
	    db_run_mode = STEP_CONTINUE;
#else
	db_run_mode = STEP_CONTINUE;
#endif
	db_inst_count = 0;
	db_last_inst_count = 0;
	db_load_count = 0;
	db_store_count = 0;

	db_cmd_loop_done = 1;
}

/* gdb */
void    
db_continue_gdb(
	db_expr_t	addr, 
	int		have_addr,
	db_expr_t	count,   
	char *		modif)
{
#if defined(__ppc__)
	db_to_gdb();
#endif
	db_run_mode = STEP_CONTINUE;
	db_inst_count = 0;
	db_last_inst_count = 0;   
	db_load_count = 0;
	db_store_count = 0;  

	db_cmd_loop_done = 1;
}
        

boolean_t
db_in_single_step(void)
{
	return(db_run_mode != STEP_NONE && db_run_mode != STEP_CONTINUE);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
de355530 A	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
de355530 A	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* Mach Operating System
	27	* Copyright (c) 1991,1990 Carnegie Mellon University
	28	* All Rights Reserved.
	29	*
	30	* Permission to use, copy, modify and distribute this software and its
	31	* documentation is hereby granted, provided that both the copyright
	32	* notice and this permission notice appear in all copies of the
	33	* software, derivative works or modified versions, and any portions
	34	* thereof, and that both notices appear in supporting documentation.
	35	*
	36	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	37	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	38	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	39	*
	40	* Carnegie Mellon requests users of this software to return to
	41	*
	42	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	43	* School of Computer Science
	44	* Carnegie Mellon University
	45	* Pittsburgh PA 15213-3890
	46	*
	47	* any improvements or extensions that they make and grant Carnegie Mellon
	48	* the rights to redistribute these changes.
	49	*/
	50	/*
	51	*/
	52	/*
	53	* Author: David B. Golub, Carnegie Mellon University
	54	* Date: 7/90
	55	*/
	56
	57	/*
	58	* Commands to run process.
	59	*/
	60	#include <mach/boolean.h>
	61	#include <machine/db_machdep.h>
	62
	63	#include <ddb/db_lex.h>
	64	#include <ddb/db_break.h>
	65	#include <ddb/db_access.h>
	66	#include <ddb/db_run.h>
	67	#include <ddb/db_cond.h>
	68	#include <ddb/db_examine.h>
	69	#include <ddb/db_output.h> /* For db_printf() */
	70	#include <ddb/db_watch.h>
	71	#include <kern/misc_protos.h>
	72	#include <kern/debug.h>
	73
	74	boolean_t db_sstep_print;
	75	int db_loop_count;
	76	int db_call_depth;
	77
	78	int db_inst_count;
	79	int db_last_inst_count;
	80	int db_load_count;
	81	int db_store_count;
	82	int db_max_inst_count = 1000;
83
84	#ifndef db_set_single_step
85	void db_set_task_single_step(
86	register db_regs_t *regs,
87	task_t task);
88	#else
89	#define db_set_task_single_step(regs,task) db_set_single_step(regs)
90	#endif
91	#ifndef db_clear_single_step
92	void db_clear_task_single_step(
93	db_regs_t *regs,
94	task_t task);
95	#else
96	#define db_clear_task_single_step(regs,task) db_clear_single_step(regs)
97	#endif
98
99	extern jmp_buf_t *db_recover;
100	boolean_t db_step_again(void);
101
102	boolean_t
103	db_stop_at_pc(
104	boolean_t *is_breakpoint,
105	task_t task,
106	task_t space)
107	{
108	register db_addr_t pc;
109	register db_thread_breakpoint_t bkpt;
110
111	db_clear_task_single_step(DDB_REGS, space);
112	db_clear_breakpoints();
113	db_clear_watchpoints();
114	pc = PC_REGS(DDB_REGS);
115
116	#ifdef FIXUP_PC_AFTER_BREAK
117	if (*is_breakpoint) {
118	/*
119	* Breakpoint trap. Fix up the PC if the
120	* machine requires it.
121	*/
122	FIXUP_PC_AFTER_BREAK
123	pc = PC_REGS(DDB_REGS);
124	}
125	#endif
126
127	/*
128	* Now check for a breakpoint at this address.
129	*/
130	bkpt = db_find_thread_breakpoint_here(space, pc);
131	if (bkpt) {
132	if (db_cond_check(bkpt)) {
133	*is_breakpoint = TRUE;
134	return (TRUE); /* stop here */
135	}
136	}
137	*is_breakpoint = FALSE;
138
139	if (db_run_mode == STEP_INVISIBLE) {
140	db_run_mode = STEP_CONTINUE;
141	return (FALSE); /* continue */
142	}
143	if (db_run_mode == STEP_COUNT) {
144	return (FALSE); /* continue */
145	}
146	if (db_run_mode == STEP_ONCE) {
147	if (--db_loop_count > 0) {
148	if (db_sstep_print) {
149	db_print_loc_and_inst(pc, task);
150	}
151	return (FALSE); /* continue */
152	}
153	}
154	if (db_run_mode == STEP_RETURN) {
155	jmp_buf_t *prev;
156	jmp_buf_t db_jmpbuf;
157	/* WARNING: the following assumes an instruction fits an int */
158	db_expr_t ins = db_get_task_value(pc, sizeof(int), FALSE, space);
159
160	/* continue until matching return */
161
162	prev = db_recover;
163	if (_setjmp(db_recover = &db_jmpbuf) == 0) {
164	if (!inst_trap_return(ins) &&
165	(!inst_return(ins) \|\| --db_call_depth != 0)) {
166	if (db_sstep_print) {
167	if (inst_call(ins) \|\| inst_return(ins)) {
168	register int i;
169
170	db_printf("[after %6d /%4d] ",
171	db_inst_count,
172	db_inst_count - db_last_inst_count);
173	db_last_inst_count = db_inst_count;
174	for (i = db_call_depth; --i > 0; )
175	db_printf(" ");
176	db_print_loc_and_inst(pc, task);
177	db_printf("\n");
178	}
179	}
180	if (inst_call(ins))
181	db_call_depth++;
182	db_recover = prev;
183	if (db_step_again())
184	return (FALSE); /* continue */
185	}
186	}
187	db_recover = prev;
188	}
189	if (db_run_mode == STEP_CALLT) {
190	/* WARNING: the following assumes an instruction fits an int */
191	db_expr_t ins = db_get_task_value(pc, sizeof(int), FALSE, space);
192
193	/* continue until call or return */
194
195	if (!inst_call(ins) &&
196	!inst_return(ins) &&
197	!inst_trap_return(ins)) {
198	if (db_step_again())
199	return (FALSE); /* continue */
200	}
201	}
202	if (db_find_breakpoint_here(space, pc))
203	return(FALSE);
204	db_run_mode = STEP_NONE;
205	return (TRUE);
206	}
207
208	void
209	db_restart_at_pc(
210	boolean_t watchpt,
211	task_t task)
212	{
213	register db_addr_t pc = PC_REGS(DDB_REGS), brpc;
214
215	if ((db_run_mode == STEP_COUNT) \|\|
216	(db_run_mode == STEP_RETURN) \|\|
217	(db_run_mode == STEP_CALLT)) {
218	db_expr_t ins;
219
220	/*
221	* We are about to execute this instruction,
222	* so count it now.
223	*/
224
225	ins = db_get_task_value(pc, sizeof(int), FALSE, task);
226	db_inst_count++;
227	db_load_count += db_inst_load(ins);
228	db_store_count += db_inst_store(ins);
229	#ifdef SOFTWARE_SSTEP
230	/* Account for instructions in delay slots */
231	brpc = next_instr_address(pc,1,task);
232	if ((brpc != pc) && (inst_branch(ins) \|\| inst_call(ins))) {
233	/* Note: this ~assumes an instruction <= sizeof(int) */
234	ins = db_get_task_value(brpc, sizeof(int), FALSE, task);
235	db_inst_count++;
236	db_load_count += db_inst_load(ins);
237	db_store_count += db_inst_store(ins);
238	}
239	#endif /* SOFTWARE_SSTEP */
240	}
241
242	if (db_run_mode == STEP_CONTINUE) {
243	if (watchpt \|\| db_find_breakpoint_here(task, pc)) {
244	/*
245	* Step over breakpoint/watchpoint.
246	*/
247	db_run_mode = STEP_INVISIBLE;
248	db_set_task_single_step(DDB_REGS, task);
249	} else {
250	db_set_breakpoints();
251	db_set_watchpoints();
252	}
253	} else {
254	db_set_task_single_step(DDB_REGS, task);
255	}
256	}
257
258	/*
259	* 'n' and 'u' commands might never return.
260	* Limit the maximum number of steps.
261	*/
262
263	boolean_t
264	db_step_again(void)
265	{
266	if (db_inst_count && !(db_inst_count%db_max_inst_count)) {
267	char c;
268	db_printf("%d instructions, continue ? (y/n) ",
269	db_inst_count);
270	c = cngetc();
271	db_printf("\n");
272	if(c == 'n')
273	return(FALSE);
274	}
275	return(TRUE);
276	}
277
278	void
279	db_single_step(
280	db_regs_t *regs,
281	task_t task)
282	{
283	if (db_run_mode == STEP_CONTINUE) {
284	db_run_mode = STEP_INVISIBLE;
285	db_set_task_single_step(regs, task);
286	}
287	}
288
289	#ifdef SOFTWARE_SSTEP
290	/*
291	* Software implementation of single-stepping.
292	* If your machine does not have a trace mode
293	* similar to the vax or sun ones you can use
294	* this implementation, done for the mips.
295	* Just define the above conditional and provide
296	* the functions/macros defined below.
297	*
298	* extern boolean_t
299	* inst_branch(), returns true if the instruction might branch
300	* extern unsigned
301	* branch_taken(), return the address the instruction might
302	* branch to
303	* db_getreg_val(); return the value of a user register,
304	* as indicated in the hardware instruction
305	* encoding, e.g. 8 for r8
306	*
307	* next_instr_address(pc,bd,task) returns the address of the first
308	* instruction following the one at "pc",
309	* which is either in the taken path of
310	* the branch (bd==1) or not. This is
311	* for machines (mips) with branch delays.
312	*
313	* A single-step may involve at most 2 breakpoints -
314	* one for branch-not-taken and one for branch taken.
315	* If one of these addresses does not already have a breakpoint,
316	* we allocate a breakpoint and save it here.
317	* These breakpoints are deleted on return.
318	*/
319	db_breakpoint_t db_not_taken_bkpt = 0;
320	db_breakpoint_t db_taken_bkpt = 0;
321
322	db_breakpoint_t
323	db_find_temp_breakpoint(
324	task_t task,
325	db_addr_t addr)
326	{
327	if (db_taken_bkpt && (db_taken_bkpt->address == addr) &&
328	db_taken_bkpt->task == task)
329	return db_taken_bkpt;
330	if (db_not_taken_bkpt && (db_not_taken_bkpt->address == addr) &&
331	db_not_taken_bkpt->task == task)
332	return db_not_taken_bkpt;
333	return 0;
334	}
335
336	void
337	db_set_task_single_step(
338	register db_regs_t *regs,
339	task_t task)
340	{
341	db_addr_t pc = PC_REGS(regs), brpc;
342	register unsigned int inst;
343	register boolean_t unconditional;
344
345	/*
346	* User was stopped at pc, e.g. the instruction
347	* at pc was not executed.
348	*/
349	inst = db_get_task_value(pc, sizeof(int), FALSE, task);
350	if (inst_branch(inst) \|\| inst_call(inst)) {
351	extern db_expr_t getreg_val(); /* XXX -- need prototype! */
352
353	brpc = branch_taken(inst, pc, getreg_val, (unsigned char*)regs);
354	if (brpc != pc) { /* self-branches are hopeless */
355	db_taken_bkpt = db_set_temp_breakpoint(task, brpc);
356	} else
357	db_taken_bkpt = 0;
358	pc = next_instr_address(pc,1,task);
359	} else
360	pc = next_instr_address(pc,0,task);
361
362	/*
363	* check if this control flow instruction is an
364	* unconditional transfer
365	*/
366
367	unconditional = inst_unconditional_flow_transfer(inst);
368
369	/*
370	We only set the sequential breakpoint if previous instruction was not
371	an unconditional change of flow of control. If the previous instruction
372	is an unconditional change of flow of control, setting a breakpoint in the
373	next sequential location may set a breakpoint in data or in another routine,
374	which could screw up either the program or the debugger.
375	(Consider, for instance, that the next sequential instruction is the
376	start of a routine needed by the debugger.)
377	*/
378	if (!unconditional && db_find_breakpoint_here(task, pc) == 0 &&
379	(db_taken_bkpt == 0 \|\| db_taken_bkpt->address != pc)) {
380	db_not_taken_bkpt = db_set_temp_breakpoint(task, pc);
381	} else
382	db_not_taken_bkpt = 0;
383	}
384
385	void
386	db_clear_task_single_step(
387	db_regs_t *regs,
388	task_t task)
389	{
390	if (db_taken_bkpt != 0) {
391	db_delete_temp_breakpoint(task, db_taken_bkpt);
392	db_taken_bkpt = 0;
393	}
394	if (db_not_taken_bkpt != 0) {
395	db_delete_temp_breakpoint(task, db_not_taken_bkpt);
396	db_not_taken_bkpt = 0;
397	}
398	}
399
400	#endif /* SOFTWARE_SSTEP */
401
402	extern int db_cmd_loop_done;
403
404	/* single-step */
405	void
406	db_single_step_cmd(
407	db_expr_t addr,
408	int have_addr,
409	db_expr_t count,
410	char * modif)
411	{
412	boolean_t print = FALSE;
413
414	if (count == -1)
415	count = 1;
416
417	if (modif[0] == 'p')
418	print = TRUE;
419
420	db_run_mode = STEP_ONCE;
421	db_loop_count = count;
422	db_sstep_print = print;
423	db_inst_count = 0;
424	db_last_inst_count = 0;
425	db_load_count = 0;
426	db_store_count = 0;
427
428	db_cmd_loop_done = 1;
429	}
430
431	/* trace and print until call/return */
432	void
433	db_trace_until_call_cmd(
434	db_expr_t addr,
435	int have_addr,
436	db_expr_t count,
437	char * modif)
438	{
439	boolean_t print = FALSE;
440
441	if (modif[0] == 'p')
442	print = TRUE;
443
444	db_run_mode = STEP_CALLT;
445	db_sstep_print = print;
446	db_inst_count = 0;
447	db_last_inst_count = 0;
448	db_load_count = 0;
449	db_store_count = 0;
450
451	db_cmd_loop_done = 1;
452	}
453
454	void
455	db_trace_until_matching_cmd(
456	db_expr_t addr,
457	int have_addr,
458	db_expr_t count,
459	char * modif)
460	{
461	boolean_t print = FALSE;
462
463	if (modif[0] == 'p')
464	print = TRUE;
465
466	db_run_mode = STEP_RETURN;
467	db_call_depth = 1;
468	db_sstep_print = print;
469	db_inst_count = 0;
470	db_last_inst_count = 0;
471	db_load_count = 0;
472	db_store_count = 0;
473
474	db_cmd_loop_done = 1;
475	}
476
477	/* continue */
478	void
479	db_continue_cmd(
480	db_expr_t addr,
481	int have_addr,
482	db_expr_t count,
483	char * modif)
484	{
485	/*
486	* Though "cont/c" works fairly well, it's not really robust
487	* enough to use in arbitrary situations, so disable it.
488	* (Doesn't seem cost-effective to debug and fix what ails
489	* it.)
490	*/
491	#if 0
492	if (modif[0] == 'c')
493	db_run_mode = STEP_COUNT;
494	else
495	db_run_mode = STEP_CONTINUE;
496	#else
497	db_run_mode = STEP_CONTINUE;
498	#endif
499	db_inst_count = 0;
500	db_last_inst_count = 0;
501	db_load_count = 0;
502	db_store_count = 0;
503
504	db_cmd_loop_done = 1;
505	}
506
507	/* gdb */
508	void
509	db_continue_gdb(
510	db_expr_t addr,
511	int have_addr,
512	db_expr_t count,
513	char * modif)
514	{
515	#if defined(__ppc__)
516	db_to_gdb();
517	#endif
518	db_run_mode = STEP_CONTINUE;
519	db_inst_count = 0;
520	db_last_inst_count = 0;
521	db_load_count = 0;
522	db_store_count = 0;
523
524	db_cmd_loop_done = 1;
525	}
526
527
528
529	boolean_t
530	db_in_single_step(void)
531	{
532	return(db_run_mode != STEP_NONE && db_run_mode != STEP_CONTINUE);
533	}