mescc: Tinycc support: word array assignment.
authorJan Nieuwenhuizen <janneke@gnu.org>
Tue, 8 Aug 2017 08:00:13 +0000 (10:00 +0200)
committerJan Nieuwenhuizen <janneke@gnu.org>
Tue, 8 Aug 2017 08:00:13 +0000 (10:00 +0200)
* stage0/x86.M1 (movzwl_(%eax),%eax): New define.
* module/mes/as-i386.mes (i386:word-mem->accu): New function.
* module/mes/as-i386.scm: Export it.
* module/language/c99/compiler.mes (expr->accu): word array assignment.
  (expr->accu*): word array assignment.
* scaffold/tests/7a-struct-char-array.c (test): Test it.

module/language/c99/compiler.mes
module/mes/as-i386.mes
module/mes/as-i386.scm
scaffold/tests/7a-struct-char-array.c
stage0/x86.M1

index f96208493400831e4688bb174758d65d564e23df..a7f06ee8f2270541a8a654fb444a67292e6ebec7 100644 (file)
         ((sizeof-expr (p-expr (string ,string)))
          (append-text info (wrap-as (i386:value->accu (1+ (string-length string))))))
 
-        ((sizeof-expr (i-sel (ident ,field) (p-expr (ident ,array))))
-         (let* ((type (ident->type info array))
+        ((sizeof-expr (i-sel (ident ,field) (p-expr (ident ,struct))))
+         (let* ((type (ident->type info struct))
                 (size (field-size info type field)))
            (append-text info (wrap-as (i386:value->accu size)))))
 
          (let ((size 4))
            (append-text info (wrap-as (i386:value->accu size)))))
 
-        ;; c+p expr->arg
-        ;; g_cells[<expr>]
+        ;; foo[bar]
         ((array-ref ,index (p-expr (ident ,array)))
-         (let* ((type (ident->type info array))
+         (let* ((info ((expr->accu* info) o))
+                (type (ident->type info array))
                 (ptr (ident->pointer info array))
                 (size (if (or (= ptr 1) (= ptr -1)) (ast-type->size info type)
-                          4))
-                (info ((expr->accu* info) o)))
+                          4)))
            (append-text info (wrap-as (case size
                                         ((1) (i386:byte-mem->accu))
+                                        ((2) (i386:word-mem->accu))
                                         ((4) (i386:mem->accu))
                                         (else '()))))))
 
                           4)))
            (append-text info (wrap-as (case size
                                         ((1) (i386:byte-mem->accu))
+                                        ((2) (i386:word-mem->accu))
                                         (else (i386:mem->accu)))))))
 
         ;; foo->bar[baz])
                           4)))
            (append-text info (wrap-as (case size
                                         ((1) (i386:byte-mem->accu))
+                                        ((2) (i386:word-mem->accu))
                                         (else (i386:mem->accu)))))))
 
         ;; <expr>[baz]
                 (ptr (expr->pointer info array))
                 (size (if (= ptr 1) (expr->size info array)
                           4)))
