Commit 84e8cd6d authored by David Howells's avatar David Howells Committed by Linus Torvalds
Browse files

[PATCH] FRV: Introduce asm-offsets for FRV arch 



Introduce the use of asm-offsets into the FRV architecture.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 6d8c4e3b

arch/frv/kernel/asm-offsets.c

+115 −1
Original line number Diff line number Diff line 
/* Dummy asm-offsets.c file. Required by kbuild and ready to be used - hint! */
 
/*

 * Generate definitions needed by assembly language modules.

 * This code generates raw asm output which is post-processed

 * to extract and format the required data.

 */



#include <linux/sched.h>

#include <linux/signal.h>

#include <linux/personality.h>

#include <asm/registers.h>

#include <asm/ucontext.h>

#include <asm/processor.h>

#include <asm/thread_info.h>

#include <asm/gdb-stub.h>



#define DEFINE(sym, val) \

        asm volatile("\n->" #sym " %0 " #val : : "i" (val))



#define DEF_PTREG(sym, reg) \

        asm volatile("\n->" #sym " %0 offsetof(struct pt_regs, " #reg ")" \

		     : : "i" (offsetof(struct pt_regs, reg)))



#define DEF_IREG(sym, reg) \

        asm volatile("\n->" #sym " %0 offsetof(struct user_context, " #reg ")" \

		     : : "i" (offsetof(struct user_context, reg)))



#define DEF_FREG(sym, reg) \

        asm volatile("\n->" #sym " %0 offsetof(struct user_context, " #reg ")" \

		     : : "i" (offsetof(struct user_context, reg)))



#define DEF_0REG(sym, reg) \

        asm volatile("\n->" #sym " %0 offsetof(struct frv_frame0, " #reg ")" \

		     : : "i" (offsetof(struct frv_frame0, reg)))



#define BLANK() asm volatile("\n->" : : )



#define OFFSET(sym, str, mem) \

	DEFINE(sym, offsetof(struct str, mem));



void foo(void)

{

	/* offsets into the thread_info structure */

	OFFSET(TI_TASK,			thread_info, task);

	OFFSET(TI_EXEC_DOMAIN,		thread_info, exec_domain);

	OFFSET(TI_FLAGS,		thread_info, flags);

	OFFSET(TI_STATUS,		thread_info, status);

	OFFSET(TI_CPU,			thread_info, cpu);

	OFFSET(TI_PREEMPT_COUNT,	thread_info, preempt_count);

	OFFSET(TI_ADDR_LIMIT,		thread_info, addr_limit);

	OFFSET(TI_RESTART_BLOCK,	thread_info, restart_block);

	BLANK();



	/* offsets into register file storage */

	DEF_PTREG(REG_PSR,		psr);

	DEF_PTREG(REG_ISR,		isr);

	DEF_PTREG(REG_CCR,		ccr);

	DEF_PTREG(REG_CCCR,		cccr);

	DEF_PTREG(REG_LR,		lr);

	DEF_PTREG(REG_LCR,		lcr);

	DEF_PTREG(REG_PC,		pc);

	DEF_PTREG(REG__STATUS,		__status);

	DEF_PTREG(REG_SYSCALLNO,	syscallno);

	DEF_PTREG(REG_ORIG_GR8,		orig_gr8);

	DEF_PTREG(REG_GNER0,		gner0);

	DEF_PTREG(REG_GNER1,		gner1);

	DEF_PTREG(REG_IACC0,		iacc0);

	DEF_PTREG(REG_TBR,		tbr);

	DEF_PTREG(REG_GR0,		tbr);

	DEFINE(REG__END,		sizeof(struct pt_regs));

	BLANK();



	DEF_0REG(REG_DCR,		debug.dcr);

	DEF_0REG(REG_IBAR0,		debug.ibar[0]);

	DEF_0REG(REG_DBAR0,		debug.dbar[0]);

	DEF_0REG(REG_DBDR00,		debug.dbdr[0][0]);

	DEF_0REG(REG_DBMR00,		debug.dbmr[0][0]);

	BLANK();



	DEF_IREG(__INT_GR0,		i.gr[0]);

	DEF_FREG(__USER_FPMEDIA,	f);

	DEF_FREG(__FPMEDIA_FR0,		f.fr[0]);

	DEF_FREG(__FPMEDIA_FNER0,	f.fner[0]);

	DEF_FREG(__FPMEDIA_MSR0,	f.msr[0]);

	DEF_FREG(__FPMEDIA_ACC0,	f.acc[0]);

	DEF_FREG(__FPMEDIA_ACCG0,	f.accg[0]);

	DEF_FREG(__FPMEDIA_FSR0,	f.fsr[0]);

	BLANK();



	DEFINE(NR_PT_REGS,		sizeof(struct pt_regs) / 4);

	DEFINE(NR_USER_INT_REGS,	sizeof(struct user_int_regs) / 4);

	DEFINE(NR_USER_FPMEDIA_REGS,	sizeof(struct user_fpmedia_regs) / 4);

	DEFINE(NR_USER_CONTEXT,		sizeof(struct user_context) / 4);

	DEFINE(FRV_FRAME0_SIZE,		sizeof(struct frv_frame0));

	BLANK();



	/* offsets into thread_struct */

	OFFSET(__THREAD_FRAME,		thread_struct, frame);

	OFFSET(__THREAD_CURR,		thread_struct, curr);

	OFFSET(__THREAD_SP,		thread_struct, sp);

	OFFSET(__THREAD_FP,		thread_struct, fp);

	OFFSET(__THREAD_LR,		thread_struct, lr);

	OFFSET(__THREAD_PC,		thread_struct, pc);

	OFFSET(__THREAD_GR16,		thread_struct, gr[0]);

	OFFSET(__THREAD_SCHED_LR,	thread_struct, sched_lr);

	OFFSET(__THREAD_FRAME0,		thread_struct, frame0);

	OFFSET(__THREAD_USER,		thread_struct, user);

	BLANK();



	/* offsets into frv_debug_status */

	OFFSET(DEBUG_BPSR,		frv_debug_status, bpsr);

	OFFSET(DEBUG_DCR,		frv_debug_status, dcr);

	OFFSET(DEBUG_BRR,		frv_debug_status, brr);

	OFFSET(DEBUG_NMAR,		frv_debug_status, nmar);

	BLANK();

}

arch/frv/kernel/break.S

+19 −15
Original line number Diff line number Diff line
@@ -9,11 +9,11 @@ 
 * 2 of the License, or (at your option) any later version.

 */



#include <linux/sys.h>

#include <linux/linkage.h>

#include <asm/setup.h>

#include <asm/segment.h>

#include <asm/ptrace.h>

#include <asm/thread_info.h>

#include <asm/spr-regs.h>



#include <asm/errno.h>
@@ -23,13 +23,11 @@ 
#

	.section	.bss.stack

	.globl		__break_user_context

	.balign		8192

	.balign		THREAD_SIZE

__break_stack:

	.space		(8192 - (USER_CONTEXT_SIZE + REG__DEBUG_XTRA)) & ~7

__break_stack_tos:

	.space		REG__DEBUG_XTRA

__break_user_context:

	.space		USER_CONTEXT_SIZE

	.space		THREAD_SIZE - FRV_FRAME0_SIZE

__break_frame_0:

	.space		FRV_FRAME0_SIZE



#

# miscellaneous variables
@@ -74,8 +72,8 @@ __entry_break: 
#endif

	LEDS		0x1001,gr31



	sethi.p		%hi(__break_user_context),gr31

	setlo		%lo(__break_user_context),gr31

	sethi.p		%hi(__break_frame_0),gr31

	setlo		%lo(__break_frame_0),gr31



	stdi		gr2,@(gr31,#REG_GR(2))

	movsg		ccr,gr3
@@ -585,8 +583,8 @@ __break_continue: 
	# set up the kernel stack pointer

	sti		sp,@(gr31,#REG_SP)



	sethi.p		%hi(__break_stack_tos),sp

	setlo		%lo(__break_stack_tos),sp

	sethi.p		%hi(__break_frame_0),sp

	setlo		%lo(__break_frame_0),sp



	# finish building the exception frame

	stdi		gr4 ,@(gr31,#REG_GR(4))
@@ -651,9 +649,12 @@ __break_continue: 
	movsg		nmar,gr5

	movsg		dcr,gr6



	stdi		gr4 ,@(gr31,#REG_BRR)

	sti		gr19,@(gr31,#REG_BPSR)

	sti.p		gr6 ,@(gr31,#REG_DCR)

	sethi.p		%hi(__debug_status),gr7

	setlo		%lo(__debug_status),gr7



	stdi		gr4 ,@(gr7,#DEBUG_BRR)

	sti		gr19,@(gr7,#DEBUG_BPSR)

	sti.p		gr6 ,@(gr7,#DEBUG_DCR)



	# trap exceptions during break handling and disable h/w breakpoints/watchpoints

	sethi		%hi(DCR_EBE),gr5
@@ -698,7 +699,10 @@ __break_continue: 
	lddi		@(gr31,#REG_PSR) ,gr22

	ldi		@(gr31,#REG_PC)  ,gr21

	ldi		@(gr31,#REG_TBR) ,gr20

	ldi.p		@(gr31,#REG_DCR) ,gr6



	sethi.p		%hi(__debug_status),gr6

	setlo		%lo(__debug_status),gr6

	ldi.p		@(gr6,#DEBUG_DCR) ,gr6



	andi		gr22,#PSR_S,gr19		/* rebuild BPSR */

	andi.p		gr22,#PSR_ET,gr5

arch/frv/kernel/debug-stub.c

+6 −7
Original line number Diff line number Diff line
@@ -39,10 +39,9 @@ do { \ 
	gdbstub_do_rx();			\

} while(!FLOWCTL_QUERY(LINE))



static void __init debug_stub_init(void);

struct frv_debug_status __debug_status;



extern asmlinkage void __break_hijack_kernel_event(void);

extern asmlinkage void __break_hijack_kernel_event_breaks_here(void);

static void __init debug_stub_init(void);



/*****************************************************************************/

/*
@@ -67,7 +66,7 @@ asmlinkage void debug_stub(void) 
		__set_HSR(0, hsr0 & ~HSR0_ETMD);



	/* disable single stepping */

	__debug_regs->dcr &= ~DCR_SE;

	__debug_status.dcr &= ~DCR_SE;



	/* kernel mode can propose an exception be handled in debug mode by jumping to a special

	 * location */
@@ -76,8 +75,8 @@ asmlinkage void debug_stub(void) 
		 * the top kernel context */

		*__debug_frame = *__frame;

		__frame = __debug_frame->next_frame;

		__debug_regs->brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_regs->brr |= BRR_EB;

		__debug_status.brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_status.brr |= BRR_EB;

	}



	if (__debug_frame->pc == (unsigned long) __debug_bug_trap + 4) {
@@ -124,7 +123,7 @@ static void __init debug_stub_init(void) 
		__debug_frame->pc = (unsigned long) start_kernel;



	/* enable the debug events we want to trap */

	__debug_regs->dcr = DCR_EBE;

	__debug_status.dcr = DCR_EBE;



#ifdef CONFIG_GDBSTUB

	gdbstub_init();

arch/frv/kernel/entry.S

+0 −1
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ 
 *

 */



#include <linux/sys.h>

#include <linux/linkage.h>

#include <asm/thread_info.h>

#include <asm/setup.h>

arch/frv/kernel/gdb-stub.c

+90 −69
Original line number Diff line number Diff line
@@ -124,6 +124,7 @@ 
#include <linux/slab.h>

#include <linux/nmi.h>



#include <asm/asm-offsets.h>

#include <asm/pgtable.h>

#include <asm/system.h>

#include <asm/gdb-stub.h>
@@ -136,7 +137,6 @@ extern void debug_to_serial(const char *p, int n); 
extern void gdbstub_console_write(struct console *co, const char *p, unsigned n);



extern volatile uint32_t __break_error_detect[3]; /* ESFR1, ESR15, EAR15 */

extern struct user_context __break_user_context;



struct __debug_amr {

	unsigned long L, P;
@@ -926,6 +926,7 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & DCR_IBE0)) {

			//gdbstub_printk("set h/w break 0: %08lx\n", addr);

			__debug_regs->dcr |= DCR_IBE0;

			__debug_regs->ibar[0] = addr;

			asm volatile("movgs %0,ibar0" : : "r"(addr));

			return 0;

		}
@@ -933,6 +934,7 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & DCR_IBE1)) {

			//gdbstub_printk("set h/w break 1: %08lx\n", addr);

			__debug_regs->dcr |= DCR_IBE1;

			__debug_regs->ibar[1] = addr;

			asm volatile("movgs %0,ibar1" : : "r"(addr));

			return 0;

		}
@@ -940,6 +942,7 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & DCR_IBE2)) {

			//gdbstub_printk("set h/w break 2: %08lx\n", addr);

			__debug_regs->dcr |= DCR_IBE2;

			__debug_regs->ibar[2] = addr;

			asm volatile("movgs %0,ibar2" : : "r"(addr));

			return 0;

		}
@@ -947,6 +950,7 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & DCR_IBE3)) {

			//gdbstub_printk("set h/w break 3: %08lx\n", addr);

			__debug_regs->dcr |= DCR_IBE3;

			__debug_regs->ibar[3] = addr;

			asm volatile("movgs %0,ibar3" : : "r"(addr));

			return 0;

		}
@@ -971,7 +975,14 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & (DCR_DRBE0|DCR_DWBE0))) {

			//gdbstub_printk("set h/w watchpoint 0 type %ld: %08lx\n", type, addr);

			tmp = type==2 ? DCR_DWBE0 : type==3 ? DCR_DRBE0 : DCR_DRBE0|DCR_DWBE0;



			__debug_regs->dcr |= tmp;

			__debug_regs->dbar[0] = addr;

			__debug_regs->dbmr[0][0] = dbmr.mask0;

			__debug_regs->dbmr[0][1] = dbmr.mask1;

			__debug_regs->dbdr[0][0] = 0;

			__debug_regs->dbdr[0][1] = 0;



			asm volatile("	movgs	%0,dbar0	\n"

				     "	movgs	%1,dbmr00	\n"

				     "	movgs	%2,dbmr01	\n"
@@ -984,7 +995,14 @@ static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsign 
		if (!(__debug_regs->dcr & (DCR_DRBE1|DCR_DWBE1))) {

			//gdbstub_printk("set h/w watchpoint 1 type %ld: %08lx\n", type, addr);

			tmp = type==2 ? DCR_DWBE1 : type==3 ? DCR_DRBE1 : DCR_DRBE1|DCR_DWBE1;



			__debug_regs->dcr |= tmp;

			__debug_regs->dbar[1] = addr;

			__debug_regs->dbmr[1][0] = dbmr.mask0;

			__debug_regs->dbmr[1][1] = dbmr.mask1;

			__debug_regs->dbdr[1][0] = 0;

			__debug_regs->dbdr[1][1] = 0;



			asm volatile("	movgs	%0,dbar1	\n"

				     "	movgs	%1,dbmr10	\n"

				     "	movgs	%2,dbmr11	\n"
@@ -1047,6 +1065,7 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 
		if (__debug_regs->dcr & DCR_IBE0 && __get_ibar(0) == addr) {

			//gdbstub_printk("clear h/w break 0: %08lx\n", addr);

			__debug_regs->dcr &= ~DCR_IBE0;

			__debug_regs->ibar[0] = 0;

			asm volatile("movgs gr0,ibar0");

			return 0;

		}
@@ -1054,6 +1073,7 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 
		if (__debug_regs->dcr & DCR_IBE1 && __get_ibar(1) == addr) {

			//gdbstub_printk("clear h/w break 1: %08lx\n", addr);

			__debug_regs->dcr &= ~DCR_IBE1;

			__debug_regs->ibar[1] = 0;

			asm volatile("movgs gr0,ibar1");

			return 0;

		}
@@ -1061,6 +1081,7 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 
		if (__debug_regs->dcr & DCR_IBE2 && __get_ibar(2) == addr) {

			//gdbstub_printk("clear h/w break 2: %08lx\n", addr);

			__debug_regs->dcr &= ~DCR_IBE2;

			__debug_regs->ibar[2] = 0;

			asm volatile("movgs gr0,ibar2");

			return 0;

		}
@@ -1068,6 +1089,7 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 
		if (__debug_regs->dcr & DCR_IBE3 && __get_ibar(3) == addr) {

			//gdbstub_printk("clear h/w break 3: %08lx\n", addr);

			__debug_regs->dcr &= ~DCR_IBE3;

			__debug_regs->ibar[3] = 0;

			asm volatile("movgs gr0,ibar3");

			return 0;

		}
@@ -1104,6 +1126,12 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 


		//gdbstub_printk("clear h/w watchpoint 0 type %ld: %08lx\n", type, addr);

		__debug_regs->dcr &= ~(DCR_DRBE0|DCR_DWBE0);

		__debug_regs->dbar[0] = 0;

		__debug_regs->dbmr[0][0] = 0;

		__debug_regs->dbmr[0][1] = 0;

		__debug_regs->dbdr[0][0] = 0;

		__debug_regs->dbdr[0][1] = 0;



		asm volatile("	movgs	gr0,dbar0	\n"

			     "	movgs	gr0,dbmr00	\n"

			     "	movgs	gr0,dbmr01	\n"
@@ -1123,6 +1151,12 @@ int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned lo 


		//gdbstub_printk("clear h/w watchpoint 1 type %ld: %08lx\n", type, addr);

		__debug_regs->dcr &= ~(DCR_DRBE1|DCR_DWBE1);

		__debug_regs->dbar[1] = 0;

		__debug_regs->dbmr[1][0] = 0;

		__debug_regs->dbmr[1][1] = 0;

		__debug_regs->dbdr[1][0] = 0;

		__debug_regs->dbdr[1][1] = 0;



		asm volatile("	movgs	gr0,dbar1	\n"

			     "	movgs	gr0,dbmr10	\n"

			     "	movgs	gr0,dbmr11	\n"
@@ -1163,7 +1197,7 @@ static void gdbstub_check_breakpoint(void) 
 */

static void __attribute__((unused)) gdbstub_show_regs(void)

{

	uint32_t *reg;

	unsigned long *reg;

	int loop;



	gdbstub_printk("\n");
@@ -1172,11 +1206,11 @@ static void __attribute__((unused)) gdbstub_show_regs(void) 
		       __debug_frame,

		       __debug_frame->psr & PSR_S ? "kernel" : "user");



	reg = (uint32_t *) __debug_frame;

	for (loop = 0; loop < REG__END; loop++) {

		printk("%s %08x", regnames[loop + 0], reg[loop + 0]);

	reg = (unsigned long *) __debug_frame;

	for (loop = 0; loop < NR_PT_REGS; loop++) {

		printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);



		if (loop == REG__END - 1 || loop % 5 == 4)

		if (loop == NR_PT_REGS - 1 || loop % 5 == 4)

			printk("\n");

		else

			printk(" | ");
@@ -1191,13 +1225,8 @@ static void __attribute__((unused)) gdbstub_show_regs(void) 
 */

static void __attribute__((unused)) gdbstub_dump_debugregs(void)

{

	unsigned long x;



	x = __debug_regs->dcr;

	gdbstub_printk("DCR    %08lx  ", x);



	x = __debug_regs->brr;

	gdbstub_printk("BRR %08lx\n", x);

	gdbstub_printk("DCR    %08lx  ", __debug_status.dcr);

	gdbstub_printk("BRR    %08lx\n", __debug_status.brr);



	gdbstub_printk("IBAR0  %08lx  ", __get_ibar(0));

	gdbstub_printk("IBAR1  %08lx  ", __get_ibar(1));
@@ -1360,7 +1389,7 @@ void gdbstub(int sigval) 
#endif

	}



	save_user_regs(&__break_user_context);

	save_user_regs(&__debug_frame0->uc);



#if 0

	gdbstub_printk("--> gdbstub() %08x %p %08x %08x\n",
@@ -1389,8 +1418,8 @@ void gdbstub(int sigval) 
		__debug_frame->psr &= ~PSR_S;

		if (__debug_frame->psr & PSR_PS)

			__debug_frame->psr |= PSR_S;

		__debug_regs->brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_regs->brr |= BRR_EB;

		__debug_status.brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_status.brr |= BRR_EB;

		sigval = SIGINT;

	}
@@ -1404,15 +1433,15 @@ void gdbstub(int sigval) 
		__debug_frame->psr &= ~PSR_S;

		if (__debug_frame->psr & PSR_PS)

			__debug_frame->psr |= PSR_S;

		__debug_regs->brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_regs->brr |= BRR_EB;

		__debug_status.brr = (__debug_frame->tbr & TBR_TT) << 12;

		__debug_status.brr |= BRR_EB;

		sigval = SIGXCPU;

	}



	LEDS(0x5002);



	/* after a BREAK insn, the PC lands on the far side of it */

	if (__debug_regs->brr & BRR_SB)

	if (__debug_status.brr & BRR_SB)

		gdbstub_check_breakpoint();



	LEDS(0x5003);
@@ -1431,7 +1460,7 @@ void gdbstub(int sigval) 
	}



	if (!sigval)

		sigval = gdbstub_compute_signal(__debug_regs->brr);

		sigval = gdbstub_compute_signal(__debug_status.brr);



	LEDS(0x5004);
@@ -1441,7 +1470,7 @@ void gdbstub(int sigval) 
	if (sigval != SIGINT && sigval != SIGTRAP && sigval != SIGILL) {

		static const char title[] = "Break ";

		static const char crlf[] = "\r\n";

		unsigned long brr = __debug_regs->brr;

		unsigned long brr = __debug_status.brr;

		char hx;



		ptr = output_buffer;
@@ -1565,28 +1594,24 @@ void gdbstub(int sigval) 
			ptr = mem2hex(&zero, ptr, 4, 0);



			for (loop = 1; loop <= 27; loop++)

				ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(loop),

					      ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->i.gr[loop], ptr, 4, 0);

			temp = (unsigned long) __frame;

			ptr = mem2hex(&temp, ptr, 4, 0);

			ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(29), ptr, 4, 0);

			ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(30), ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->i.gr[29], ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->i.gr[30], ptr, 4, 0);

#ifdef CONFIG_MMU

			ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(31), ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->i.gr[31], ptr, 4, 0);

#else

			temp = (unsigned long) __debug_frame;

			ptr = mem2hex(&temp, ptr, 4, 0);

#endif



			for (loop = 32; loop <= 63; loop++)

				ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(loop),

					      ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->i.gr[loop], ptr, 4, 0);



			/* deal with FR0-FR63 */

			for (loop = 0; loop <= 63; loop++)

				ptr = mem2hex((unsigned long *)&__break_user_context +

					      __FPMEDIA_FR(loop),

					      ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->f.fr[loop], ptr, 4, 0);



			/* deal with special registers */

			ptr = mem2hex(&__debug_frame->pc,    ptr, 4, 0);
@@ -1597,7 +1622,7 @@ void gdbstub(int sigval) 
			ptr = mem2hex(&zero, ptr, 4, 0);

			ptr = mem2hex(&zero, ptr, 4, 0);

			ptr = mem2hex(&__debug_frame->tbr,   ptr, 4, 0);

			ptr = mem2hex(&__debug_regs->brr ,   ptr, 4, 0);

			ptr = mem2hex(&__debug_status.brr ,   ptr, 4, 0);



			asm volatile("movsg dbar0,%0" : "=r"(dbar));

			ptr = mem2hex(&dbar, ptr, 4, 0);
@@ -1622,21 +1647,21 @@ void gdbstub(int sigval) 


			ptr = mem2hex(&__debug_frame->iacc0, ptr, 8, 0);



			ptr = mem2hex(&__break_user_context.f.fsr[0], ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->f.fsr[0], ptr, 4, 0);



			for (loop = 0; loop <= 7; loop++)

				ptr = mem2hex(&__break_user_context.f.acc[loop], ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->f.acc[loop], ptr, 4, 0);



			ptr = mem2hex(&__break_user_context.f.accg, ptr, 8, 0);

			ptr = mem2hex(&__debug_user_context->f.accg, ptr, 8, 0);



			for (loop = 0; loop <= 1; loop++)

				ptr = mem2hex(&__break_user_context.f.msr[loop], ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->f.msr[loop], ptr, 4, 0);



			ptr = mem2hex(&__debug_frame->gner0, ptr, 4, 0);

			ptr = mem2hex(&__debug_frame->gner1, ptr, 4, 0);



			ptr = mem2hex(&__break_user_context.f.fner[0], ptr, 4, 0);

			ptr = mem2hex(&__break_user_context.f.fner[1], ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->f.fner[0], ptr, 4, 0);

			ptr = mem2hex(&__debug_user_context->f.fner[1], ptr, 4, 0);



			break;
@@ -1648,8 +1673,7 @@ void gdbstub(int sigval) 
			ptr = hex2mem(ptr, &temp, 4);



			for (loop = 1; loop <= 27; loop++)

				ptr = hex2mem(ptr, (unsigned long *)__debug_frame + REG_GR(loop),

					      4);

				ptr = hex2mem(ptr, &__debug_user_context->i.gr[loop], 4);



			ptr = hex2mem(ptr, &temp, 4);

			__frame = (struct pt_regs *) temp;
@@ -1662,14 +1686,11 @@ void gdbstub(int sigval) 
#endif



			for (loop = 32; loop <= 63; loop++)

				ptr = hex2mem(ptr, (unsigned long *)__debug_frame + REG_GR(loop),

					      4);

				ptr = hex2mem(ptr, &__debug_user_context->i.gr[loop], 4);



			/* deal with FR0-FR63 */

			for (loop = 0; loop <= 63; loop++)

				ptr = mem2hex((unsigned long *)&__break_user_context +

					      __FPMEDIA_FR(loop),

					      ptr, 4, 0);

				ptr = mem2hex(&__debug_user_context->f.fr[loop], ptr, 4, 0);



			/* deal with special registers */

			ptr = hex2mem(ptr, &__debug_frame->pc,  4);
@@ -1694,21 +1715,21 @@ void gdbstub(int sigval) 


			ptr = hex2mem(ptr, &__debug_frame->iacc0, 8);



			ptr = hex2mem(ptr, &__break_user_context.f.fsr[0], 4);

			ptr = hex2mem(ptr, &__debug_user_context->f.fsr[0], 4);



			for (loop = 0; loop <= 7; loop++)

				ptr = hex2mem(ptr, &__break_user_context.f.acc[loop], 4);

				ptr = hex2mem(ptr, &__debug_user_context->f.acc[loop], 4);



			ptr = hex2mem(ptr, &__break_user_context.f.accg, 8);

			ptr = hex2mem(ptr, &__debug_user_context->f.accg, 8);



			for (loop = 0; loop <= 1; loop++)

				ptr = hex2mem(ptr, &__break_user_context.f.msr[loop], 4);

				ptr = hex2mem(ptr, &__debug_user_context->f.msr[loop], 4);



			ptr = hex2mem(ptr, &__debug_frame->gner0, 4);

			ptr = hex2mem(ptr, &__debug_frame->gner1, 4);



			ptr = hex2mem(ptr, &__break_user_context.f.fner[0], 4);

			ptr = hex2mem(ptr, &__break_user_context.f.fner[1], 4);

			ptr = hex2mem(ptr, &__debug_user_context->f.fner[0], 4);

			ptr = hex2mem(ptr, &__debug_user_context->f.fner[1], 4);



			gdbstub_strcpy(output_buffer,"OK");

			break;
@@ -1769,52 +1790,52 @@ void gdbstub(int sigval) 
			case GDB_REG_GR(0):

				break;

			case GDB_REG_GR(1) ... GDB_REG_GR(63):

				__break_user_context.i.gr[addr - GDB_REG_GR(0)] = temp;

				__debug_user_context->i.gr[addr - GDB_REG_GR(0)] = temp;

				break;

			case GDB_REG_FR(0) ... GDB_REG_FR(63):

				__break_user_context.f.fr[addr - GDB_REG_FR(0)] = temp;

				__debug_user_context->f.fr[addr - GDB_REG_FR(0)] = temp;

				break;

			case GDB_REG_PC:

				__break_user_context.i.pc = temp;

				__debug_user_context->i.pc = temp;

				break;

			case GDB_REG_PSR:

				__break_user_context.i.psr = temp;

				__debug_user_context->i.psr = temp;

				break;

			case GDB_REG_CCR:

				__break_user_context.i.ccr = temp;

				__debug_user_context->i.ccr = temp;

				break;

			case GDB_REG_CCCR:

				__break_user_context.i.cccr = temp;

				__debug_user_context->i.cccr = temp;

				break;

			case GDB_REG_BRR:

				__debug_regs->brr = temp;

				__debug_status.brr = temp;

				break;

			case GDB_REG_LR:

				__break_user_context.i.lr = temp;

				__debug_user_context->i.lr = temp;

				break;

			case GDB_REG_LCR:

				__break_user_context.i.lcr = temp;

				__debug_user_context->i.lcr = temp;

				break;

			case GDB_REG_FSR0:

				__break_user_context.f.fsr[0] = temp;

				__debug_user_context->f.fsr[0] = temp;

				break;

			case GDB_REG_ACC(0) ... GDB_REG_ACC(7):

				__break_user_context.f.acc[addr - GDB_REG_ACC(0)] = temp;

				__debug_user_context->f.acc[addr - GDB_REG_ACC(0)] = temp;

				break;

			case GDB_REG_ACCG(0):

				*(uint32_t *) &__break_user_context.f.accg[0] = temp;

				*(uint32_t *) &__debug_user_context->f.accg[0] = temp;

				break;

			case GDB_REG_ACCG(4):

				*(uint32_t *) &__break_user_context.f.accg[4] = temp;

				*(uint32_t *) &__debug_user_context->f.accg[4] = temp;

				break;

			case GDB_REG_MSR(0) ... GDB_REG_MSR(1):

				__break_user_context.f.msr[addr - GDB_REG_MSR(0)] = temp;

				__debug_user_context->f.msr[addr - GDB_REG_MSR(0)] = temp;

				break;

			case GDB_REG_GNER(0) ... GDB_REG_GNER(1):

				__break_user_context.i.gner[addr - GDB_REG_GNER(0)] = temp;

				__debug_user_context->i.gner[addr - GDB_REG_GNER(0)] = temp;

				break;

			case GDB_REG_FNER(0) ... GDB_REG_FNER(1):

				__break_user_context.f.fner[addr - GDB_REG_FNER(0)] = temp;

				__debug_user_context->f.fner[addr - GDB_REG_FNER(0)] = temp;

				break;

			default:

				temp2 = 0;
@@ -1850,6 +1871,7 @@ void gdbstub(int sigval) 
			/* step to next instruction */

		case 's':

			__debug_regs->dcr |= DCR_SE;

			__debug_status.dcr |= DCR_SE;

			goto done;



			/* set baud rate (bBB) */
@@ -1934,7 +1956,7 @@ void gdbstub(int sigval) 
	}



 done:

	restore_user_regs(&__break_user_context);

	restore_user_regs(&__debug_frame0->uc);



	//gdbstub_dump_debugregs();

	//gdbstub_printk("<-- gdbstub() %08x\n", __debug_frame->pc);
@@ -1966,7 +1988,6 @@ void __init gdbstub_init(void) 
#endif



	gdbstub_printk("%s", gdbstub_banner);

	gdbstub_printk("DCR: %x\n", __debug_regs->dcr);



	gdbstub_io_init();