[people/ms/u-boot.git] / examples / standalone / stubs.c

#include <common.h>
#include <exports.h>
#include <linux/compiler.h>

#define FO(x) offsetof(struct jt_funcs, x)

#if defined(CONFIG_X86)
/*
 * x86 does not have a dedicated register to store the pointer to
 * the global_data. Thus the jump table address is stored in a
 * global variable, but such approach does not allow for execution
 * from flash memory. The global_data address is passed as argv[-1]
 * to the application program.
 */
static struct jt_funcs *jt;
gd_t *global_data;

#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	movl	%0, %%eax\n"		\
"	movl	jt, %%ecx\n"		\
"	jmp	*(%%ecx, %%eax)\n"	\
	: : "i"(FO(x)) : "eax", "ecx");
#elif defined(CONFIG_PPC)
/*
 * r2 holds the pointer to the global_data, r11 is a call-clobbered
 * register
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	lwz	%%r11, %0(%%r2)\n"	\
"	lwz	%%r11, %1(%%r11)\n"	\
"	mtctr	%%r11\n"		\
"	bctr\n"				\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r11");
#elif defined(CONFIG_ARM)
#ifdef CONFIG_ARM64
/*
 * x18 holds the pointer to the global_data, x9 is a call-clobbered
 * register
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	ldr	x9, [x18, %0]\n"		\
"	ldr	x9, [x9, %1]\n"		\
"	br	x9\n"		\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "x9");
#else
/*
 * r9 holds the pointer to the global_data, ip is a call-clobbered
 * register
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	ldr	ip, [r9, %0]\n"		\
"	ldr	pc, [ip, %1]\n"		\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "ip");
#endif
#elif defined(CONFIG_MIPS)
#ifdef CONFIG_CPU_MIPS64
/*
 * k0 ($26) holds the pointer to the global_data; t9 ($25) is a call-
 * clobbered register that is also used to set gp ($26). Note that the
 * jr instruction also executes the instruction immediately following
 * it; however, GCC/mips generates an additional `nop' after each asm
 * statement
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	ld	$25, %0($26)\n"		\
"	ld	$25, %1($25)\n"		\
"	jr	$25\n"			\
        : : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "t9");
#else
/*
 * k0 ($26) holds the pointer to the global_data; t9 ($25) is a call-
 * clobbered register that is also used to set gp ($26). Note that the
 * jr instruction also executes the instruction immediately following
 * it; however, GCC/mips generates an additional `nop' after each asm
 * statement
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	lw	$25, %0($26)\n"		\
"	lw	$25, %1($25)\n"		\
"	jr	$25\n"			\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "t9");
#endif
#elif defined(CONFIG_NIOS2)
/*
 * gp holds the pointer to the global_data, r8 is call-clobbered
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	movhi	r8, %%hi(%0)\n"		\
"	ori	r8, r0, %%lo(%0)\n"	\
"	add	r8, r8, gp\n"		\
"	ldw	r8, 0(r8)\n"		\
"	ldw	r8, %1(r8)\n"		\
"	jmp	r8\n"			\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "gp");
#elif defined(CONFIG_M68K)
/*
 * d7 holds the pointer to the global_data, a0 is a call-clobbered
 * register
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	move.l	%%d7, %%a0\n"		\
"	adda.l	%0, %%a0\n"		\
"	move.l	(%%a0), %%a0\n"		\
"	adda.l	%1, %%a0\n"		\
"	move.l	(%%a0), %%a0\n"		\
"	jmp	(%%a0)\n"			\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "a0");
#elif defined(CONFIG_MICROBLAZE)
/*
 * r31 holds the pointer to the global_data. r5 is a call-clobbered.
 */
