mescc: Support globals.
authorJan Nieuwenhuizen <janneke@gnu.org>
Tue, 10 Jan 2017 19:12:06 +0000 (20:12 +0100)
committerJan Nieuwenhuizen <janneke@gnu.org>
Tue, 10 Jan 2017 19:12:06 +0000 (20:12 +0100)
* module/language/c99/compiler.mes (write-any): Catch writing of
  procedure and give more debug information.
  (ref-local, ref-global): Remove.
  (push-global-ref, push-global, push-ident-ref): New functions.
  (push-ident): New function.
  (expr->arg): Use them.
  (ident->accu, ident->accu, accu->ident, value->ident, ident->base):
  Take info parameter, also handle globals.
  (ident-address->accu, ident->global, cstring->number): New functions.
  (ast->info): Update.
* module/mes/libc-i386.mes (i386:ret-local): Remove.
  (i386:push-global-ref): Rename from i386:ref-global.
  (i386:push-local): Rename from i386:ref-local.
  (i386:value->local): Rename from i386:local-assign.
  (i386:push-global, i386:push-local-ref, i386:value->global,
  i386:local-address->accu): New functions.
* module/mes/libc-i386.scm: Export them.

module/language/c99/compiler.mes
module/mes/libc-i386.mes
module/mes/libc-i386.scm

index a25aefca4553970fa3cfb96713ebbf3e51d4388d..df66d847b054cf36fcf65f24898bdb7cbb377e3c 100644 (file)
   (write-char (cond ((char? x) x)
                     ((and (number? x) (< (+ x 256) 0)) (format (current-error-port) "***BROKEN*** x=~a\n" x) (integer->char #xaa))
                     ((number? x) (integer->char (if (>= x 0) x (+ x 256))))
+                    ((procedure? x)
+                     (stderr "write-any: proc: ~a\n" x)
+                     (stderr "  ==> ~a\n" (map dec->hex (x '() '() 0 0)))
+                     barf)
                     (else (stderr "write-any: ~a\n" x) barf))))
 
 (define (ast:function? o)
                           (text text))
                          (make <info> #:functions functions #:globals globals #:locals locals #:function function #:text text))))))
 
-(define (ref-local locals)
+(define (push-global-ref globals)
   (lambda (o)
-    ;; (stderr "IDENT REF[~a]: ~a => ~a\n" o (assoc-ref locals o) (i386:ref-local (assoc-ref locals o)))
-    (i386:ref-local (assoc-ref locals o))))
+    (lambda (f g t d)
+      (i386:push-global-ref (+ (data-offset o g) d)))))
 
-(define (ref-global globals)
+(define (push-global globals)
   (lambda (o)
     (lambda (f g t d)
-      (i386:ref-global (+ (data-offset o g;;lobals
-                                       ) d)))))
+      (i386:push-global (+ (data-offset o g) d)))))
+
+(define (push-ident globals locals)
+  (lambda (o)
+    (let ((local (assoc-ref locals o)))
+      (if local (i386:push-local local)
+          ((push-global globals) o)))))
+
+(define (push-ident-ref globals locals)
+  (lambda (o)
+    (let ((local (assoc-ref locals o)))
+      (if local (i386:push-local-ref local)
+          ((push-global-ref globals) o)))))
 