-           (append-text info (wrap-as (if (= size 1) (i386:byte-mem->accu)
-                                          (i386:mem->accu))))))
+           (append-text info (wrap-as (case size
+                                        ((1) (i386:byte-mem->accu))
+                                        ((2) (i386:word-mem->accu))
+                                        (else (i386:mem->accu)))))))
 
         ;; bar.f.i
         ((d-sel (ident ,field1) (d-sel (ident ,field0) (p-expr (ident ,struct0))))
                           4)))
            (append-text info (append (if (or #t (assoc-ref locals name)) ((ident->accu info) name)
                                          ((ident-address->accu info) name))
-                                     (wrap-as (if (= size 1) (i386:byte-mem->accu)
-                                                  (i386:mem->accu)))))))
+                                     (wrap-as (case size
+                                                ((1) (i386:byte-mem->accu))
+                                                ((2) (i386:word-mem->accu))
+                                                (else (i386:mem->accu))))))))
 
         ((de-ref (post-inc (p-expr (ident ,name))))
          (let* ((info ((expr->accu info) `(de-ref (p-expr (ident ,name)))))
                 (ptr (expr->pointer info expr))
                 (size (if (= ptr 1) (expr->size info expr)
                           4)))
-           (append-text info (wrap-as (if (= size 1) (i386:byte-mem->accu)
-                                          (i386:mem->accu))))))
+           (append-text info (wrap-as (case size
+                                        ((1) (i386:byte-mem->accu))
+                                        ((2) (i386:word-mem->accu))
+                                        (else (i386:mem->accu)))))))
 
         ((fctn-call (p-expr (ident ,name)) (expr-list . ,expr-list))
          (if (equal? name "asm") (let ((arg0 (cadr (cadar expr-list)))) ;; FIXME
                           4))
                      (info ((expr->base* info) a)))
                 (append-text info
-                             (append (if (eq? size 1) (wrap-as (i386:byte-accu->base-mem))
-                                         (if (<= size 4) (wrap-as (i386:accu->base-mem))
-                                          (append
-                                           (wrap-as (i386:accu-mem->base-mem))
-                                           (wrap-as (append (i386:accu+value 4)
-                                                            (i386:base+value 4)
-                                                            (i386:accu-mem->base-mem)))
-                                           (if (<= size 8) '()
-                                               (wrap-as (append (i386:accu+value 4)
-                                                                (i386:base+value 4)
-                                                                (i386:accu-mem->base-mem)))))))))))
+                             (append (case size
+                                       ((1) (wrap-as (i386:byte-accu->base-mem)))
+                                       ((2) (wrap-as (i386:word-accu->base-mem)))
+                                       (else (if (<= size 4) (wrap-as (i386:accu->base-mem))
+                                                 (append
+                                                  (wrap-as (i386:accu-mem->base-mem))
+                                                  (wrap-as (append (i386:accu+value 4)
+                                                                   (i386:base+value 4)
+                                                                   (i386:accu-mem->base-mem)))
+                                                  (if (<= size 8) '()
+                                                      (wrap-as (append (i386:accu+value 4)
+                                                                       (i386:base+value 4)
+                                                                       (i386:accu-mem->base-mem))))))))))))
              (_ (error "expr->accu: unsupported assign: " a)))))
 
         (_ (error "expr->accu: unsupported: " o))))))
 (define (expr->accu* info)
   (lambda (o)
     (pmatch o
-      ;; g_cells[<expr>]
+      ;; foo[bar]
       ((array-ref ,index (p-expr (ident ,array)))
        (let* ((info ((expr->accu info) index))
               (type (ident->type info array))
               (size (if (or (= ptr 1) (= ptr -1)) (ast-type->size info type)
                         4)))
          (append-text info (append (wrap-as (append (i386:accu->base)
-                                                    (if (eq? size 1) '()
-                                                        (append
-                                                         (if (<= size 4) '()
-                                                             (i386:accu+accu))
-                                                         (if (<= size 8) '()
-                                                             (i386:accu+base))
-                                                         (i386:accu-shl 2)))))
+                                                    (case size
+                                                      ((1) '())
+                                                      ((2) (i386:accu+accu))
+                                                      (else (append (if (<= size 4) '()
+                                                                        (i386:accu+accu))
+                                                                    (if (<= size 8) '()
+                                                                        (i386:accu+base))
+                                                                    (i386:accu-shl 2))))))
                                    ((ident->base info) array)
                                    (wrap-as (i386:accu+base))))))
 
index 3200d5ef3c7de53ebd1dedae84488820bd8d6f52..30baed2321f9089459d14726e880ba7cc42ef7ed 100644 (file)
 (define (i386:byte-mem->accu)
   '(("movzbl_(%eax),%eax")))            ; movzbl (%eax),%eax
 
+(define (i386:word-mem->accu)
+  '(("movzwl_(%eax),%eax")))
+
 (define (i386:byte-mem->base)
   '(("movzbl_(%edx),%edx")))            ; movzbl (%edx),%edx
 
index 54a7bcd0ffa4dc54e6a0c6f7ce31097eaab4cffa..9649194bcf52f092dcf458c77da6f80bdd34db25 100644 (file)
@@ -69,6 +69,7 @@
             i386:base-mem->accu
             i386:base-sub
             i386:byte-accu->base-mem
+            i386:word-accu->base-mem
             i386:byte-base->accu-mem
             i386:byte-base->accu-mem+n
             i386:byte-base-mem->accu
@@ -76,6 +77,7 @@
             i386:byte-local->accu
             i386:byte-local->base
             i386:byte-mem->accu
+            i386:word-mem->accu
             i386:byte-mem->base
             i386:byte-sub-base
             i386:byte-test-base
index 9c0d0084e584d3d9dd359491427f0028efce457d..11cef4c0a9941484e2eb20062135dede5d32ee6f 100644 (file)
@@ -118,5 +118,27 @@ test ()
   if (p[8] != ' ') return 32;
   if (p[9] != '9') return 33;
   
+  short *ps;
+  ps = pfile->buffer;
+  p = pfile->buffer;
+
+  strcpy (file.buffer, "0123456789\n");
+  eputs (file.buffer);
+  memcpy (ps + 1, "  ", 2);
+  eputs (file.buffer);
+  eputs (itoa (ps[1])); eputs ("\n");
+  eputs (itoa (((' ' << 8) + ' ')));  eputs ("\n");
+  if (ps[1] != ((' ' << 8) + ' ')) return 40;
+  if (p[4] != '4') return 41;
+
+  strcpy (file.buffer, "0123456789\n");
+  eputs (file.buffer);
+  ps[2] = ((' ' << 8) + ' ');
+  eputs (file.buffer);
+  eputs (itoa (ps[2])); eputs ("\n");
+  eputs (itoa (((' ' << 8) + ' ')));  eputs ("\n");
+  if (ps[2] != ((' ' << 8) + ' ')) return 42;
+  if (p[6] != '6') return 43;
+
   return 0;
 }
index bb68b670120d0a5413a79fd840e0cde9a227105f..8543a12ffab1d3e04da7acc57d897c0e0b601a51 100644 (file)
@@ -139,6 +139,7 @@ DEFINE movzbl_0x32(%ebp),%eax 0fb685
 DEFINE movzbl_0x8(%eax),%eax 0fb640
 DEFINE movzbl_0x8(%ebp),%eax 0fb645
 DEFINE movzbl_0x8(%ebp),%edx 0fb655
+DEFINE movzwl_(%eax),%eax 0fb700
 DEFINE movzwl_0x32(%eax),%eax 0fb780
 DEFINE movzwl_0x8(%eax),%eax 0fb740
 DEFINE mul____%edx f7e2