Mercurial > pub > dyncall > dyncall

comparison dyncall/dyncall_call_x86.S @ 610:fea865cd1305

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- whitespace cosmetics
author Tassilo Philipp
date Thu, 29 Sep 2022 10:51:24 +0200
parents ab2d78e48ca2
children e5ad8cf0aa72
comparison
equal deleted inserted replaced
609:f2f0e53d8b02 610:fea865cd1305
55 55
56 */ 56 */
57 57
58 GLOBAL(dcCall_x86_cdecl) 58 GLOBAL(dcCall_x86_cdecl)
59 BEGIN_PROC(dcCall_x86_cdecl) 59 BEGIN_PROC(dcCall_x86_cdecl)
60 PUSH(EBP) /* prolog. */ 60 PUSH(EBP) /* prolog. */
61 MOVL(ESP,EBP) 61 MOVL(ESP,EBP)
62 PUSH(ESI) /* save preserved registers. */ 62 PUSH(ESI) /* save preserved registers. */
63 PUSH(EDI) 63 PUSH(EDI)
64 MOVL(DWORD(EBP,12),ESI) /* ESI = arg buffer ptr */ 64 MOVL(DWORD(EBP,12),ESI) /* ESI = arg buffer ptr */
65 MOVL(DWORD(EBP,16),ECX) /* ECX = arg buffer size */ 65 MOVL(DWORD(EBP,16),ECX) /* ECX = arg buffer size */
66 ADDL(LIT(15),ECX) /* ECX = align(ECX,16) */ 66 ADDL(LIT(15),ECX) /* ECX = align(ECX,16) */
67 ANDL(LIT(-16),ECX) 67 ANDL(LIT(-16),ECX)
68 MOVL(ECX,DWORD(EBP,16)) /* save ECX. */ 68 MOVL(ECX,DWORD(EBP,16)) /* save ECX. */
69 SUBL(ECX,ESP) /* allocate stack size */ 69 SUBL(ECX,ESP) /* allocate stack size */
70 MOVL(ESP,EDI) /* EDI = stack ptr */ 70 MOVL(ESP,EDI) /* EDI = stack ptr */
71 71
72 /* 72 /*
73 work around for rep movsd (not supported by SunPro) 73 work around for rep movsd (not supported by SunPro)
74 74
75 SHRL(LIT(2),ECX) 75 SHRL(LIT(2),ECX)
84 POP(ESI) 84 POP(ESI)
85 MOVL(EBP,ESP) 85 MOVL(EBP,ESP)
86 POP(EBP) 86 POP(EBP)
87 RET() 87 RET()
88 END_PROC(dcCall_x86_cdecl) 88 END_PROC(dcCall_x86_cdecl)
89
90
89 /* ---- C++ this calls (microsoft) ------------------------------------------ 91 /* ---- C++ this calls (microsoft) ------------------------------------------
90 92
91 Details: 93 Details:
92 - this pointer is in ECX 94 - this pointer is in ECX
93 95
94 */ 96 */
95 97
96 GLOBAL(dcCall_x86_win32_msthis) 98 GLOBAL(dcCall_x86_win32_msthis)
97 BEGIN_PROC(dcCall_x86_win32_msthis) 99 BEGIN_PROC(dcCall_x86_win32_msthis)
98 PUSH(EBP) /* prolog. */ 100 PUSH(EBP) /* prolog. */
99 MOVL(ESP,EBP) 101 MOVL(ESP,EBP)
100 PUSH(ESI) /* save preserved. */ 102 PUSH(ESI) /* save preserved. */
101 PUSH(EDI) 103 PUSH(EDI)
102 MOVL(DWORD(EBP,12),ESI) /* ESI = pointer on args. */ 104 MOVL(DWORD(EBP,12),ESI) /* ESI = pointer on args. */
103 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */ 105 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */
104 MOVL(DWORD(ESI,0),EAX) /* EAX = this pointer. */ 106 MOVL(DWORD(ESI,0),EAX) /* EAX = this pointer. */
105 ADDL(LIT(4),ESI) /* increment args pointer by thisptr. */ 107 ADDL(LIT(4),ESI) /* increment args pointer by thisptr. */
106 SUBL(LIT(4),ECX) /* decrement size by sizeof(thisptr). */ 108 SUBL(LIT(4),ECX) /* decrement size by sizeof(thisptr). */
107 SUBL(ECX,ESP) /* allocate argument-block on stack. */ 109 SUBL(ECX,ESP) /* allocate argument-block on stack. */
108 MOVL(ESP,EDI) /* EDI = stack args. */ 110 MOVL(ESP,EDI) /* EDI = stack args. */
109 REP(MOVSB) /* copy arguments. */ 111 REP(MOVSB) /* copy arguments. */
110 MOVL(EAX,ECX) /* ECX = this pointer. */ 112 MOVL(EAX,ECX) /* ECX = this pointer. */
111 CALL_DWORD(EBP,8) /* call function. */ 113 CALL_DWORD(EBP,8) /* call function. */
112 POP(EDI) /* restore preserved. */ 114 POP(EDI) /* restore preserved. */
113 POP(ESI) 115 POP(ESI)
114 MOVL(EBP,ESP) /* epilog. */ 116 MOVL(EBP,ESP) /* epilog. */
115 POP(EBP) 117 POP(EBP)
116 RET() 118 RET()
117 END_PROC(dcCall_x86_win32_msthis) 119 END_PROC(dcCall_x86_win32_msthis)
120
118 121
119 /*---- win32 stdcall --------------------------------------------------------- 122 /*---- win32 stdcall ---------------------------------------------------------
120 123
121 Details: 124 Details:
122 - callee cleans up stack 125 - callee cleans up stack
123 126
124 */ 127 */
125 128
126 GLOBAL(dcCall_x86_win32_std) 129 GLOBAL(dcCall_x86_win32_std)
127 BEGIN_PROC(dcCall_x86_win32_std) 130 BEGIN_PROC(dcCall_x86_win32_std)
128 PUSH(EBP) /* prolog. */ 131 PUSH(EBP) /* prolog. */
129 MOVL(ESP,EBP) 132 MOVL(ESP,EBP)
130 PUSH(ESI) /* save ESI, EDI. */ 133 PUSH(ESI) /* save ESI, EDI. */
131 PUSH(EDI) 134 PUSH(EDI)
132 MOVL(DWORD(EBP,12),ESI) /* ESI = args. */ 135 MOVL(DWORD(EBP,12),ESI) /* ESI = args. */
133 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */ 136 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */
134 SUBL(ECX,ESP) /* allocate size bytes on stack. */ 137 SUBL(ECX,ESP) /* allocate size bytes on stack. */
135 MOVL(ESP,EDI) /* EDI = copy destination stack. */ 138 MOVL(ESP,EDI) /* EDI = copy destination stack. */
136 REP(MOVSB) /* copy BYTEs. */ 139 REP(MOVSB) /* copy BYTEs. */
137 CALL_DWORD(EBP,8) /* call target. */ 140 CALL_DWORD(EBP,8) /* call target. */
138 POP(EDI) /* restore EDI, ESI. */ 141 POP(EDI) /* restore EDI, ESI. */
139 POP(ESI) 142 POP(ESI)
140 MOVL(EBP,ESP) /* epilog. */ 143 MOVL(EBP,ESP) /* epilog. */
141 POP(EBP) 144 POP(EBP)
142 RET() 145 RET()
143 END_PROC(dcCall_x86_win32_std) 146 END_PROC(dcCall_x86_win32_std)
147
144 148
145 /*---- win32 fastcall (GNU/Microsoft) ---------------------------------------- 149 /*---- win32 fastcall (GNU/Microsoft) ----------------------------------------
146 150
147 Details: 151 Details:
148 - callee cleans up stack 152 - callee cleans up stack
150 154
151 */ 155 */
152 156
153 GLOBAL(dcCall_x86_win32_fast) 157 GLOBAL(dcCall_x86_win32_fast)
154 BEGIN_PROC(dcCall_x86_win32_fast) 158 BEGIN_PROC(dcCall_x86_win32_fast)
155 PUSH(EBP) /* prolog. */ 159 PUSH(EBP) /* prolog. */
156 MOVL(ESP,EBP) 160 MOVL(ESP,EBP)
157 PUSH(ESI) /* save preserved. */ 161 PUSH(ESI) /* save preserved. */
158 PUSH(EDI) 162 PUSH(EDI)
159 MOVL(DWORD(EBP,12),ESI) /* ESI = copy source args. */ 163 MOVL(DWORD(EBP,12),ESI) /* ESI = copy source args. */
160 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */ 164 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */
161 MOVL(DWORD(ESI,0),EAX) /* EAX = first argument. */ 165 MOVL(DWORD(ESI,0),EAX) /* EAX = first argument. */
162 MOVL(DWORD(ESI,4),EDX) /* EDX = second argument. */ 166 MOVL(DWORD(ESI,4),EDX) /* EDX = second argument. */
163 ADDL(LIT(8),ESI) /* skip registers. */ 167 ADDL(LIT(8),ESI) /* skip registers. */
164 SUBL(LIT(8),ECX) 168 SUBL(LIT(8),ECX)
165 MOVL(ECX,DWORD(EBP,16)) /* save stack alloc size. */ 169 MOVL(ECX,DWORD(EBP,16)) /* save stack alloc size. */
166 SUBL(ECX,ESP) /* allocate stack. */ 170 SUBL(ECX,ESP) /* allocate stack. */
167 MOVL(ESP,EDI) /* EDI = stack args. */ 171 MOVL(ESP,EDI) /* EDI = stack args. */
168 REP(MOVSB) /* copy BYTEs. */ 172 REP(MOVSB) /* copy BYTEs. */
169 MOVL(EAX,ECX) /* ECX = first argument. */ 173 MOVL(EAX,ECX) /* ECX = first argument. */
170 CALL_DWORD(EBP,8) /* call target. */ 174 CALL_DWORD(EBP,8) /* call target. */
171 POP(EDI) /* restore preserved. */ 175 POP(EDI) /* restore preserved. */
172 POP(ESI) 176 POP(ESI)
173 MOVL(EBP,ESP) /* epilog. */ 177 MOVL(EBP,ESP) /* epilog. */
174 POP(EBP) 178 POP(EBP)
175 RET() 179 RET()
176 END_PROC(dcCall_x86_win32_fast) 180 END_PROC(dcCall_x86_win32_fast)
181
177 182
178 /*--- syscall int80 linux --------------------------------------------------- 183 /*--- syscall int80 linux ---------------------------------------------------
179 184
180 Details: 185 Details:
181 - all arguments are passed via registers 186 - all arguments are passed via registers
182 187
183 */ 188 */
184 189
185 GLOBAL(dcCall_x86_syscall_int80h_linux) 190 GLOBAL(dcCall_x86_syscall_int80h_linux)
186 BEGIN_PROC(dcCall_x86_syscall_int80h_linux) 191 BEGIN_PROC(dcCall_x86_syscall_int80h_linux)
187 PUSH(EBP) /* prolog. */ 192 PUSH(EBP) /* prolog. */
188 MOVL(ESP,EBP) 193 MOVL(ESP,EBP)
189 PUSH(EBX) /* save preserved. */ 194 PUSH(EBX) /* save preserved. */
190 PUSH(ESI) 195 PUSH(ESI)
191 PUSH(EDI) 196 PUSH(EDI)
192 MOVL(DWORD(EBP,12),EAX) /* EAX = argument buffer. */ 197 MOVL(DWORD(EBP,12),EAX) /* EAX = argument buffer. */
193 MOVL(DWORD(EAX,0),EBX) /* move first five arguments. */ 198 MOVL(DWORD(EAX,0),EBX) /* move first five arguments. */
194 MOVL(DWORD(EAX,4),ECX) 199 MOVL(DWORD(EAX,4),ECX)
195 MOVL(DWORD(EAX,8),EDX) 200 MOVL(DWORD(EAX,8),EDX)
196 MOVL(DWORD(EAX,12),ESI) 201 MOVL(DWORD(EAX,12),ESI)
197 MOVL(DWORD(EAX,16),EDI) 202 MOVL(DWORD(EAX,16),EDI)
198 MOVL(DWORD(EBP,8),EAX) /* EAX = syscall id. */ 203 MOVL(DWORD(EBP,8),EAX) /* EAX = syscall id. */
199 INT(LIT(HEX(80))) 204 INT(LIT(HEX(80)))
200 POP(EDI) /* restore preserved. */ 205 POP(EDI) /* restore preserved. */
201 POP(ESI) 206 POP(ESI)
202 POP(EBX) 207 POP(EBX)
203 MOVL(EBP,ESP) /* epilog. */ 208 MOVL(EBP,ESP) /* epilog. */
204 POP(EBP) 209 POP(EBP)
205 RET() 210 RET()
206 END_PROC(dcCall_x86_syscall_int80h_linux) 211 END_PROC(dcCall_x86_syscall_int80h_linux)
212
207 213
208 /*--- syscall int80 bsd ----------------------------------------------------- 214 /*--- syscall int80 bsd -----------------------------------------------------
209 215
210 Details: 216 Details:
211 - all arguments are passed via stack 217 - all arguments are passed via stack
212 218
213 */ 219 */
214 220
215 GLOBAL(dcCall_x86_syscall_int80h_bsd) 221 GLOBAL(dcCall_x86_syscall_int80h_bsd)
216 BEGIN_PROC(dcCall_x86_syscall_int80h_bsd) 222 BEGIN_PROC(dcCall_x86_syscall_int80h_bsd)
217 PUSH(EBP) /* prolog. */ 223 PUSH(EBP) /* prolog. */
218 MOVL(ESP,EBP) 224 MOVL(ESP,EBP)
219 PUSH(ESI) /* save preserved. */ 225 PUSH(ESI) /* save preserved. */
220 PUSH(EDI) 226 PUSH(EDI)
221 MOVL(DWORD(EBP,12),ESI) /* ESI = pointer on args. */ 227 MOVL(DWORD(EBP,12),ESI) /* ESI = pointer on args. */
222 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */ 228 MOVL(DWORD(EBP,16),ECX) /* ECX = size. */
223 SUBL(ECX,ESP) /* allocate stack space. */ 229 SUBL(ECX,ESP) /* allocate stack space. */
224 MOVL(ESP,EDI) /* EDI = stack args. */ 230 MOVL(ESP,EDI) /* EDI = stack args. */
225 REP(MOVSB) 231 REP(MOVSB)
226 MOVL(DWORD(EBP,8),EAX) /* load system call id. */ 232 MOVL(DWORD(EBP,8),EAX) /* load system call id. */
227 CALL(_do_int) 233 CALL(_do_int)
228 POP(EDI) /* restore preserved. */ 234 POP(EDI) /* restore preserved. */
229 POP(ESI) 235 POP(ESI)
230 MOVL(EBP,ESP) /* epilog. */ 236 MOVL(EBP,ESP) /* epilog. */
231 POP(EBP) 237 POP(EBP)
232 RET() 238 RET()
233 _do_int: 239 _do_int:
234 INT(LIT(HEX(80))) 240 INT(LIT(HEX(80)))
235 RET() 241 RET()