WebSVN – HelenOS – Diff – /trunk/kernel/arch/mips32/src/debugger.c



 */
/** @file
 */
 
#include <arch/debugger.h>
#include <arch/barrier.h>
#include <memstr.h>
#include <console/kconsole.h>
#include <console/cmd.h>
#include <symtab.h>
#include <print.h>

static cmd_arg_t add_argv = {
    .type = ARG_TYPE_INT
};
static cmd_info_t addbkpt_info = {
    .name = "addbkpt",
    .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch "
        "insts unsupported.",
    .func = cmd_add_breakpoint,
    .argc = 1,
    .argv = &add_argv
};
 

    { .type = ARG_TYPE_INT },
    { .type = ARG_TYPE_INT }
};
static cmd_info_t addbkpte_info = {
    .name = "addbkpte",
    .description = "addebkpte <&symbol> <&func> - new bkpoint. Call "
        "func(or Nothing if 0).",
    .func = cmd_add_breakpoint,
    .argc = 2,
    .argv = adde_argv
};
 
static struct {
    uint32_t andmask;
    uint32_t value;
} jmpinstr[] = {
    {0xf3ff0000, 0x41000000}, /* BCzF */
    {0xf3ff0000, 0x41020000}, /* BCzFL */
    {0xf3ff0000, 0x41010000}, /* BCzT */
    {0xf3ff0000, 0x41030000}, /* BCzTL */
    {0xfc000000, 0x10000000}, /* BEQ */

    {0xfc000000, 0x14000000}, /* BNE */
    {0xfc000000, 0x54000000}, /* BNEL */
    {0xfc000000, 0x08000000}, /* J */
    {0xfc000000, 0x0c000000}, /* JAL */
    {0xfc1f07ff, 0x00000009}, /* JALR */
    {0, 0} /* EndOfTable */
};
 
/** Test, if the given instruction is a jump or branch instruction
 *
 * @param instr Instruction code

 */
static bool is_jump(unative_t instr)
{
    int i;
 
    for (i = 0; jmpinstr[i].andmask; i++) {
        if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)
            return true;
    }
 
    return false;

    for (i = 0; i < BKPOINTS_MAX; i++) {
        if (breakpoints[i].address == (uintptr_t)argv->intval) {
            printf("Duplicate breakpoint %d.\n", i);
            spinlock_unlock(&bkpoints_lock);
            return 0;
        } else if (breakpoints[i].address == (uintptr_t)argv->intval +
            sizeof(unative_t) || breakpoints[i].address ==
            (uintptr_t)argv->intval - sizeof(unative_t)) {
            printf("Adjacent breakpoints not supported, conflict "
                "with %d.\n", i);
            spinlock_unlock(&bkpoints_lock);
            return 0;
        }
           
    }
 
    for (i = 0; i < BKPOINTS_MAX; i++)
        if (!breakpoints[i].address) {
            cur = &breakpoints[i];
            break;
        }
    if (!cur) {

    cur->nextinstruction = ((unative_t *)cur->address)[1];
    if (argv == &add_argv) {
        cur->flags = 0;
    } else { /* We are add extended */
        cur->flags = BKPOINT_FUNCCALL;
        cur->bkfunc = (void (*)(void *, istate_t *)) argv[1].intval;
    }
    if (is_jump(cur->instruction))
        cur->flags |= BKPOINT_ONESHOT;
    cur->counter = 0;
 
    /* Set breakpoint */
    *((unative_t *)cur->address) = 0x0d;
    smc_coherence(cur->address);
 
    spinlock_unlock(&bkpoint_lock);
    interrupts_restore(ipl);
 
    return 1;
}
 
 
 
/** Remove breakpoint from table */
int cmd_del_breakpoint(cmd_arg_t *argv)
{
    bpinfo_t *cur;
    ipl_t ipl;

        spinlock_unlock(&bkpoint_lock);
        interrupts_restore(ipl);
        return 0;
    }
    ((uint32_t *)cur->address)[0] = cur->instruction;
    smc_coherence(((uint32_t *)cur->address)[0]);
    ((uint32_t *)cur->address)[1] = cur->nextinstruction;
    smc_coherence(((uint32_t *)cur->address)[1]);
 
    cur->address = NULL;
 
    spinlock_unlock(&bkpoint_lock);
    interrupts_restore(ipl);

    for (i = 0; i < BKPOINTS_MAX; i++)
        if (breakpoints[i].address) {
            symbol = get_symtab_entry(breakpoints[i].address);
           
            printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,
                breakpoints[i].counter, breakpoints[i].address,
                ((breakpoints[i].flags & BKPOINT_INPROG) ? "true" :
                "false"), ((breakpoints[i].flags & BKPOINT_ONESHOT)
                ? "true" : "false"), ((breakpoints[i].flags &
                BKPOINT_FUNCCALL) ? "true" : "false"), symbol);
 
        }
    return 1;
}
 
