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

/*
 * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_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>

#include <IOKit/IOPlatformExpert.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);

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

	db_clear_task_single_step(DDB_REGS, space);
	db_clear_breakpoints();
	db_clear_watchpoints();
	db_stop_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
	    db_stop_pc = PC_REGS(DDB_REGS);
	}
#endif

	/*
	 * Now check for a breakpoint at this address.
	 */
	bkpt = db_find_thread_breakpoint_here(space, db_stop_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(db_stop_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;
	   
		ins = db_get_task_value(db_stop_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(db_stop_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;
		ins = db_get_task_value(db_stop_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, db_stop_pc))
		return(FALSE);
	db_run_mode = STEP_NONE;
	return (TRUE);
}

void
db_restart_at_pc(
	boolean_t	watchpt,
	task_t	  	task)
{
	db_addr_t pc = PC_REGS(DDB_REGS);
#ifdef	SOFTWARE_SSTEP
	db_addr_t brpc;
#endif


	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((unsigned long)ins);
	    db_store_count += db_inst_store((unsigned long)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, __unused 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(__unused db_expr_t addr, __unused boolean_t have_addr,
		   db_expr_t count, char *modif)
{
	boolean_t	print = FALSE;

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

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

	db_run_mode = STEP_ONCE;
	db_loop_count = (typeof(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(__unused db_expr_t addr, __unused boolean_t have_addr,
			__unused 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(__unused db_expr_t addr,
			    __unused boolean_t have_addr,
			    __unused 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(__unused db_expr_t addr, __unused boolean_t have_addr,
		__unused db_expr_t count, __unused 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;
}


/*
 * Switch to gdb
 */
static void
db_to_gdb(void)
{
	switch_debugger = 1;
}

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