@scriptc/compiler 0.3.5 → 0.3.6

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

@@ -273,6 +273,9 @@ export declare class LlEmitter {
     private stableGlobals;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
+    /** Constant-key reads on checked-dynamic objects, each with its own
+     * zero-initialized ScrDynReadIc (scr_runtime.h). */
+    private dynReadIcSites;
     /** May-throw analysis (computeMayThrow): pending
      * checks are emitted only after calls that can actually raise. */
     readonly mayThrow: Set<string>;
@@ -415,6 +418,17 @@ export declare class LlEmitter {
         };
     }>;
     private countedLoopsEnabled;
+    /** Speculative integer loops (speculative-integers.ts) run in this function. */
+    private speculativeLoopsEnabled;
+    /** The fast copy of a speculative integer loop being emitted: its
+     * integer-computed writes and where each resumes in the ordinary copy. */
+    private speculation;
+    /** The ordinary copy being emitted: resume labels still to place. */
+    private speculationResume;
+    /** The function being emitted, for speculative globals. */
+    private speculativeFunction;
+    /** Every function that writes each number global (computed on demand). */
+    private globalWriters;
     /** Whole-program final reference fields (ir/final-fields.ts). */
     private finalFields;
     /** The current function may borrow final fields of borrowable objects:
@@ -722,6 +736,31 @@ export declare class LlEmitter {
      * conditions in expr-calls.ts). */
     private callTestsPending;
     private workerLoopBudget;
+    /** Emit a loop's condition, body and update through `emitCopy`, twice
+     * when speculative-integers.ts plans a fast integer copy. Both copies
+     * share the loop's setup and exit; the ordinary copy comes first so the
+     * fast copy is only emitted when every resume point exists. */
+    private emitLoopCopies;
+    private writeBackSpeculativeGlobals;
+    /** A number local whose only storage is its own double slot, so an i64
+     * shadow beside it can stand for it within one loop. */
+    private speculativeLocal;
+    /** A module-level number written only by the file's top-level code that
+     * is emitting this loop. Calls may still read it: the fast copy keeps its
+     * double current. An init function runs once and is never re-entered, so
+     * no call from the loop can write the global behind the shadow. */
+    private speculativeGlobal;
+    /** A module-level number a loop of any function only reads, written by
+     * nothing but top-level code: an init function never runs during a loop
+     * of another function, so the entry value stays its value. */
+    private speculativeInvariantGlobal;
+    /** The functions writing a number global a shadow may stand for, or null
+     * when the global is not such a number. */
+    private numberGlobalWriters;
+    /** A speculated write in the fast copy: compute the value as a safe
+     * integer, store it to the shadow and its exact double to the local.
+     * Any failed check re-executes the statement in the ordinary copy. */
+    private emitSpeculativeWrite;
     /** The amortized cancellation poll, emitted on the loop's back edge (the
      * continue target), after the body. A poll in the header would be a loop
      * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
@@ -802,6 +841,9 @@ export declare class LlEmitter {
     };
     /** The overflow map's slot pointer on an index-signature shape. */
     recordOvfPtr(objName: string, shapeId: string): string;
+    /** The pointer to ScrMap.flags of an index-signature record's overflow
+     * map (byte offset sizeof(size_t) + 3; SCR_MAP_NULL_PROTO is bit 0). */
+    recordMapFlagsPtr(objName: string, shapeId: string): string;
     /** Loads a record field (i8-stored bools trunc to i1). An inline union
      * field answers a private stack box with the slot's own bits, ABSENT
      * included: it may only be borrowed. */
@@ -1107,7 +1149,7 @@ export declare class LlEmitter {
     /** A direct async call an enclosing `await` consumes whole: emitted
      * through the callee's await-call entry, yielding the awaited value. */
     emitAwaitedCall(e: ExprOf<"call">, adopt?: boolean): LlValue;
-    emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordHas" | "fieldAbsent">): LlValue;
+    emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordNullProto" | "recordHas" | "fieldAbsent">): LlValue;
     emitDynamicExpr(e: ExprOf<"dynFrom" | "dynCall" | "dynInvoke" | "dynArrLit" | "dynObjLit" | "unionWrap" | "unionNarrow" | "unionDisc" | "unionKeyGet" | "unionIsTag" | "dynKeyGet" | "dynHasKey" | "dynScalarEq" | "dynTest" | "unionEq" | "unionFuncEq" | "caughtTest" | "caughtCheck" | "caughtNarrow" | "caughtToDyn">): LlValue;
     emitIntrinsicExpr(e: ExprOf<"intrinsic">): LlValue;
     /** InternTable's runtime calls (scr_itable.c). Table and entry handles
@@ -1232,6 +1274,8 @@ export declare class LlEmitter {
     borrowableNullableWrap(e: IrExpr): "unit" | "ref" | null;
     materializeSplitLocal(localId: string): void;
     emitExpr(e: IrExpr): LlValue;
+    /** A fresh read-site cache for one constant-key dyn read. */
+    dynReadIcSite(): string;
     dynKind(d: string): string;
     raceAdapterFor(from: IrType, to: IrType): string;
     genResultThunkFor(genT: IrType & {