/** Initialize debugger */
void debugger_init()
{
    int i;
 
    for (i = 0; i < BKPOINTS_MAX; i++)
        breakpoints[i].address = NULL;
   
    cmd_initialize(&bkpts_info);
    if (!cmd_register(&bkpts_info))
        panic("could not register command %s\n", bkpts_info.name);

    /* test branch delay slot */
    if (cp0_cause_read() & 0x80000000)
        panic("Breakpoint in branch delay slot not supported.\n");
 
    spinlock_lock(&bkpoint_lock);
    for (i = 0; i < BKPOINTS_MAX; i++) {
        /* Normal breakpoint */
        if (fireaddr == breakpoints[i].address &&
            !(breakpoints[i].flags & BKPOINT_REINST)) {
            cur = &breakpoints[i];
            break;
        }
        /* Reinst only breakpoint */
        if ((breakpoints[i].flags & BKPOINT_REINST) &&
            (fireaddr == breakpoints[i].address + sizeof(unative_t))) {
            cur = &breakpoints[i];
            break;
        }
    }
    if (cur) {
        if (cur->flags & BKPOINT_REINST) {
            /* Set breakpoint on first instruction */
            ((uint32_t *)cur->address)[0] = 0x0d;
            smc_coherence(((uint32_t *)cur->address)[0]);
            /* Return back the second */
            ((uint32_t *)cur->address)[1] = cur->nextinstruction;
            smc_coherence(((uint32_t *)cur->address)[1]);
            cur->flags &= ~BKPOINT_REINST;
            spinlock_unlock(&bkpoint_lock);
            return;
        }
        if (cur->flags & BKPOINT_INPROG)
            printf("Warning: breakpoint recursion\n");
       
        if (!(cur->flags & BKPOINT_FUNCCALL))
            printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
                get_symtab_entry(istate->epc));
 
        /* Return first instruction back */
        ((uint32_t *)cur->address)[0] = cur->instruction;
        smc_coherence(cur->address);
 
        if (! (cur->flags & BKPOINT_ONESHOT)) {
            /* Set Breakpoint on next instruction */
            ((uint32_t *)cur->address)[1] = 0x0d;
            cur->flags |= BKPOINT_REINST;

Rev 3071	Rev 3139
Line 31...	Line 31...
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <arch/debugger.h>	35	#include <arch/debugger.h>
-		36	#include <arch/barrier.h>
36	#include <memstr.h>	37	#include <memstr.h>
37	#include <console/kconsole.h>	38	#include <console/kconsole.h>
38	#include <console/cmd.h>	39	#include <console/cmd.h>
39	#include <symtab.h>	40	#include <symtab.h>
40	#include <print.h>	41	#include <print.h>
Line 70...	Line 71...
70	static cmd_arg_t add_argv = {	71	static cmd_arg_t add_argv = {
71	.type = ARG_TYPE_INT	72	.type = ARG_TYPE_INT
72	};	73	};
73	static cmd_info_t addbkpt_info = {	74	static cmd_info_t addbkpt_info = {
74	.name = "addbkpt",	75	.name = "addbkpt",
75	.description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.",	76	.description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch "
-		77	"insts unsupported.",
76	.func = cmd_add_breakpoint,	78	.func = cmd_add_breakpoint,
77	.argc = 1,	79	.argc = 1,
78	.argv = &add_argv	80	.argv = &add_argv
79	};	81	};
80		82
Line 82...	Line 84...
82	{ .type = ARG_TYPE_INT },	84	{ .type = ARG_TYPE_INT },
83	{ .type = ARG_TYPE_INT }	85	{ .type = ARG_TYPE_INT }
84	};	86	};
85	static cmd_info_t addbkpte_info = {	87	static cmd_info_t addbkpte_info = {
86	.name = "addbkpte",	88	.name = "addbkpte",
87	.description = "addebkpte <&symbol> <&func> - new bkpoint. Call func(or Nothing if 0).",	89	.description = "addebkpte <&symbol> <&func> - new bkpoint. Call "
-		90	"func(or Nothing if 0).",
88	.func = cmd_add_breakpoint,	91	.func = cmd_add_breakpoint,
89	.argc = 2,	92	.argc = 2,
90	.argv = adde_argv	93	.argv = adde_argv
91	};	94	};
92		95
93	static struct {	96	static struct {
94	uint32_t andmask;	97	uint32_t andmask;
95	uint32_t value;	98	uint32_t value;
96	}jmpinstr[] = {	99	} jmpinstr[] = {
97	{0xf3ff0000, 0x41000000}, /* BCzF */	100	{0xf3ff0000, 0x41000000}, /* BCzF */
98	{0xf3ff0000, 0x41020000}, /* BCzFL */	101	{0xf3ff0000, 0x41020000}, /* BCzFL */
99	{0xf3ff0000, 0x41010000}, /* BCzT */	102	{0xf3ff0000, 0x41010000}, /* BCzT */
100	{0xf3ff0000, 0x41030000}, /* BCzTL */	103	{0xf3ff0000, 0x41030000}, /* BCzTL */
101	{0xfc000000, 0x10000000}, /* BEQ */	104	{0xfc000000, 0x10000000}, /* BEQ */
Line 115...	Line 118...
115	{0xfc000000, 0x14000000}, /* BNE */	118	{0xfc000000, 0x14000000}, /* BNE */
116	{0xfc000000, 0x54000000}, /* BNEL */	119	{0xfc000000, 0x54000000}, /* BNEL */
117	{0xfc000000, 0x08000000}, /* J */	120	{0xfc000000, 0x08000000}, /* J */
118	{0xfc000000, 0x0c000000}, /* JAL */	121	{0xfc000000, 0x0c000000}, /* JAL */
119	{0xfc1f07ff, 0x00000009}, /* JALR */	122	{0xfc1f07ff, 0x00000009}, /* JALR */
120	{0,0} /* EndOfTable */	123	{0, 0} /* EndOfTable */
121	};	124	};
122		125
123	/** Test, if the given instruction is a jump or branch instruction	126	/** Test, if the given instruction is a jump or branch instruction
124	*	127	*
125	* @param instr Instruction code	128	* @param instr Instruction code
Line 127...	Line 130...
127	*/	130	*/
128	static bool is_jump(unative_t instr)	131	static bool is_jump(unative_t instr)
129	{	132	{
130	int i;	133	int i;
131		134
132	for (i=0;jmpinstr[i].andmask;i++) {	135	for (i = 0; jmpinstr[i].andmask; i++) {
133	if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)	136	if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)
134	return true;	137	return true;
135	}	138	}
136		139
137	return false;	140	return false;
Line 155...	Line 158...
155	for (i = 0; i < BKPOINTS_MAX; i++) {	158	for (i = 0; i < BKPOINTS_MAX; i++) {
156	if (breakpoints[i].address == (uintptr_t)argv->intval) {	159	if (breakpoints[i].address == (uintptr_t)argv->intval) {
157	printf("Duplicate breakpoint %d.\n", i);	160	printf("Duplicate breakpoint %d.\n", i);
158	spinlock_unlock(&bkpoints_lock);	161	spinlock_unlock(&bkpoints_lock);
159	return 0;	162	return 0;
160	} else if (breakpoints[i].address == (uintptr_t)argv->intval + sizeof(unative_t) \|\| \	163	} else if (breakpoints[i].address == (uintptr_t)argv->intval +
-		164	sizeof(unative_t) \|\| breakpoints[i].address ==
161	breakpoints[i].address == (uintptr_t)argv->intval - sizeof(unative_t)) {	165	(uintptr_t)argv->intval - sizeof(unative_t)) {
162	printf("Adjacent breakpoints not supported, conflict with %d.\n", i);	166	printf("Adjacent breakpoints not supported, conflict "
-		167	"with %d.\n", i);
163	spinlock_unlock(&bkpoints_lock);	168	spinlock_unlock(&bkpoints_lock);
164	return 0;	169	return 0;
165	}	170	}
166		171
167	}	172	}
168		173
169	for (i=0; i<BKPOINTS_MAX; i++)	174	for (i = 0; i < BKPOINTS_MAX; i++)
170	if (!breakpoints[i].address) {	175	if (!breakpoints[i].address) {
171	cur = &breakpoints[i];	176	cur = &breakpoints[i];
172	break;	177	break;
173	}	178	}
174	if (!cur) {	179	if (!cur) {
Line 183...	Line 188...
183	cur->nextinstruction = ((unative_t *)cur->address)[1];	188	cur->nextinstruction = ((unative_t *)cur->address)[1];
184	if (argv == &add_argv) {	189	if (argv == &add_argv) {
185	cur->flags = 0;	190	cur->flags = 0;
186	} else { /* We are add extended */	191	} else { /* We are add extended */
187	cur->flags = BKPOINT_FUNCCALL;	192	cur->flags = BKPOINT_FUNCCALL;
188	cur->bkfunc = (void ()(void , istate_t *)) argv[1].intval;	193	cur->bkfunc = (void ()(void , istate_t *)) argv[1].intval;
189	}	194	}
190	if (is_jump(cur->instruction))	195	if (is_jump(cur->instruction))
191	cur->flags \|= BKPOINT_ONESHOT;	196	cur->flags \|= BKPOINT_ONESHOT;
192	cur->counter = 0;	197	cur->counter = 0;
193		198
194	/* Set breakpoint */	199	/* Set breakpoint */
195	((unative_t )cur->address) = 0x0d;	200	((unative_t )cur->address) = 0x0d;
-		201	smc_coherence(cur->address);
196		202
197	spinlock_unlock(&bkpoint_lock);	203	spinlock_unlock(&bkpoint_lock);
198	interrupts_restore(ipl);	204	interrupts_restore(ipl);
199		205
200	return 1;	206	return 1;
201	}	207	}
202		208
203		-
204		-
205	/** Remove breakpoint from table */	209	/** Remove breakpoint from table */
206	int cmd_del_breakpoint(cmd_arg_t *argv)	210	int cmd_del_breakpoint(cmd_arg_t *argv)
207	{	211	{
208	bpinfo_t *cur;	212	bpinfo_t *cur;
209	ipl_t ipl;	213	ipl_t ipl;
Line 227...	Line 231...
227	spinlock_unlock(&bkpoint_lock);	231	spinlock_unlock(&bkpoint_lock);
228	interrupts_restore(ipl);	232	interrupts_restore(ipl);
229	return 0;	233	return 0;
230	}	234	}
231	((uint32_t *)cur->address)[0] = cur->instruction;	235	((uint32_t *)cur->address)[0] = cur->instruction;
-		236	smc_coherence(((uint32_t *)cur->address)[0]);
232	((uint32_t *)cur->address)[1] = cur->nextinstruction;	237	((uint32_t *)cur->address)[1] = cur->nextinstruction;
-		238	smc_coherence(((uint32_t *)cur->address)[1]);
233		239
234	cur->address = NULL;	240	cur->address = NULL;
235		241
236	spinlock_unlock(&bkpoint_lock);	242	spinlock_unlock(&bkpoint_lock);
237	interrupts_restore(ipl);	243	interrupts_restore(ipl);
Line 250...	Line 256...
250	for (i = 0; i < BKPOINTS_MAX; i++)	256	for (i = 0; i < BKPOINTS_MAX; i++)
251	if (breakpoints[i].address) {	257	if (breakpoints[i].address) {
252	symbol = get_symtab_entry(breakpoints[i].address);	258	symbol = get_symtab_entry(breakpoints[i].address);
253		259
254	printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,	260	printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,
255	breakpoints[i].counter, breakpoints[i].address,	261	breakpoints[i].counter, breakpoints[i].address,
256	((breakpoints[i].flags & BKPOINT_INPROG) ? "true" : "false"),	262	((breakpoints[i].flags & BKPOINT_INPROG) ? "true" :
257	((breakpoints[i].flags & BKPOINT_ONESHOT) ? "true" : "false"),	263	"false"), ((breakpoints[i].flags & BKPOINT_ONESHOT)
-		264	? "true" : "false"), ((breakpoints[i].flags &
258	((breakpoints[i].flags & BKPOINT_FUNCCALL) ? "true" : "false"),	265	BKPOINT_FUNCCALL) ? "true" : "false"), symbol);
259	symbol);	-
260	}	266	}
261	return 1;	267	return 1;
262	}	268	}
263		269
264	/** Initialize debugger */	270	/** Initialize debugger */
265	void debugger_init()	271	void debugger_init()
266	{	272	{
267	int i;	273	int i;
268		274
269	for (i=0; i<BKPOINTS_MAX; i++)	275	for (i = 0; i < BKPOINTS_MAX; i++)
270	breakpoints[i].address = NULL;	276	breakpoints[i].address = NULL;
271		277
272	cmd_initialize(&bkpts_info);	278	cmd_initialize(&bkpts_info);
273	if (!cmd_register(&bkpts_info))	279	if (!cmd_register(&bkpts_info))
274	panic("could not register command %s\n", bkpts_info.name);	280	panic("could not register command %s\n", bkpts_info.name);
Line 303...	Line 309...
303	/* test branch delay slot */	309	/* test branch delay slot */
304	if (cp0_cause_read() & 0x80000000)	310	if (cp0_cause_read() & 0x80000000)
305	panic("Breakpoint in branch delay slot not supported.\n");	311	panic("Breakpoint in branch delay slot not supported.\n");
306		312
307	spinlock_lock(&bkpoint_lock);	313	spinlock_lock(&bkpoint_lock);
308	for (i=0; i<BKPOINTS_MAX; i++) {	314	for (i = 0; i < BKPOINTS_MAX; i++) {
309	/* Normal breakpoint */	315	/* Normal breakpoint */
310	if (fireaddr == breakpoints[i].address \	316	if (fireaddr == breakpoints[i].address &&
311	&& !(breakpoints[i].flags & BKPOINT_REINST)) {	317	!(breakpoints[i].flags & BKPOINT_REINST)) {
312	cur = &breakpoints[i];	318	cur = &breakpoints[i];
313	break;	319	break;
314	}	320	}
315	/* Reinst only breakpoint */	321	/* Reinst only breakpoint */
316	if ((breakpoints[i].flags & BKPOINT_REINST) \	322	if ((breakpoints[i].flags & BKPOINT_REINST) &&
317	&& (fireaddr == breakpoints[i].address + sizeof(unative_t))) {	323	(fireaddr == breakpoints[i].address + sizeof(unative_t))) {
318	cur = &breakpoints[i];	324	cur = &breakpoints[i];
319	break;	325	break;
320	}	326	}
321	}	327	}
322	if (cur) {	328	if (cur) {
323	if (cur->flags & BKPOINT_REINST) {	329	if (cur->flags & BKPOINT_REINST) {
324	/* Set breakpoint on first instruction */	330	/* Set breakpoint on first instruction */
325	((uint32_t *)cur->address)[0] = 0x0d;	331	((uint32_t *)cur->address)[0] = 0x0d;
-		332	smc_coherence(((uint32_t *)cur->address)[0]);
326	/* Return back the second */	333	/* Return back the second */
327	((uint32_t *)cur->address)[1] = cur->nextinstruction;	334	((uint32_t *)cur->address)[1] = cur->nextinstruction;
-		335	smc_coherence(((uint32_t *)cur->address)[1]);
328	cur->flags &= ~BKPOINT_REINST;	336	cur->flags &= ~BKPOINT_REINST;
329	spinlock_unlock(&bkpoint_lock);	337	spinlock_unlock(&bkpoint_lock);
330	return;	338	return;
331	}	339	}
332	if (cur->flags & BKPOINT_INPROG)	340	if (cur->flags & BKPOINT_INPROG)
333	printf("Warning: breakpoint recursion\n");	341	printf("Warning: breakpoint recursion\n");
334		342
335	if (!(cur->flags & BKPOINT_FUNCCALL))	343	if (!(cur->flags & BKPOINT_FUNCCALL))
336	printf("***Breakpoint %d: %p in %s.\n", i,	344	printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
337	fireaddr, get_symtab_entry(istate->epc));	345	get_symtab_entry(istate->epc));
338		346
339	/* Return first instruction back */	347	/* Return first instruction back */
340	((uint32_t *)cur->address)[0] = cur->instruction;	348	((uint32_t *)cur->address)[0] = cur->instruction;
-		349	smc_coherence(cur->address);
341		350
342	if (! (cur->flags & BKPOINT_ONESHOT)) {	351	if (! (cur->flags & BKPOINT_ONESHOT)) {
343	/* Set Breakpoint on next instruction */	352	/* Set Breakpoint on next instruction */
344	((uint32_t *)cur->address)[1] = 0x0d;	353	((uint32_t *)cur->address)[1] = 0x0d;
345	cur->flags \|= BKPOINT_REINST;	354	cur->flags \|= BKPOINT_REINST;

Subversion Repositories HelenOS

(root)/trunk/kernel/arch/mips32/src/debugger.c – Rev 3071 → 3139