]>
Commit | Line | Data |
---|---|---|
27b207fd WD |
1 | #include <exports.h> |
2 | ||
93f6a677 WD |
3 | #ifndef GCC_VERSION |
4 | #define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) | |
5 | #endif /* GCC_VERSION */ | |
6 | ||
27b207fd WD |
7 | #if defined(CONFIG_I386) |
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 | */ | |
15 | static void **jt; | |
77846748 | 16 | gd_t *global_data; |
27b207fd WD |
17 | |
18 | #define EXPORT_FUNC(x) \ | |
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" \ | |
25 | : : "i"(XF_ ## x * sizeof(void *)) : "eax", "ecx"); | |
26 | #elif defined(CONFIG_PPC) | |
27 | /* | |
e7670f6c | 28 | * r2 holds the pointer to the global_data, r11 is a call-clobbered |
27b207fd WD |
29 | * register |
30 | */ | |
31 | #define EXPORT_FUNC(x) \ | |
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" \ | |
39 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "r11"); | |
40 | #elif defined(CONFIG_ARM) | |
41 | /* | |
42 | * r8 holds the pointer to the global_data, ip is a call-clobbered | |
43 | * register | |
44 | */ | |
45 | #define EXPORT_FUNC(x) \ | |
46 | asm volatile ( \ | |
47 | " .globl " #x "\n" \ | |
48 | #x ":\n" \ | |
49 | " ldr ip, [r8, %0]\n" \ | |
50 | " ldr pc, [ip, %1]\n" \ | |
51 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "ip"); | |
52 | #elif defined(CONFIG_MIPS) | |
53 | /* | |
54 | * k0 ($26) holds the pointer to the global_data; t9 ($25) is a call- | |
55 | * clobbered register that is also used to set gp ($26). Note that the | |
56 | * jr instruction also executes the instruction immediately following | |
57 | * it; however, GCC/mips generates an additional `nop' after each asm | |
58 | * statement | |
59 | */ | |
60 | #define EXPORT_FUNC(x) \ | |
61 | asm volatile ( \ | |
62 | " .globl " #x "\n" \ | |
63 | #x ":\n" \ | |
64 | " lw $25, %0($26)\n" \ | |
65 | " lw $25, %1($25)\n" \ | |
66 | " jr $25\n" \ | |
67 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "t9"); | |
4a551709 WD |
68 | #elif defined(CONFIG_NIOS) |
69 | /* | |
70 | * %g7 holds the pointer to the global_data. %g0 is call clobbered. | |
71 | */ | |
72 | #define EXPORT_FUNC(x) \ | |
73 | asm volatile ( \ | |
74 | " .globl " #x "\n" \ | |
75 | #x ":\n" \ | |
76 | " pfx %%hi(%0)\n" \ | |
77 | " movi %%g0, %%lo(%0)\n" \ | |
78 | " add %%g0, %%g7\n" \ | |
79 | " ld %%g0, [%%g0]\n" \ | |
80 | " pfx %1\n" \ | |
81 | " ld %%g0, [%%g0]\n" \ | |
82 | " jmp %%g0\n" \ | |
83 | " nop \n" \ | |
84 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x) : "r0"); | |
5c952cf0 WD |
85 | #elif defined(CONFIG_NIOS2) |
86 | /* | |
87 | * r15 holds the pointer to the global_data, r8 is call-clobbered | |
88 | */ | |
89 | #define EXPORT_FUNC(x) \ | |
90 | asm volatile ( \ | |
91 | " .globl " #x "\n" \ | |
92 | #x ":\n" \ | |
93 | " movhi r8, %%hi(%0)\n" \ | |
94 | " ori r8, r0, %%lo(%0)\n" \ | |
c2ced000 | 95 | " add r8, r8, r15\n" \ |
5c952cf0 WD |
96 | " ldw r8, 0(r8)\n" \ |
97 | " ldw r8, %1(r8)\n" \ | |
98 | " jmp r8\n" \ | |
99 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "r15"); | |
bf9e3b38 WD |
100 | #elif defined(CONFIG_M68K) |
101 | /* | |
102 | * d7 holds the pointer to the global_data, a0 is a call-clobbered | |
103 | * register | |
104 | */ | |
105 | #define EXPORT_FUNC(x) \ | |
106 | asm volatile ( \ | |
107 | " .globl " #x "\n" \ | |
108 | #x ":\n" \ | |
109 | " move.l %%d7, %%a0\n" \ | |
110 | " adda.l %0, %%a0\n" \ | |
111 | " move.l (%%a0), %%a0\n" \ | |
112 | " adda.l %1, %%a0\n" \ | |
113 | " move.l (%%a0), %%a0\n" \ | |
114 | " jmp (%%a0)\n" \ | |
115 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "a0"); | |
857cad37 | 116 | #elif defined(CONFIG_MICROBLAZE) |
507bbe3e WD |
117 | /* |
118 | * r31 holds the pointer to the global_data. r5 is a call-clobbered. | |
119 | */ | |
120 | #define EXPORT_FUNC(x) \ | |
121 | asm volatile ( \ | |
122 | " .globl " #x "\n" \ | |
123 | #x ":\n" \ | |
124 | " lwi r5, r31, %0\n" \ | |
125 | " lwi r5, r5, %1\n" \ | |
126 | " bra r5\n" \ | |
127 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "r5"); | |
0afe519a WD |
128 | #elif defined(CONFIG_BLACKFIN) |
129 | /* | |
130 | * P5 holds the pointer to the global_data, P0 is a call-clobbered | |
131 | * register | |
132 | */ | |
133 | #define EXPORT_FUNC(x) \ | |
8e7b703a | 134 | asm volatile ( \ |
61fb15c5 | 135 | " .globl _" #x "\n_" \ |
0afe519a WD |
136 | #x ":\n" \ |
137 | " P0 = [P5 + %0]\n" \ | |
138 | " P0 = [P0 + %1]\n" \ | |
139 | " JUMP (P0)\n" \ | |
140 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "P0"); | |
7b64fef3 WD |
141 | #elif defined(CONFIG_AVR32) |
142 | /* | |
143 | * r6 holds the pointer to the global_data. r8 is call clobbered. | |
144 | */ | |
145 | #define EXPORT_FUNC(x) \ | |
146 | asm volatile( \ | |
147 | " .globl\t" #x "\n" \ | |
148 | #x ":\n" \ | |
149 | " ld.w r8, r6[%0]\n" \ | |
150 | " ld.w pc, r8[%1]\n" \ | |
151 | : \ | |
152 | : "i"(offsetof(gd_t, jt)), "i"(XF_ ##x) \ | |
153 | : "r8"); | |
0b135cfc NI |
154 | #elif defined(CONFIG_SH) |
155 | /* | |
156 | * r13 holds the pointer to the global_data. r1 is a call clobbered. | |
157 | */ | |
61fb15c5 WD |
158 | #define EXPORT_FUNC(x) \ |
159 | asm volatile ( \ | |
160 | " .align 2\n" \ | |
161 | " .globl " #x "\n" \ | |
162 | #x ":\n" \ | |
163 | " mov r13, r1\n" \ | |
164 | " add %0, r1\n" \ | |
cae6f909 NI |
165 | " mov.l @r1, r2\n" \ |
166 | " add %1, r2\n" \ | |
167 | " mov.l @r2, r1\n" \ | |
61fb15c5 WD |
168 | " jmp @r1\n" \ |
169 | " nop\n" \ | |
170 | " nop\n" \ | |
cae6f909 | 171 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x * sizeof(void *)) : "r1", "r2"); |
c2f02da2 DH |
172 | #elif defined(CONFIG_SPARC) |
173 | /* | |
174 | * g7 holds the pointer to the global_data. g1 is call clobbered. | |
175 | */ | |
176 | #define EXPORT_FUNC(x) \ | |
177 | asm volatile( \ | |
178 | " .globl\t" #x "\n" \ | |
179 | #x ":\n" \ | |
180 | " set %0, %%g1\n" \ | |
181 | " or %%g1, %%g7, %%g1\n" \ | |
182 | " ld [%%g1], %%g1\n" \ | |
183 | " ld [%%g1 + %1], %%g1\n" \ | |
184 | " call %%g1\n" \ | |
185 | " nop\n" \ | |
186 | : : "i"(offsetof(gd_t, jt)), "i"(XF_ ## x) : "g1" ); | |
187 | ||
27b207fd WD |
188 | #else |
189 | #error stubs definition missing for this architecture | |
190 | #endif | |
191 | ||
192 | /* This function is necessary to prevent the compiler from | |
193 | * generating prologue/epilogue, preparing stack frame etc. | |
194 | * The stub functions are special, they do not use the stack | |
195 | * frame passed to them, but pass it intact to the actual | |
196 | * implementation. On the other hand, asm() statements with | |
197 | * arguments can be used only inside the functions (gcc limitation) | |
198 | */ | |
93f6a677 WD |
199 | #if GCC_VERSION < 3004 |
200 | static | |
201 | #endif /* GCC_VERSION */ | |
202 | void __attribute__((unused)) dummy(void) | |
27b207fd WD |
203 | { |
204 | #include <_exports.h> | |
205 | } | |
206 | ||
d716b126 WD |
207 | extern unsigned long __bss_start, _end; |
208 | ||
27b207fd WD |
209 | void app_startup(char **argv) |
210 | { | |
118978c8 | 211 | unsigned char * cp = (unsigned char *) &__bss_start; |
d716b126 WD |
212 | |
213 | /* Zero out BSS */ | |
118978c8 | 214 | while (cp < (unsigned char *)&_end) { |
d716b126 WD |
215 | *cp++ = 0; |
216 | } | |
217 | ||
27b207fd WD |
218 | #if defined(CONFIG_I386) |
219 | /* x86 does not have a dedicated register for passing global_data */ | |
77846748 WD |
220 | global_data = (gd_t *)argv[-1]; |
221 | jt = global_data->jt; | |
27b207fd WD |
222 | #endif |
223 | } | |
224 | ||
225 | #undef EXPORT_FUNC |