format elf executable at 1 shl 16       ; must start in 32-bit mode or we can't access memory after a 64 --> 32 switch

TRIALS=8 ; do some example trial runs

STDOUT_FILENO   = 1
SYS32_write     = 4
SYS32_exit      = 1
SYS64_write     = 1
SYS64_exit      = 60

entry $
        mov     ebp,TRIALS
    .32:
        use32
        mov     eax,SYS32_write
        mov     ebx,STDOUT_FILENO
        mov     ecx,text32
        mov     edx,len32
        int     0x80
        dec     ebp
        jz      .exit32
        mov     ecx,.64
        jmp     toggle_mode
    .exit32:
        mov     eax,SYS32_exit
        xor     ebx,ebx
        int     0x80

    .64:
        use64
        mov     eax,SYS64_write
        mov     edi,STDOUT_FILENO
        lea     rsi,[text64]
        mov     edx,len64
        syscall
        dec     ebp
        jz      .exit64
        lea     ecx,[.32]
        jmp     toggle_mode
    .exit64:
        mov     eax,SYS64_exit
        xor     edi,edi
        syscall

toggle_mode:
        use64                   ; this is code for both modes
        mov     edx,.far_ptr    ; use absolute address only
        mov     eax,cs
        xor     eax,0x10        ; offset is +-16
        mov     [rdx],ecx
        mov     [rdx+4],ax
        jmp     fword[rdx]      ; jmp to ax:ecx
    .far_ptr    df ?

text32 db 'Hello from 32-bit code!',10
len32 = $ - text32
text64 db 'Hello from 64-bit code!',10
len64 = $ - text64

; See this comment at https://github.com/torvalds/linux/blob/master/arch/x86/include/asm/segment.h
;
;/*
; * We cannot use the same code segment descriptor for user and kernel mode,
; * not even in long flat mode, because of different DPL.
; *
; * GDT layout to get 64-bit SYSCALL/SYSRET support right. SYSRET hardcodes
; * selectors:
; *
; *   if returning to 32-bit userspace: cs = STAR.SYSRET_CS,
; *   if returning to 64-bit userspace: cs = STAR.SYSRET_CS+16,
; *
; * ss = STAR.SYSRET_CS+8 (in either case)
; *
; * thus USER_DS should be between 32-bit and 64-bit code selectors:
; */
;
;#define GDT_ENTRY_DEFAULT_USER32_CS    4
;#define GDT_ENTRY_DEFAULT_USER_DS      5
;#define GDT_ENTRY_DEFAULT_USER_CS      6    

• All memory allocations should be done in 32-bit code through int 0x80 to ensure the addresses are <4G.

format elf executable at 1 shl 16

STDOUT_FILENO   = 1
SYS32_write     = 4
SYS32_exit      = 1
SYS64_write     = 1
SYS64_exit      = 60
CS_TOGGLE       = 0x10  ; offset is +-16

entry $
        ;initialise call pointers
        mov     eax,cs
        mov     word[print_hello_32+4],ax
        xor     eax,CS_TOGGLE
        mov     word[print_hello_64+4],ax
        call    [print_hello_64]
        mov     eax,SYS32_exit
        xor     ebx,ebx
        int     0x80

print_hello_32  df      0:_print_hello_32
_print_hello_32:
        use32
        mov     eax,SYS32_write
        mov     ebx,STDOUT_FILENO
        mov     ecx,text32
        mov     edx,len32
        int     0x80
        retf

print_hello_64  df      0:_print_hello_64
_print_hello_64:
        use64
        call    [print_hello_32]
        mov     eax,SYS64_write
        mov     edi,STDOUT_FILENO
        lea     rsi,[text64]
        mov     edx,len64
        syscall
        retfd

text32 db 'Hello from 32-bit code!',10
len32 = $ - text32
text64 db 'Hello from 64-bit code!',10
len64 = $ - text64