db_trace.c revision 1.12
1 /* $NetBSD: db_trace.c,v 1.12 2000/05/26 20:59:00 mhitch Exp $ */ 2 3 /* 4 * Mach Operating System 5 * Copyright (c) 1993-1987 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 "AS IS" 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 Mellon 26 * the rights to redistribute these changes. 27 */ 28 29 #include <sys/types.h> 30 #include <vm/vm_param.h> /* XXX boolean_t */ 31 32 #include <mips/mips_opcode.h> 33 34 #include <machine/param.h> 35 #include <machine/db_machdep.h> 36 #include <ddb/db_interface.h> 37 #include <ddb/db_output.h> 38 #include <ddb/db_variables.h> 39 #include <ddb/db_sym.h> 40 41 int __start __P((void)); /* lowest kernel code address */ 42 vaddr_t getreg_val __P((db_expr_t regno)); 43 44 #define REG_ARG(i) (4+i) 45 #define SAVES_RA(x) isa_spill((x),31) 46 47 #define KERN_SAVE_REG_IDX(vp) ( \ 48 ((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->s0) && \ 49 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->s7))? \ 50 vp->valuep - (int *)(&((struct mips_saved_state *)0)->s0): \ 51 ((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->sp) && \ 52 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->ra))? \ 53 ((vp)->valuep-(int *)(&((struct mips_saved_state *)0)->sp)) + \ 54 ((int *)(&((struct mips_kernel_state *)0)->sp) - (int *)0): \ 55 -1) 56 57 db_sym_t localsym __P((db_sym_t sym, boolean_t isreg, int *lex_level)); 58 59 /* 60 * Machine register set. 61 */ 62 struct mips_saved_state *db_cur_exc_frame = 0; 63 64 /* 65 * forward declarations 66 */ 67 int print_exception_frame __P((struct mips_saved_state *fp, 68 unsigned epc)); 69 70 /*XXX*/ 71 void stacktrace_subr __P((int a0, int a1, int a2, int a3, 72 u_int pc, u_int sp, u_int fp, u_int ra, 73 void (*)(const char*, ...))); 74 75 /* 76 * Stack trace helper. 77 */ 78 void db_mips_stack_trace __P((int count, vaddr_t stackp, 79 vaddr_t the_pc, vaddr_t the_ra, int flags, 80 vaddr_t kstackp)); 81 int db_mips_variable_func __P((struct db_variable *vp, db_expr_t *valuep, 82 int db_var_fun)); 83 84 #define DB_SETF_REGS db_mips_variable_func 85 #define DBREGS_REG() 86 87 struct db_variable db_regs[] = { 88 { "at", (long *)&ddb_regs.f_regs[AST], DB_SETF_REGS }, 89 { "v0", (long *)&ddb_regs.f_regs[V0], DB_SETF_REGS }, 90 { "v1", (long *)&ddb_regs.f_regs[V1], DB_SETF_REGS }, 91 { "a0", (long *)&ddb_regs.f_regs[A0], DB_SETF_REGS }, 92 { "a1", (long *)&ddb_regs.f_regs[A1], DB_SETF_REGS }, 93 { "a2", (long *)&ddb_regs.f_regs[A2], DB_SETF_REGS }, 94 { "a3", (long *)&ddb_regs.f_regs[A3], DB_SETF_REGS }, 95 { "t0", (long *)&ddb_regs.f_regs[T0], DB_SETF_REGS }, 96 { "t1", (long *)&ddb_regs.f_regs[T1], DB_SETF_REGS }, 97 { "t2", (long *)&ddb_regs.f_regs[T2], DB_SETF_REGS }, 98 { "t3", (long *)&ddb_regs.f_regs[T3], DB_SETF_REGS }, 99 { "t4", (long *)&ddb_regs.f_regs[T4], DB_SETF_REGS }, 100 { "t5", (long *)&ddb_regs.f_regs[T5], DB_SETF_REGS }, 101 { "t6", (long *)&ddb_regs.f_regs[T6], DB_SETF_REGS }, 102 { "t7", (long *)&ddb_regs.f_regs[T7], DB_SETF_REGS }, 103 { "s0", (long *)&ddb_regs.f_regs[S0], DB_SETF_REGS }, 104 { "s1", (long *)&ddb_regs.f_regs[S1], DB_SETF_REGS }, 105 { "s2", (long *)&ddb_regs.f_regs[S2], DB_SETF_REGS }, 106 { "s3", (long *)&ddb_regs.f_regs[S3], DB_SETF_REGS }, 107 { "s4", (long *)&ddb_regs.f_regs[S4], DB_SETF_REGS }, 108 { "s5", (long *)&ddb_regs.f_regs[S5], DB_SETF_REGS }, 109 { "s6", (long *)&ddb_regs.f_regs[S6], DB_SETF_REGS }, 110 { "s7", (long *)&ddb_regs.f_regs[S7], DB_SETF_REGS }, 111 { "t8", (long *)&ddb_regs.f_regs[T8], DB_SETF_REGS }, 112 { "t9", (long *)&ddb_regs.f_regs[T9], DB_SETF_REGS }, 113 { "k0", (long *)&ddb_regs.f_regs[K0], DB_SETF_REGS }, 114 { "k1", (long *)&ddb_regs.f_regs[K1], DB_SETF_REGS }, 115 { "gp", (long *)&ddb_regs.f_regs[GP], DB_SETF_REGS }, 116 { "sp", (long *)&ddb_regs.f_regs[SP], DB_SETF_REGS }, 117 { "fp", (long *)&ddb_regs.f_regs[S8], DB_SETF_REGS }, /* frame ptr */ 118 { "ra", (long *)&ddb_regs.f_regs[RA], DB_SETF_REGS }, 119 { "sr", (long *)&ddb_regs.f_regs[SR], DB_SETF_REGS }, 120 { "mdlo",(long *)&ddb_regs.f_regs[MULLO], DB_SETF_REGS }, 121 { "mdhi",(long *)&ddb_regs.f_regs[MULHI], DB_SETF_REGS }, 122 { "bad", (long *)&ddb_regs.f_regs[BADVADDR], DB_SETF_REGS }, 123 { "cs", (long *)&ddb_regs.f_regs[CAUSE], DB_SETF_REGS }, 124 { "pc", (long *)&ddb_regs.f_regs[PC], DB_SETF_REGS }, 125 }; 126 struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); 127 128 void 129 db_stack_trace_print(addr, have_addr, count, modif, pr) 130 db_expr_t addr; 131 boolean_t have_addr; 132 db_expr_t count; 133 char *modif; 134 void (*pr) __P((const char *, ...)); 135 { 136 #ifndef DDB_TRACE 137 stacktrace_subr(ddb_regs.f_regs[A0], ddb_regs.f_regs[A1], 138 ddb_regs.f_regs[A2], ddb_regs.f_regs[A3], 139 ddb_regs.f_regs[PC], 140 ddb_regs.f_regs[SP], 141 ddb_regs.f_regs[S8], /* non-virtual frame pointer */ 142 ddb_regs.f_regs[RA], 143 pr); 144 #else 145 /* 146 * Imcomplete but practically useful stack backtrace. 147 */ 148 #define MIPS_JR_RA 0x03e00008 /* instruction code for jr ra */ 149 #define MIPS_JR_K0 0x03400008 /* instruction code for jr k0 */ 150 #define MIPS_ERET 0x42000018 /* instruction code for eret */ 151 unsigned va, pc, ra, sp, func; 152 int insn; 153 InstFmt i; 154 int stacksize; 155 db_addr_t offset; 156 char *name; 157 extern char verylocore[]; 158 159 pc = ddb_regs.f_regs[PC]; 160 sp = ddb_regs.f_regs[SP]; 161 ra = ddb_regs.f_regs[RA]; 162 do { 163 va = pc; 164 do { 165 va -= sizeof(int); 166 insn = *(int *)va; 167 if (insn == MIPS_ERET) 168 goto mips3_eret; 169 } while (insn != MIPS_JR_RA && insn != MIPS_JR_K0); 170 va += sizeof(int); 171 mips3_eret: 172 va += sizeof(int); 173 while (*(int *)va == 0x00000000) 174 va += sizeof(int); 175 func = va; 176 stacksize = 0; 177 do { 178 i.word = *(int *)va; 179 if (i.IType.op == OP_SW 180 && i.IType.rs == SP 181 && i.IType.rt == RA) 182 ra = *(int *)(sp + (short)i.IType.imm); 183 if (i.IType.op == OP_ADDIU 184 && i.IType.rs == SP 185 && i.IType.rt == SP) 186 stacksize = -(short)i.IType.imm; 187 va += sizeof(int); 188 } while (va < pc); 189 190 db_find_sym_and_offset(func, &name, &offset); 191 if (name == 0) 192 name = "?"; 193 (*pr)("%s()+0x%x, called by %p, stack size %d\n", 194 name, pc - func, (void *)ra, stacksize); 195 196 if (ra == pc) { 197 (*pr)("-- loop? --\n"); 198 return; 199 } 200 sp += stacksize; 201 pc = ra; 202 } while (pc > (unsigned)verylocore); 203 if (pc < 0x80000000) 204 (*pr)("-- user process --\n"); 205 else 206 (*pr)("-- kernel entry --\n"); 207 #endif 208 } 209 210 void 211 db_mips_stack_trace(count, stackp, the_pc, the_ra, flags, kstackp) 212 int count; 213 vaddr_t stackp, the_pc, the_ra; 214 int flags; 215 vaddr_t kstackp; 216 { 217 return; 218 } 219 220 221 int 222 db_mips_variable_func (struct db_variable *vp, 223 db_expr_t *valuep, 224 int db_var_fcn) 225 { 226 switch (db_var_fcn) { 227 case DB_VAR_GET: 228 *valuep = *(mips_reg_t *) vp->valuep; 229 break; 230 case DB_VAR_SET: 231 *(mips_reg_t *) vp->valuep = *valuep; 232 break; 233 } 234 return 0; 235 } 236
Indexes created Tue Sep 23 14:10:03 GMT 2025