PERFORCE change 54988 for review
Marcel Moolenaar
marcel at FreeBSD.org
Tue Jun 15 04:07:45 GMT 2004
http://perforce.freebsd.org/chv.cgi?CH=54988
Change 54988 by marcel at marcel_nfs on 2004/06/15 04:07:19
First round of getting alpha and sparc64 from trapframe to PCB.
This also fixes softwate single stepping in DDB (used by alpha).
Affected files ...
.. //depot/projects/gdb/sys/alpha/alpha/db_disasm.c#2 edit
.. //depot/projects/gdb/sys/alpha/alpha/db_interface.c#7 edit
.. //depot/projects/gdb/sys/alpha/alpha/db_trace.c#3 edit
.. //depot/projects/gdb/sys/alpha/include/db_machdep.h#3 edit
.. //depot/projects/gdb/sys/ddb/db_run.c#3 edit
.. //depot/projects/gdb/sys/sparc64/include/db_machdep.h#2 edit
.. //depot/projects/gdb/sys/sparc64/include/kdb.h#3 edit
.. //depot/projects/gdb/sys/sparc64/sparc64/db_trace.c#3 edit
.. //depot/projects/gdb/sys/sparc64/sparc64/trap.c#7 edit
Differences ...
==== //depot/projects/gdb/sys/alpha/alpha/db_disasm.c#2 (text+ko) ====
@@ -813,26 +813,9 @@
* (optional) alternate format. Return address of start of
* next instruction.
*/
-int alpha_print_instruction(db_addr_t, alpha_instruction, boolean_t);
-db_addr_t
-db_disasm(loc, altfmt)
- db_addr_t loc;
- boolean_t altfmt;
-{
- alpha_instruction inst;
-
- inst.bits = db_get_value(loc, 4, 0);
-
- loc += alpha_print_instruction(loc, inst, altfmt);
- return (loc);
-}
-
-int
-alpha_print_instruction(iadr, i, showregs)
- db_addr_t iadr;
- alpha_instruction i;
- boolean_t showregs;
+static int
+alpha_print_instr(db_addr_t iadr, alpha_instruction i, boolean_t showregs)
{
const char *opcode;
int ireg;
@@ -1038,7 +1021,7 @@
if (i.mem_format.opcode == op_ldah)
signed_immediate <<= 16;
db_printf(" <0x%lx>", signed_immediate +
- db_register_value(DDB_REGS, i.mem_format.rs));
+ db_register_value(i.mem_format.rs));
}
break;
case op_br:
@@ -1084,10 +1067,23 @@
db_printf(",");
db_printf("%s=0x%lx",
name_of_register[regnum[ireg]],
- db_register_value(DDB_REGS, regnum[ireg]));
+ db_register_value(regnum[ireg]));
}
db_printf(">");
}
db_printf("\n");
return (sizeof(alpha_instruction));
}
+
+db_addr_t
+db_disasm(loc, altfmt)
+ db_addr_t loc;
+ boolean_t altfmt;
+{
+ alpha_instruction inst;
+
+ inst.bits = db_get_value(loc, 4, 0);
+
+ loc += alpha_print_instr(loc, inst, altfmt);
+ return (loc);
+}
==== //depot/projects/gdb/sys/alpha/alpha/db_interface.c#7 (text+ko) ====
@@ -72,45 +72,60 @@
#include <ddb/db_sym.h>
#include <ddb/db_variables.h>
+static db_varfcn_t db_frame;
+
struct db_variable db_regs[] = {
- { "v0", &ddb_regs.tf_regs[FRAME_V0], FCN_NULL },
- { "t0", &ddb_regs.tf_regs[FRAME_T0], FCN_NULL },
- { "t1", &ddb_regs.tf_regs[FRAME_T1], FCN_NULL },
- { "t2", &ddb_regs.tf_regs[FRAME_T2], FCN_NULL },
- { "t3", &ddb_regs.tf_regs[FRAME_T3], FCN_NULL },
- { "t4", &ddb_regs.tf_regs[FRAME_T4], FCN_NULL },
- { "t5", &ddb_regs.tf_regs[FRAME_T5], FCN_NULL },
- { "t6", &ddb_regs.tf_regs[FRAME_T6], FCN_NULL },
- { "t7", &ddb_regs.tf_regs[FRAME_T7], FCN_NULL },
- { "s0", &ddb_regs.tf_regs[FRAME_S0], FCN_NULL },
- { "s1", &ddb_regs.tf_regs[FRAME_S1], FCN_NULL },
- { "s2", &ddb_regs.tf_regs[FRAME_S2], FCN_NULL },
- { "s3", &ddb_regs.tf_regs[FRAME_S3], FCN_NULL },
- { "s4", &ddb_regs.tf_regs[FRAME_S4], FCN_NULL },
- { "s5", &ddb_regs.tf_regs[FRAME_S5], FCN_NULL },
- { "s6", &ddb_regs.tf_regs[FRAME_S6], FCN_NULL },
- { "a0", &ddb_regs.tf_regs[FRAME_A0], FCN_NULL },
- { "a1", &ddb_regs.tf_regs[FRAME_A1], FCN_NULL },
- { "a2", &ddb_regs.tf_regs[FRAME_A2], FCN_NULL },
- { "a3", &ddb_regs.tf_regs[FRAME_A3], FCN_NULL },
- { "a4", &ddb_regs.tf_regs[FRAME_A4], FCN_NULL },
- { "a5", &ddb_regs.tf_regs[FRAME_A5], FCN_NULL },
- { "t8", &ddb_regs.tf_regs[FRAME_T8], FCN_NULL },
- { "t9", &ddb_regs.tf_regs[FRAME_T9], FCN_NULL },
- { "t10", &ddb_regs.tf_regs[FRAME_T10], FCN_NULL },
- { "t11", &ddb_regs.tf_regs[FRAME_T11], FCN_NULL },
- { "ra", &ddb_regs.tf_regs[FRAME_RA], FCN_NULL },
- { "t12", &ddb_regs.tf_regs[FRAME_T12], FCN_NULL },
- { "at", &ddb_regs.tf_regs[FRAME_AT], FCN_NULL },
- { "gp", &ddb_regs.tf_regs[FRAME_GP], FCN_NULL },
- { "sp", &ddb_regs.tf_regs[FRAME_SP], FCN_NULL },
- { "pc", &ddb_regs.tf_regs[FRAME_PC], FCN_NULL },
- { "ps", &ddb_regs.tf_regs[FRAME_PS], FCN_NULL },
- { "ai", &ddb_regs.tf_regs[FRAME_T11], FCN_NULL },
- { "pv", &ddb_regs.tf_regs[FRAME_T12], FCN_NULL },
+ { "v0", (db_expr_t *)FRAME_V0, db_frame },
+ { "t0", (db_expr_t *)FRAME_T0, db_frame },
+ { "t1", (db_expr_t *)FRAME_T1, db_frame },
+ { "t2", (db_expr_t *)FRAME_T2, db_frame },
+ { "t3", (db_expr_t *)FRAME_T3, db_frame },
+ { "t4", (db_expr_t *)FRAME_T4, db_frame },
+ { "t5", (db_expr_t *)FRAME_T5, db_frame },
+ { "t6", (db_expr_t *)FRAME_T6, db_frame },
+ { "t7", (db_expr_t *)FRAME_T7, db_frame },
+ { "s0", (db_expr_t *)FRAME_S0, db_frame },
+ { "s1", (db_expr_t *)FRAME_S1, db_frame },
+ { "s2", (db_expr_t *)FRAME_S2, db_frame },
+ { "s3", (db_expr_t *)FRAME_S3, db_frame },
+ { "s4", (db_expr_t *)FRAME_S4, db_frame },
+ { "s5", (db_expr_t *)FRAME_S5, db_frame },
+ { "s6", (db_expr_t *)FRAME_S6, db_frame },
+ { "a0", (db_expr_t *)FRAME_A0, db_frame },
+ { "a1", (db_expr_t *)FRAME_A1, db_frame },
+ { "a2", (db_expr_t *)FRAME_A2, db_frame },
+ { "a3", (db_expr_t *)FRAME_A3, db_frame },
+ { "a4", (db_expr_t *)FRAME_A4, db_frame },
+ { "a5", (db_expr_t *)FRAME_A5, db_frame },
+ { "t8", (db_expr_t *)FRAME_T8, db_frame },
+ { "t9", (db_expr_t *)FRAME_T9, db_frame },
+ { "t10", (db_expr_t *)FRAME_T10, db_frame },
+ { "t11", (db_expr_t *)FRAME_T11, db_frame },
+ { "ra", (db_expr_t *)FRAME_RA, db_frame },
+ { "t12", (db_expr_t *)FRAME_T12, db_frame },
+ { "at", (db_expr_t *)FRAME_AT, db_frame },
+ { "gp", (db_expr_t *)FRAME_GP, db_frame },
+ { "sp", (db_expr_t *)FRAME_SP, db_frame },
+ { "pc", (db_expr_t *)FRAME_PC, db_frame },
+ { "ps", (db_expr_t *)FRAME_PS, db_frame },
+ { "ai", (db_expr_t *)FRAME_T11, db_frame },
+ { "pv", (db_expr_t *)FRAME_T12, db_frame },
};
struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]);
+static int
+db_frame(struct db_variable *vp, db_expr_t *valuep, int op)
+{
+
+ if (kdb_frame == NULL)
+ return (0);
+ if (op == DB_VAR_GET)
+ *valuep = kdb_frame->tf_regs[(uintptr_t)vp->valuep];
+ else
+ kdb_frame->tf_regs[(uintptr_t)vp->valuep] = *valuep;
+ return (1);
+}
+
/*
* Read bytes from kernel address space for debugger.
*/
@@ -216,9 +231,7 @@
};
u_long
-db_register_value(regs, regno)
- db_regs_t *regs;
- int regno;
+db_register_value(int regno)
{
if (regno > 31 || regno < 0) {
@@ -229,7 +242,7 @@
if (regno == 31)
return (0);
- return (regs->tf_regs[reg_to_frame[regno]]);
+ return (kdb_frame->tf_regs[reg_to_frame[regno]]);
}
/*
@@ -385,10 +398,7 @@
}
db_addr_t
-db_branch_taken(ins, pc, regs)
- int ins;
- db_addr_t pc;
- db_regs_t *regs;
+db_branch_taken(int ins, db_addr_t pc)
{
alpha_instruction insn;
db_addr_t newpc;
@@ -399,7 +409,7 @@
* Jump format: target PC is (contents of instruction's "RB") & ~3.
*/
case op_j:
- newpc = db_register_value(regs, insn.jump_format.rs) & ~3;
+ newpc = db_register_value(insn.jump_format.rs) & ~3;
break;
/*
==== //depot/projects/gdb/sys/alpha/alpha/db_trace.c#3 (text+ko) ====
@@ -204,10 +204,10 @@
}
static int
-db_backtrace(struct thread *td, struct trapframe *tf, db_addr_t frame,
- db_addr_t pc, int count)
+db_backtrace(struct thread *td, db_addr_t frame, db_addr_t pc, int count)
{
struct prologue_info pi;
+ struct trapframe *tf;
const char *symname;
c_db_sym_t sym;
db_expr_t diff;
@@ -219,6 +219,7 @@
count = 1024;
last_ipl = ~0L;
+ tf = NULL;
while (count--) {
sym = db_search_symbol(pc, DB_STGY_ANY, &diff);
if (sym == DB_SYM_NULL)
@@ -326,7 +327,6 @@
db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
char *modif)
{
- struct trapframe *tf;
struct thread *td;
td = (have_addr) ? kdb_thr_lookup(addr) : kdb_thread;
@@ -334,9 +334,7 @@
db_printf("Thread %d not found\n", (int)addr);
return;
}
- tf = td->td_last_frame;
- db_backtrace(td, tf, (db_addr_t)(tf + 1), tf->tf_regs[FRAME_PC],
- count);
+ db_trace_thread(td, count);
}
void
@@ -349,17 +347,17 @@
" lda %1,1f \n"
"1:\n"
: "=r" (sp), "=r" (pc));
- db_backtrace(curthread, NULL, sp, pc, -1);
+ db_backtrace(curthread, sp, pc, -1);
}
int
db_trace_thread(struct thread *thr, int count)
{
- struct trapframe *tf;
+ struct pcb *ctx;
- tf = thr->td_last_frame;
- return (db_backtrace(thr, tf, (db_addr_t)(tf + 1),
- tf->tf_regs[FRAME_PC], count));
+ ctx = kdb_thr_ctx(thr);
+ return (db_backtrace(thr, ctx->pcb_hw.apcb_ksp, ctx->pcb_context[7],
+ count));
}
int
==== //depot/projects/gdb/sys/alpha/include/db_machdep.h#3 (text+ko) ====
@@ -31,55 +31,41 @@
#ifndef _ALPHA_DB_MACHDEP_H_
#define _ALPHA_DB_MACHDEP_H_
-/*
- * Machine-dependent defines for new kernel debugger.
- */
-#ifndef KLD_MODULE
-#include "opt_ddb.h"
-#endif
-
#include <sys/param.h>
#include <vm/vm.h>
#include <machine/frame.h>
-#define DB_NO_AOUT
+#define DB_NO_AOUT
typedef vm_offset_t db_addr_t; /* address - unsigned */
typedef long db_expr_t; /* expression - signed */
-typedef struct trapframe db_regs_t;
-#ifdef DDB
-extern db_regs_t ddb_regs; /* register state */
-#endif
-#define DDB_REGS (&ddb_regs)
+#define PC_REGS() ((db_addr_t)kdb_thrctx->pcb_context[7])
-#define PC_REGS(regs) ((db_addr_t)(regs)->tf_regs[FRAME_PC])
-
#define BKPT_INST 0x00000080 /* breakpoint instruction */
#define BKPT_SIZE (4) /* size of breakpoint inst */
#define BKPT_SET(inst) (BKPT_INST)
-#define FIXUP_PC_AFTER_BREAK \
- (ddb_regs.tf_regs[FRAME_PC] -= BKPT_SIZE);
+#define FIXUP_PC_AFTER_BREAK (kdb_frame->tf_regs[FRAME_PC] -= BKPT_SIZE);
#define SOFTWARE_SSTEP 1 /* no hardware support */
-#define IS_BREAKPOINT_TRAP(type, code) ((type) == ALPHA_KENTRY_IF && \
- (code) == ALPHA_IF_CODE_BPT)
+
+#define IS_BREAKPOINT_TRAP(type, code) \
+ ((type) == ALPHA_KENTRY_IF && (code) == ALPHA_IF_CODE_BPT)
#define IS_WATCHPOINT_TRAP(type, code) 0
/*
* Functions needed for software single-stepping.
*/
+boolean_t db_inst_trap_return(int inst);
+boolean_t db_inst_return(int inst);
+boolean_t db_inst_call(int inst);
+boolean_t db_inst_branch(int inst);
+boolean_t db_inst_load(int inst);
+boolean_t db_inst_store(int inst);
+boolean_t db_inst_unconditional_flow_transfer(int inst);
+db_addr_t db_branch_taken(int inst, db_addr_t pc);
-boolean_t db_inst_trap_return(int inst);
-boolean_t db_inst_return(int inst);
-boolean_t db_inst_call(int inst);
-boolean_t db_inst_branch(int inst);
-boolean_t db_inst_load(int inst);
-boolean_t db_inst_store(int inst);
-boolean_t db_inst_unconditional_flow_transfer(int inst);
-db_addr_t db_branch_taken(int inst, db_addr_t pc, db_regs_t *regs);
-
#define inst_trap_return(ins) db_inst_trap_return(ins)
#define inst_return(ins) db_inst_return(ins)
#define inst_call(ins) db_inst_call(ins)
@@ -88,13 +74,12 @@
#define inst_store(ins) db_inst_store(ins)
#define inst_unconditional_flow_transfer(ins) \
db_inst_unconditional_flow_transfer(ins)
-#define branch_taken(ins, pc, regs) \
- db_branch_taken((ins), (pc), (regs))
+#define branch_taken(ins, pc) db_branch_taken(ins, pc)
/* No delay slots on Alpha. */
#define next_instr_address(v, b) ((db_addr_t) ((b) ? (v) : ((v) + 4)))
-u_long db_register_value(db_regs_t *, int);
+u_long db_register_value(int);
/*
* Pretty arbitrary
==== //depot/projects/gdb/sys/ddb/db_run.c#3 (text+ko) ====
@@ -65,10 +65,10 @@
int db_store_count;
#ifndef db_set_single_step
-extern void db_set_single_step(db_regs_t *regs);
+void db_set_single_step(void);
#endif
#ifndef db_clear_single_step
-extern void db_clear_single_step(db_regs_t *regs);
+void db_clear_single_step(void);
#endif
boolean_t
@@ -249,11 +249,10 @@
db_breakpoint_t db_taken_bkpt = 0;
void
-db_set_single_step(regs)
- register db_regs_t *regs;
+db_set_single_step(void)
{
- db_addr_t pc = PC_REGS(regs), brpc;
- unsigned inst;
+ db_addr_t pc = PC_REGS(), brpc;
+ unsigned inst;
/*
* User was stopped at pc, e.g. the instruction
@@ -261,28 +260,27 @@
*/
inst = db_get_value(pc, sizeof(int), FALSE);
if (inst_branch(inst) || inst_call(inst)) {
- brpc = branch_taken(inst, pc, regs);
- if (brpc != pc) { /* self-branches are hopeless */
- db_taken_bkpt = db_set_temp_breakpoint(brpc);
- }
- pc = next_instr_address(pc,1);
+ brpc = branch_taken(inst, pc);
+ if (brpc != pc) { /* self-branches are hopeless */
+ db_taken_bkpt = db_set_temp_breakpoint(brpc);
+ }
+ pc = next_instr_address(pc, 1);
}
- pc = next_instr_address(pc,0);
+ pc = next_instr_address(pc, 0);
db_not_taken_bkpt = db_set_temp_breakpoint(pc);
}
void
-db_clear_single_step(regs)
- db_regs_t *regs;
+db_clear_single_step(void)
{
if (db_not_taken_bkpt != 0) {
- db_delete_temp_breakpoint(db_not_taken_bkpt);
- db_not_taken_bkpt = 0;
+ db_delete_temp_breakpoint(db_not_taken_bkpt);
+ db_not_taken_bkpt = 0;
}
if (db_taken_bkpt != 0) {
- db_delete_temp_breakpoint(db_taken_bkpt);
- db_taken_bkpt = 0;
+ db_delete_temp_breakpoint(db_taken_bkpt);
+ db_taken_bkpt = 0;
}
}
==== //depot/projects/gdb/sys/sparc64/include/db_machdep.h#2 (text+ko) ====
@@ -38,23 +38,19 @@
typedef vm_offset_t db_addr_t;
typedef long db_expr_t;
-typedef struct trapframe db_regs_t;
-extern db_regs_t ddb_regs;
-#define DDB_REGS (&ddb_regs)
+#define PC_REGS() ((db_addr_t)kdb_thrctx->pcb_pc)
-#define PC_REGS(regs) ((db_addr_t)(regs)->tf_tpc)
-
#define BKPT_INST (0x91d03001)
#define BKPT_SIZE (4)
#define BKPT_SET(inst) (BKPT_INST)
#define BKPT_SKIP do { \
- ddb_regs.tf_tpc = ddb_regs.tf_tnpc + 4; \
- ddb_regs.tf_tnpc += 8; \
+ kdb_frame->tf_tpc = kdb_frame->tf_tnpc + 4; \
+ kdb_frame->tf_tnpc += 8; \
} while (0)
-#define db_clear_single_step(regs)
-#define db_set_single_step(regs)
+#define db_clear_single_step kdb_cpu_clear_singlestep
+#define db_set_single_step kdb_cpu_set_singlestep
#define IS_BREAKPOINT_TRAP(type, code) (type == T_BREAKPOINT)
#define IS_WATCHPOINT_TRAP(type, code) (0)
==== //depot/projects/gdb/sys/sparc64/include/kdb.h#3 (text+ko) ====
@@ -29,7 +29,7 @@
#ifndef _MACHINE_KDB_H_
#define _MACHINE_KDB_H_
-#include <machine/frame.h>
+#include <machine/cpufunc.h>
static __inline void
kdb_cpu_clear_singlestep(void)
==== //depot/projects/gdb/sys/sparc64/sparc64/db_trace.c#3 (text+ko) ====
@@ -51,29 +51,47 @@
#define INKERNEL(va) \
((va) >= VM_MIN_KERNEL_ADDRESS && (va) <= VM_MAX_KERNEL_ADDRESS)
+static db_varfcn_t db_frame;
+
+#define DB_OFFSET(x) (db_expr_t *)offsetof(struct trapframe, x)
struct db_variable db_regs[] = {
- { "g0", &ddb_regs.tf_global[0], FCN_NULL },
- { "g1", &ddb_regs.tf_global[1], FCN_NULL },
- { "g2", &ddb_regs.tf_global[2], FCN_NULL },
- { "g3", &ddb_regs.tf_global[3], FCN_NULL },
- { "g4", &ddb_regs.tf_global[4], FCN_NULL },
- { "g5", &ddb_regs.tf_global[5], FCN_NULL },
- { "g6", &ddb_regs.tf_global[6], FCN_NULL },
- { "g7", &ddb_regs.tf_global[7], FCN_NULL },
- { "i0", &ddb_regs.tf_out[0], FCN_NULL },
- { "i1", &ddb_regs.tf_out[1], FCN_NULL },
- { "i2", &ddb_regs.tf_out[2], FCN_NULL },
- { "i3", &ddb_regs.tf_out[3], FCN_NULL },
- { "i4", &ddb_regs.tf_out[4], FCN_NULL },
- { "i5", &ddb_regs.tf_out[5], FCN_NULL },
- { "i6", &ddb_regs.tf_out[6], FCN_NULL },
- { "i7", &ddb_regs.tf_out[7], FCN_NULL },
- { "tnpc", &ddb_regs.tf_tnpc, FCN_NULL },
- { "tpc", &ddb_regs.tf_tpc, FCN_NULL },
- { "tstate", &ddb_regs.tf_tstate, FCN_NULL },
+ { "g0", DB_OFFSET(tf_global[0]), db_frame },
+ { "g1", DB_OFFSET(tf_global[1]), db_frame },
+ { "g2", DB_OFFSET(tf_global[2]), db_frame },
+ { "g3", DB_OFFSET(tf_global[3]), db_frame },
+ { "g4", DB_OFFSET(tf_global[4]), db_frame },
+ { "g5", DB_OFFSET(tf_global[5]), db_frame },
+ { "g6", DB_OFFSET(tf_global[6]), db_frame },
+ { "g7", DB_OFFSET(tf_global[7]), db_frame },
+ { "i0", DB_OFFSET(tf_out[0]), db_frame },
+ { "i1", DB_OFFSET(tf_out[1]), db_frame },
+ { "i2", DB_OFFSET(tf_out[2]), db_frame },
+ { "i3", DB_OFFSET(tf_out[3]), db_frame },
+ { "i4", DB_OFFSET(tf_out[4]), db_frame },
+ { "i5", DB_OFFSET(tf_out[5]), db_frame },
+ { "i6", DB_OFFSET(tf_out[6]), db_frame },
+ { "i7", DB_OFFSET(tf_out[7]), db_frame },
+ { "tnpc", DB_OFFSET(tf_tnpc), db_frame },
+ { "tpc", DB_OFFSET(tf_tpc), db_frame },
+ { "tstate", DB_OFFSET(tf_tstate), db_frame },
};
struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]);
+static int
+db_frame(struct db_variable *vp, db_expr_t *valuep, int op)
+{
+ uint64_t *reg;
+
+ if (kdb_frame == NULL)
+ return (0);
+ reg = (uint64_t*)((uintptr_t)kdb_frame + (uintptr_t)vp->valuep);
+ if (op == DB_VAR_GET)
+ *valuep = *reg;
+ else
+ *reg = *valuep;
+ return (1);
+}
+
/*
* User stack trace (debugging aid).
*/
@@ -200,9 +218,9 @@
}
static int
-db_backtrace(struct thread *td, struct trapframe *tf, struct frame *fp,
- int count)
+db_backtrace(struct thread *td, struct frame *fp, int count)
{
+ struct trapframe *tf;
const char *name;
c_db_sym_t sym;
db_expr_t offset;
@@ -215,9 +233,6 @@
if (count == -1)
count = 1024;
- if (fp == NULL && tf != NULL)
- fp = (struct frame *)(tf->tf_out[6] + SPOFF);
-
trap = 0;
user = 0;
npc = 0;
@@ -267,7 +282,7 @@
db_printf("Thread %d not found\n", (int)addr);
return;
}
- db_backtrace(td, td->td_last_frame, NULL, count);
+ db_trace_thread(td, count);
}
void
@@ -276,12 +291,14 @@
db_expr_t addr;
addr = (db_expr_t)__builtin_frame_address(1);
- db_backtrace(curthread, NULL, (struct frame *)(addr + SPOFF), -1);
+ db_backtrace(curthread, (struct frame *)(addr + SPOFF), -1);
}
int
db_trace_thread(struct thread *td, int count)
{
+ struct pcb *ctx;
- return (db_backtrace(td, td->td_last_frame, NULL, count));
+ ctx = kdb_thr_ctx(td);
+ return (db_backtrace(td, (struct frame*)(ctx->pcb_sp + SPOFF), count));
}
==== //depot/projects/gdb/sys/sparc64/sparc64/trap.c#7 (text+ko) ====
@@ -250,7 +250,6 @@
p = td->td_proc;
sticks = td->td_sticks;
td->td_frame = tf;
- td->td_last_frame = tf;
if (td->td_ucred != p->p_ucred)
cred_update_thread(td);
@@ -305,8 +304,6 @@
}
#endif
- td->td_last_frame = tf;
-
switch (tf->tf_type & ~T_KERNEL) {
#ifdef KDB
case T_BREAKPOINT:
@@ -526,7 +523,6 @@
sticks = td->td_sticks;
td->td_frame = tf;
- td->td_last_frame = tf;
if (td->td_ucred != p->p_ucred)
cred_update_thread(td);
if (p->p_flag & P_SA)
More information about the p4-projects
mailing list