home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / CLIPPER / MISC / EMXLIB8F.ZIP / EMX / LIB / SYS / THUNK.ASM < prev    next >
Encoding:
Assembly Source File  |  1992-10-22  |  5.8 KB  |  185 lines

  1. ; thunk.asm (emx+gcc) -- Copyright (c) 1992 by Eberhard Mattes
  2.  
  3.                 .386
  4.  
  5.                 .MODEL  FLAT
  6.  
  7.                 PUBLIC  _emx_16to32
  8.                 PUBLIC  _emx_32to16
  9.                 PUBLIC  _emx_thunk1
  10.  
  11. TEXT32          SEGMENT DWORD PUBLIC FLAT 'CODE'
  12.  
  13.                 EXTRN   DosFlatToSel:PROC
  14.                 EXTRN   DosSelToFlat:PROC
  15. ;
  16. ;
  17. ;
  18.                 ALIGN  4
  19. _emx_32to16     PROC
  20.                 MOV     EAX, [ESP+4]
  21.                 JMP     DosFlatToSel
  22. _emx_32to16     ENDP
  23.  
  24. ;
  25. ;
  26. ;
  27.                 ALIGN  4
  28. _emx_16to32     PROC
  29.                 MOV     EAX, [ESP+4]
  30.                 JMP     DosSelToFlat
  31. _emx_16to32     ENDP
  32.  
  33. ;
  34. ; unsigned long _emx_thunk1 (void *args, void *fun)
  35. ;
  36. ; Call 16-bit code
  37. ;
  38. ; In:   ARGS    Pointer to argument list. The first DWORD contains the
  39. ;               number of argument bytes, excluding that DWORD. The
  40. ;               remaining values are packed appropriately for calling
  41. ;               an 16-bit function. Pointers have been converted to
  42. ;               sel:offset format
  43. ;
  44. ;       FUN     16:16 address of 16-bit function to be called. The
  45. ;               function is assumed to use the pascal calling
  46. ;               convention, that is, the function removes its arguments
  47. ;               from the stack
  48. ;
  49. ; Out:  EAX     Return value (DX:AX) of 16-bit function
  50. ;
  51. ; Stack on entry (1):
  52. ;
  53. ;       ...
  54. ;       FUN
  55. ;       ARGS
  56. ; ESP-> return address
  57. ; ---------------------------------------------------------------------------
  58. ;
  59. ; Stack after setting up stack frame (2):
  60. ;
  61. ;       ...
  62. ;       FUN
  63. ;       ARGS
  64. ;       return address
  65. ; EBP-> caller's EBP
  66. ;       caller's EBX
  67. ;       caller's ESI
  68. ;       caller's EDI
  69. ; ---------------------------------------------------------------------------
  70. ;
  71. ; Stack before jumping to 16-bit code (3):
  72. ;
  73. ;       ...
  74. ;       FUN
  75. ;       ARGS
  76. ;       return address
  77. ; EBP-> caller's EBP
  78. ;       caller's EBX
  79. ;       caller's ESI
  80. ;       caller's EDI
  81. ;       padding                                 (0 to 1000H-4 bytes)
  82. ;       SS:ESP -> caller's EBP                  (2 DWORDs, DWORD-aligned)
  83. ; SP->  arguments                               (WORD aligned)
  84. ; ---------------------------------------------------------------------------
  85. ;
  86. ; Stack after return from 16-bit code (4):
  87. ;
  88. ;       ...
  89. ;       FUN
  90. ;       ARGS
  91. ;       return address
  92. ;       caller's EBP
  93. ;       caller's ESI
  94. ;       caller's EDI
  95. ;       padding                                 (0 to 1000H-4 bytes)
  96. ; SP->  SS:ESP -> caller's EBP                  (2 DWORDs, DWORD-aligned)
  97. ; ---------------------------------------------------------------------------
  98. ;
  99.                 ALIGN  4
  100. ARGS            EQU     (DWORD PTR [EBP+2*4])
  101. FUN             EQU     (DWORD PTR [EBP+3*4])
  102. _emx_thunk1     PROC                            ; (1)
  103.                 PUSH    EBP                     ; Set up stack frame
  104.                 MOV     EBP, ESP
  105.                 PUSH    ESI                     ; Save ESI
  106.                 PUSH    EDI                     ; Save EDI
  107.                 PUSH    EBX                     ; (2) Save EBX
  108.                 MOV     DX, SS                  ; Prepare conversion of
  109.                 AND     DL, 3                   ; ESP to SS:SP
  110.                 OR      DL, 4                   ; LDT
  111.                 MOV     EAX, ESP                ; Check stack
  112.                 CMP     AX, 1000H               ; 1000H bytes left in this 64K
  113.                 JAE     SHORT THUNK1_1          ; segment? Yes => skip
  114.                 XOR     AX, AX                  ; Move ESP down to next 64K seg
  115.                 MOV     BYTE PTR [EAX], 0       ; Stack probe
  116.                 XCHG    ESP, EAX                ; Set new ESP, EAX := old ESP
  117. THUNK1_1:       PUSH    SS                      ; Save original SS:ESP on
  118.                 PUSH    EAX                     ; stack (points to saved EBX)
  119. ;
  120. ; Copy arguments
  121. ;
  122.                 MOV     ESI, ARGS
  123.                 LODSD
  124.                 MOV     ECX, EAX
  125.                 SUB     ESP, ECX
  126.                 MOV     EDI, ESP
  127.                 SHR     ECX, 2
  128.                 REP     MOVSD
  129.                 MOV     ECX, EAX
  130.                 AND     ECX, 03H
  131.                 REP     MOVSB
  132.                 LEA     ESI, FUN
  133. ;
  134. ; Convert ESP to SS:SP
  135. ;
  136.                 MOV     EAX, ESP
  137.                 ROL     EAX, 16
  138.                 SHL     AX, 3
  139.                 OR      AL, DL
  140.                 PUSH    EAX                     ; Push new SS
  141.                 SHR     EAX, 16
  142.                 PUSH    EAX                     ; Push new ESP
  143.                 LSS     ESP, [ESP]              ; Switch to new SS:SP
  144.                 JMP     FAR PTR TEXT16:THUNK16_CALL ; (3)
  145. ;
  146. ; Jump to 16-bit code
  147. ;
  148.                 RETF
  149.  
  150.                 ALIGN  4
  151. THUNK1_RET::    MOVZX   ESP, SP                 ; (4) Don't trust...
  152.                 LSS     ESP, [ESP]              ; Get 32-bit stack pointer
  153.                 POP     EBX                     ; Restore EBX
  154.                 POP     EDI                     ; Restore EDI
  155.                 POP     ESI                     ; Restore ESI
  156.                 POP     EBP                     ; Restore EBP
  157.                 MOVZX   EAX, AX                 ; Compute return value
  158.                 MOVZX   EDX, DX
  159.                 SHL     EDX, 16
  160.                 OR      EAX, EDX
  161.                 RET                             ; Return to 32-bit code
  162.  
  163. _emx_thunk1     ENDP
  164.  
  165. TEXT32          ENDS
  166.  
  167. ;
  168. ;
  169. ;
  170.  
  171. TEXT16          SEGMENT DWORD PUBLIC USE16 'CODE'
  172.  
  173. ;
  174. ; Call 16-bit function
  175. ;
  176. ; In:    ESI    Points to 16:16 function address
  177. ;
  178.                 ALIGN  4
  179. THUNK16_CALL:   CALL    DWORD PTR [ESI]
  180.                 JMP     FAR PTR FLAT:THUNK1_RET
  181.  
  182. TEXT16          ENDS
  183.  
  184.                 END
  185.