jseption 0.0.0-stage → 0.0.2

package/dist/jit_hook.d.ts

@@ -0,0 +1,21 @@
+import type { JSFunctionBytecode, JSValue } from './values.ts';
+export declare const JIT_NOT_COMPILED: unique symbol;
+export interface HostFrame {
+    kind: 'compiled' | 'interp' | 'cfunc' | 'native';
+    name: string;
+    file: string;
+    line: number;
+    col: number;
+}
+export interface JitStackHooks {
+    capture(): string;
+    frames(host_stack: string): HostFrame[];
+    compiled_on_top(host_stack: string): boolean;
+}
+export interface JitHooks {
+    try_call: ((ctx: any, func_obj: JSValue, func_data: any, b: JSFunctionBytecode, this_obj: JSValue, new_target: JSValue, argv: JSValue[], flags: number) => JSValue | typeof JIT_NOT_COMPILED) | null;
+    stack: JitStackHooks | null;
+    make_wrapper: ((ctx: any, b: JSFunctionBytecode, var_refs: any[], proto: JSValue | null, is_ctor: boolean) => JSValue | null) | null;
+    osr: ((ctx: any, func_obj: JSValue, b: JSFunctionBytecode, sf: any, pc: number, sp: number) => JSValue | typeof JIT_NOT_COMPILED) | null;
+}
+export declare const jit_hooks: JitHooks;

package/dist/jit_hook.js

@@ -0,0 +1,4 @@
+/* returned by try_call when the function is not (yet) compiled */
+export const JIT_NOT_COMPILED = Symbol('JIT_NOT_COMPILED');
+export const jit_hooks = { try_call: null, stack: null, make_wrapper: null, osr: null };
+//# sourceMappingURL=jit_hook.js.map

package/dist/jit_hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit_hook.js","sourceRoot":"","sources":["../src/jit_hook.ts"],"names":[],"mappings":"AASA,kEAAkE;AAClE,MAAM,CAAC,MAAM,gBAAgB,GAAkB,MAAM,CAAC,kBAAkB,CAAC,CAAC;AA0C1E,MAAM,CAAC,MAAM,SAAS,GAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC","sourcesContent":["/*\n * Hook between the interpreter and the compiled tier (src/jit.ts).\n *\n * This module has no imports so that the interpreter can depend on it\n * without creating an import cycle. jit.ts installs `try_call` when it is\n * loaded; when it is not loaded the interpreter runs everything.\n */\nimport type { JSFunctionBytecode, JSValue } from './values.ts';\n\n/* returned by try_call when the function is not (yet) compiled */\nexport const JIT_NOT_COMPILED: unique symbol = Symbol('JIT_NOT_COMPILED');\n\n/* a guest-relevant frame of the host stack (see src/jit_stack.ts):\n   compiled: a compiled guest function, with its guest position when known;\n   interp:   the host frame running an interpreter frame (`js_interpret`);\n   cfunc:    the host frame running a C function frame (`js_call_c_function`);\n   native:   a host builtin called by guest code (`[].map`) */\nexport interface HostFrame {\n  kind: 'compiled' | 'interp' | 'cfunc' | 'native';\n  name: string;\n  file: string;\n  line: number;\n  col: number;\n}\n\nexport interface JitStackHooks {\n  /* the current host stack, captured with a frame limit high enough for guest backtraces */\n  capture(): string;\n  /* the guest-relevant frames of a host stack, innermost first */\n  frames(host_stack: string): HostFrame[];\n  /* true when the innermost guest frame of the host stack is compiled code (its position is\n     only available now, from the host stack), false when it is an interpreter frame */\n  compiled_on_top(host_stack: string): boolean;\n}\n\nexport interface JitHooks {\n  /* Called at the entry of JS_CallInternal for bytecode functions.\n     `func_data` is the closure data of the function object (bytecode + var refs). */\n  try_call: ((ctx: any, func_obj: JSValue, func_data: any, b: JSFunctionBytecode, this_obj: JSValue,\n              new_target: JSValue, argv: JSValue[], flags: number) => JSValue | typeof JIT_NOT_COMPILED) | null;\n  /* backtrace support for compiled frames; null while the compiled tier is off */\n  stack: JitStackHooks | null;\n  /* Creates the function object of an interpreted closure of a normal function as a\n     retargetable wrapper (it calls the compiled body once one exists), or returns null for the\n     generic interpreter wrapper. */\n  make_wrapper: ((ctx: any, b: JSFunctionBytecode, var_refs: any[], proto: JSValue | null, is_ctor: boolean) => JSValue | null) | null;\n  /* On-stack replacement: called by the interpreter when a backward jump to `pc` is taken in a\n     frame of `func_obj`; returns the frame's result (JS_EXCEPTION with the exception pending)\n     when the rest of the frame ran in compiled code, else JIT_NOT_COMPILED. */\n  osr: ((ctx: any, func_obj: JSValue, b: JSFunctionBytecode, sf: any, pc: number, sp: number) => JSValue | typeof JIT_NOT_COMPILED) | null;\n}\n\nexport const jit_hooks: JitHooks = { try_call: null, stack: null, make_wrapper: null, osr: null };\n"]}

