70 lines
2.7 KiB
Plaintext
70 lines
2.7 KiB
Plaintext
;;;; The aggregate case across the reload boundary, v2.
|
|
;;;;
|
|
;;;; The same four signatures with different arithmetic, so that the host's
|
|
;;;; un-rebuilt `outer' printing a different number can only mean its call
|
|
;;;; sites followed four redefined bodies that take and return structs.
|
|
;;;;
|
|
;;;; The `defstruct' blocks are byte-identical to v1's and must stay that way.
|
|
;;;; Layout is computed per module, so a field reordered here would make the
|
|
;;;; host and the module disagree about offsets — a real bug, but one wearing
|
|
;;;; this test's clothes, and it would be indistinguishable in the transcript
|
|
;;;; from the convention mismatch the fixture exists to detect.
|
|
;;;;
|
|
;;;; The four `weigh' functions are changed and the change must be dead text: a
|
|
;;;; module declares a sibling rather than defining it, so each call has to
|
|
;;;; land on the host's copy. With the bodies identical nothing at run time
|
|
;;;; would notice a module that grew its own; multiplied by ten, it is the
|
|
;;;; difference between 1611 and 12411 in the first term alone.
|
|
;;;;
|
|
;;;; Nothing here introduces a name the host was not built with. X86.redefinition
|
|
;;;; refuses those by name — that is the registry path, and it is item 1 of
|
|
;;;; docs/handoffs/HANDOFF-x86-redef.md's "what remains" rather than anything to do with
|
|
;;;; aggregates.
|
|
|
|
(defstruct Pair [a i64 b i64])
|
|
(defstruct Quad [a i64 b i64 c i64 d i64])
|
|
(defstruct Duo [x f64 y f64])
|
|
(defstruct Mix [n i64 z f64])
|
|
|
|
(defvar counter i64)
|
|
|
|
(defn weigh-pair [p Pair] i64 (+ (.a p) (* 30 (.b p))))
|
|
|
|
(defn weigh-quad [q Quad] i64
|
|
(+ (+ (.a q) (* 30 (.b q))) (+ (* 50 (.c q)) (* 70 (.d q)))))
|
|
|
|
(defn weigh-duo [d Duo] i64 (+ (i64 (.x d)) (* 30 (i64 (.y d)))))
|
|
|
|
(defn weigh-mix [m Mix] i64 (+ (.n m) (* 30 (i64 (.z m)))))
|
|
|
|
(defn step-pair [p Pair] Pair
|
|
(println "a2")
|
|
(set counter (+ counter 10))
|
|
(Pair {.a (+ (.a p) 10) .b (+ (.b p) (* 2 (weigh-pair p)))}))
|
|
|
|
(defn step-quad [q Quad] Quad
|
|
(Quad {.a (+ (.a q) 10) .b (+ (.b q) 20) .c (+ (.c q) 30)
|
|
.d (+ (.d q) (* 2 (weigh-quad q)))}))
|
|
|
|
(defn step-duo [d Duo] Duo
|
|
(Duo {.x (+ (.x d) 10.0) .y (+ (.y d) (f64 (* 2 (weigh-duo d))))}))
|
|
|
|
(defn step-mix [m Mix] Mix
|
|
(Mix {.n (+ (.n m) 10) .z (+ (.z m) (f64 (* 2 (weigh-mix m))))}))
|
|
|
|
(defn sum-pair [p Pair] i64 (+ (.a p) (* 100 (.b p))))
|
|
|
|
(defn sum-quad [q Quad] i64
|
|
(+ (+ (.a q) (* 100 (.b q))) (+ (* 10000 (.c q)) (* 1000000 (.d q)))))
|
|
|
|
(defn sum-duo [d Duo] i64 (+ (i64 (.x d)) (* 100 (i64 (.y d)))))
|
|
|
|
(defn sum-mix [m Mix] i64 (+ (.n m) (* 100 (i64 (.z m)))))
|
|
|
|
(defn outer [] i64
|
|
(let [p (step-pair (Pair {.a 1 .b 2}))
|
|
q (step-quad (Quad {.a 1 .b 2 .c 3 .d 4}))
|
|
d (step-duo (Duo {.x 1.0 .y 2.0}))
|
|
m (step-mix (Mix {.n 1 .z 2.0}))]
|
|
(+ (+ (sum-pair p) (sum-quad q)) (+ (sum-duo d) (sum-mix m)))))
|