[js-api] The type confusion in builtin section

未关闭
#2,330 0 条评论 0 个 reaction 已指派 0 人 在 GitHub 查看

维护者通常 1 天内回复

还没有人认领这个 Issue。

评估

难度
5/5
预计耗时
一周以上
新手友好度
35/100
Issue 类型
重构
描述清晰度
基本清楚
活跃度
活跃
领域
documentation

调研方向

Read the JS API Builtins section and compare its create a builtin function steps with run a host function and the Core Spec's ToJSValue and ToWebAssemblyValue conversions. The issue proposes defining argument and result conversion, trap handling, store handling, and unsigned i32 interpretation across the builtins; work out the array handling details it identifies. Done means the builtin algorithms use one consistent convention and resolve the cited type mismatches.

由索引模型根据 Issue 内容生成。

描述

In the Core Spec and the rest of the JS API, a numeric WebAssembly value such as (i32.cosnt n) is a term,
and its actual value is compared only after it is taken out of one, with its signedness spelled out.

In the Core Spec, i32.lt_u and i32.lt_s take the payloads c1 and c2 out of two i32.const values and compare them with ilt: unsigned is c1 < c2, and signed is signed_32(c1) < signed_32(c2).

The JS API does the same when it tries to read a value:
ToJSValue matches i32.const u32 and uses signed_32(u32).

The Builtins section however, has no such convention.
create a builtin function only says the host function "executes steps when called",
so nothing says what the steps receive or return,
and the steps mix WebAssembly values, JavaScript values and plain numbers:

  • i32 parameters are used both as numbers and as WebAssembly values.
    fromCodePoint checks v > 0x10ffff and then calls ToJSValue(v);
    charCodeAt/codePointAt (index) and substring (start, end) do the same.
  • Conversions are written in some places only.
    FromCharCode and CharCodeAt assert is of type i32 and call ToJSValue,
    but externref parameters are used as if they are already JavaScript values (If v is not a String),
    and results are returned unconverted (Return 0., Return -1., a JavaScript String).
  • Values of the wrong kind are passed on.
    intoCharCodeArray passes its loop counter, a number, to CharCodeAt, which asserts an i32.
    fromCharCodeArray passes a packed i16 array element to FromCharCode, which asserts the same.
    And intoCharCodeArray stores an i32.const value into that i16 array.
Why it matters

These implicit conversions brings ambiguity. For instance, substring(string, start, end) can have different interpretations:

1. Let string be ? UnwrapString(string).
1. Let length be the length of string.
1. If start > end or start > length,
    1. Return the empty string.
1. Return ! Call(String.prototype.substring, string, « ToJSValue(start), ToJSValue(end) »).

For substring("hello", 1, -1):

  • If end stays a WebAssembly value and only > implicitly reads it as a number:
    • read as signed: 1 > -1, so the result is "".
    • read as unsigned: the check passes, then ToJSValue turns end back into -1,
      and String.prototype.substring("hello", 1, -1) gives "h".
  • If end is already implicitly a number or JSValue when the steps start (which makes the last step's ToJSValue redundant):
    • converted as signed (-1): "". (This is what JavaScriptCore returns.)
    • converted as unsigned (4294967295): "ello". (This is what V8 and SpiderMonkey return, and likely be the intention.)
Suggestion

The proposal's Overview does have a single convention, and V8 and SpiderMonkey follow it.
Builtins "have the same semantics as following create a host function",
so "Calling a function builtin from Wasm will have the Wasm parameters converted to JS values,
and JS results converted back to Wasm values", and each builtin then reinterprets its i32 parameters as unsigned:

// NOTE: `index` is interpreted as a signed 32-bit integer when converted to
// a JS value using standard conversions. Reinterpret as unsigned here.
index >>>= 0;

I would suggest writing the section in that convention:

  • create a builtin function's host function explicitly converts its arguments with ToJSValue and the result with ToWebAssemblyValue, as run a host function does, and maps a throw to a trap, perhaps something like:

    1. Let func parameters → results be the expansion of funcType.
    1. Let hostfunc be a host function which performs the following steps when called with store store and arguments arguments:
        1. Set the surrounding agent's associated store to store.
        1. Let jsArguments be « ».
        1. For each arg of arguments, append ToJSValue(arg) to jsArguments.
        1. Let result be the result of running steps with jsArguments.
        1. Let store be the surrounding agent's associated store.
        1. If result is an abrupt completion, return (store, trap).
        1. Return (store, « ! ToWebAssemblyValue(result.[[Value]], results[0]) »).
    1. ...
    
  • Each builtin starts by reinterpreting its i32 parameters with
    ToUint32, and compares them with ℝ(...). For example, substring:

    1. Let string be ? UnwrapString(string).
    1. Let start be ! ToUint32(start).
    1. Let end be ! ToUint32(end).
    1. Let length be the length of string.
    1. If ℝ(start) > ℝ(end) or ℝ(start) > length,
        1. Return the empty string.
    1. Return ! Call(String.prototype.substring, string, « start, end »).
    

    (Alternatively, the host function could pass i32 arguments as unsigned Numbers (𝔽(u32)) in the first place, instead of ToJSValue. That saves repeating ToUint32 in every builtin)

  • Results the steps return as plain numbers
    (Return 0., Return -1., Return stringLength., Return the length of string.)
    become Numbers (+0𝔽, -1𝔽, 𝔽(stringLength)),
    so that ToWebAssemblyValue can convert them like any other JavaScript result.

  • The host function explicitly takes and returns the store, as #2326 does for create a host function.

Some details would still need working out.
For example, with ToJSValue an array parameter arrives as an Exported GC Object,
so fromCharCodeArray and intoCharCodeArray would have to reach the array through its address.
I would work these out in the PR.

Does that direction sound right? If so, I can open a PR for it.

主要语言
WebAssembly
星标
3.5k
派生
545
平均合并
1 天 4 小时
30 天内合并 PR
25

环境准备

  • 没有 Dockerfile 或 Docker Compose 文件
  • 没有 Pull Request 模板
  • 阅读贡献指南

从这里开始

  1. 先读完整个 Issue,再读项目的贡献指南。
  2. 在 Issue 下留言说明你要接手 —— 这能避免两个人做同样的事。
  3. Fork 仓库,在一个分支上完成修改。
  4. 提交 Pull Request,并在描述里引用这个 Issue 编号。

WebAssembly/spec 的其他 Issue

查看 WebAssembly/spec 的全部 Issue

相似的 Issue

更多 Documentation Issue

把新 issue 发到你的邮箱

精选适合新手参与的 GitHub issue 摘要。