#define EXPORT_FUNC(f, a, x, ...)				\
	asm volatile (				\
"	.globl " #x "\n"			\
#x ":\n"					\
"	lwi	r5, r31, %0\n"			\
"	lwi	r5, r5, %1\n"			\
"	bra	r5\n"				\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r5");
#elif defined(CONFIG_AVR32)
/*
 * r6 holds the pointer to the global_data. r8 is call clobbered.
 */
#define EXPORT_FUNC(f, a, x, ...)					\
	asm volatile(					\
		"	.globl\t" #x "\n"		\
		#x ":\n"				\
		"	ld.w	r8, r6[%0]\n"		\
		"	ld.w	pc, r8[%1]\n"		\
		:					\
		: "i"(offsetof(gd_t, jt)), "i"(FO(x))	\
		: "r8");
#elif defined(CONFIG_SH)
/*
 * r13 holds the pointer to the global_data. r1 is a call clobbered.
 */
#define EXPORT_FUNC(f, a, x, ...)					\
	asm volatile (					\
		"	.align	2\n"			\
		"	.globl " #x "\n"		\
		#x ":\n"				\
		"	mov	r13, r1\n"		\
		"	add	%0, r1\n"		\
		"	mov.l @r1, r2\n"	\
		"	add	%1, r2\n"		\
		"	mov.l @r2, r1\n"	\
		"	jmp	@r1\n"			\
		"	nop\n"				\
		"	nop\n"				\
		: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r1", "r2");
#elif defined(CONFIG_NDS32)
/*
 * r16 holds the pointer to the global_data. gp is call clobbered.
 * not support reduced register (16 GPR).
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	lwi	$r16, [$gp + (%0)]\n"	\
"	lwi	$r16, [$r16 + (%1)]\n"	\
"	jr	$r16\n"			\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "$r16");
#elif defined(CONFIG_OPENRISC)
/*
 * r10 holds the pointer to the global_data, r13 is a call-clobbered
 * register
 */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile (			\
"	.globl " #x "\n"		\
#x ":\n"				\
"	l.lwz	r13, %0(r10)\n"	\
"	l.lwz	r13, %1(r13)\n"	\
"	l.jr	r13\n"		\
"	l.nop\n"				\
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r13");
#elif defined(CONFIG_ARC)
/*
 * r25 holds the pointer to the global_data. r10 is call clobbered.
  */
#define EXPORT_FUNC(f, a, x, ...) \
	asm volatile( \
"	.align 4\n" \
"	.globl " #x "\n" \
#x ":\n" \
"	ld	r10, [r25, %0]\n" \
"	ld	r10, [r10, %1]\n" \
"	j	[r10]\n" \
	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r10");
#elif defined(CONFIG_XTENSA)
/*
 * Global data ptr is in global_data, jump table ptr is in jt.
 * Windowed ABI: Jump just past 'entry' in target and adjust stack frame
 * (extract stack frame size from target 'entry' instruction).
 */

static void **jt;

#if defined(__XTENSA_CALL0_ABI__)
#define EXPORT_FUNC(f, a, x, ...)	\
	asm volatile (			\
"	.extern jt\n"			\
"	.globl " #x "\n"		\
"	.align 4\n"			\
#x ":\n"				\
"	l32i	a8, %0, 0\n"		\
"	l32i	a8, a8, %1\n"		\
"	jx	a8\n"			\
	: : "r"(jt), "i" (FO(x)) : "a8");
#elif defined(__XTENSA_WINDOWED_ABI__)
#if XCHAL_HAVE_BE
# define SFT "8"
#else
# define SFT "12"
#endif
#define EXPORT_FUNC(f, a, x, ...)	\
	asm volatile (			\
"	.extern jt\n"			\
"	.globl " #x "\n"		\
"	.align 4\n"			\
#x ":\n"				\
"	entry	sp, 16\n"		\
"	l32i	a8, %0, 0\n"		\
"	l32i	a8, a8, %1\n"		\
"	l32i	a9, a8, 0\n"		\
"	extui	a9, a9, " SFT ", 12\n"	\
"	subx8	a9, a9, sp\n"		\
"	movi	a10, 16\n"		\
"	sub	a9, a10, a9\n"		\
"	movsp	sp, a9\n"		\
"	addi	a8, a8, 3\n"		\
"	jx	a8\n"			\
	: : "r"(jt), "i" (FO(x)) : "a8", "a9", "a10");
#else
#error Unsupported Xtensa ABI
#endif
#else
/*"	addi	$sp, $sp, -24\n"	\
"	br	$r16\n"			\*/

#error stubs definition missing for this architecture
#endif

/* This function is necessary to prevent the compiler from
 * generating prologue/epilogue, preparing stack frame etc.
 * The stub functions are special, they do not use the stack
 * frame passed to them, but pass it intact to the actual
 * implementation. On the other hand, asm() statements with
 * arguments can be used only inside the functions (gcc limitation)
 */
#if GCC_VERSION < 30400
static
#endif /* GCC_VERSION */
void __attribute__((unused)) dummy(void)
{
#include <_exports.h>
}

#include <asm/sections.h>

void app_startup(char * const *argv)
{
	char *cp = __bss_start;

	/* Zero out BSS */
	while (cp < _end)
		*cp++ = 0;

#if defined(CONFIG_X86)
	/* x86 does not have a dedicated register for passing global_data */
	global_data = (gd_t *)argv[-1];
	jt = global_data->jt;
#endif
}

#undef EXPORT_FUNC
Commit	Line	Data
0910d0bc	1	#include <common.h>
27b207fd	2	#include <exports.h>
2d5db193	3	#include <linux/compiler.h>
93f6a677	4
49cad547 MD	5	#define FO(x) offsetof(struct jt_funcs, x)
49cad547 MD	6
fea25720	7	#if defined(CONFIG_X86)
27b207fd WD	8	/*
	9	* x86 does not have a dedicated register to store the pointer to
	10	* the global_data. Thus the jump table address is stored in a
	11	* global variable, but such approach does not allow for execution
	12	* from flash memory. The global_data address is passed as argv[-1]
	13	* to the application program.
	14	*/
49cad547	15	static struct jt_funcs *jt;
77846748	16	gd_t *global_data;
27b207fd	17
49cad547	18	#define EXPORT_FUNC(f, a, x, ...) \
27b207fd WD	19	asm volatile ( \
	20	" .globl " #x "\n" \
	21	#x ":\n" \
	22	" movl %0, %%eax\n" \
	23	" movl jt, %%ecx\n" \
	24	" jmp *(%%ecx, %%eax)\n" \
49cad547	25	: : "i"(FO(x)) : "eax", "ecx");
27b207fd WD	26	#elif defined(CONFIG_PPC)
27b207fd WD	27	/*
e7670f6c	28	* r2 holds the pointer to the global_data, r11 is a call-clobbered
27b207fd WD	29	* register
27b207fd WD	30	*/
49cad547	31	#define EXPORT_FUNC(f, a, x, ...) \
27b207fd WD	32	asm volatile ( \
	33	" .globl " #x "\n" \
	34	#x ":\n" \
e7670f6c	35	" lwz %%r11, %0(%%r2)\n" \
27b207fd WD	36	" lwz %%r11, %1(%%r11)\n" \
	37	" mtctr %%r11\n" \
	38	" bctr\n" \
49cad547	39	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r11");
27b207fd	40	#elif defined(CONFIG_ARM)
0ae76531 DF	41	#ifdef CONFIG_ARM64
	42	/*
	43	* x18 holds the pointer to the global_data, x9 is a call-clobbered
	44	* register
	45	*/
49cad547	46	#define EXPORT_FUNC(f, a, x, ...) \
0ae76531 DF	47	asm volatile ( \
	48	" .globl " #x "\n" \
	49	#x ":\n" \
	50	" ldr x9, [x18, %0]\n" \
	51	" ldr x9, [x9, %1]\n" \
	52	" br x9\n" \
49cad547	53	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "x9");
0ae76531	54	#else
27b207fd	55	/*
a5a42eec	56	* r9 holds the pointer to the global_data, ip is a call-clobbered
27b207fd WD	57	* register
27b207fd WD	58	*/
49cad547	59	#define EXPORT_FUNC(f, a, x, ...) \
27b207fd WD	60	asm volatile ( \
	61	" .globl " #x "\n" \
	62	#x ":\n" \
a5a42eec	63	" ldr ip, [r9, %0]\n" \
27b207fd	64	" ldr pc, [ip, %1]\n" \
49cad547	65	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "ip");
0ae76531	66	#endif
27b207fd	67	#elif defined(CONFIG_MIPS)
4a48cfc4 SG	68	#ifdef CONFIG_CPU_MIPS64
	69	/*
	70	* k0 ($26) holds the pointer to the global_data; t9 ($25) is a call-
	71	* clobbered register that is also used to set gp ($26). Note that the
	72	* jr instruction also executes the instruction immediately following
	73	* it; however, GCC/mips generates an additional `nop' after each asm
	74	* statement
	75	*/
	76	#define EXPORT_FUNC(f, a, x, ...) \
	77	asm volatile ( \
	78	" .globl " #x "\n" \
	79	#x ":\n" \
	80	" ld $25, %0($26)\n" \
	81	" ld $25, %1($25)\n" \
	82	" jr $25\n" \
	83	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "t9");
	84	#else
27b207fd WD	85	/*
	86	* k0 ($26) holds the pointer to the global_data; t9 ($25) is a call-
	87	* clobbered register that is also used to set gp ($26). Note that the
	88	* jr instruction also executes the instruction immediately following
	89	* it; however, GCC/mips generates an additional `nop' after each asm
	90	* statement
	91	*/
49cad547	92	#define EXPORT_FUNC(f, a, x, ...) \
27b207fd WD	93	asm volatile ( \
	94	" .globl " #x "\n" \
	95	#x ":\n" \
	96	" lw $25, %0($26)\n" \
	97	" lw $25, %1($25)\n" \
	98	" jr $25\n" \
49cad547	99	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "t9");
4a48cfc4	100	#endif
5c952cf0 WD	101	#elif defined(CONFIG_NIOS2)
5c952cf0 WD	102	/*
0df01fd3	103	* gp holds the pointer to the global_data, r8 is call-clobbered
5c952cf0	104	*/
49cad547	105	#define EXPORT_FUNC(f, a, x, ...) \
5c952cf0 WD	106	asm volatile ( \
	107	" .globl " #x "\n" \
	108	#x ":\n" \
	109	" movhi r8, %%hi(%0)\n" \
	110	" ori r8, r0, %%lo(%0)\n" \
0df01fd3	111	" add r8, r8, gp\n" \
5c952cf0 WD	112	" ldw r8, 0(r8)\n" \
	113	" ldw r8, %1(r8)\n" \
	114	" jmp r8\n" \
49cad547	115	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "gp");
bf9e3b38 WD	116	#elif defined(CONFIG_M68K)
	117	/*
	118	* d7 holds the pointer to the global_data, a0 is a call-clobbered
	119	* register
	120	*/
49cad547	121	#define EXPORT_FUNC(f, a, x, ...) \
bf9e3b38 WD	122	asm volatile ( \
	123	" .globl " #x "\n" \
	124	#x ":\n" \
	125	" move.l %%d7, %%a0\n" \
	126	" adda.l %0, %%a0\n" \
	127	" move.l (%%a0), %%a0\n" \
	128	" adda.l %1, %%a0\n" \
	129	" move.l (%%a0), %%a0\n" \
	130	" jmp (%%a0)\n" \
49cad547	131	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "a0");
857cad37	132	#elif defined(CONFIG_MICROBLAZE)
507bbe3e WD	133	/*
	134	* r31 holds the pointer to the global_data. r5 is a call-clobbered.
	135	*/
49cad547	136	#define EXPORT_FUNC(f, a, x, ...) \
507bbe3e WD	137	asm volatile ( \
	138	" .globl " #x "\n" \
	139	#x ":\n" \
	140	" lwi r5, r31, %0\n" \
	141	" lwi r5, r5, %1\n" \
	142	" bra r5\n" \
49cad547	143	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r5");
7b64fef3 WD	144	#elif defined(CONFIG_AVR32)
	145	/*
	146	* r6 holds the pointer to the global_data. r8 is call clobbered.
	147	*/
49cad547	148	#define EXPORT_FUNC(f, a, x, ...) \
7b64fef3 WD	149	asm volatile( \
	150	" .globl\t" #x "\n" \
	151	#x ":\n" \
	152	" ld.w r8, r6[%0]\n" \
	153	" ld.w pc, r8[%1]\n" \
	154	: \
49cad547	155	: "i"(offsetof(gd_t, jt)), "i"(FO(x)) \
7b64fef3	156	: "r8");
0b135cfc NI	157	#elif defined(CONFIG_SH)
	158	/*
	159	* r13 holds the pointer to the global_data. r1 is a call clobbered.
	160	*/
49cad547	161	#define EXPORT_FUNC(f, a, x, ...) \
61fb15c5 WD	162	asm volatile ( \
	163	" .align 2\n" \
	164	" .globl " #x "\n" \
	165	#x ":\n" \
	166	" mov r13, r1\n" \
	167	" add %0, r1\n" \
cae6f909 NI	168	" mov.l @r1, r2\n" \
	169	" add %1, r2\n" \
	170	" mov.l @r2, r1\n" \
61fb15c5 WD	171	" jmp @r1\n" \
	172	" nop\n" \
	173	" nop\n" \
49cad547	174	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r1", "r2");
72c73dde ML	175	#elif defined(CONFIG_NDS32)
	176	/*
	177	* r16 holds the pointer to the global_data. gp is call clobbered.
	178	* not support reduced register (16 GPR).
	179	*/
49cad547	180	#define EXPORT_FUNC(f, a, x, ...) \
72c73dde ML	181	asm volatile ( \
	182	" .globl " #x "\n" \
	183	#x ":\n" \
	184	" lwi $r16, [$gp + (%0)]\n" \
	185	" lwi $r16, [$r16 + (%1)]\n" \
	186	" jr $r16\n" \
49cad547	187	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "$r16");
3553493d SK	188	#elif defined(CONFIG_OPENRISC)
	189	/*
	190	* r10 holds the pointer to the global_data, r13 is a call-clobbered
	191	* register
	192	*/
49cad547	193	#define EXPORT_FUNC(f, a, x, ...) \
3553493d SK	194	asm volatile ( \
	195	" .globl " #x "\n" \
	196	#x ":\n" \
	197	" l.lwz r13, %0(r10)\n" \
	198	" l.lwz r13, %1(r13)\n" \
	199	" l.jr r13\n" \
	200	" l.nop\n" \
49cad547	201	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r13");
794ab574 AB	202	#elif defined(CONFIG_ARC)
	203	/*
	204	* r25 holds the pointer to the global_data. r10 is call clobbered.
	205	*/
49cad547	206	#define EXPORT_FUNC(f, a, x, ...) \
794ab574 AB	207	asm volatile( \
	208	" .align 4\n" \
	209	" .globl " #x "\n" \
	210	#x ":\n" \
	211	" ld r10, [r25, %0]\n" \
	212	" ld r10, [r10, %1]\n" \
	213	" j [r10]\n" \
49cad547	214	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r10");
de5e5cea CZ	215	#elif defined(CONFIG_XTENSA)
	216	/*
	217	* Global data ptr is in global_data, jump table ptr is in jt.
	218	* Windowed ABI: Jump just past 'entry' in target and adjust stack frame
	219	* (extract stack frame size from target 'entry' instruction).
	220	*/
	221
	222	static void **jt;
	223
	224	#if defined(__XTENSA_CALL0_ABI__)
	225	#define EXPORT_FUNC(f, a, x, ...) \
	226	asm volatile ( \
	227	" .extern jt\n" \
	228	" .globl " #x "\n" \
	229	" .align 4\n" \
	230	#x ":\n" \
	231	" l32i a8, %0, 0\n" \
	232	" l32i a8, a8, %1\n" \
	233	" jx a8\n" \
	234	: : "r"(jt), "i" (FO(x)) : "a8");
	235	#elif defined(__XTENSA_WINDOWED_ABI__)
	236	#if XCHAL_HAVE_BE
	237	# define SFT "8"
	238	#else
	239	# define SFT "12"
	240	#endif
	241	#define EXPORT_FUNC(f, a, x, ...) \
	242	asm volatile ( \
	243	" .extern jt\n" \
	244	" .globl " #x "\n" \
	245	" .align 4\n" \
	246	#x ":\n" \
	247	" entry sp, 16\n" \
	248	" l32i a8, %0, 0\n" \
	249	" l32i a8, a8, %1\n" \
	250	" l32i a9, a8, 0\n" \
	251	" extui a9, a9, " SFT ", 12\n" \
	252	" subx8 a9, a9, sp\n" \
	253	" movi a10, 16\n" \
	254	" sub a9, a10, a9\n" \
	255	" movsp sp, a9\n" \
	256	" addi a8, a8, 3\n" \
	257	" jx a8\n" \
	258	: : "r"(jt), "i" (FO(x)) : "a8", "a9", "a10");
	259	#else
	260	#error Unsupported Xtensa ABI
	261	#endif
27b207fd	262	#else
72c73dde ML	263	/*" addi $sp, $sp, -24\n" \
	264	" br $r16\n" \*/
	265
27b207fd WD	266	#error stubs definition missing for this architecture
	267	#endif
	268
	269	/* This function is necessary to prevent the compiler from
	270	* generating prologue/epilogue, preparing stack frame etc.
	271	* The stub functions are special, they do not use the stack
	272	* frame passed to them, but pass it intact to the actual
	273	* implementation. On the other hand, asm() statements with
	274	* arguments can be used only inside the functions (gcc limitation)
	275	*/
2d5db193	276	#if GCC_VERSION < 30400
93f6a677 WD	277	static
	278	#endif /* GCC_VERSION */
	279	void __attribute__((unused)) dummy(void)
27b207fd WD	280	{
	281	#include <_exports.h>
	282	}
	283
716cc8cc	284	#include <asm/sections.h>
d716b126	285
54841ab5	286	void app_startup(char * const *argv)
27b207fd	287	{
716cc8cc	288	char *cp = __bss_start;
d716b126 WD	289
d716b126 WD	290	/* Zero out BSS */
716cc8cc	291	while (cp < _end)
d716b126	292	*cp++ = 0;
d716b126	293
fea25720	294	#if defined(CONFIG_X86)
27b207fd	295	/* x86 does not have a dedicated register for passing global_data */
77846748 WD	296	global_data = (gd_t *)argv[-1];
77846748 WD	297	jt = global_data->jt;
27b207fd WD	298	#endif
	299	}
	300
	301	#undef EXPORT_FUNC