package/dist/jit_runtime.d.ts

@@ -0,0 +1,104 @@
+import { JSContext, JSValue, JSFunctionBytecode, JSAtom } from './quickjs.ts';
+import { JSVarRef } from './values.ts';
+export interface JitCompiledLike {
+    make: (var_refs: JSVarRef[], func_obj?: JSValue) => [Function, Function, (() => Function) | null];
+}
+export declare const JIT_FACTORY_PARAMS: string[];
+export declare function jit_runtime_factory_args(RT: JitRuntime, b: JSFunctionBytecode): any[];
+export declare function make_jit_runtime(ctx: JSContext, compile: (b: JSFunctionBytecode) => JitCompiledLike | null): JitRuntime;
+export declare function jit_runtime_call_priv(ctx: JSContext, priv: Function, this_obj: JSValue, argv: JSValue[]): JSValue;
+export declare function jit_bytecode_uses_args(b: JSFunctionBytecode): boolean;
+export declare function jit_runtime_make_wrapper(ctx: JSContext, b: JSFunctionBytecode, var_refs: JSVarRef[], proto: JSValue | null, is_ctor: boolean): JSValue | null;
+export declare function jit_runtime_call_compiled(ctx: JSContext, direct: Function, this_obj: JSValue, new_target: JSValue, argv: JSValue[], flags: number): JSValue;
+export declare class JitRuntime {
+    ctx: JSContext;
+    compile: (b: JSFunctionBytecode) => JitCompiledLike | null;
+    DONE: any;
+    Obj: Function;
+    constructor(ctx: JSContext, compile: (b: JSFunctionBytecode) => JitCompiledLike | null);
+    throw_pending(): never;
+    check<T>(v: T): T;
+    checkn(r: number): void;
+    to_guest_exception(e: unknown): JSValue;
+    catchable(e: unknown): JSValue;
+    poll(): void;
+    poll_handler(): void;
+    throw_type_error(msg: string): never;
+    throw_reference_error(msg: string): never;
+    throw_internal_error(msg: string): never;
+    throw_not_a_constructor(_f: JSValue): never;
+    throw_uninitialized(b: JSFunctionBytecode, idx: number, is_ref: boolean): never;
+    throw_error(atom: JSAtom, type: number): never;
+    new_cell(v: JSValue): JSVarRef;
+    new_object(): JSValue;
+    new_object_null(): JSValue;
+    array(elems: JSValue[]): JSValue;
+    atom_value(atom: JSAtom): JSValue;
+    private_symbol(atom: JSAtom): JSValue;
+    sloppy_this(t: JSValue): JSValue;
+    regexp(pattern: JSValue, flags: JSValue): JSValue;
+    to_object(v: JSValue): JSValue;
+    to_propkey(v: JSValue): JSValue;
+    to_numeric(v: JSValue): JSValue;
+    inc(v: JSValue): JSValue;
+    dec(v: JSValue): JSValue;
+    in(k: JSValue, o: JSValue): boolean;
+    instanceof(v: JSValue, c: JSValue): boolean;
+    get_prototype(o: JSValue): JSValue;
+    call_slow(f: JSValue, thisv: JSValue, args: JSValue[]): JSValue;
+    construct_slow(f: JSValue, new_target: JSValue, args: JSValue[]): JSValue;
+    call_method_prim(o: JSValue, atom: JSAtom, args: JSValue[]): JSValue;
+    call_method_prim_key(o: JSValue, key: JSValue, args: JSValue[]): JSValue;
+    apply(f: JSValue, thisv: JSValue, arr: JSValue, magic: number): JSValue;
+    create_this(new_target: JSValue): JSValue;
+    init_ctor(self: JSValue, new_target: JSValue, args: IArguments, off: number): JSValue;
+    arguments(args: IArguments, off: number): JSValue;
+    mapped_arguments(args: IArguments, off: number, cells: JSVarRef[], self: JSValue): JSValue;
+    rest(args: IArguments, off: number, first: number): JSValue;
+    home_object(self: JSValue): JSValue;
+    closure(b: JSFunctionBytecode, var_refs: JSVarRef[], _parent: JSValue): JSValue;
+    define_class(name: JSAtom | JSValue, parent_class: JSValue, b: JSFunctionBytecode, class_flags: number, var_refs: JSVarRef[], is_computed_name: boolean): [JSValue, JSValue];
+    set_home_object(f: JSValue, home: JSValue): void;
+    set_name(f: JSValue, atom: JSAtom): void;
+    set_name_computed(f: JSValue, name: JSValue): void;
+    define_method(obj: JSValue, key: JSAtom | JSValue, fn: JSValue, op_flags: number, computed: boolean): void;
+    set_proto(o: JSValue, proto: JSValue): void;
+    check_brand(o: JSValue, f: JSValue): void;
+    add_brand(o: JSValue, f: JSValue): void;
+    get_private_field(o: JSValue, name: JSValue): JSValue;
+    put_private_field(o: JSValue, name: JSValue, v: JSValue): void;
+    define_private_field(o: JSValue, name: JSValue, v: JSValue): void;
+    private_in(o: JSValue, name: JSValue): boolean;
+    check_var(atom: JSAtom): boolean;
+    get_global(atom: JSAtom, throw_ref_error: boolean): JSValue;
+    put_global(atom: JSAtom, v: JSValue, flag: number, strict: boolean): void;
+    put_global_strict(atom: JSAtom, defined: JSValue, v: JSValue): void;
+    check_define_var(atom: JSAtom, flags: number): void;
+    define_var(atom: JSAtom, flags: number): void;
+    define_func(atom: JSAtom, v: JSValue, flags: number): void;
+    get_global_ref(atom: JSAtom): [JSValue, JSValue];
+    delete_global(atom: JSAtom): boolean;
+    get_field(o: JSValue, atom: JSAtom): JSValue;
+    get_field_str(o: JSValue, name: string): JSValue;
+    get_length(o: JSValue): JSValue;
+    get_el(o: JSValue, k: JSValue): JSValue;
+    put_field(o: JSValue, atom: JSAtom, v: JSValue, strict: boolean): void;
+    put_el(o: JSValue, k: JSValue, v: JSValue, strict: boolean): void;
+    delete(o: JSValue, k: JSValue, strict: boolean): boolean;
+    define_field(o: JSValue, atom: JSAtom, v: JSValue): void;
+    define_array_el(arr: JSValue, pos: JSValue, v: JSValue): void;
+    append(arr: JSValue, pos: JSValue, src: JSValue): number;
+    copy_data_properties(target: JSValue, source: JSValue, excluded: JSValue): void;
+    get_ref_value(o: JSValue, k: JSValue, strict: boolean): JSValue;
+    put_ref_value(o: JSValue, k: JSValue, v: JSValue, strict: boolean): void;
+    get_super_value(thisv: JSValue, o: JSValue, k: JSValue): JSValue;
+    put_super_value(thisv: JSValue, o: JSValue, k: JSValue, v: JSValue): void;
+    for_in_start(o: JSValue): JSValue;
+    for_in_next(it: JSValue): JSValue;
+    get_iterator(o: JSValue): JSValue;
+    for_of_start(o: JSValue): [JSValue, JSValue];
+    for_of_next(iter: JSValue, next: JSValue): JSValue;
+    iterator_close(iter: JSValue): void;
+    iterator_close_exc(iter: JSValue): void;
+    iterator_call(iter: JSValue, val: JSValue, flags: number): JSValue;
+}