Overhaul spill parameter filling

Author: shirok

ext/lang/test.scm

@@ -519,57 +519,44 @@
            '(#x08 #x07 #x06 #x05 #x04 #x03 #x02 #x01)
            (u8vector->list b))))
 
-;; --- asm-template :postamble ---
+;; --- link-template :postamble ---
 
-;; No postamble: bytes size equals assembled code size.
-(let ()
-  (define tmpl (asm-template '((ret)) :postamble 0))
-  (receive (b _) (link-template tmpl '())
-    (test* "asm-template :postamble 0"
+;; :postamble 0: no change to output size.
+(let ([tmpl (asm-template '((ret)))])
+  (receive (b _) (link-template tmpl '() :postamble 0)
+    (test* "link-template :postamble 0"
            '(#xc3)
            (u8vector->list b))))
 
-;; :postamble 8: eight zero bytes appended after the code.
-(let ()
-  (define tmpl (asm-template '((ret)) :postamble 8))
-  (receive (b _) (link-template tmpl '())
-    (test* "asm-template :postamble 8 size"
+;; :postamble 8: eight zero bytes appended after the linked bytes.
+(let ([tmpl (asm-template '((ret)))])
+  (receive (b _) (link-template tmpl '() :postamble 8)
+    (test* "link-template :postamble 8 size"
            9
            (uvector-size b))
-    (test* "asm-template :postamble 8 content"
+    (test* "link-template :postamble 8 content"
            '(#xc3 0 0 0 0 0 0 0 0)
            (u8vector->list b))))
 
-;; :postamble preserves labels (labels point into code, not postamble).
-(let ()
-  (define tmpl (asm-template '(entry: (ret)) :postamble 4))
-  (receive (_ labels) (link-template tmpl '())
-    (test* "asm-template :postamble labels preserved"
-           '((entry: . 0))
-           labels)))
-
-;; .align at end of insn list pads code; postamble follows the aligned size.
-;; ret (1 byte) + .align 8 (7 padding bytes) = 8 bytes of code.
-(let ()
-  (define tmpl (asm-template '((ret) (.align 8)) :postamble 8))
-  (receive (b _) (link-template tmpl '())
-    (test* "asm-template ends with .align + :postamble"
-           (append '(#xc3 0 0 0 0 0 0 0)   ; ret + 7 align bytes
-                   '(0 0 0 0 0 0 0 0))      ; 8-byte postamble
-           (u8vector->list b))))
-
-;; offset-form can fill into the postamble region using a patch as anchor.
-;; Template: (.dataq :anchor) [8 bytes] + postamble [8 bytes] = 16 bytes.
-;; :anchor patch is at offset 0; extra-offset 8 reaches into the postamble.
-(let ()
-  (define tmpl (asm-template '((.dataq :anchor)) :postamble 8))
+;; :postamble region can be filled via offset form.
+;; Template: (.dataq :anchor) at offset 0 (8 bytes); postamble adds 8 more.
+;; Offset 8 from :anchor reaches into the postamble.
+(let ([tmpl (asm-template '((.dataq :anchor)))])
   (receive (b _) (link-template tmpl `((:anchor ,<uint64> #xfeedface00000000 0)
-                                       (:anchor ,<uint32> #xdeadbeef         8)))
-    (test* "asm-template :postamble filled via offset form"
-           (append '(#x00 #x00 #x00 #x00 #xce #xfa #xed #xfe)  ; .dataq
-                   '(#xef #xbe #xad #xde 0 0 0 0))              ; postamble
+                                       (:anchor ,<uint32> #xdeadbeef         8))
+                                :postamble 8)
+    (test* "link-template :postamble filled via offset form"
+           (append '(#x00 #x00 #x00 #x00 #xce #xfa #xed #xfe)
+                   '(#xef #xbe #xad #xde 0 0 0 0))
            (u8vector->list b))))
 
+;; labels are unchanged regardless of :postamble.
+(let ([tmpl (asm-template '(entry: (ret)))])
+  (receive (_ labels) (link-template tmpl '() :postamble 4)
+    (test* "link-template :postamble labels unchanged"
+           '((entry: . 0))
+           labels)))
+
 ;; --- offset parameter form (keyword native-type value extra-offset) ---
 
 ;; Template: 16 zero bytes, one 8-byte patch at offset 0 for :base.

lib/lang/asm/object.scm

@@ -112,18 +112,23 @@
   (hash-table-set! *patch-handlers* key handler))
 
 ;; link-template :: <obj-template>, [(keyword native-type value [extra-offset])]
+;;                  [#:postamble <int>]
 ;;                  -> u8vector, AList
 ;;   Applies patches from PARAMS and returns the finalized byte vector and
 ;;   label alist.  The template is never mutated; a fresh u8vector is returned.
+;;   If POSTAMBLE > 0, the returned vector is extended by that many zero bytes
+;;   beyond the template's own bytes (useful for per-call data regions).
 ;;   Each param entry is either:
 ;;     (keyword native-type value)              -- fill at the patch's own offset
 ;;     (keyword native-type value extra-offset) -- fill at patch-offset + extra-offset
 ;;     (keyword c-array-type values)            -- fill array starting at patch's offset
 ;;     (keyword c-array-type values extra-offset) -- fill array starting at patch-offset + extra-offset
 ;;   The offset form lets callers fill locations derived from a named anchor.
-(define (link-template tmpl params)
-  (let* ([bytes (u8vector-copy (~ tmpl'bytes))]
-         [len   (uvector-size bytes)])
+(define (link-template tmpl params :key (postamble 0))
+  (let* ([base  (~ tmpl'bytes)]
+         [len   (+ (uvector-size base) postamble)]
+         [bytes (rlet1 v (make-u8vector len 0)
+                  (u8vector-copy! v 0 base))])
 
     ;; Bounds-check ACTUAL then fill VALUE of NTYPE at that position.
     (define (checked-fill! kw actual ntype val)

libsrc/lang/asm/x86_64.scm

@@ -88,18 +88,17 @@
 ;; Entry and x86 ISA definitions (subset)
 ;;
 
-;; asm-template :: [Insn] :postamble Int -> <obj-template>
+;; asm-template :: [Insn] -> <obj-template>
 ;;   First stage of assembly.  Builds the full byte sequence with zeros at
 ;;   placeholder holes, and records where each hole is.
 ;;   :postamble N appends N zero bytes after the assembled code, making the
 ;;   returned bytes larger without adding any patches or labels there.
-(define (asm-template insns :key (postamble 0))
+(define (asm-template insns)
   (let* ([a-map   (run-pass1 insns)]
          [acc     (list '())]           ; mutable cell: (list <patch-list>)
          [bss     (parameterize ([patch-collector acc])
                     (run-pass2 a-map))]
-         [padding (make-list postamble 0)]
-         [code    (list->u8vector (concatenate (append bss (list padding))))]
+         [code    (list->u8vector (concatenate bss))]
          [labels  (filter-map (^p (and (symbol? (car p)) p)) a-map)]
          [patches (car acc)])
     (make-obj-template code labels patches)))