@scriptc/compiler 0.2.8 → 0.2.9

package/dist/backend/llvm/emitter.d.ts

@@ -45,6 +45,10 @@ export interface LlvmTargetOptions {
     /** Emit retain/release fast paths inline (the `speed` posture). Off, every
      * retain and release is a runtime call. */
     inlineRc?: boolean;
+    /** Define `scr_detached_exit` so the Linux runtime hands the address-space
+     * teardown after `process.exit` to a helper process (`--detached-exit`).
+     * Executables only; the runtime's weak default keeps it off. */
+    detachedExit?: boolean;
 }
 export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOptions): string;
 /** Keep large translation units below the host's single-string limit. */
@@ -73,12 +77,27 @@ export declare class LlEmitter {
     private debugScope;
     readonly sizeType: "i32" | "i64";
     readonly ffiExtendNarrowIntegers: boolean;
-    readonly cycleColorOffset: number;
+    readonly cycleBufferedOffset: number;
+    /** Emitted ScrCycType descriptors so far (their collector statistics
+     * indices; see ShapeHost.nextCycKind). */
+    private cycKinds;
     readonly wasi: boolean;
+    /** The target lacks a rounding instruction at its baseline CPU (x86-64
+     * before SSE4.1), so `llvm.trunc` would lower to a libm call: emit
+     * truncation inline through an integer round trip instead. */
+    readonly inlineTrunc: boolean;
     /** ELF worker executables give thread-locals the executable TLS models. */
     private readonly executableTls;
+    /** Source loops enclosing the statement being emitted in the current
+     * function body. */
+    private loopDepth;
+    /** Darwin worker executables read the stack guard from a pthread
+     * thread-specific-data slot off the thread pointer (scr_runtime.h's
+     * SCR_STACK_GUARD_TSD): the architecture names the access sequence. */
+    private readonly stackGuardTsd;
     private readonly emitLibraryIdentity;
     private readonly runtimeAbiMarker;
+    private readonly detachedExit;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
     private readonly literals;
@@ -286,6 +305,11 @@ export declare class LlEmitter {
         };
     }>;
     private countedLoopsEnabled;
+    /** Whole-program final reference fields (ir/final-fields.ts). */
+    private finalFields;
+    /** The current function may borrow final fields of borrowable objects:
+     * not a constructor (where they change), not async or a generator. */
+    private finalFieldBorrows;
     integerRanges: IntegerRanges;
     private byteWindowsEnabled;
     private byteWindowEntries;
@@ -486,6 +510,13 @@ export declare class LlEmitter {
      * unwind returns it as the dummy, so a call in tail position keeps a single
      * return and stays eligible for tail-call and recursion elimination. */
     private emitUnwind;
+    /** Loads the running thread's exact pending word (ELF worker
+     * executables, scr_exception.c): bit 0 mirrors the active cell, bit 1
+     * requests the context's stop. It lives in the executable's static TLS
+     * block, so the access is one thread-pointer-relative load. Monotonic by
+     * default: a loop must not hoist the load out and miss a cross-thread
+     * stop (see emitPendingCheck for the unordered tests). */
+    private loadExcFlag;
     /** Instructions (two-space indented) that set the i1 `dest` to "an
      * exception is pending in the active context" — scr_exc_pending()'s
      * meaning — for the helper and adapter bodies that test it outside
@@ -501,11 +532,12 @@ export declare class LlEmitter {
      * call's result temp must join its frame BEFORE this runs so the unwind
      * releases the dummy (NULL for refcounted kinds) harmlessly. A scalar
      * call result of the function's return type may be passed as the unwind's
-     * dummy value (see emitUnwind). */
+     * dummy value (see emitUnwind). `poll` marks a worker termination poll
+     * (function entry or loop budget), whose test must stay ordered. */
     emitPendingCheck(passThrough?: {
         name: string;
         type: IrType;
-    }): void;
+    }, poll?: boolean): void;
     /** After a runtime call that ALWAYS leaves an exception pending (the
      * compiler-resolved Node throws): the pending test would always answer
      * true, so unwind unconditionally. Emission continues in a block with no
@@ -515,6 +547,9 @@ export declare class LlEmitter {
     /** A recursive function's entry check: below the running stack's guard,
      * throw Node's RangeError and unwind like any other pending exception. */
     private emitStackCheck;
+    /** Whether the emitter follows this call with a pending test (the
+     * conditions in expr-calls.ts). */
+    private callTestsPending;
     private workerLoopBudget;
     private emitWorkerLoopCheck;
     /** Moves an already-evaluated value into the runtime's exception cell —
@@ -621,6 +656,13 @@ export declare class LlEmitter {
      * array cell holding the value and move it into the ARR-kind box
      * (set_ref releases nothing — the slot was the empty sentinel). */
     private tdzScalarInit;
+    /** The payload a TDZ box holds before its declaration runs, when that is
+     * not NULL. A nullable union's value is its arm pointer with NULL as a
+     * unit arm (nullable-unions.ts), so a stored `null`/`undefined` would
+     * read back as the temporal dead zone; such boxes start at the module's
+     * immortal NULLABLE_ABSENT sentinel instead, which no value of the
+     * binding can hold and every RC entry point and the collector skip. */
+    private tdzEmptySentinel;
     /** The TDZ-guarded read of a boxed binding: an empty payload slot is
      * the temporal dead zone — throw Node's exact catchable ReferenceError
      * (exprs.ts's varRef guard). Scalars then peek the one-element