boot2

070-struct-ret-1word.scm (2358B)

---

 ;; tests/cc-cg/70-struct-ret-1word.scm — one-word direct struct return.
 ;;
 ;; Models:
 ;;   struct S { int a; int b; };
 ;;   struct S make(int a, int b) { struct S s; s.a = a; s.b = b; return s; }
 ;;   int main(void) {
 ;;     struct S r = make(7, 9);
 ;;     return r.a + r.b * 10;     /* 97 */
 ;;   }
 ;;
 ;; Exercises Stream A1's one-word direct return convention (P1.md
 ;; §Arguments and return values): result word 0 in a0; cg-fn-end emits
 ;; LD a0, [sp + ret-slot] at exit; cg-call's receive side allocates a
 ;; fresh frame slot sized to the return ctype, stores back from a0,
 ;; and pushes a struct frame-lval so chained .field works.
 
 (let* ((cg     (cg-init))
        (st-ty  (%ctype 'struct 8 4
                        (list "S" #t
                              (list (list "a" %t-i32 0)
                                    (list "b" %t-i32 4)))))
        (fn-ty  (%ctype 'fn 8 8
                        (cons st-ty (cons (list %t-i32 %t-i32) #f))))
        (make-sym (%sym "make" 'fn 'extern fn-ty #f)))
   ;; struct S make(int a, int b) { ... return s; }
   (let* ((params (cg-fn-begin cg "make"
                               (list (cons "a" %t-i32) (cons "b" %t-i32))
                               st-ty))
          (a*     (cdr (car params)))
          (b*     (cdr (cadr params)))
          (s-off  (cg-alloc-slot cg 8 4))
          (s-sym  (%sym "s" 'var 'auto st-ty s-off)))
     ;; s.a = a
     (cg-push-sym cg s-sym) (cg-push-field cg "a")
     (cg-push-sym cg a*)    (cg-load cg)
     (cg-assign cg) (cg-pop cg)
     ;; s.b = b
     (cg-push-sym cg s-sym) (cg-push-field cg "b")
     (cg-push-sym cg b*)    (cg-load cg)
     (cg-assign cg) (cg-pop cg)
     ;; return s   — struct-typed return
     (cg-push-sym cg s-sym)
     (cg-return cg)
     (cg-fn-end cg))
   ;; int main(void) { struct S r = make(7, 9); return r.a + r.b * 10; }
   (cg-fn-begin cg "main" '() %t-i32)
   (cg-push-sym cg make-sym)
   (cg-push-imm cg %t-i32 7)
   (cg-push-imm cg %t-i32 9)
   (cg-call cg 2 #t)              ; pushes struct lval (recv slot)
   ;; The result is a struct lval. Read .a and .b.
   (let ((r-lval (cg-pop cg)))
     (cg-push cg r-lval) (cg-push-field cg "a") (cg-load cg)
     (cg-push cg r-lval) (cg-push-field cg "b") (cg-load cg)
     (cg-push-imm cg %t-i32 10) (cg-binop cg 'mul)
     (cg-binop cg 'add))
   (cg-return cg)
   (cg-fn-end cg)
   (write-bv-fd 1 (cg-finish cg)))