[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_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_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");
0b135cfc NI	144	#elif defined(CONFIG_SH)
	145	/*
	146	* r13 holds the pointer to the global_data. r1 is a call clobbered.
	147	*/
49cad547	148	#define EXPORT_FUNC(f, a, x, ...) \
61fb15c5 WD	149	asm volatile ( \
	150	" .align 2\n" \
	151	" .globl " #x "\n" \
	152	#x ":\n" \
	153	" mov r13, r1\n" \
	154	" add %0, r1\n" \
cae6f909 NI	155	" mov.l @r1, r2\n" \
	156	" add %1, r2\n" \
	157	" mov.l @r2, r1\n" \
61fb15c5 WD	158	" jmp @r1\n" \
	159	" nop\n" \
	160	" nop\n" \
49cad547	161	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r1", "r2");
72c73dde ML	162	#elif defined(CONFIG_NDS32)
	163	/*
	164	* r16 holds the pointer to the global_data. gp is call clobbered.
	165	* not support reduced register (16 GPR).
	166	*/
49cad547	167	#define EXPORT_FUNC(f, a, x, ...) \
72c73dde ML	168	asm volatile ( \
	169	" .globl " #x "\n" \
	170	#x ":\n" \
	171	" lwi $r16, [$gp + (%0)]\n" \
	172	" lwi $r16, [$r16 + (%1)]\n" \
	173	" jr $r16\n" \
49cad547	174	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "$r16");
794ab574 AB	175	#elif defined(CONFIG_ARC)
	176	/*
	177	* r25 holds the pointer to the global_data. r10 is call clobbered.
	178	*/
49cad547	179	#define EXPORT_FUNC(f, a, x, ...) \
794ab574 AB	180	asm volatile( \
	181	" .align 4\n" \
	182	" .globl " #x "\n" \
	183	#x ":\n" \
	184	" ld r10, [r25, %0]\n" \
	185	" ld r10, [r10, %1]\n" \
	186	" j [r10]\n" \
49cad547	187	: : "i"(offsetof(gd_t, jt)), "i"(FO(x)) : "r10");
de5e5cea CZ	188	#elif defined(CONFIG_XTENSA)
	189	/*
	190	* Global data ptr is in global_data, jump table ptr is in jt.
	191	* Windowed ABI: Jump just past 'entry' in target and adjust stack frame
	192	* (extract stack frame size from target 'entry' instruction).
	193	*/
	194
	195	static void **jt;
	196
	197	#if defined(__XTENSA_CALL0_ABI__)
	198	#define EXPORT_FUNC(f, a, x, ...) \
	199	asm volatile ( \
	200	" .extern jt\n" \
	201	" .globl " #x "\n" \
	202	" .align 4\n" \
	203	#x ":\n" \
	204	" l32i a8, %0, 0\n" \
	205	" l32i a8, a8, %1\n" \
	206	" jx a8\n" \
	207	: : "r"(jt), "i" (FO(x)) : "a8");
	208	#elif defined(__XTENSA_WINDOWED_ABI__)
	209	#if XCHAL_HAVE_BE
	210	# define SFT "8"
	211	#else
	212	# define SFT "12"
	213	#endif
	214	#define EXPORT_FUNC(f, a, x, ...) \
	215	asm volatile ( \
	216	" .extern jt\n" \
	217	" .globl " #x "\n" \
	218	" .align 4\n" \
	219	#x ":\n" \
	220	" entry sp, 16\n" \
	221	" l32i a8, %0, 0\n" \
	222	" l32i a8, a8, %1\n" \
	223	" l32i a9, a8, 0\n" \
	224	" extui a9, a9, " SFT ", 12\n" \
	225	" subx8 a9, a9, sp\n" \
	226	" movi a10, 16\n" \
	227	" sub a9, a10, a9\n" \
	228	" movsp sp, a9\n" \
	229	" addi a8, a8, 3\n" \
	230	" jx a8\n" \
	231	: : "r"(jt), "i" (FO(x)) : "a8", "a9", "a10");
	232	#else
	233	#error Unsupported Xtensa ABI
	234	#endif
27b207fd	235	#else
72c73dde ML	236	/*" addi $sp, $sp, -24\n" \
	237	" br $r16\n" \*/
	238
27b207fd WD	239	#error stubs definition missing for this architecture
	240	#endif
	241
	242	/* This function is necessary to prevent the compiler from
	243	* generating prologue/epilogue, preparing stack frame etc.
	244	* The stub functions are special, they do not use the stack
	245	* frame passed to them, but pass it intact to the actual
	246	* implementation. On the other hand, asm() statements with
	247	* arguments can be used only inside the functions (gcc limitation)
	248	*/
2d5db193	249	#if GCC_VERSION < 30400
93f6a677 WD	250	static
	251	#endif /* GCC_VERSION */
	252	void __attribute__((unused)) dummy(void)
27b207fd WD	253	{
	254	#include <_exports.h>
	255	}
	256
716cc8cc	257	#include <asm/sections.h>
d716b126	258
54841ab5	259	void app_startup(char * const *argv)
27b207fd	260	{
716cc8cc	261	char *cp = __bss_start;
d716b126 WD	262
d716b126 WD	263	/* Zero out BSS */
716cc8cc	264	while (cp < _end)
d716b126	265	*cp++ = 0;
d716b126	266
fea25720	267	#if defined(CONFIG_X86)
27b207fd	268	/* x86 does not have a dedicated register for passing global_data */
77846748 WD	269	global_data = (gd_t *)argv[-1];
77846748 WD	270	jt = global_data->jt;
27b207fd WD	271	#endif
	272	}
	273
	274	#undef EXPORT_FUNC