123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716 |
- /*
- * librm: a library for interfacing to real-mode code
- *
- * Michael Brown <mbrown@fensystems.co.uk>
- *
- */
-
- FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
-
- /* Drag in local definitions */
- #include "librm.h"
-
- /* For switches to/from protected mode */
- #define CR0_PE 1
-
- /* Size of various C data structures */
- #define SIZEOF_I386_SEG_REGS 12
- #define SIZEOF_I386_REGS 32
- #define SIZEOF_REAL_MODE_REGS ( SIZEOF_I386_SEG_REGS + SIZEOF_I386_REGS )
- #define SIZEOF_I386_FLAGS 4
- #define SIZEOF_I386_ALL_REGS ( SIZEOF_REAL_MODE_REGS + SIZEOF_I386_FLAGS )
-
- /* Size of an address */
- #ifdef __x86_64__
- #define SIZEOF_ADDR 8
- #else
- #define SIZEOF_ADDR 4
- #endif
-
- /* Selectively assemble code for 32-bit/64-bit builds */
- #ifdef __x86_64__
- #define if32 if 0
- #define if64 if 1
- #else
- #define if32 if 1
- #define if64 if 0
- #endif
-
- /****************************************************************************
- * Global descriptor table
- *
- * Call init_librm to set up the GDT before attempting to use any
- * protected-mode code.
- *
- * NOTE: This must be located before prot_to_real, otherwise gas
- * throws a "can't handle non absolute segment in `ljmp'" error due to
- * not knowing the value of REAL_CS when the ljmp is encountered.
- *
- * Note also that putting ".word gdt_end - gdt - 1" directly into
- * gdt_limit, rather than going via gdt_length, will also produce the
- * "non absolute segment" error. This is most probably a bug in gas.
- ****************************************************************************
- */
- .section ".data16.gdt", "aw", @progbits
- .align 16
- gdt:
- gdtr: /* The first GDT entry is unused, the GDTR can fit here. */
- gdt_limit: .word gdt_length - 1
- gdt_base: .long 0
- .word 0 /* padding */
-
- .org gdt + VIRTUAL_CS, 0
- virtual_cs: /* 32 bit protected mode code segment, virtual addresses */
- .word 0xffff, 0
- .byte 0, 0x9f, 0xcf, 0
-
- .org gdt + VIRTUAL_DS, 0
- virtual_ds: /* 32 bit protected mode data segment, virtual addresses */
- .word 0xffff, 0
- .byte 0, 0x93, 0xcf, 0
-
- .org gdt + PHYSICAL_CS, 0
- physical_cs: /* 32 bit protected mode code segment, physical addresses */
- .word 0xffff, 0
- .byte 0, 0x9f, 0xcf, 0
-
- .org gdt + PHYSICAL_DS, 0
- physical_ds: /* 32 bit protected mode data segment, physical addresses */
- .word 0xffff, 0
- .byte 0, 0x93, 0xcf, 0
-
- .org gdt + REAL_CS, 0
- real_cs: /* 16 bit real mode code segment */
- .word 0xffff, 0
- .byte 0, 0x9b, 0x00, 0
-
- .org gdt + REAL_DS, 0
- real_ds: /* 16 bit real mode data segment */
- .word 0xffff, 0
- .byte 0, 0x93, 0x00, 0
-
- .org gdt + P2R_DS, 0
- p2r_ds: /* 16 bit real mode data segment for prot_to_real transition */
- .word 0xffff, ( P2R_DS << 4 )
- .byte 0, 0x93, 0x00, 0
-
- gdt_end:
- .equ gdt_length, gdt_end - gdt
-
- /****************************************************************************
- * Stored real-mode and protected-mode stack pointers
- *
- * The real-mode stack pointer is stored here whenever real_to_prot
- * is called and restored whenever prot_to_real is called. The
- * converse happens for the protected-mode stack pointer.
- *
- * Despite initial appearances this scheme is, in fact re-entrant,
- * because program flow dictates that we always return via the point
- * we left by. For example:
- * PXE API call entry
- * 1 real => prot
- * ...
- * Print a text string
- * ...
- * 2 prot => real
- * INT 10
- * 3 real => prot
- * ...
- * ...
- * 4 prot => real
- * PXE API call exit
- *
- * At point 1, the RM mode stack value, say RPXE, is stored in
- * rm_ss,sp. We want this value to still be present in rm_ss,sp when
- * we reach point 4.
- *
- * At point 2, the RM stack value is restored from RPXE. At point 3,
- * the RM stack value is again stored in rm_ss,sp. This *does*
- * overwrite the RPXE that we have stored there, but it's the same
- * value, since the code between points 2 and 3 has managed to return
- * to us.
- ****************************************************************************
- */
- .section ".bss.rm_sp", "aw", @nobits
- .globl rm_sp
- rm_sp: .word 0
-
- .section ".bss.rm_ss", "aw", @nobits
- .globl rm_ss
- rm_ss: .word 0
-
- .section ".data.pm_esp", "aw", @progbits
- pm_esp: .long VIRTUAL(_estack)
-
- /****************************************************************************
- * Virtual address offsets
- *
- * These are used by the protected-mode code to map between virtual
- * and physical addresses, and to access variables in the .text16 or
- * .data16 segments.
- ****************************************************************************
- */
- .struct 0
- VA_VIRT_OFFSET: .space SIZEOF_ADDR
- VA_TEXT16: .space SIZEOF_ADDR
- VA_DATA16: .space SIZEOF_ADDR
- VA_SIZE:
- .previous
-
- /* Internal copies, used only by librm itself */
- .section ".bss16.rm_virt_addrs", "aw", @nobits
- rm_virt_addrs: .space VA_SIZE
- .equ rm_virt_offset, ( rm_virt_addrs + VA_VIRT_OFFSET )
- .equ rm_text16, ( rm_virt_addrs + VA_TEXT16 )
- .equ rm_data16, ( rm_virt_addrs + VA_DATA16 )
-
- /* Externally visible variables, used by C code */
- .section ".bss.virt_addrs", "aw", @nobits
- virt_addrs: .space VA_SIZE
- .globl virt_offset
- .equ virt_offset, ( virt_addrs + VA_VIRT_OFFSET )
- .globl text16
- .equ text16, ( virt_addrs + VA_TEXT16 )
- .globl data16
- .equ data16, ( virt_addrs + VA_DATA16 )
-
- /****************************************************************************
- * init_librm (real-mode far call, 16-bit real-mode far return address)
- *
- * Initialise the GDT ready for transitions to protected mode.
- *
- * Parameters:
- * %cs : .text16 segment
- * %ds : .data16 segment
- * %edi : Physical base of protected-mode code
- ****************************************************************************
- */
- .section ".text16.init_librm", "ax", @progbits
- .code16
- .globl init_librm
- init_librm:
- /* Preserve registers */
- pushl %eax
- pushl %ebx
- pushl %edi
-
- /* Store rm_virt_offset and set up virtual_cs and virtual_ds segments */
- subl $VIRTUAL(_textdata), %edi
- movl %edi, rm_virt_offset
- .if64 ; setae (rm_virt_offset+4) ; .endif
- movl %edi, %eax
- movw $virtual_cs, %bx
- call set_seg_base
- movw $virtual_ds, %bx
- call set_seg_base
-
- /* Store rm_cs and rm_text16, set up real_cs segment */
- xorl %eax, %eax
- movw %cs, %ax
- movw %ax, %cs:rm_cs
- shll $4, %eax
- movw $real_cs, %bx
- call set_seg_base
- .if32 ; subl %edi, %eax ; .endif
- movl %eax, rm_text16
-
- /* Store rm_ds and rm_data16, set up real_ds segment and GDT base */
- xorl %eax, %eax
- movw %ds, %ax
- movw %ax, %cs:rm_ds
- shll $4, %eax
- movw $real_ds, %bx
- call set_seg_base
- movl %eax, gdt_base
- addl $gdt, gdt_base
- .if32 ; subl %edi, %eax ; .endif
- movl %eax, rm_data16
-
- /* Switch to protected mode */
- virtcall init_librm_pmode
- .section ".text.init_librm", "ax", @progbits
- .code32
- init_librm_pmode:
-
- /* Store virt_offset, text16, and data16 */
- pushw %ds
- movw $REAL_DS, %ax
- movw %ax, %ds
- movl $rm_virt_addrs, %esi
- movl $VIRTUAL(virt_addrs), %edi
- movl $( VA_SIZE / 4 ), %ecx
- rep movsl
- popw %ds
-
- /* Return to real mode */
- ret
- .section ".text16.init_librm", "ax", @progbits
- .code16
- init_librm_rmode:
-
- /* Initialise IDT */
- virtcall init_idt
-
- /* Restore registers */
- popl %edi
- popl %ebx
- popl %eax
- lret
-
- .section ".text16.set_seg_base", "ax", @progbits
- .code16
- set_seg_base:
- 1: movw %ax, 2(%bx)
- rorl $16, %eax
- movb %al, 4(%bx)
- movb %ah, 7(%bx)
- roll $16, %eax
- ret
-
- /****************************************************************************
- * real_to_prot (real-mode near call, 32-bit virtual return address)
- *
- * Switch from 16-bit real-mode to 32-bit protected mode with virtual
- * addresses. The real-mode %ss:sp is stored in rm_ss and rm_sp, and
- * the protected-mode %esp is restored from the saved pm_esp.
- * Interrupts are disabled. All other registers may be destroyed.
- *
- * The return address for this function should be a 32-bit virtual
- * address.
- *
- * Parameters:
- * %ecx : number of bytes to move from RM stack to PM stack
- *
- ****************************************************************************
- */
- .section ".text16.real_to_prot", "ax", @progbits
- .code16
- real_to_prot:
- /* Enable A20 line */
- call enable_a20
- /* A failure at this point is fatal, and there's nothing we
- * can do about it other than lock the machine to make the
- * problem immediately visible.
- */
- 1: jc 1b
-
- /* Make sure we have our data segment available */
- movw %cs:rm_ds, %ds
-
- /* Add protected-mode return address to length of data to be copied */
- addw $4, %cx /* %ecx must be less than 64kB anyway */
-
- /* Real-mode %ss:%sp => %ebp:%edx and virtual address => %esi */
- xorl %ebp, %ebp
- movw %ss, %bp
- movzwl %sp, %edx
- movl %ebp, %eax
- shll $4, %eax
- addr32 leal (%eax,%edx), %esi
- subl rm_virt_offset, %esi
-
- /* Load protected-mode global descriptor table */
- data32 lgdt gdtr
-
- /* Zero segment registers. This wastes around 12 cycles on
- * real hardware, but saves a substantial number of emulated
- * instructions under KVM.
- */
- xorw %ax, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
-
- /* Switch to protected mode */
- cli
- movl %cr0, %eax
- orb $CR0_PE, %al
- movl %eax, %cr0
- data32 ljmp $VIRTUAL_CS, $VIRTUAL(r2p_pmode)
- .section ".text.real_to_prot", "ax", @progbits
- .code32
- r2p_pmode:
- /* Set up protected-mode data segments and stack pointer */
- movw $VIRTUAL_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- movl VIRTUAL(pm_esp), %esp
-
- /* Load protected-mode interrupt descriptor table */
- lidt VIRTUAL(idtr)
-
- /* Record real-mode %ss:sp (after removal of data) */
- movw %bp, VIRTUAL(rm_ss)
- addl %ecx, %edx
- movw %dx, VIRTUAL(rm_sp)
-
- /* Move data from RM stack to PM stack */
- subl %ecx, %esp
- movl %esp, %edi
- rep movsb
-
- /* Return to virtual address */
- ret
-
- /****************************************************************************
- * prot_to_real (protected-mode near call, 32-bit real-mode return address)
- *
- * Switch from 32-bit protected mode with virtual addresses to 16-bit
- * real mode. The protected-mode %esp is stored in pm_esp and the
- * real-mode %ss:sp is restored from the saved rm_ss and rm_sp. The
- * high word of the real-mode %esp is set to zero. All real-mode data
- * segment registers are loaded from the saved rm_ds. Interrupts are
- * *not* enabled, since we want to be able to use prot_to_real in an
- * ISR. All other registers may be destroyed.
- *
- * The return address for this function should be a 32-bit (sic)
- * real-mode offset within .code16.
- *
- * Parameters:
- * %ecx : number of bytes to move from PM stack to RM stack
- * %esi : real-mode global and interrupt descriptor table registers
- *
- ****************************************************************************
- */
- .section ".text.prot_to_real", "ax", @progbits
- .code32
- prot_to_real:
- /* Copy real-mode global descriptor table register to RM code segment */
- movl VIRTUAL(text16), %edi
- .if64 ; subl VIRTUAL(virt_offset), %edi ; .endif
- leal rm_gdtr(%edi), %edi
- movsw
- movsl
-
- /* Load real-mode interrupt descriptor table register */
- lidt (%esi)
-
- /* Add return address to data to be moved to RM stack */
- addl $4, %ecx
-
- /* Real-mode %ss:sp => %ebp:edx and virtual address => %edi */
- movzwl VIRTUAL(rm_ss), %ebp
- movzwl VIRTUAL(rm_sp), %edx
- subl %ecx, %edx
- movl %ebp, %eax
- shll $4, %eax
- leal (%eax,%edx), %edi
- subl VIRTUAL(virt_offset), %edi
-
- /* Move data from PM stack to RM stack */
- movl %esp, %esi
- rep movsb
-
- /* Record protected-mode %esp (after removal of data) */
- movl %esi, VIRTUAL(pm_esp)
-
- /* Load real-mode segment limits */
- movw $P2R_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- ljmp $REAL_CS, $p2r_rmode
- .section ".text16.prot_to_real", "ax", @progbits
- .code16
- p2r_rmode:
- /* Load real-mode GDT */
- data32 lgdt %cs:rm_gdtr
- /* Switch to real mode */
- movl %cr0, %eax
- andb $0!CR0_PE, %al
- movl %eax, %cr0
- p2r_ljmp_rm_cs:
- ljmp $0, $1f
- 1:
- /* Set up real-mode data segments and stack pointer */
- movw %cs:rm_ds, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %bp, %ss
- movl %edx, %esp
-
- /* Return to real-mode address */
- data32 ret
-
-
- /* Real-mode code and data segments. Assigned by the call to
- * init_librm. rm_cs doubles as the segment part of the jump
- * instruction used by prot_to_real. Both are located in
- * .text16 rather than .data16: rm_cs since it forms part of
- * the jump instruction within the code segment, and rm_ds
- * since real-mode code needs to be able to locate the data
- * segment with no other reference available.
- */
- .globl rm_cs
- .equ rm_cs, ( p2r_ljmp_rm_cs + 3 )
-
- .section ".text16.data.rm_ds", "aw", @progbits
- .globl rm_ds
- rm_ds: .word 0
-
- /* Real-mode global and interrupt descriptor table registers */
- .section ".text16.data.rm_gdtr", "aw", @progbits
- rm_gdtr:
- .word 0 /* Limit */
- .long 0 /* Base */
-
- /****************************************************************************
- * prot_call (real-mode near call, 16-bit real-mode near return address)
- *
- * Call a specific C function in the protected-mode code. The
- * prototype of the C function must be
- * void function ( struct i386_all_regs *ix86 );
- * ix86 will point to a struct containing the real-mode registers
- * at entry to prot_call.
- *
- * All registers will be preserved across prot_call(), unless the C
- * function explicitly overwrites values in ix86. Interrupt status
- * and GDT will also be preserved. Gate A20 will be enabled.
- *
- * Note that prot_call() does not rely on the real-mode stack
- * remaining intact in order to return, since everything relevant is
- * copied to the protected-mode stack for the duration of the call.
- * In particular, this means that a real-mode prefix can make a call
- * to main() which will return correctly even if the prefix's stack
- * gets vapourised during the Etherboot run. (The prefix cannot rely
- * on anything else on the stack being preserved, so should move any
- * critical data to registers before calling main()).
- *
- * Parameters:
- * function : virtual address of protected-mode function to call
- *
- * Example usage:
- * pushl $pxe_api_call
- * call prot_call
- * to call in to the C function
- * void pxe_api_call ( struct i386_all_regs *ix86 );
- ****************************************************************************
- */
- .struct 0
- PC_OFFSET_GDT: .space 6
- PC_OFFSET_IDT: .space 6
- PC_OFFSET_IX86: .space SIZEOF_I386_ALL_REGS
- PC_OFFSET_PADDING: .space 2 /* for alignment */
- PC_OFFSET_RETADDR: .space 2
- PC_OFFSET_FUNCTION: .space 4
- PC_OFFSET_END:
- .previous
-
- .section ".text16.prot_call", "ax", @progbits
- .code16
- .globl prot_call
- prot_call:
- /* Preserve registers, flags and GDT on external RM stack */
- pushfw /* padding */
- pushfl
- pushal
- pushw %gs
- pushw %fs
- pushw %es
- pushw %ds
- pushw %ss
- pushw %cs
- subw $PC_OFFSET_IX86, %sp
- movw %sp, %bp
- sidt PC_OFFSET_IDT(%bp)
- sgdt PC_OFFSET_GDT(%bp)
-
- /* For sanity's sake, clear the direction flag as soon as possible */
- cld
-
- /* Switch to protected mode and move register dump to PM stack */
- movl $PC_OFFSET_END, %ecx
- pushl $VIRTUAL(pc_pmode)
- jmp real_to_prot
- .section ".text.prot_call", "ax", @progbits
- .code32
- pc_pmode:
- /* Call function */
- leal PC_OFFSET_IX86(%esp), %eax
- pushl %eax
- call *(PC_OFFSET_FUNCTION+4)(%esp)
- popl %eax /* discard */
-
- /* Switch to real mode and move register dump back to RM stack */
- movl $PC_OFFSET_END, %ecx
- movl %esp, %esi
- pushl $pc_rmode
- jmp prot_to_real
- .section ".text16.prot_call", "ax", @progbits
- .code16
- pc_rmode:
- /* Restore registers and flags and return */
- addw $( PC_OFFSET_IX86 + 4 /* also skip %cs and %ss */ ), %sp
- popw %ds
- popw %es
- popw %fs
- popw %gs
- popal
- /* popal skips %esp. We therefore want to do "movl -20(%sp),
- * %esp", but -20(%sp) is not a valid 80386 expression.
- * Fortunately, prot_to_real() zeroes the high word of %esp, so
- * we can just use -20(%esp) instead.
- */
- addr32 movl -20(%esp), %esp
- popfl
- popfw /* padding */
- ret $4
-
- /****************************************************************************
- * real_call (protected-mode near call, 32-bit virtual return address)
- *
- * Call a real-mode function from protected-mode code.
- *
- * The non-segment register values will be passed directly to the
- * real-mode code. The segment registers will be set as per
- * prot_to_real. The non-segment register values set by the real-mode
- * function will be passed back to the protected-mode caller. A
- * result of this is that this routine cannot be called directly from
- * C code, since it clobbers registers that the C ABI expects the
- * callee to preserve.
- *
- * librm.h defines a convenient macro REAL_CODE() for using real_call.
- * See librm.h and realmode.h for details and examples.
- *
- * Parameters:
- * (32-bit) near pointer to real-mode function to call
- *
- * Returns: none
- ****************************************************************************
- */
- .struct 0
- RC_OFFSET_REGS: .space SIZEOF_I386_REGS
- RC_OFFSET_REGS_END:
- RC_OFFSET_RETADDR: .space 4
- RC_OFFSET_FUNCTION: .space 4
- RC_OFFSET_END:
- .previous
-
- .section ".text.real_call", "ax", @progbits
- .code32
- .globl real_call
- real_call:
- /* Create register dump and function pointer copy on PM stack */
- pushal
- pushl RC_OFFSET_FUNCTION(%esp)
-
- /* Switch to real mode and move register dump to RM stack */
- movl $( RC_OFFSET_REGS_END + 4 /* function pointer copy */ ), %ecx
- pushl $rc_rmode
- movl $VIRTUAL(rm_default_gdtr_idtr), %esi
- jmp prot_to_real
- .section ".text16.real_call", "ax", @progbits
- .code16
- rc_rmode:
- /* Call real-mode function */
- popl rc_function
- popal
- call *rc_function
- pushal
-
- /* For sanity's sake, clear the direction flag as soon as possible */
- cld
-
- /* Switch to protected mode and move register dump back to PM stack */
- movl $RC_OFFSET_REGS_END, %ecx
- pushl $VIRTUAL(rc_pmode)
- jmp real_to_prot
- .section ".text.real_call", "ax", @progbits
- .code32
- rc_pmode:
- /* Restore registers and return */
- popal
- ret $4
-
-
- /* Function vector, used because "call xx(%sp)" is not a valid
- * 16-bit expression.
- */
- .section ".bss16.rc_function", "aw", @nobits
- rc_function: .word 0, 0
-
- /* Default real-mode global and interrupt descriptor table registers */
- .section ".data.rm_default_gdtr_idtr", "aw", @progbits
- rm_default_gdtr_idtr:
- .word 0 /* Global descriptor table limit */
- .long 0 /* Global descriptor table base */
- .word 0x03ff /* Interrupt descriptor table limit */
- .long 0 /* Interrupt descriptor table base */
-
- /****************************************************************************
- * flatten_real_mode (real-mode near call)
- *
- * Switch to flat real mode
- *
- ****************************************************************************
- */
- .section ".text16.flatten_real_mode", "ax", @progbits
- .code16
- .globl flatten_real_mode
- flatten_real_mode:
- /* Modify GDT to use flat real mode */
- movb $0x8f, real_cs + 6
- movb $0x8f, real_ds + 6
- /* Call dummy protected-mode function */
- virtcall flatten_dummy
- /* Restore GDT */
- movb $0x00, real_cs + 6
- movb $0x00, real_ds + 6
- /* Return */
- ret
-
- .section ".text.flatten_dummy", "ax", @progbits
- .code32
- flatten_dummy:
- ret
-
- /****************************************************************************
- * Interrupt wrapper
- *
- * Used by the protected-mode interrupt vectors to call the
- * interrupt() function.
- *
- * May be entered with either physical or virtual stack segment.
- ****************************************************************************
- */
- .section ".text.interrupt_wrapper", "ax", @progbits
- .code32
- .globl interrupt_wrapper
- interrupt_wrapper:
- /* Preserve segment registers and original %esp */
- pushl %ds
- pushl %es
- pushl %fs
- pushl %gs
- pushl %ss
- pushl %esp
-
- /* Switch to virtual addressing */
- call _intr_to_virt
-
- /* Expand IRQ number to whole %eax register */
- movzbl %al, %eax
-
- /* Call interrupt handler */
- call interrupt
-
- /* Restore original stack and segment registers */
- lss (%esp), %esp
- popl %ss
- popl %gs
- popl %fs
- popl %es
- popl %ds
-
- /* Restore registers and return */
- popal
- iret
|