mescc: Support global pointer assignments.
[mes.git] / module / mes / libc-i386.mes
1 ;;; -*-scheme-*-
2
3 ;;; Mes --- Maxwell Equations of Software
4 ;;; Copyright © 2016,2017 Jan Nieuwenhuizen <janneke@gnu.org>
5 ;;;
6 ;;; This file is part of Mes.
7 ;;;
8 ;;; Mes is free software; you can redistribute it and/or modify it
9 ;;; under the terms of the GNU General Public License as published by
10 ;;; the Free Software Foundation; either version 3 of the License, or (at
11 ;;; your option) any later version.
12 ;;;
13 ;;; Mes is distributed in the hope that it will be useful, but
14 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ;;; GNU General Public License for more details.
17 ;;;
18 ;;; You should have received a copy of the GNU General Public License
19 ;;; along with Mes.  If not, see <http://www.gnu.org/licenses/>.
20
21 ;;; Commentary:
22
23 ;;; libc-i386.mes defines C library routines
24
25 ;;; Code:
26
27 (define (i386:function-preamble)
28   '(#x55                                ; push   %ebp
29     #x89 #xe5))                         ; mov    %esp,%ebp
30
31 (define (i386:function-locals)
32   '(#x83 #xec #x20))               ; sub    $0x10,%esp -- 8 local vars
33
34 (define (i386:push-global-ref o)
35   (or o push-global-ref)
36   `(#x68 ,@(int->bv32 o)))              ; push  $0x<o>
37
38 (define (i386:push-global o)
39   (or o push-global)
40   `(#xa1 ,@(int->bv32 o)                ; mov    0x804a000,%eax
41          #x50))                         ; push  %eax
42
43 (define (i386:push-local n)
44   (or n push-local)
45   `(#xff #x75 ,(- 0 (* 4 n))))          ; pushl  0x<n>(%ebp)
46
47 (define (i386:push-local-ref n)
48   (or n push-local-ref)
49   `(#x8d #x45 ,(- 0 (* 4 n))            ; lea 0x<n>(%ebp),%eax
50          #x50))                         ; push %eax
51
52 (define (i386:push-local-de-ref n)
53   (or n push-local-de-ref)
54   `(#x8b #x45 ,(- 0 (* 4 n))            ; mov    -0x<n>(%ebp),%eax
55          #x0f #xb6 #x00                 ; movzbl (%eax),%eax
56          ;;#x0f #xbe #xc0                 ; movsbl %al,%eax ***FIXME BYTE****
57          #x50))                         ; push   %eax
58
59 (define (i386:push-accu)
60   `(#x50))                              ; push %eax
61
62 (define (i386:push-arg f g t d)
63   (lambda (o)
64     (or o push-arg)
65     (cond ((number? o)
66            `(#x68 ,@(int->bv32 o)))     ; push $<o>
67           ((and (pair? o) (procedure? (car o)))
68            (append-map (lambda (p) (p f g t d)) o))
69           ((pair? o) o)
70           ((procedure? o) (o f g t d))
71           (_ barf))))
72
73 (define (i386:ret . rest)
74   (lambda (f g t d)
75     `(
76       ,@(cond ((null? rest) '())
77               ((number? (car rest))
78                `(#xb8                     ; mov    $<>,%eax
79                  ,@(int->bv32 (car rest))))
80               ((pair? (car rest)) (car rest))
81               ((procedure? (car rest))
82                ((car rest) f g t d)))
83     #xc9                                ; leave
84     #xc3                                ; ret
85     )))
86
87 (define (i386:accu->local n)
88   (or n accu->local)
89   `(#x89 #x45 ,(- 0 (* 4 n))))          ; mov    ,%eax,-<0xn>(%ebp)
90
91 (define (i386:accu->global n)
92   (or n accu->global)
93   `(#xa3 ,@(int->bv32 n)))              ; mov    %eax,0x0
94
95 (define (i386:accu-zero?)
96   '(#x85 #xc0))                         ; cmpl   %eax,%eax
97
98 (define (i386:accu-non-zero?)
99   (append '(#x85 #xc0)                  ; cmpl   %eax,%eax
100           (i386:xor-zf)))
101
102 (define (i386:accu-shl n)
103   `(#xc1 #xe0 ,n))                      ; shl    $0x8,%eax
104
105 (define (i386:accu+accu)
106   '(#x01 #xc0))                         ; add    %eax,%eax
107
108 (define (i386:accu+base)
109   `(#x01 #xd0))                         ; add    %edx,%eax
110
111 (define (i386:base->accu)
112   '(#x89 #xd0))                         ; mov    %edx,%eax
113
114 (define (i386:local->accu n)
115   (or n local->accu)
116   `(#x8b #x45 ,(- 0 (* 4 n))))          ; mov    -<0xn>(%ebp),%eax
117
118 (define (i386:byte-local->accu n)
119   (or n byte-local->accu)
120   `(#x0f #xb6 #x45 ,(- 0 (* 4 n))))     ; movzbl 0x<n>(%ebp),%eax
121
122 (define (i386:local->base n)
123   (or n local->base)
124   `(#x8b #x55 ,(- 0 (* 4 n))))          ; mov    -<0xn>(%ebp),%edx
125
126 ;; (define (i386:local-ref->base n)
127 ;;   (or n local-ref->base)
128 ;;   `(#x8b #x15 ,@(int->bv32 (- 0 (* 4 n))))) ; mov    0x<n>,%edx
129
130 (define (i386:local-ref->base n)
131   (or n local-ref->base)
132   `(#x8d #x55 ,(- 0 (* 4 n))))          ; lea    0x<n>(%ebp),%edx
133
134 (define (i386:global-ref->base n)
135   (or n global->base)
136   `(#x8b #x15 ,@(int->bv32 n)))         ; mov    0x<n>,%edx
137
138 (define (i386:global->base n)
139   (or n global->base)
140   `(#xba ,@(int->bv32 n)))              ; mov    $<n>,%edx
141
142 (define (i386:byte-base-mem->accu)
143   '(#x01 #xd0                           ; add    %edx,%eax
144          #x0f #xb6 #x00))               ; movzbl (%eax),%eax
145
146 (define (i386:byte-mem->accu)
147   '(#x0f #xb6 #x00))                    ; movzbl (%eax),%eax
148
149 (define (i386:byte-mem->base)
150   '(#x0f #xb6 #x10))                    ; movzbl (%eax),%edx
151
152 (define (i386:base-mem->accu)
153   '(#x01 #xd0                           ; add    %edx,%eax
154          #x8b #x00))                    ; mov    (%eax),%eax
155
156 (define (i386:base-mem+n->accu n)
157   `(#x01 #xd0                           ; add    %edx,%eax
158          #x8b #x40 ,n))                 ; mov    <n>(%eax),%eax
159
160 (define (i386:global->accu o)
161   (or o global->accu)
162   `(#xb8 ,@(int->bv32 o)))              ; mov    $<>,%eax
163
164 (define (i386:value->accu v)
165   (or v value->accu)
166   `(#xb8 ,@(int->bv32 v)))              ; mov    $<v>,%eax
167
168 (define (i386:value->accu-ref v)
169   (or v value->accu-ref)
170   `(#xc7 #x00 ,@(int->bv32 v)))         ; movl   $0x<v>,(%eax)
171
172 (define (i386:value->accu-ref+n n v)
173   `(#xc7 #x40 ,n ,@(int->bv32 v)))      ; movl   $<v>,0x<n>(%eax)
174
175 (define (i386:base->accu-ref)
176   '(#x89 #x10))                         ; mov    %edx,(%eax)
177
178 (define (i386:byte-base->accu-ref)
179   '(#x88 #x10))                         ; mov    %dl,(%eax)
180
181 (define (i386:value->base v)
182   `(#xba ,@(int->bv32 v)))              ; mov    $<v>,%edx
183
184 (define (i386:local-add n v)
185   (or n ladd)
186   `(#x83 #x45 ,(- 0 (* 4 n)) ,v))       ; addl   $<v>,0x<n>(%ebp)
187
188 (define (i386:local-address->accu n)
189   (or n ladd)
190   `(#x8d #x45 ,(- 0 (* 4 n))))          ; lea 0x<n>(%ebp),%eax
191
192 (define (i386:local-address->accu n)
193   (or n ladd)
194   `(#x8d #x45 ,(- 0 (* 4 n))))          ; lea 0x<n>(%ebp),%eax
195
196 (define (i386:value->global n v)
197   (or n value->global)
198   `(#xc7 #x05 ,@(int->bv32 n)           ; movl   $<v>,(<n>)
199          ,@(int->bv32 v)))
200
201 (define (i386:value->local n v)
202   (or n value->local)
203   `(#xc7 #x45 ,(- 0 (* 4 n))            ; movl   $<v>,0x<n>(%ebp)
204          ,@(int->bv32 v)))
205
206 (define (i386:local-test n v)
207   (or n lt)
208   `(#x83 #x7d ,(- 0 (* 4 n)) ,v))       ; cmpl   $<v>,0x<n>(%ebp)
209
210 (define (i386:call f g t d address . arguments)
211   (let* ((pushes (append-map (i386:push-arg f g t d) (reverse arguments)))
212          (s (length pushes))
213          (n (length arguments)))
214    `(
215      ,@pushes                           ; push args
216      #xe8 ,@(int->bv32 (- address 5 s)) ; call relative
217      #x83 #xc4 ,(* n 4)                 ; add    $00,%esp
218      )))
219  
220 (define (i386:accu-not)
221   `(#x0f #x94 #xc0                      ; sete %al
222          #x0f #xb6 #xc0))               ; movzbl %al,%eax
223
224 (define (i386:xor-accu v)
225   `(#x35 ,@(int->bv32 v)))              ;xor    $0xff,%eax
226
227 (define (i386:xor-zf)
228   '(#x9f                                ; lahf   
229     #x80 #xf4 #x40                      ; xor    $0x40,%ah
230     #x9e))                              ; sahf   
231
232 (define (i386:accu-cmp-value v)
233   `(#x83 #xf8 ,v))                      ; cmp    $<v>,%eax
234
235 (define (i386:accu-test)
236   '(#x85 #xc0))                         ; test   %eax,%eax
237
238 (define (i386:Xjump n)
239   `(#xe9 ,@(int->bv32 n)))              ; jmp . + <n>
240
241 (define (i386:Xjump-nz n)
242   `(#x0f #x85 ,@(int->bv32 n)))         ; jnz . + <n>
243
244 (define (i386:jump n)  ;;FIXME: NEED THIS WEIRDNESS for t.c
245   `(#xeb ,(if (>= n 0) (- n 2) (- n 2))))   ; jmp <n>
246
247 ;; (define (i386:jump n)
248 ;;   `(#xeb ,(if (>= n 0) n (- n 2))))     ; jmp <n>
249
250 (define (i386:jump-c n)
251   `(#x72 ,(if (>= n 0) n (- n 2))))     ; jc <n>
252
253 (define (i386:jump-cz n)
254   `(#x76 ,(if (>= n 0) n (- n 2))))     ; jna <n>
255
256 (define (i386:jump-ncz n)
257   `(#x77 ,(if (>= n 0) n (- n 2))))     ; ja <n>
258
259 (define (i386:jump-nc n)
260   `(#x73 ,(if (>= n 0) n (- n 2))))     ; jnc <n>
261
262 (define (i386:jump-z n)
263   `(#x74 ,(if (>= n 0) n (- n 2)))) ; jz <n>
264
265 (define (i386:jump-nz n)
266   `(#x75 ,(if (>= n 0) n (- n 2)))) ; jnz <n>
267
268 (define (i386:test-jump-z n)
269   `(#x85 #xc0                           ; test   %eax,%eax
270     #x74 ,(if (>= n 0) n (- n 4))))     ; jz <n>
271
272 (define (i386:jump-byte-nz n)
273   `(#x84 #xc0                           ; test   %al,%al
274     #x75 ,(if (>= n 0) n (- n 4))))     ; jne <n>
275
276 (define (i386:jump-byte-z n)
277   `(#x84 #xc0                           ; test   %al,%al
278     #x74 ,(if (>= n 0) n (- n 4))))     ; jne <n>
279
280 (define (i386:byte-test-base)
281   `(#x38 #xc2))                         ; cmp    %al,%dl
282
283 (define (i386:test-base)
284   `(#x39 #xd0))                         ; cmp    %edx,%eax
285
286 (define (i386:byte-sub-base)
287   `(#x28 #xd0))                         ; sub    %dl,%al
288
289 (define (i386:byte-base-sub)
290   `(#x28 #xd0))                         ; sub    %al,%dl
291
292 (define (i386:sub-base)
293   `(#x29 #xd0))                         ; sub    %edx,%eax
294
295 (define (i386:base-sub)
296   `(#x29 #xc2))                         ; sub    %eax,%edx
297
298 ;;;\f libc bits
299 (define (i386:exit f g t d)
300   `(
301     #x5b                                ; pop    %ebx
302     #x5b                                ; pop    %ebx
303     #xb8 #x01 #x00 #x00 #x00            ; mov    $0x1,%eax
304     #xcd #x80                           ; int    $0x80
305     ))
306
307 (define (i386:open f g t d)
308   `(
309     #x55                                ; push   %ebp
310     #x89 #xe5                           ; mov    %esp,%ebp
311
312     #x8b #x5d #x08                      ; mov    0x8(%ebp),%ebx
313     #x8b #x4d #x0c                      ; mov    0xc(%ebp),%ecx
314
315     #xb8 #x05 #x00 #x00 #x00            ; mov    $0x5,%eax
316     #xcd #x80                           ; int    $0x80
317
318     #xc9                                ; leave
319     #xc3                                ; ret
320     ))
321
322 (define (i386:read f g t d)
323   `(
324     #x55                                ; push   %ebp
325     #x89 #xe5                           ; mov    %esp,%ebp
326
327     #x8b #x5d #x08                      ; mov    0x8(%ebp),%ebx
328     #x8b #x4d #x0c                      ; mov    0xc(%ebp),%ecx
329     #x8b #x55 #x10                      ; mov    0x10(%ebp),%edx
330
331     #xb8 #x03 #x00 #x00 #x00            ; mov    $0x3,%eax
332     #xcd #x80                           ; int    $0x80
333
334     #xc9                                ; leave
335     #xc3                                ; ret
336     ))
337
338 (define (i386:write f g t d)
339   `(
340     #x55                                ; push   %ebp
341     #x89 #xe5                           ; mov    %esp,%ebp
342
343     #x8b #x5d #x08                      ; mov    0x8(%ebp),%ebx
344     #x8b #x4d #x0c                      ; mov    0xc(%ebp),%ecx
345     #x8b #x55 #x10                      ; mov    0x10(%ebp),%edx
346
347     #xb8 #x04 #x00 #x00 #x00            ; mov    $0x4,%eax
348     #xcd #x80                           ; int    $0x80
349
350     #xc9                                ; leave
351     #xc3                                ; ret
352     ))
353
354 #!
355 08048121 <strcmp>:
356  8048121:       55                      push   %ebp
357  8048122:       89 e5                   mov    %esp,%ebp
358  8048124:       83 ec 10                sub    $0x10,%esp
359  8048127:       eb 08                   jmp    8048131 <strcmp+0x10>
360
361 <body>
362  8048129:       83 45 08 01             addl   $0x1,0x8(%ebp)
363  804812d:       83 45 0c 01             addl   $0x1,0xc(%ebp)
364
365 <test> *a
366  8048131:       8b 45 08                mov    0x8(%ebp),%eax
367  8048134:       0f b6 00                movzbl (%eax),%eax
368  8048137:       84 c0                   test   %al,%al
369  8048139:       74 08                   je     8048143 <strcmp+0x22>
370
371 <test1> *b
372  804813b:       8b 45 0c                mov    0xc(%ebp),%eax
373  804813e:       0f b6 00                movzbl (%eax),%eax
374  8048141:       84 c0                   test   %al,%al
375  8048143:       74 10                   je     8048155 <strcmp+0x34>
376
377 <test2> *a == *b
378  8048145:       8b 45 08                mov    0x8(%ebp),%eax
379  8048148:       0f b6 10                movzbl (%eax),%edx
380  804814b:       8b 45 0c                mov    0xc(%ebp),%eax
381  804814e:       0f b6 00                movzbl (%eax),%eax
382  8048151:       38 c2                   cmp    %al,%dl
383  8048153:       84 c0                   test   %al,%al
384  8048155:       75 d2                   jne    8048129 <strcmp+0x8>
385
386
387  8048157:       8b 45 08                mov    0x8(%ebp),%eax
388  804815a:       0f b6 10                movzbl (%eax),%edx
389  804815d:       8b 45 0c                mov    0xc(%ebp),%eax
390  8048160:       0f b6 00                movzbl (%eax),%eax
391  8048163:       28 d0                   sub    %dl,%al
392  8048165:       c9                      leave
393  8048166:       c3                      ret  
394 !#