Joseph Ferano
5b39730f07
The guard flag was named .init-once.<global>, and . and - are ordinary symbol constituents, so (defvar .init-once.x i64 7) beside a computed x emitted the same symbol twice: the dev build died at the assembler on both backends, and the flag's Bool was registered over the user's global in Emit.globals so the store came out as an i1. It is .init~once.<global> now; ~ terminates a symbol in the reader, the same trick destructure~N uses. test/programs/dev-rerun.flan carries such a global and no new printed line. Three places said a defconst is the linker's image on one backend and a constructor's stores on the other and a re-run reaches neither. Tast.const_init splits on the initialiser and not on the form, so that holds only for a constant initialiser; a computed defconst is guarded like a defvar on x86 and refused outright by emit.ml's const. The sentences now say that, including the divergence. emit.ml also claimed Check.no_transfer_in_init made it impossible to leave the guarded branch between the store and the flag. It is syntactic over the written initialiser only: a callee can signal unhandled and take the call's transfer edge out, leaving the flag false — which is what should happen, since the next run retries. Read off the emitted IR for such a program. The x86 float-Rem comment says why the dead movabs before fmod is kept, and its mid-sentence line break is gone; math3.flan's first float-% line prints six values, not four.
63 lines
2.8 KiB
Plaintext
63 lines
2.8 KiB
Plaintext
;;;; What a re-run does to a global, which is decided by the form that
|
|
;;;; defined it and not by the daemon.
|
|
;;;;
|
|
;;;; A [defvar] is Common Lisp's [defvar]: its initialiser runs only if the
|
|
;;;; variable is not already initialised, so its value survives a re-run. A
|
|
;;;; plain zeroed one always did — .bss is untouched by a second entry into
|
|
;;;; main — and a computed one did not, because the startup function [main]
|
|
;;;; calls ran again from the top and stored the initial value back over
|
|
;;;; whatever the last run had left. A [defconst] whose initialiser is a
|
|
;;;; compile-time constant is written into the image and no startup code
|
|
;;;; reaches it at all, so the question does not arise for it. The split is
|
|
;;;; over the initialiser and not over the form — a computed [defconst] would
|
|
;;;; be guarded like a [defvar], and the LLVM backend refuses one outright.
|
|
;;;;
|
|
;;;; So each line printed below is a claim about one of those cases, and the
|
|
;;;; run number is the first of them: [runs] is computed, so before the fix it
|
|
;;;; counted 1, 1, 1.
|
|
(import agent "vendor:agent")
|
|
|
|
(defconst base i64 40)
|
|
|
|
;; Computed, and the whole reproduction: the initialiser is a call, so it is
|
|
;; lifted into the startup function rather than written into the image.
|
|
(defn start [] i64 base)
|
|
|
|
(defvar counter i64 (start))
|
|
|
|
;; Zero-valued, which needs no startup at all and must keep needing none.
|
|
(defvar zeroed i64)
|
|
|
|
;; A computed dyn global: the map is built by a function, rooted before the
|
|
;; startup function runs, and mutated by every run. Its contents have to
|
|
;; survive a re-run for the same reason [counter]'s value does, and its root
|
|
;; has to survive collection either way.
|
|
(defn table [] dyn {:runs 0})
|
|
|
|
(defvar state dyn (table))
|
|
|
|
;; The guard flags the fix adds are the compiler's own globals, and they used
|
|
;; to be spelled [.init-once.<name>] — a name a program can write, since [.]
|
|
;; is an ordinary symbol constituent. This one is exactly the old spelling of
|
|
;; [counter]'s flag. It compiles only because the flag is mangled with a [~]
|
|
;; now; before that the dev build died at the assembler with the symbol
|
|
;; defined twice, and the flag's Bool retyped this i64 on the way. It stays
|
|
;; unprinted on purpose — the expected output is what it was.
|
|
(defvar .init-once.counter i64 7)
|
|
|
|
(defn main [] i32
|
|
(agent/start "/tmp/flan-dev-rerun-fallback.sock")
|
|
(set counter (+ counter 1))
|
|
(set zeroed (+ zeroed 2))
|
|
(set .init-once.counter (+ .init-once.counter 1))
|
|
(put state :runs (+ (get state :runs) 1))
|
|
(print "counter ") (print counter) (println "")
|
|
(print "zeroed ") (print zeroed) (println "")
|
|
(print "runs ") (print (get state :runs)) (println "")
|
|
(print "base ") (print base) (println "")
|
|
;; Long enough for a client to be served, short enough to park well inside
|
|
;; any watchdog — dev-macro.flan's clock, for its reason.
|
|
(dotimes [i 100]
|
|
(agent/wait 5))
|
|
0)
|