-(define (expr->arg globals locals) ;; FIXME: get Mes curried-definitions
+(define (expr->arg info) ;; FIXME: get Mes curried-definitions
   (lambda (o)
     (pmatch o
-      ((p-expr (fixed ,value)) (string->number value))
-      ((p-expr (string ,string)) ((ref-global globals) string))
-      ((p-expr (ident ,name)) ((ref-local locals) name))
+      ((p-expr (fixed ,value)) (cstring->number value))
+      ((p-expr (string ,string)) ((push-global-ref (.globals info)) string))
+      ((p-expr (ident ,name))
+       ((push-ident (.globals info) (.locals info)) name))
 
-      ((array-ref (p-expr (fixed ,value)) (p-expr (ident ,name)))
-       (let ((value (string->number value))
+      ((array-refo (p-expr (fixed ,value)) (p-expr (ident ,name)))
+       (let ((value (cstring->number value))
              (size 4)) ;; FIXME: type: int
          (lambda (f g t d)
            (append
-            ((ident->base locals) name)
+            ((ident->base (.locals info)) name)
             (i386:value->accu (* size value)) ;; FIXME: type: int
             (i386:base-mem->accu) ;; FIXME: type: int
             (i386:push-accu) ;; hmm
             ))))
-
+      ((ref-to (p-expr (ident ,name)))
+       (lambda (f g t d)
+         ((push-ident-ref (.globals info) (.locals info)) name)))
+      ((cast (type-name (decl-spec-list (type-spec (fixed-type _)))
+                        (abs-declr (pointer)))
+             ,cast)
+       ((expr->arg info) cast))
       (_
        (format (current-error-port) "SKIP expr->arg=~a\n" o)     
        0))))
 
-(define (ident->accu locals)
+(define (ident->accu info)
   (lambda (o)
-    (i386:local->accu (assoc-ref locals o))))
-
-(define (accu->ident locals)
+    (let ((local (assoc-ref (.locals info) o)))
+      (if local
+          (list (lambda (f g t d)
+                  (i386:local->accu local)))
+          (list (lambda (f g t d)
+                  (i386:global->accu (+ (data-offset o g) d))))))))
+
+(define (accu->ident info)
   (lambda (o)
-    (i386:accu->local (assoc-ref locals o))))
-
-(define (ident->base locals)
+    (let ((local (assoc-ref (.locals info) o)))
+      (if local
+          (list (lambda (f g t d)
+                  (i386:accu->local local)))
+          (list (lambda (f g t d)
+                  (i386:accu->global (+ (data-offset o g) d))))))))
+
+(define (value->ident info)
+  (lambda (o value)
+    (let ((local (assoc-ref (.locals info) o)))
+      (if local
+          (list (lambda (f g t d)
+                  (i386:value->local local value)))
+          (list (lambda (f g t d)
+                  (i386:value->global (+ (data-offset o g) d) value)))))))
+
+(define (ident-address->accu info)
+  (lambda (o)
+    (let ((local (assoc-ref (.locals info) o)))
+      (if local
+          (list (lambda (f g t d)
+                  (i386:local-address->accu local)))
+          (list (lambda (f g t d)
+                  (i386:global->accu (+ (data-offset o g) d))))))))
+
+(define (ident->base info)
   (lambda (o)
-    (i386:local->base (assoc-ref locals o))))
+    (let ((local (assoc-ref (.locals info) o)))
+      (if local
+          (list (lambda (f g t d)
+                  (i386:local->base local)))
+          (list (lambda (f g t d)
+                  (i386:global->base (+ (data-offset o g) d))))))))
 
 (define (expr->accu info)
   (lambda (o)
     (pmatch o
-      ((p-expr (fixed ,value)) (string->number value))
-      ((p-expr (ident ,name)) ((ident->accu (.locals info)) name))
+      ((p-expr (fixed ,value)) (cstring->number value))
+      ((p-expr (ident ,name)) (car ((ident->accu info) name)))
       ((fctn-call . _) ((ast->info info) `(expr-stmt ,o)))
       ((not (fctn-call . _)) ((ast->info info) o))
       ((sub . _) ((ast->info info) o)) ;; FIXME: expr-stmt
+      ((neg (p-expr (fixed ,value))) (- (cstring->number value)))
       (_
        (format (current-error-port) "SKIP expr->accu=~a\n" o)
        0)
 (define (string->global string)
   (cons string (append (string->list string) (list #\nul))))
 
+(define (ident->global name value)
+  (cons name (int->bv32 value)))
+
 (define (expr->global o)
   (pmatch o
     ((p-expr (string ,string)) (string->global string))
       ((de-ref _) ((jump i386:jump-byte-z) o))
       (_ ((jump i386:jump-z) o)))))
 
+(define (cstring->number s)
+  (if (string-prefix? "0" s) (string->number s 8)
+      (string->number s)))
+
 (define (ast->info info)
   (lambda (o)
     (let ((globals (.globals info))
         (let ((locals (acons name (1+ (length (filter positive? (map cdr locals)))) locals)))
           locals))
 
-      ;; (stderr "\nS=~a\n" o)
+      ;;(stderr "\nS=~a\n" o)
       ;; (stderr "  text=~a\n" text)
       ;; (stderr "   info=~a\n" info)
       ;; (stderr "   globals=~a\n" globals)
          (if (equal? name "asm") (let ((arg0 (cadr (cadar expr-list)))) ;; FIXME
                                    (clone info #:text (append text (list (lambda (f g t d) (asm->hex arg0))))))
              (let* ((globals (append globals (filter-map expr->global expr-list)))
-                    (args (map (expr->arg globals locals) expr-list)))
+                    (info (clone info #:globals globals))
+                    (args (map (expr->arg info) expr-list)))
                (clone info #:text
                       (append text (list (lambda (f g t d)
                                            (apply i386:call (cons* f g t d
                                  (i386:accu-zero?)))))))
 
         ((p-expr (fixed ,value))
-         (let ((value (string->number value)))
+         (let ((value (cstring->number value)))
           (clone info #:text
                  (append text
                          (list (lambda (f g t d)
                   #:globals (.globals test-info))))
 
         ((eq (p-expr (ident ,a)) (p-expr (fixed ,b)))
-         (let ((b (string->number b)))
+         (let ((b (cstring->number b)))
+           (clone info #:text
+                  (append text
+                          ((ident->base info) a)
+                          (list (lambda (f g t d)
+                                  (append
+                                   (i386:value->accu b)
+                                   (i386:sub-base))))))))
+
+        ((eq (p-expr (ident ,a)) (p-expr (char ,b)))
+         (let ((b (char->integer (car (string->list b)))))
            (clone info #:text
                   (append text
+                          ((ident->base info) a)
+                          (list (lambda (f g t d)
+                                  (append
+                                   (i386:value->accu b)
+                                   (i386:sub-base))))))))
+
+        ((eq (p-expr (ident ,a)) (neg (p-expr (fixed ,b))))
+         (let ((b (- (cstring->number b))))
+           (clone info #:text
+                  (append text
+                          ((ident->base info) a)
                           (list (lambda (f g t d)
                                   (append 
-                                   (i386:local->base (assoc-ref locals a))
                                    (i386:value->accu b)
                                    (i386:sub-base))))))))
 
         ((eq (fctn-call . ,call) (p-expr (fixed ,b)))
-         (let ((b (string->number b))
+         (let ((b (cstring->number b))
+               (info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
+           (clone info #:text
+                  (append text
+                          (.text info)
+                          (list (lambda (f g t d)
+                                  (append
+                                   (i386:value->base b)
+                                   (i386:sub-base))))))))
+
+        ((eq (fctn-call . ,call) (p-expr (char ,b)))
+         (let ((b (char->integer (car (string->list b))))
                (info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
            (clone info #:text
                   (append text
                                    (i386:value->base b)
                                    (i386:sub-base))))))))
 
+        ((cast (type-name (decl-spec-list (type-spec (void)))) _)
+         info)
+
         ((eq (fctn-call . ,call) (p-expr (ident ,b)))
          (let ((info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
            (clone info #:text
                   (append text
                           (.text info)
+                          ((ident->base info) b)
                           (list (lambda (f g t d)
                                   (append
-                                   (i386:local->base b)
                                    (i386:sub-base))))))))
 
         ((eq (de-ref (p-expr (ident ,a))) (de-ref (p-expr (ident ,b))))
                                    (i386:byte-test-base)))))))
 
         ((gt (p-expr (ident ,a)) (p-expr (fixed ,b)))
-         (let ((b (string->number b)))
+         (let ((b (cstring->number b)))
            (clone info #:text
                   (append text
+                          ((ident->base info) a)
                           (list (lambda (f g t d)
                                   (append 
-                                   (i386:local->base (assoc-ref locals a))
                                    (i386:value->accu b)
                                    (i386:sub-base))))))))
 
         ((gt (p-expr (ident ,a)) (neg (p-expr (fixed ,b))))
-         (let ((b (- (string->number b))))
+         (let ((b (- (cstring->number b))))
            (clone info #:text
                   (append text
+                          ((ident->base info) a)
                           (list (lambda (f g t d)
                                   (append 
-                                   (i386:local->base (assoc-ref locals a))
                                    (i386:value->accu b)
                                    (i386:sub-base))))))))        
 
         
         ((ne (p-expr (ident ,a)) (p-expr (fixed ,b)))
-         (let ((b (string->number b)))
+         (let ((b (cstring->number b)))
            (clone info #:text
                   (append text
+                          ((ident->base info) a)
                           (list (lambda (f g t d)
                                   (append 
-                                   (i386:local->base (assoc-ref locals a))
                                    (i386:value->accu b)
                                    (i386:sub-base)
                                    (i386:xor-zf))))))))
         
+        ((ne (p-expr (ident ,a)) (neg (p-expr (fixed ,b))))
+         (let ((b (- (cstring->number b))))
+           (clone info #:text
+                  (append text
+                          ((ident->base info) a)
+                          (list (lambda (f g t d)
+                                  (append
+                                   (i386:value->accu b)
+                                   (i386:sub-base)
+                                   (i386:xor-zf))))))))
+
         ((ne (fctn-call . ,call) (p-expr (fixed ,b)))
-         (let ((b (string->number b))
+         (let ((b (cstring->number b))
                (info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
            (clone info #:text
                   (append text
            (clone info #:text
                   (append text
                           (.text info)
+                          ((ident->base info) b)
                           (list (lambda (f g t d)
                                   (append
-                                   (i386:local->base b)
                                    (i386:sub-base)
                                    (i386:xor-zf))))))))
 
                                    (i386:xor-zf)))))))
 
         ((lt (p-expr (ident ,a)) (p-expr (fixed ,b)))
-         (let ((b (string->number b)))
+         (let ((b (cstring->number b)))
            (clone info #:text
                   (append text
+                          ((ident->base info) a)
                           (list (lambda (f g t d)
                                   (append 
-                                   (i386:local->base (assoc-ref locals a))
                                    (i386:value->accu b)
                                    (i386:base-sub))))))))
 
                                  (i386:byte-sub-base)))))))
 
         ((array-ref (p-expr (fixed ,value)) (p-expr (ident ,name)))
-         (let ((value (string->number value)))
+         (let ((value (cstring->number value)))
            (clone info #:text
-                  (append text (list (lambda (f g t d)
+                  (append text
+                          ((ident->base info) name)
+                          (list (lambda (f g t d)
                                        (append
-                                        ((ident->base locals) name)
                                         (i386:value->accu value)
                                         (i386:byte-base-mem->accu)))))))) ; FIXME: type: char
         
         ((array-ref (p-expr (ident ,name)) (p-expr (ident ,index)))
          (clone info #:text
-                (append text (list (lambda (f g t d)
-                                     (append
-                                      ((ident->base locals) name)
-                                      ((ident->accu locals) index)
-                                      (i386:byte-base-mem->accu))))))) ; FIXME: type: char
+                (append text
+                        ((ident->base info) name)
+                        ((ident->accu info) index)
+                        (list (lambda (f g t d)
+                                (i386:byte-base-mem->accu)))))) ; FIXME: type: char
         
         ((return ,expr)
          (let ((accu ((expr->accu info) expr)))
                (clone accu #:text
                       (append (.text accu) (list (i386:ret (lambda _ '())))))
                (clone info #:text
-                      (append text (list (i386:ret ((expr->accu info) expr))))))))
+                      (append text (list (i386:ret accu)))))))
 
         ;; int i;
         ((decl (decl-spec-list (type-spec (fixed-type ,type))) (init-declr-list (init-declr (ident ,name))))
          (clone info #:locals (add-local name)))
 
         ((decl (decl-spec-list (type-spec (fixed-type ,type))) (init-declr-list (init-declr (ident ,name) (initzer (p-expr (fixed ,value))))))
-         (let ((locals (add-local name)))
-           (let ((value (string->number value)))
+         (let* ((locals (add-local name))
+                (info (clone info #:locals locals)))
+           (let ((value (cstring->number value)))
              (clone info #:text
-                    (append text (list (lambda (f g t d)
-                                       (i386:local-assign (assoc-ref locals name) value))))
-                  #:locals locals))))
+                    (append text ((value->ident info) name value))))))
 
         ;; int i = argc;
         ((decl (decl-spec-list (type-spec (fixed-type ,type))) (init-declr-list (init-declr (ident ,name) (initzer (p-expr (ident ,local))))))
-         (let ((locals (add-local name)))
+         (let* ((locals (add-local name))
+                (info (clone info #:locals locals)))
            (clone info #:text
-                  (append text (list (lambda (f g t d)
-                                       (append
-                                        ((ident->accu locals) local)
-                                        ((accu->ident locals) name)))))
-                 #:locals locals)))
+                  (append text
+                          ((ident->accu info) local)
+                          ((accu->ident info) name)))))
 
         ;; char *p = "t.c";
         ;;(decl (decl-spec-list (type-spec (fixed-type "char"))) (init-declr-list (init-declr (ptr-declr (pointer) (ident "p")) (initzer (p-expr (string "t.c\n"))))))
         ((decl (decl-spec-list (type-spec (fixed-type _))) (init-declr-list (init-declr (ptr-declr (pointer) (ident ,name)) (initzer (p-expr (string ,value))))))
-         (let ((locals (add-local name))
-               (globals (append globals (list (string->global value)))))
+         (let* ((locals (add-local name))
+                (globals (append globals (list (string->global value))))
+                (info (clone info #:locals locals #:globals globals)))
            (clone info #:text
                   (append text
                           (list (lambda (f g t d)
                                   (append
-                                   (i386:global->accu (+ (data-offset value g) d))
-                                   ((accu->ident locals) name)))))
-                  #:locals locals
-                  #:globals globals)))
+                                   (i386:global->accu (+ (data-offset value g) d)))))
+                          ((accu->ident info) name)))))
         
+        ;; SCM g_stack = 0;
+        ((decl (decl-spec-list (type-spec (typename _))) (init-declr-list (init-declr (ident _) (initzer (p-expr (fixed _))))) (comment _))
+         ((ast->info info) (list-head o (- (length o) 1))))
+
+        ((decl (decl-spec-list (type-spec (typename _))) (init-declr-list (init-declr (ident ,name) (initzer (p-expr (fixed ,value))))))
+         (if (.function info)
+             (let* ((locals (add-local name))
+                    (globals (append globals (list (string->global value))))
+                    (info (clone info #:locals locals #:globals globals)))
+               (clone info #:text
+                      (append text
+                              (list (lambda (f g t d)
+                                      (append
+                                       (i386:global->accu (+ (data-offset value g) d)))))
+                              ((accu->ident info) name))))
+             (let* ((value (length (globals->data globals)))
+                    (globals (append globals (list (ident->global name value)))))
+               (clone info #:globals globals))))
+
         ;; SCM i = argc;
         ((decl (decl-spec-list (type-spec (typename ,type))) (init-declr-list (init-declr (ident ,name) (initzer (p-expr (ident ,local))))))
-         (let ((locals (add-local name)))
+         (let* ((locals (add-local name))
+               (info (clone info #:locals locals)))
            (clone info #:text
-                (append text (list (lambda (f g t d)
-                                     (append
-                                      ((ident->accu locals) local)
-                                      ((accu->ident locals) name)))))
-                #:locals locals)))
+                  (append text
+                          ((ident->accu info) local)
+                          ((accu->ident info) name)))))
         
         ;; int i = f ();
         ((decl (decl-spec-list (type-spec (fixed-type ,type))) (init-declr-list (init-declr (ident ,name) (initzer (fctn-call . ,call)))))
              (clone info
                     #:text
                     (append (.text info)
-                            (list (lambda (f g t d)
-                                    (i386:ret-local (assoc-ref locals name)))))
+                            ((accu->ident info) name))
                     #:locals locals))))
         
+        ;; SCM x = car (e);
+        ((decl (decl-spec-list (type-spec (typename _))) (init-declr-list (init-declr (ident ,name) (initzer (fctn-call . ,call)))))
+         (let* ((locals (add-local name))
+                (info (clone info #:locals locals)))
+           (let ((info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
+             (clone info
+                    #:text
+                    (append (.text info)
+                            ((accu->ident info) name))))))
+
         ;; i = 0;
         ((expr-stmt (assn-expr (p-expr (ident ,name)) (op _) (p-expr (fixed ,value))))
          ;;(stderr "RET LOCAL[~a]: ~a\n" name (assoc-ref locals name))
-         (let ((value (string->number value)))
-           (clone info #:text (append text (list (lambda (f g t d) (i386:local-assign (assoc-ref locals name) value)))))))
+         (let ((value (cstring->number value)))
+           (clone info #:text (append text ((value->ident info) name value)))))
 
         ;; i = 0; ...from for init FIXME
         ((assn-expr (p-expr (ident ,name)) (op _) (p-expr (fixed ,value)))
-         (let ((value (string->number value)))
-           (clone info #:text (append text (list (lambda (f g t d) (i386:local-assign (assoc-ref locals name) value)))))))
-        
+         (let ((value (cstring->number value)))
+           (clone info #:text (append text ((value->ident info) name value)))))
+
         ((expr-stmt (assn-expr (p-expr (ident ,name)) (op _) (fctn-call . ,call)))
          (let* ((info ((ast->info info) `(expr-stmt (fctn-call ,@call)))))
-           (clone info #:text (append (.text info) (list (lambda (f g t d) (i386:ret-local (assoc-ref locals name))))))))
+           (clone info #:text (append (.text info) ((accu->ident info) name)))))
 
         (_
          (format (current-error-port) "SKIP statement=~s\n" o)
index 77743793a77d38d30d69345ea0926c923a9088c1..d5c07230fb7c8b650b4fe30681b9362b3807a4f1 100644 (file)
 (define (i386:function-locals)
   '(#x83 #xec #x20))               ; sub    $0x10,%esp -- 8 local vars
 
-(define (i386:ref-global o)
-  `(#x68 ,@(int->bv32 o)))               ; push  $0x<o>
+(define (i386:push-global-ref o)
+  `(#x68 ,@(int->bv32 o)))              ; push  $0x<o>
 
-(define (i386:global->accu o)
-  `(#xb8 ,@(int->bv32 o)))              ; mov    $<>,%eax
+(define (i386:push-global o)
+  `(#xa1 ,@(int->bv32 o)                ; mov    0x804a000,%eax
+         #x50))                         ; push  %eax
 
-(define (i386:ref-local n)
-  (or n rl)
+(define (i386:push-local n)
+  (or n push-local)
   `(#xff #x75 ,(- 0 (* 4 n))))          ; pushl  0x<n>(%ebp)
 
+(define (i386:push-local-ref n)
+  (or n push-local-ref)
+  `(#x8d #x45 ,(- 0 (* 4 n))            ; lea 0x<n>(%ebp),%eax
+         #x50))                         ; push %eax
+
 (define (i386:push-accu)
   `(#x50))                              ; push %eax
 
     )))
 
 (define (i386:accu->local n)
-  (or n al)
+  (or n accu->local)
   `(#x89 #x45 ,(- 0 (* 4 n))))          ; mov    ,%eax,-<0xn>(%ebp)
 
+(define (i386:accu->global n)
+  (or n accu->global)
+  `(#xa3 ,@(int->bv32 n)))                ; mov    %eax,0x0
+
 (define (i386:accu-zero?)
   `(#x85 #xc0))                         ; cmpl   %eax,%eax
 
           (i386:xor-zf)))
 
 (define (i386:local->accu n)
-  (or n la)
+  (or n local->accu)
   `(#x8b #x45 ,(- 0 (* 4 n))))          ; mov    -<0xn>(%ebp),%eax
 
 (define (i386:local->base n)
-  (or n lb)
+  (or n local->base)
   `(#x8b #x55 ,(- 0 (* 4 n))))          ; mov    -<0xn>(%ebp),%edx
 
+(define (i386:global->base n)
+  (or n global->base)
+  `(#x8b #x15 ,@(int->bv32 n)))         ; mov    0xn,%edx
+
 (define (i386:byte-base-mem->accu)
   '(#x01 #xd0                           ; add    %edx,%eax
          #x0f #xb6 #x00))               ; movzbl (%eax),%eax
   '(#x01 #xd0                           ; add    %edx,%eax
          #x8b #x00))                    ; mov    (%eax),%eax
 
+(define (i386:global->accu o)
+  `(#xb8 ,@(int->bv32 o)))              ; mov    $<>,%eax
+
 (define (i386:value->accu v)
   `(#xb8 ,@(int->bv32 v)))              ; mov    $<v>,%eax
 
 (define (i386:local-add n v)
   (or n ladd)
   `(#x83 #x45 ,(- 0 (* 4 n)) ,v))       ; addl   $<v>,0x<n>(%ebp)
-    
-(define (i386:local-assign n v)
-  (or n lassign)
+
+(define (i386:local-address->accu n)
+  (or n ladd)
+  `(#x8d #x45 ,(- 0 (* 4 n))))          ; lea 0x<n>(%ebp),%eax
+
+(define (i386:local-address->accu n)
+  (or n ladd)
+  `(#x8d #x45 ,(- 0 (* 4 n))))        ; lea 0x<n>(%ebp),%eax
+
+(define (i386:value->global n v)
+  (or n value->global)
+  `(#xc7 #x05 ,@(int->bv32 n)            ; movl   $<v>,(<n>)
+         ,@(int->bv32 v)))
+
+(define (i386:value->local n v)
+  (or n value->local)
   `(#xc7 #x45 ,(- 0 (* 4 n))            ; movl   $<v>,0x<n>(%ebp)
          ,@(int->bv32 v)))
 
   (or n lt)
   `(#x83 #x7d ,(- 0 (* 4 n)) ,v))       ; cmpl   $<v>,0x<n>(%ebp)
 
-(define (i386:ret-local n)
-  (or n rl)
-  `(
-    #x89 #x45 ,(- 0 (* 4 n))            ; mov    %eax,-0x<n>(%ebp)
-    ))
-
 (define (i386:call f g t d address . arguments)
   (let* ((pushes (append-map (i386:push-arg f g t d) (reverse arguments)))
          (s (length pushes))
index 02c521bbdef762a3216c8978831656e646c44033..f029eed012c27678d10716326e165b56aafccfcb 100644 (file)
@@ -29,6 +29,7 @@
   #:use-module (mes elf)
   #:export (
             i386:accu-not
+            i386:accu->global
             i386:accu->local
             i386:accu-non-zero?
             i386:accu-test
@@ -46,6 +47,7 @@
             i386:function-locals
             i386:function-preamble
             i386:global->accu
+            i386:global->base
             i386:jump
             i386:jump
             i386:jump-byte-nz
             i386:local->accu
             i386:local->base
             i386:local-add
-            i386:local-assign
+            i386:local-address->accu
             i386:local-test
             i386:push-accu
-            i386:ref-global
-            i386:ref-local
+            i386:push-global
+            i386:push-global-ref
+            i386:push-local
+            i386:push-local-ref
             i386:ret
             i386:ret-local
             i386:sub-base
             i386:test-base
             i386:test-jump-z
             i386:value->accu
+            i386:value->global
+            i386:value->local
             i386:value->base
             i386:xor-accu
             i386:xor-zf