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