531 lines
10 KiB
ArmAsm
531 lines
10 KiB
ArmAsm
/*
|
||
* Copyright Robert J. Amstadt, 1993
|
||
*/
|
||
#ifdef linux
|
||
#define UDATASEL 0x2b
|
||
#endif
|
||
#if defined(__NetBSD__) || defined(__FreeBSD__)
|
||
#define UDATASEL 0x27
|
||
#endif
|
||
#ifdef __ELF__
|
||
#define A(addr) addr
|
||
#else
|
||
#define A(addr) _##addr
|
||
#endif
|
||
.data
|
||
jump_target:
|
||
return_value:
|
||
.long 0
|
||
|
||
/**********************************************************************
|
||
* Places to keep info about the current 32-bit stack frame.
|
||
*/
|
||
.globl A( IF1632_Saved32_esp), A(IF1632_Saved32_ebp), A(IF1632_Saved32_ss)
|
||
A(IF1632_Saved32_esp:)
|
||
.long 0
|
||
A(IF1632_Saved32_ebp:)
|
||
.long 0
|
||
A(IF1632_Saved32_ss:)
|
||
.word 0
|
||
#ifdef __ELF__
|
||
A(IF1632_ELF_KLUDGE:)
|
||
.long 0
|
||
.word 0x0f
|
||
#endif
|
||
|
||
/**********************************************************************
|
||
* Places to keep info about the current 16-bit stack frame.
|
||
*/
|
||
.globl A(IF1632_Saved16_sp),A(IF1632_Saved16_bp),A(IF1632_Saved16_ss)
|
||
A(IF1632_Saved16_sp:)
|
||
.word 0
|
||
A(IF1632_Saved16_bp:)
|
||
.word 0
|
||
A(IF1632_Saved16_ss:)
|
||
.word 0
|
||
|
||
nbytes:
|
||
.word 0
|
||
selector:
|
||
.word 0
|
||
offset:
|
||
.word 0
|
||
|
||
.text
|
||
|
||
/**********************************************************************
|
||
* int CallToInit16(unsigned long csip, unsigned long sssp,
|
||
* unsigned short ds)
|
||
*
|
||
* Stack: 0 ebp
|
||
* 4 eip
|
||
* 8 target ip
|
||
* 10 target cs
|
||
* 12 target sp
|
||
* 14 target ss
|
||
* 16 target ds
|
||
*/
|
||
.align 4
|
||
.globl A(CallToInit16)
|
||
A(CallToInit16:)
|
||
pushl %ebp
|
||
movl %esp,%ebp
|
||
|
||
/*
|
||
* Save our registers
|
||
*/
|
||
pushal
|
||
pushl A(IF1632_Saved32_esp)
|
||
pushl A(IF1632_Saved32_ebp)
|
||
pushw A(IF1632_Saved32_ss)
|
||
|
||
#ifdef __ELF__
|
||
/* change to the other code segment */
|
||
movw $0x0f, %ax
|
||
movw %ax, A(IF1632_ELF_KLUDGE)+4
|
||
movl $L4, %eax
|
||
andl $0x0000ffff, %eax
|
||
movl %eax,A(IF1632_ELF_KLUDGE)
|
||
ljmp A(IF1632_ELF_KLUDGE)
|
||
L4:
|
||
#endif
|
||
/*
|
||
* Get target address.
|
||
*/
|
||
movl 8(%ebp),%eax
|
||
movl %eax,jump_target
|
||
lea jump_target,%edx
|
||
|
||
/*
|
||
* Put stack registers where we can get them after stack switch.
|
||
*/
|
||
movw %ss,A(IF1632_Saved32_ss)
|
||
movl %esp,A(IF1632_Saved32_esp)
|
||
movl %ebp,A(IF1632_Saved32_ebp)
|
||
|
||
/*
|
||
* Load initial registers
|
||
*/
|
||
movw A(WIN_StackSize),%bx
|
||
movw A(WIN_HeapSize),%cx
|
||
movl $0,%esi
|
||
xorl %eax,%eax
|
||
movw A(PSPSelector),%ax
|
||
movw %ax,%es
|
||
movw 16(%ebp),%ax
|
||
movw %ax,%ds
|
||
movl %eax,%edi
|
||
xorl %eax,%eax
|
||
movw 12(%ebp),%ax
|
||
movl %eax,%esp
|
||
movw 14(%ebp),%ax
|
||
movw %ax,%ss
|
||
movl %esp,%eax
|
||
movl %eax,%ebp
|
||
movw $UDATASEL,%ax
|
||
movw %ax,%fs
|
||
movw %ax,%gs
|
||
movw %ds,%ax
|
||
|
||
/*
|
||
* Call entry point
|
||
*/
|
||
.byte 0x66
|
||
lcall %fs:(%edx)
|
||
|
||
/*
|
||
* Restore old stack and segment registers.
|
||
*
|
||
* Two choices here:
|
||
* 1. Trust that fs or gs hasn't changed.
|
||
* 2. Rely on knowledge of Linux use of segments.
|
||
*
|
||
* I'll opt for choice 2 because who knows what programs we
|
||
* going to run. Linux should be fairly stable in terms of
|
||
* GDT usage.
|
||
*/
|
||
pushl %eax
|
||
movw $UDATASEL,%ax
|
||
movw %ax,%ds
|
||
movw %ax,%es
|
||
movw %ax,%fs
|
||
movw %ax,%gs
|
||
popl %eax
|
||
movw A(IF1632_Saved32_ss),%ss
|
||
movl A(IF1632_Saved32_esp),%esp
|
||
movl A(IF1632_Saved32_ebp),%ebp
|
||
|
||
/*
|
||
* Restore registers, but do not destroy return value.
|
||
*/
|
||
popw A(IF1632_Saved32_ss)
|
||
popl A(IF1632_Saved32_ebp)
|
||
popl A(IF1632_Saved32_esp)
|
||
movl %eax,return_value
|
||
#ifdef __ELF__
|
||
/* change back */
|
||
movw $0x23, %ax
|
||
movw %ax, A(IF1632_ELF_KLUDGE)+4
|
||
movl $L5, %eax
|
||
movl %eax,A(IF1632_ELF_KLUDGE)
|
||
ljmp A(IF1632_ELF_KLUDGE)
|
||
L5:
|
||
#endif
|
||
popal
|
||
movl return_value,%eax
|
||
.align 2,0x90
|
||
leave
|
||
ret
|
||
|
||
/**********************************************************************
|
||
* int CallTo16 (unsigned long csip, unsigned short ds)
|
||
* int CallTo16cx(unsigned long csip, unsigned long dscx);
|
||
*
|
||
* Stack: 0 ebp
|
||
* 4 eip
|
||
* 8 target ip
|
||
* 10 target cs
|
||
* 12 target ds
|
||
* 14 target cx (only CallTo16cx)
|
||
* 16 target di
|
||
*/
|
||
.align 4
|
||
.globl A(CallTo16), A(CallTo16cx), A(CallToLibMain)
|
||
A(CallToLibMain:)
|
||
pushl %ebp
|
||
movl %esp,%ebp
|
||
movw 16(%ebp),%di
|
||
movw 0,%si
|
||
movw 0,%es
|
||
jmp L1
|
||
A(CallTo16:)
|
||
A(CallTo16cx:)
|
||
pushl %ebp
|
||
movl %esp,%ebp
|
||
|
||
/*
|
||
* Get target address and new ds
|
||
*/
|
||
L1:
|
||
#ifdef __ELF__
|
||
/* change code segments */
|
||
movw $0x0f, %ax
|
||
movw %ax, A(IF1632_ELF_KLUDGE)+4
|
||
movl $L2, %eax
|
||
andl $0x0000ffff, %eax
|
||
movl %eax,A(IF1632_ELF_KLUDGE)
|
||
ljmp A(IF1632_ELF_KLUDGE)
|
||
L2:
|
||
#endif
|
||
/* At this point we have changed segments. */
|
||
movl 8(%ebp),%eax
|
||
movl %eax,jump_target
|
||
lea jump_target,%edx
|
||
movw 12(%ebp),%ax
|
||
movw 14(%ebp),%cx
|
||
|
||
/*
|
||
* Switch to 16-bit stack
|
||
*/
|
||
pushl A(IF1632_Saved32_esp)
|
||
pushl A(IF1632_Saved32_ebp)
|
||
pushw A(IF1632_Saved32_ss)
|
||
|
||
movw %ss,A(IF1632_Saved32_ss)
|
||
movl %esp,A(IF1632_Saved32_esp)
|
||
movl %ebp,A(IF1632_Saved32_ebp)
|
||
|
||
movw A(IF1632_Saved16_ss),%ss
|
||
movw A(IF1632_Saved16_sp),%sp
|
||
movw A(IF1632_Saved16_bp),%bp
|
||
|
||
/*
|
||
* Call entry point
|
||
*/
|
||
movw %ax,%ds
|
||
movw %ax,%di
|
||
.byte 0x66
|
||
lcall %fs:(%edx)
|
||
|
||
/*
|
||
* Restore old stack and segment registers.
|
||
*
|
||
* Two choices here:
|
||
* 1. Trust that fs or gs hasn't changed.
|
||
* 2. Rely on knowledge of Linux use of segments.
|
||
*
|
||
* I'll opt for choice 2 because who knows what programs we
|
||
* going to run. Linux should be fairly stable in terms of
|
||
* GDT usage.
|
||
*/
|
||
pushl %eax
|
||
movw $UDATASEL,%ax
|
||
movw %ax,%ds
|
||
movw %ax,%es
|
||
movw %ax,%fs
|
||
movw %ax,%gs
|
||
popl %eax
|
||
|
||
movw %ss,A(IF1632_Saved16_ss)
|
||
movw %esp,A(IF1632_Saved16_sp)
|
||
movw %ebp,A(IF1632_Saved16_bp)
|
||
|
||
movw A(IF1632_Saved32_ss),%ss
|
||
movl A(IF1632_Saved32_esp),%esp
|
||
movl A(IF1632_Saved32_ebp),%ebp
|
||
|
||
popw A(IF1632_Saved32_ss)
|
||
popl A(IF1632_Saved32_ebp)
|
||
popl A(IF1632_Saved32_esp)
|
||
|
||
movl %eax,return_value
|
||
movw return_value+2,%dx
|
||
/* switch segments */
|
||
#ifdef __ELF__
|
||
movw $0x23, %ax
|
||
movw %ax, A(IF1632_ELF_KLUDGE)+4
|
||
movl $L3, %eax
|
||
movl %eax,A(IF1632_ELF_KLUDGE)
|
||
ljmp A(IF1632_ELF_KLUDGE)
|
||
L3:
|
||
/* back in the regular segment set up. */
|
||
/* restore eax */
|
||
movl return_value, %eax
|
||
#endif
|
||
.align 2,0x90
|
||
leave
|
||
ret
|
||
|
||
/**********************************************************************
|
||
* CallTo32()
|
||
*
|
||
* This function is called as a relay point to the built function
|
||
* handler. KERNEL, USER and GDI calls are dealt with by this
|
||
* handler. Calls to these DLLs will be mapped to a call handler
|
||
* which will set EAX to a number indicating which DLL and which
|
||
* function within that DLL.
|
||
*
|
||
* This function will pass to the function handler two arguments.
|
||
* The first argument will be the contents of EAX, the second
|
||
* argument will be a segment:offset pair that points to the
|
||
* 16-bit stack.
|
||
*/
|
||
.align 4
|
||
.globl A(CallTo32)
|
||
A(CallTo32:)
|
||
andl $0x0000ffff,%esp
|
||
pushw %bp
|
||
movl %esp,%ebp
|
||
|
||
/*
|
||
* Save registers. 286 mode does not have fs or gs.
|
||
*/
|
||
pushw %ds
|
||
|
||
/*
|
||
* Restore segment registers.
|
||
*/
|
||
pushl %eax
|
||
movw $UDATASEL,%ax
|
||
movw %ax,%ds
|
||
movw %ax,%es
|
||
popl %eax
|
||
|
||
/*
|
||
* Save old stack save variables, save stack registers, reload
|
||
* stack registers.
|
||
*/
|
||
pushw A(IF1632_Saved16_sp)
|
||
pushw A(IF1632_Saved16_bp)
|
||
pushw A(IF1632_Saved16_ss)
|
||
|
||
movw %ss,A(IF1632_Saved16_ss)
|
||
movw %sp,A(IF1632_Saved16_sp)
|
||
movw %bp,A(IF1632_Saved16_bp)
|
||
|
||
movw A(IF1632_Saved32_ss),%ss
|
||
movl A(IF1632_Saved32_esp),%esp
|
||
movl A(IF1632_Saved32_ebp),%ebp
|
||
|
||
/*
|
||
* Call entry point
|
||
*/
|
||
pushl %edx
|
||
pushw A(IF1632_Saved16_ss)
|
||
pushw A(IF1632_Saved16_sp)
|
||
pushl %eax
|
||
call A(DLLRelay)
|
||
|
||
popl %edx
|
||
popl %edx
|
||
popl %edx
|
||
|
||
/*
|
||
* Restore registers, but do not destroy return value.
|
||
*/
|
||
movw A(IF1632_Saved16_ss),%ss
|
||
movw A(IF1632_Saved16_sp),%sp
|
||
movw A(IF1632_Saved16_bp),%bp
|
||
|
||
popw A(IF1632_Saved16_ss)
|
||
popw A(IF1632_Saved16_bp)
|
||
popw A(IF1632_Saved16_sp)
|
||
|
||
popw %ds
|
||
popw %bp
|
||
|
||
/*
|
||
* Now we need to ditch the parameter bytes that were left on the
|
||
* stack. We do this by effectively popping the number of bytes,
|
||
* and the return address, removing the parameters and then putting
|
||
* the return address back on the stack.
|
||
* Normally this field is filled in by the relevant function in
|
||
* the emulation library, since it should know how many bytes to
|
||
* expect.
|
||
*/
|
||
popw %gs:nbytes
|
||
cmpw $0,%gs:nbytes
|
||
je noargs
|
||
popw %gs:offset
|
||
popw %gs:selector
|
||
addw %gs:nbytes,%esp
|
||
pushw %gs:selector
|
||
pushw %gs:offset
|
||
noargs:
|
||
|
||
/*
|
||
* Last, but not least we need to move the high word from eax to dx
|
||
*/
|
||
|
||
pushl %eax
|
||
popw %dx
|
||
popw %dx
|
||
|
||
.byte 0x66
|
||
lret
|
||
|
||
/**********************************************************************
|
||
* CallTo32_16()
|
||
*
|
||
* This function is same one as CallTo32() except that the high
|
||
* word of EAX won't be moved to DX.
|
||
*/
|
||
.align 4
|
||
.globl A(CallTo32_16)
|
||
A(CallTo32_16:)
|
||
andl $0x0000ffff,%esp
|
||
pushw %bp
|
||
movl %esp,%ebp
|
||
|
||
/*
|
||
* Save registers. 286 mode does not have fs or gs.
|
||
*/
|
||
pushw %ds
|
||
|
||
/*
|
||
* Restore segment registers.
|
||
*/
|
||
pushl %eax
|
||
movw $UDATASEL,%ax
|
||
movw %ax,%ds
|
||
movw %ax,%es
|
||
popl %eax
|
||
|
||
/*
|
||
* Save old stack save variables, save stack registers, reload
|
||
* stack registers.
|
||
*/
|
||
pushw A(IF1632_Saved16_sp)
|
||
pushw A(IF1632_Saved16_bp)
|
||
pushw A(IF1632_Saved16_ss)
|
||
|
||
movw %ss,A(IF1632_Saved16_ss)
|
||
movw %esp,A(IF1632_Saved16_sp)
|
||
movw %ebp,A(IF1632_Saved16_bp)
|
||
|
||
movw A(IF1632_Saved32_ss),%ss
|
||
movl A(IF1632_Saved32_esp),%esp
|
||
movl A(IF1632_Saved32_ebp),%ebp
|
||
|
||
/*
|
||
* Call entry point
|
||
*/
|
||
pushl %edx
|
||
pushw A(IF1632_Saved16_ss)
|
||
pushw A(IF1632_Saved16_sp)
|
||
pushl %eax
|
||
call A(DLLRelay)
|
||
|
||
popl %edx
|
||
popl %edx
|
||
popl %edx
|
||
|
||
/*
|
||
* Restore registers, but do not destroy return value.
|
||
*/
|
||
movw A(IF1632_Saved16_ss),%ss
|
||
movw A(IF1632_Saved16_sp),%sp
|
||
movw A(IF1632_Saved16_bp),%bp
|
||
|
||
popw A(IF1632_Saved16_ss)
|
||
popw A(IF1632_Saved16_bp)
|
||
popw A(IF1632_Saved16_sp)
|
||
|
||
popw %ds
|
||
popw %bp
|
||
|
||
/*
|
||
* Now we need to ditch the parameter bytes that were left on the
|
||
* stack. We do this by effectively popping the number of bytes,
|
||
* and the return address, removing the parameters and then putting
|
||
* the return address back on the stack.
|
||
* Normally this field is filled in by the relevant function in
|
||
* the emulation library, since it should know how many bytes to
|
||
* expect.
|
||
*/
|
||
popw %gs:nbytes
|
||
cmpw $0,%gs:nbytes
|
||
je noargs2
|
||
popw %gs:offset
|
||
popw %gs:selector
|
||
addw %gs:nbytes,%esp
|
||
pushw %gs:selector
|
||
pushw %gs:offset
|
||
noargs2:
|
||
.byte 0x66
|
||
lret
|
||
|
||
/**********************************************************************
|
||
* ReturnFromRegisterFunc()
|
||
*/
|
||
.globl A(ReturnFromRegisterFunc)
|
||
A(ReturnFromRegisterFunc:)
|
||
/*
|
||
* Restore 16-bit stack
|
||
*/
|
||
movw A(IF1632_Saved16_ss),%ss
|
||
movw A(IF1632_Saved16_sp),%sp
|
||
movw A(IF1632_Saved16_bp),%bp
|
||
|
||
popw A(IF1632_Saved16_ss)
|
||
popw A(IF1632_Saved16_bp)
|
||
popw A(IF1632_Saved16_sp)
|
||
|
||
popw %ds
|
||
popw %bp
|
||
|
||
/*
|
||
* This leaves us with a stack that has number of arguments,
|
||
* the return address, the saved registers, and the return
|
||
* address again.
|
||
*/
|
||
add $6,%esp /* argument count, return address */
|
||
#include "pop.h" /* restore context */
|
||
|
||
/*
|
||
* Return to original caller.
|
||
*/
|
||
.byte 0x66
|
||
lret
|
||
|