Joseph Ferano
4aa24c0e33
Two decisions in this lane went against the brief and both are written down where the next reader will meet them: the return slot stayed mandatory, so the third state ret = None was to grow does not exist and neither does the fallout listed for load.ml, shim.ml and cimport.ml; and the parameter rule is resolved in Check rather than in parse.ml, because cimport passes C type names through verbatim and POSIX's lowercase stat and timespec are writable in parameter position, which is what makes a syntactic rule unsound rather than merely awkward. The open ABI point is in flan_dyn.h beside the root functions rather than only in the handoff, because the header is what the two sides diff. A rooted slot holding 0 is not a value: the compiler zeroes every root at entry because the push happens before the code that fills it and possibly for a branch that never runs, and 0 is the only pattern it can write without knowing the encoding. If the real runtime NaN-boxes and integer zero is the zero word then this is wrong and both sides change together. Session.compatible needed nothing: it compares with Types.equal over the parameters and the return, and dyn is equal to itself and to nothing else. Both directions are pinned anyway, because this is the one place "changes signature" covers a change the source does not spell out -- a parameter can become dyn, or stop being dyn, by a type being declared elsewhere in the program. @x86 128 match 0 differ 0 refused, @sanitize clean, dune test green.
133 lines
6.7 KiB
C
133 lines
6.7 KiB
C
/* flan_dyn — the dynamic-value ABI.
|
|
*
|
|
* Milestone 1 of dynamic-by-default. A [flan_dyn] is one machine word, and
|
|
* every operation the compiler cannot type statically becomes a call to one of
|
|
* the functions below. The compiler emits these declarations from Emit; this
|
|
* header is the same contract written for C, and the two are diffed rather
|
|
* than trusted to agree.
|
|
*
|
|
* The word is opaque. Nothing outside the runtime may read a tag out of it,
|
|
* because which bits carry the tag is the runtime's business and milestone 2
|
|
* moves them: the compiler only ever passes words it was given back to the
|
|
* functions here. That is what lets boxing change representation without a
|
|
* recompile of the emitter.
|
|
*
|
|
* Every function takes and returns scalars, for the reason flan_rt.c gives:
|
|
* nothing returns a struct by value, so the emitted .ll never has to agree
|
|
* with a platform's struct-return ABI.
|
|
*/
|
|
|
|
#ifndef FLAN_DYN_H
|
|
#define FLAN_DYN_H
|
|
|
|
#include <stdint.h>
|
|
|
|
typedef uint64_t flan_dyn;
|
|
|
|
/* ── Construction ──────────────────────────────────────────────────────
|
|
*
|
|
* The typed-to-dyn direction. Integer literals in dyn context box as i64:
|
|
* there is one integer width behind a dyn value, so the defaulting question
|
|
* that a wider set of boxes would raise does not arise.
|
|
*
|
|
* [flan_dyn_nil] is the absent value, and is what an [if] with no else branch
|
|
* answers in dyn context. It is not Unit — Unit does not box, because a value
|
|
* of the zero-sized type carries nothing a dyn word could hold. */
|
|
flan_dyn flan_dyn_nil(void);
|
|
flan_dyn flan_dyn_from_i64(int64_t v);
|
|
flan_dyn flan_dyn_from_f64(double v);
|
|
flan_dyn flan_dyn_from_bool(int32_t v);
|
|
|
|
/* A string, as ptr+len — the shape [T] and string already have in Emit.ll.
|
|
* The runtime copies: the bytes behind a Flan string may be a literal in
|
|
* rodata or a slice of a buffer the program goes on to write. */
|
|
flan_dyn flan_dyn_from_bytes(const uint8_t *ptr, int64_t len);
|
|
|
|
/* The heterogeneous vector. In milestone 1 this is the runtime's own object
|
|
* rather than a Flan (Vec T) that happens to hold dyn words, which is why
|
|
* push/at/len on it go through the dyn ops below: the compiler knows only
|
|
* that it holds a dyn. */
|
|
flan_dyn flan_dyn_vec_new(void);
|
|
|
|
/* ── Operations ────────────────────────────────────────────────────────
|
|
*
|
|
* Arithmetic dispatches on what the two words actually hold and traps through
|
|
* flan_trap_hook when they do not agree. The message is the runtime's: it is
|
|
* the side that knows which pair of types arrived, and a message assembled by
|
|
* the compiler could only name the static types, which are dyn and dyn. */
|
|
flan_dyn flan_dyn_add(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_sub(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_mul(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_div(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_rem(flan_dyn a, flan_dyn b);
|
|
|
|
/* The orderings answer a dyn holding a bool, not a C int: the result of an
|
|
* operation on dyn operands is a dyn, so that a comparison can be pushed into
|
|
* a heterogeneous vector like anything else. Where the compiler needs an i1 to
|
|
* branch on it follows with flan_dyn_need_bool. */
|
|
flan_dyn flan_dyn_lt(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_le(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_gt(flan_dyn a, flan_dyn b);
|
|
flan_dyn flan_dyn_ge(flan_dyn a, flan_dyn b);
|
|
|
|
/* Structural, and never traps. Two values of unrelated types are not an error
|
|
* to compare — they are unequal. This is the one op where a type mismatch has
|
|
* an answer instead of a trap, and = is the operator most likely to meet a
|
|
* heterogeneous container. */
|
|
flan_dyn flan_dyn_eq(flan_dyn a, flan_dyn b);
|
|
|
|
flan_dyn flan_dyn_len(flan_dyn v);
|
|
flan_dyn flan_dyn_at(flan_dyn v, flan_dyn i);
|
|
void flan_dyn_set_at(flan_dyn v, flan_dyn i, flan_dyn x);
|
|
void flan_dyn_push(flan_dyn v, flan_dyn x);
|
|
void flan_dyn_print(flan_dyn v);
|
|
|
|
/* ── Extraction ────────────────────────────────────────────────────────
|
|
*
|
|
* The dyn-to-typed direction, and the only one: a dyn reaches a typed slot
|
|
* through an annotation the programmer wrote — a typed parameter, a typed
|
|
* binding — and never by inference. A mismatch traps; the runtime owns the
|
|
* message for the reason given above. */
|
|
int64_t flan_dyn_need_i64(flan_dyn v);
|
|
double flan_dyn_need_f64(flan_dyn v);
|
|
int32_t flan_dyn_need_bool(flan_dyn v);
|
|
|
|
/* ── Roots ─────────────────────────────────────────────────────────────
|
|
*
|
|
* The collector is precise, so it has to be told where the live dyn words on
|
|
* the machine stack are. A dyn local or temporary that lives across a call or
|
|
* an allocation is pushed as a root at its binding and popped at scope exit,
|
|
* one [flan_dyn_root_pop] per scope carrying the count the scope pushed.
|
|
*
|
|
* The address is registered, not the word: the slot is written again while it
|
|
* is rooted, and a collection in between has to see the current value.
|
|
*
|
|
* ── OPEN POINT FOR THE INTEGRATOR ──────────────────────────────────────
|
|
*
|
|
* A ROOTED SLOT HOLDING 0 IS NOT A VALUE, AND THE COLLECTOR MUST SKIP IT.
|
|
*
|
|
* This is a constraint the compiler puts on the encoding, and it is the one
|
|
* thing in this header that was decided by one side alone. The reason it is
|
|
* forced: roots are pushed in the function's entry block, before the code that
|
|
* fills them has run, and a slot may belong to a branch that never runs at
|
|
* all. So the compiler zeroes every root slot at entry and has to mean
|
|
* something by it, and 0 is the only bit pattern it can write without knowing
|
|
* how values are encoded. Globals get the same treatment for free, from BSS.
|
|
*
|
|
* If the real runtime's encoding makes 0 a legitimate value — a NaN-boxing
|
|
* scheme where integer zero is the zero word is the obvious way this breaks —
|
|
* then this is wrong and the two sides need a different empty sentinel, which
|
|
* is a change to this header that both make together. Do not resolve it by
|
|
* changing one side.
|
|
*
|
|
* The root stack is strictly LIFO and the pops say how many, because there is
|
|
* no way to read its depth. Globals are pushed once, in main, before anything
|
|
* else and never popped. */
|
|
void flan_dyn_root_push(flan_dyn *slot);
|
|
void flan_dyn_root_pop(int64_t n);
|
|
|
|
/* Called once from main before any other function here. */
|
|
void flan_gc_init(void);
|
|
|
|
#endif /* FLAN_DYN_H */
|