]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | #ifndef _ASM_IA64_IA32_PRIV_H |
2 | #define _ASM_IA64_IA32_PRIV_H | |
3 | ||
4 | #include <linux/config.h> | |
5 | ||
6 | #include <asm/ia32.h> | |
7 | ||
8 | #ifdef CONFIG_IA32_SUPPORT | |
9 | ||
10 | #include <linux/binfmts.h> | |
11 | #include <linux/compat.h> | |
12 | #include <linux/rbtree.h> | |
13 | ||
14 | #include <asm/processor.h> | |
15 | ||
16 | /* | |
17 | * 32 bit structures for IA32 support. | |
18 | */ | |
19 | ||
20 | #define IA32_PAGE_SIZE (1UL << IA32_PAGE_SHIFT) | |
21 | #define IA32_PAGE_MASK (~(IA32_PAGE_SIZE - 1)) | |
22 | #define IA32_PAGE_ALIGN(addr) (((addr) + IA32_PAGE_SIZE - 1) & IA32_PAGE_MASK) | |
23 | #define IA32_CLOCKS_PER_SEC 100 /* Cast in stone for IA32 Linux */ | |
24 | ||
25 | /* | |
26 | * partially mapped pages provide precise accounting of which 4k sub pages | |
27 | * are mapped and which ones are not, thereby improving IA-32 compatibility. | |
28 | */ | |
29 | struct partial_page { | |
30 | struct partial_page *next; /* linked list, sorted by address */ | |
31 | struct rb_node pp_rb; | |
32 | /* 64K is the largest "normal" page supported by ia64 ABI. So 4K*32 | |
33 | * should suffice.*/ | |
34 | unsigned int bitmap; | |
35 | unsigned int base; | |
36 | }; | |
37 | ||
38 | struct partial_page_list { | |
39 | struct partial_page *pp_head; /* list head, points to the lowest | |
40 | * addressed partial page */ | |
41 | struct rb_root ppl_rb; | |
42 | struct partial_page *pp_hint; /* pp_hint->next is the last | |
43 | * accessed partial page */ | |
44 | atomic_t pp_count; /* reference count */ | |
45 | }; | |
46 | ||
47 | #if PAGE_SHIFT > IA32_PAGE_SHIFT | |
48 | struct partial_page_list* ia32_init_pp_list (void); | |
49 | #else | |
50 | # define ia32_init_pp_list() 0 | |
51 | #endif | |
52 | ||
53 | /* sigcontext.h */ | |
54 | /* | |
55 | * As documented in the iBCS2 standard.. | |
56 | * | |
57 | * The first part of "struct _fpstate" is just the | |
58 | * normal i387 hardware setup, the extra "status" | |
59 | * word is used to save the coprocessor status word | |
60 | * before entering the handler. | |
61 | */ | |
62 | struct _fpreg_ia32 { | |
63 | unsigned short significand[4]; | |
64 | unsigned short exponent; | |
65 | }; | |
66 | ||
67 | struct _fpxreg_ia32 { | |
68 | unsigned short significand[4]; | |
69 | unsigned short exponent; | |
70 | unsigned short padding[3]; | |
71 | }; | |
72 | ||
73 | struct _xmmreg_ia32 { | |
74 | unsigned int element[4]; | |
75 | }; | |
76 | ||
77 | ||
78 | struct _fpstate_ia32 { | |
79 | unsigned int cw, | |
80 | sw, | |
81 | tag, | |
82 | ipoff, | |
83 | cssel, | |
84 | dataoff, | |
85 | datasel; | |
86 | struct _fpreg_ia32 _st[8]; | |
87 | unsigned short status; | |
88 | unsigned short magic; /* 0xffff = regular FPU data only */ | |
89 | ||
90 | /* FXSR FPU environment */ | |
91 | unsigned int _fxsr_env[6]; /* FXSR FPU env is ignored */ | |
92 | unsigned int mxcsr; | |
93 | unsigned int reserved; | |
94 | struct _fpxreg_ia32 _fxsr_st[8]; /* FXSR FPU reg data is ignored */ | |
95 | struct _xmmreg_ia32 _xmm[8]; | |
96 | unsigned int padding[56]; | |
97 | }; | |
98 | ||
99 | struct sigcontext_ia32 { | |
100 | unsigned short gs, __gsh; | |
101 | unsigned short fs, __fsh; | |
102 | unsigned short es, __esh; | |
103 | unsigned short ds, __dsh; | |
104 | unsigned int edi; | |
105 | unsigned int esi; | |
106 | unsigned int ebp; | |
107 | unsigned int esp; | |
108 | unsigned int ebx; | |
109 | unsigned int edx; | |
110 | unsigned int ecx; | |
111 | unsigned int eax; | |
112 | unsigned int trapno; | |
113 | unsigned int err; | |
114 | unsigned int eip; | |
115 | unsigned short cs, __csh; | |
116 | unsigned int eflags; | |
117 | unsigned int esp_at_signal; | |
118 | unsigned short ss, __ssh; | |
119 | unsigned int fpstate; /* really (struct _fpstate_ia32 *) */ | |
120 | unsigned int oldmask; | |
121 | unsigned int cr2; | |
122 | }; | |
123 | ||
124 | /* user.h */ | |
125 | /* | |
126 | * IA32 (Pentium III/4) FXSR, SSE support | |
127 | * | |
128 | * Provide support for the GDB 5.0+ PTRACE_{GET|SET}FPXREGS requests for | |
129 | * interacting with the FXSR-format floating point environment. Floating | |
130 | * point data can be accessed in the regular format in the usual manner, | |
131 | * and both the standard and SIMD floating point data can be accessed via | |
132 | * the new ptrace requests. In either case, changes to the FPU environment | |
133 | * will be reflected in the task's state as expected. | |
134 | */ | |
135 | struct ia32_user_i387_struct { | |
136 | int cwd; | |
137 | int swd; | |
138 | int twd; | |
139 | int fip; | |
140 | int fcs; | |
141 | int foo; | |
142 | int fos; | |
143 | /* 8*10 bytes for each FP-reg = 80 bytes */ | |
144 | struct _fpreg_ia32 st_space[8]; | |
145 | }; | |
146 | ||
147 | struct ia32_user_fxsr_struct { | |
148 | unsigned short cwd; | |
149 | unsigned short swd; | |
150 | unsigned short twd; | |
151 | unsigned short fop; | |
152 | int fip; | |
153 | int fcs; | |
154 | int foo; | |
155 | int fos; | |
156 | int mxcsr; | |
157 | int reserved; | |
158 | int st_space[32]; /* 8*16 bytes for each FP-reg = 128 bytes */ | |
159 | int xmm_space[32]; /* 8*16 bytes for each XMM-reg = 128 bytes */ | |
160 | int padding[56]; | |
161 | }; | |
162 | ||
163 | /* signal.h */ | |
164 | #define IA32_SET_SA_HANDLER(ka,handler,restorer) \ | |
165 | ((ka)->sa.sa_handler = (__sighandler_t) \ | |
166 | (((unsigned long)(restorer) << 32) \ | |
167 | | ((handler) & 0xffffffff))) | |
168 | #define IA32_SA_HANDLER(ka) ((unsigned long) (ka)->sa.sa_handler & 0xffffffff) | |
169 | #define IA32_SA_RESTORER(ka) ((unsigned long) (ka)->sa.sa_handler >> 32) | |
170 | ||
171 | #define __IA32_NR_sigreturn 119 | |
172 | #define __IA32_NR_rt_sigreturn 173 | |
173 | ||
174 | struct sigaction32 { | |
175 | unsigned int sa_handler; /* Really a pointer, but need to deal with 32 bits */ | |
176 | unsigned int sa_flags; | |
177 | unsigned int sa_restorer; /* Another 32 bit pointer */ | |
178 | compat_sigset_t sa_mask; /* A 32 bit mask */ | |
179 | }; | |
180 | ||
181 | struct old_sigaction32 { | |
182 | unsigned int sa_handler; /* Really a pointer, but need to deal | |
183 | with 32 bits */ | |
184 | compat_old_sigset_t sa_mask; /* A 32 bit mask */ | |
185 | unsigned int sa_flags; | |
186 | unsigned int sa_restorer; /* Another 32 bit pointer */ | |
187 | }; | |
188 | ||
189 | typedef struct sigaltstack_ia32 { | |
190 | unsigned int ss_sp; | |
191 | int ss_flags; | |
192 | unsigned int ss_size; | |
193 | } stack_ia32_t; | |
194 | ||
195 | struct ucontext_ia32 { | |
196 | unsigned int uc_flags; | |
197 | unsigned int uc_link; | |
198 | stack_ia32_t uc_stack; | |
199 | struct sigcontext_ia32 uc_mcontext; | |
200 | sigset_t uc_sigmask; /* mask last for extensibility */ | |
201 | }; | |
202 | ||
203 | struct stat64 { | |
204 | unsigned long long st_dev; | |
205 | unsigned char __pad0[4]; | |
206 | unsigned int __st_ino; | |
207 | unsigned int st_mode; | |
208 | unsigned int st_nlink; | |
209 | unsigned int st_uid; | |
210 | unsigned int st_gid; | |
211 | unsigned long long st_rdev; | |
212 | unsigned char __pad3[4]; | |
213 | unsigned int st_size_lo; | |
214 | unsigned int st_size_hi; | |
215 | unsigned int st_blksize; | |
216 | unsigned int st_blocks; /* Number 512-byte blocks allocated. */ | |
217 | unsigned int __pad4; /* future possible st_blocks high bits */ | |
218 | unsigned int st_atime; | |
219 | unsigned int st_atime_nsec; | |
220 | unsigned int st_mtime; | |
221 | unsigned int st_mtime_nsec; | |
222 | unsigned int st_ctime; | |
223 | unsigned int st_ctime_nsec; | |
224 | unsigned int st_ino_lo; | |
225 | unsigned int st_ino_hi; | |
226 | }; | |
227 | ||
228 | typedef struct compat_siginfo { | |
229 | int si_signo; | |
230 | int si_errno; | |
231 | int si_code; | |
232 | ||
233 | union { | |
234 | int _pad[((128/sizeof(int)) - 3)]; | |
235 | ||
236 | /* kill() */ | |
237 | struct { | |
238 | unsigned int _pid; /* sender's pid */ | |
239 | unsigned int _uid; /* sender's uid */ | |
240 | } _kill; | |
241 | ||
242 | /* POSIX.1b timers */ | |
243 | struct { | |
0d77e5a2 | 244 | compat_timer_t _tid; /* timer id */ |
1da177e4 LT |
245 | int _overrun; /* overrun count */ |
246 | char _pad[sizeof(unsigned int) - sizeof(int)]; | |
247 | compat_sigval_t _sigval; /* same as below */ | |
248 | int _sys_private; /* not to be passed to user */ | |
249 | } _timer; | |
250 | ||
251 | /* POSIX.1b signals */ | |
252 | struct { | |
253 | unsigned int _pid; /* sender's pid */ | |
254 | unsigned int _uid; /* sender's uid */ | |
255 | compat_sigval_t _sigval; | |
256 | } _rt; | |
257 | ||
258 | /* SIGCHLD */ | |
259 | struct { | |
260 | unsigned int _pid; /* which child */ | |
261 | unsigned int _uid; /* sender's uid */ | |
262 | int _status; /* exit code */ | |
263 | compat_clock_t _utime; | |
264 | compat_clock_t _stime; | |
265 | } _sigchld; | |
266 | ||
267 | /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ | |
268 | struct { | |
269 | unsigned int _addr; /* faulting insn/memory ref. */ | |
270 | } _sigfault; | |
271 | ||
272 | /* SIGPOLL */ | |
273 | struct { | |
274 | int _band; /* POLL_IN, POLL_OUT, POLL_MSG */ | |
275 | int _fd; | |
276 | } _sigpoll; | |
277 | } _sifields; | |
278 | } compat_siginfo_t; | |
279 | ||
280 | struct old_linux32_dirent { | |
281 | u32 d_ino; | |
282 | u32 d_offset; | |
283 | u16 d_namlen; | |
284 | char d_name[1]; | |
285 | }; | |
286 | ||
287 | /* | |
288 | * IA-32 ELF specific definitions for IA-64. | |
289 | */ | |
290 | ||
291 | #define _ASM_IA64_ELF_H /* Don't include elf.h */ | |
292 | ||
293 | #include <linux/sched.h> | |
294 | #include <asm/processor.h> | |
295 | ||
296 | /* | |
297 | * This is used to ensure we don't load something for the wrong architecture. | |
298 | */ | |
299 | #define elf_check_arch(x) ((x)->e_machine == EM_386) | |
300 | ||
301 | /* | |
302 | * These are used to set parameters in the core dumps. | |
303 | */ | |
304 | #define ELF_CLASS ELFCLASS32 | |
305 | #define ELF_DATA ELFDATA2LSB | |
306 | #define ELF_ARCH EM_386 | |
307 | ||
1da177e4 LT |
308 | #define IA32_STACK_TOP IA32_PAGE_OFFSET |
309 | #define IA32_GATE_OFFSET IA32_PAGE_OFFSET | |
310 | #define IA32_GATE_END IA32_PAGE_OFFSET + PAGE_SIZE | |
311 | ||
312 | /* | |
313 | * The system segments (GDT, TSS, LDT) have to be mapped below 4GB so the IA-32 engine can | |
314 | * access them. | |
315 | */ | |
316 | #define IA32_GDT_OFFSET (IA32_PAGE_OFFSET + PAGE_SIZE) | |
317 | #define IA32_TSS_OFFSET (IA32_PAGE_OFFSET + 2*PAGE_SIZE) | |
318 | #define IA32_LDT_OFFSET (IA32_PAGE_OFFSET + 3*PAGE_SIZE) | |
319 | ||
320 | #define ELF_EXEC_PAGESIZE IA32_PAGE_SIZE | |
321 | ||
322 | /* | |
323 | * This is the location that an ET_DYN program is loaded if exec'ed. | |
324 | * Typical use of this is to invoke "./ld.so someprog" to test out a | |
325 | * new version of the loader. We need to make sure that it is out of | |
326 | * the way of the program that it will "exec", and that there is | |
327 | * sufficient room for the brk. | |
328 | */ | |
329 | #define ELF_ET_DYN_BASE (IA32_PAGE_OFFSET/3 + 0x1000000) | |
330 | ||
331 | void ia64_elf32_init(struct pt_regs *regs); | |
332 | #define ELF_PLAT_INIT(_r, load_addr) ia64_elf32_init(_r) | |
333 | ||
334 | #define elf_addr_t u32 | |
335 | ||
336 | /* This macro yields a bitmask that programs can use to figure out | |
337 | what instruction set this CPU supports. */ | |
338 | #define ELF_HWCAP 0 | |
339 | ||
340 | /* This macro yields a string that ld.so will use to load | |
341 | implementation specific libraries for optimization. Not terribly | |
342 | relevant until we have real hardware to play with... */ | |
343 | #define ELF_PLATFORM NULL | |
344 | ||
345 | #ifdef __KERNEL__ | |
346 | # define SET_PERSONALITY(EX,IBCS2) \ | |
347 | (current->personality = (IBCS2) ? PER_SVR4 : PER_LINUX) | |
348 | #endif | |
349 | ||
350 | #define IA32_EFLAG 0x200 | |
351 | ||
352 | /* | |
353 | * IA-32 ELF specific definitions for IA-64. | |
354 | */ | |
355 | ||
356 | #define __USER_CS 0x23 | |
357 | #define __USER_DS 0x2B | |
358 | ||
359 | /* | |
360 | * The per-cpu GDT has 32 entries: see <asm-i386/segment.h> | |
361 | */ | |
362 | #define GDT_ENTRIES 32 | |
363 | ||
364 | #define GDT_SIZE (GDT_ENTRIES * 8) | |
365 | ||
366 | #define TSS_ENTRY 14 | |
367 | #define LDT_ENTRY (TSS_ENTRY + 1) | |
368 | ||
369 | #define IA32_SEGSEL_RPL (0x3 << 0) | |
370 | #define IA32_SEGSEL_TI (0x1 << 2) | |
371 | #define IA32_SEGSEL_INDEX_SHIFT 3 | |
372 | ||
373 | #define _TSS ((unsigned long) TSS_ENTRY << IA32_SEGSEL_INDEX_SHIFT) | |
374 | #define _LDT ((unsigned long) LDT_ENTRY << IA32_SEGSEL_INDEX_SHIFT) | |
375 | ||
376 | #define IA32_SEG_BASE 16 | |
377 | #define IA32_SEG_TYPE 40 | |
378 | #define IA32_SEG_SYS 44 | |
379 | #define IA32_SEG_DPL 45 | |
380 | #define IA32_SEG_P 47 | |
381 | #define IA32_SEG_HIGH_LIMIT 48 | |
382 | #define IA32_SEG_AVL 52 | |
383 | #define IA32_SEG_DB 54 | |
384 | #define IA32_SEG_G 55 | |
385 | #define IA32_SEG_HIGH_BASE 56 | |
386 | ||
387 | #define IA32_SEG_DESCRIPTOR(base, limit, segtype, nonsysseg, dpl, segpresent, avl, segdb, gran) \ | |
388 | (((limit) & 0xffff) \ | |
389 | | (((unsigned long) (base) & 0xffffff) << IA32_SEG_BASE) \ | |
390 | | ((unsigned long) (segtype) << IA32_SEG_TYPE) \ | |
391 | | ((unsigned long) (nonsysseg) << IA32_SEG_SYS) \ | |
392 | | ((unsigned long) (dpl) << IA32_SEG_DPL) \ | |
393 | | ((unsigned long) (segpresent) << IA32_SEG_P) \ | |
394 | | ((((unsigned long) (limit) >> 16) & 0xf) << IA32_SEG_HIGH_LIMIT) \ | |
395 | | ((unsigned long) (avl) << IA32_SEG_AVL) \ | |
396 | | ((unsigned long) (segdb) << IA32_SEG_DB) \ | |
397 | | ((unsigned long) (gran) << IA32_SEG_G) \ | |
398 | | ((((unsigned long) (base) >> 24) & 0xff) << IA32_SEG_HIGH_BASE)) | |
399 | ||
400 | #define SEG_LIM 32 | |
401 | #define SEG_TYPE 52 | |
402 | #define SEG_SYS 56 | |
403 | #define SEG_DPL 57 | |
404 | #define SEG_P 59 | |
405 | #define SEG_AVL 60 | |
406 | #define SEG_DB 62 | |
407 | #define SEG_G 63 | |
408 | ||
409 | /* Unscramble an IA-32 segment descriptor into the IA-64 format. */ | |
410 | #define IA32_SEG_UNSCRAMBLE(sd) \ | |
411 | ( (((sd) >> IA32_SEG_BASE) & 0xffffff) | ((((sd) >> IA32_SEG_HIGH_BASE) & 0xff) << 24) \ | |
412 | | ((((sd) & 0xffff) | ((((sd) >> IA32_SEG_HIGH_LIMIT) & 0xf) << 16)) << SEG_LIM) \ | |
413 | | ((((sd) >> IA32_SEG_TYPE) & 0xf) << SEG_TYPE) \ | |
414 | | ((((sd) >> IA32_SEG_SYS) & 0x1) << SEG_SYS) \ | |
415 | | ((((sd) >> IA32_SEG_DPL) & 0x3) << SEG_DPL) \ | |
416 | | ((((sd) >> IA32_SEG_P) & 0x1) << SEG_P) \ | |
417 | | ((((sd) >> IA32_SEG_AVL) & 0x1) << SEG_AVL) \ | |
418 | | ((((sd) >> IA32_SEG_DB) & 0x1) << SEG_DB) \ | |
419 | | ((((sd) >> IA32_SEG_G) & 0x1) << SEG_G)) | |
420 | ||
421 | #define IA32_IOBASE 0x2000000000000000UL /* Virtual address for I/O space */ | |
422 | ||
423 | #define IA32_CR0 0x80000001 /* Enable PG and PE bits */ | |
424 | #define IA32_CR4 0x600 /* MMXEX and FXSR on */ | |
425 | ||
426 | /* | |
427 | * IA32 floating point control registers starting values | |
428 | */ | |
429 | ||
430 | #define IA32_FSR_DEFAULT 0x55550000 /* set all tag bits */ | |
431 | #define IA32_FCR_DEFAULT 0x17800000037fUL /* extended precision, all masks */ | |
432 | ||
433 | #define IA32_PTRACE_GETREGS 12 | |
434 | #define IA32_PTRACE_SETREGS 13 | |
435 | #define IA32_PTRACE_GETFPREGS 14 | |
436 | #define IA32_PTRACE_SETFPREGS 15 | |
437 | #define IA32_PTRACE_GETFPXREGS 18 | |
438 | #define IA32_PTRACE_SETFPXREGS 19 | |
439 | ||
440 | #define ia32_start_thread(regs,new_ip,new_sp) do { \ | |
441 | set_fs(USER_DS); \ | |
442 | ia64_psr(regs)->cpl = 3; /* set user mode */ \ | |
443 | ia64_psr(regs)->ri = 0; /* clear return slot number */ \ | |
444 | ia64_psr(regs)->is = 1; /* IA-32 instruction set */ \ | |
445 | regs->cr_iip = new_ip; \ | |
446 | regs->ar_rsc = 0xc; /* enforced lazy mode, priv. level 3 */ \ | |
447 | regs->ar_rnat = 0; \ | |
448 | regs->loadrs = 0; \ | |
449 | regs->r12 = new_sp; \ | |
450 | } while (0) | |
451 | ||
452 | /* | |
453 | * Local Descriptor Table (LDT) related declarations. | |
454 | */ | |
455 | ||
456 | #define IA32_LDT_ENTRIES 8192 /* Maximum number of LDT entries supported. */ | |
457 | #define IA32_LDT_ENTRY_SIZE 8 /* The size of each LDT entry. */ | |
458 | ||
459 | #define LDT_entry_a(info) \ | |
460 | ((((info)->base_addr & 0x0000ffff) << 16) | ((info)->limit & 0x0ffff)) | |
461 | ||
462 | #define LDT_entry_b(info) \ | |
463 | (((info)->base_addr & 0xff000000) | \ | |
464 | (((info)->base_addr & 0x00ff0000) >> 16) | \ | |
465 | ((info)->limit & 0xf0000) | \ | |
466 | (((info)->read_exec_only ^ 1) << 9) | \ | |
467 | ((info)->contents << 10) | \ | |
468 | (((info)->seg_not_present ^ 1) << 15) | \ | |
469 | ((info)->seg_32bit << 22) | \ | |
470 | ((info)->limit_in_pages << 23) | \ | |
471 | ((info)->useable << 20) | \ | |
472 | 0x7100) | |
473 | ||
474 | #define LDT_empty(info) ( \ | |
475 | (info)->base_addr == 0 && \ | |
476 | (info)->limit == 0 && \ | |
477 | (info)->contents == 0 && \ | |
478 | (info)->read_exec_only == 1 && \ | |
479 | (info)->seg_32bit == 0 && \ | |
480 | (info)->limit_in_pages == 0 && \ | |
481 | (info)->seg_not_present == 1 && \ | |
482 | (info)->useable == 0 ) | |
483 | ||
484 | static inline void | |
485 | load_TLS (struct thread_struct *t, unsigned int cpu) | |
486 | { | |
487 | extern unsigned long *cpu_gdt_table[NR_CPUS]; | |
488 | ||
489 | memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 0, &t->tls_array[0], sizeof(long)); | |
490 | memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 1, &t->tls_array[1], sizeof(long)); | |
491 | memcpy(cpu_gdt_table[cpu] + GDT_ENTRY_TLS_MIN + 2, &t->tls_array[2], sizeof(long)); | |
492 | } | |
493 | ||
494 | struct ia32_user_desc { | |
495 | unsigned int entry_number; | |
496 | unsigned int base_addr; | |
497 | unsigned int limit; | |
498 | unsigned int seg_32bit:1; | |
499 | unsigned int contents:2; | |
500 | unsigned int read_exec_only:1; | |
501 | unsigned int limit_in_pages:1; | |
502 | unsigned int seg_not_present:1; | |
503 | unsigned int useable:1; | |
504 | }; | |
505 | ||
506 | struct linux_binprm; | |
507 | ||
508 | extern void ia32_init_addr_space (struct pt_regs *regs); | |
509 | extern int ia32_setup_arg_pages (struct linux_binprm *bprm, int exec_stack); | |
510 | extern unsigned long ia32_do_mmap (struct file *, unsigned long, unsigned long, int, int, loff_t); | |
511 | extern void ia32_load_segment_descriptors (struct task_struct *task); | |
512 | ||
513 | #define ia32f2ia64f(dst,src) \ | |
514 | do { \ | |
515 | ia64_ldfe(6,src); \ | |
516 | ia64_stop(); \ | |
517 | ia64_stf_spill(dst, 6); \ | |
518 | } while(0) | |
519 | ||
520 | #define ia64f2ia32f(dst,src) \ | |
521 | do { \ | |
522 | ia64_ldf_fill(6, src); \ | |
523 | ia64_stop(); \ | |
524 | ia64_stfe(dst, 6); \ | |
525 | } while(0) | |
526 | ||
527 | struct user_regs_struct32 { | |
528 | __u32 ebx, ecx, edx, esi, edi, ebp, eax; | |
529 | unsigned short ds, __ds, es, __es; | |
530 | unsigned short fs, __fs, gs, __gs; | |
531 | __u32 orig_eax, eip; | |
532 | unsigned short cs, __cs; | |
533 | __u32 eflags, esp; | |
534 | unsigned short ss, __ss; | |
535 | }; | |
536 | ||
537 | /* Prototypes for use in elfcore32.h */ | |
538 | extern int save_ia32_fpstate (struct task_struct *, struct ia32_user_i387_struct __user *); | |
539 | extern int save_ia32_fpxstate (struct task_struct *, struct ia32_user_fxsr_struct __user *); | |
540 | ||
541 | #endif /* !CONFIG_IA32_SUPPORT */ | |
542 | ||
543 | #endif /* _ASM_IA64_IA32_PRIV_H */ |