Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://webassembly.github.io/spec/js-api/ below:

WebAssembly JavaScript Interface

By design, the scope of the WebAssembly core specification [WEBASSEMBLY] does not include a description of how WebAssembly programs interact with their surrounding execution environment. Instead it defines an abstract embedding interface between WebAssembly and its environment, (called the embedder). It is only through this interface that an embedder interacts with the semantics of WebAssembly, and the embedder implements the connection between its host environment and the embedding API. This document describes the embedding of WebAssembly into JavaScript [ECMASCRIPT] environments, including how WebAssembly modules can be constructed and instantiated, how imported and exported functions are called, how data is exchanged, and how errors are handled. When the JavaScript environment is itself embedded in a Web browser, the Web API spec [WASMWEB] describes additional behavior relevant to the Web environment.

This section is non-normative.

Given demo.wat (encoded to demo.wasm):

(module
    (import "js" "import1" (func $i1))
    (import "js" "import2" (func $i2))
    (func $main (call $i1))
    (start $main)
    (func (export "f") (call $i2))
)

and the following JavaScript, run in a browser:

var importObj = {js: {
    import1: () => console.log("hello,"),
    import2: () => console.log("world!")
}};
fetch('demo.wasm').then(response =>
    response.arrayBuffer()
).then(buffer =>
    WebAssembly.instantiate(buffer, importObj)
).then(({module, instance}) =>
    instance.exports.f()
);

This specification depends on the Infra Standard. [INFRA]

The WebAssembly sequence type is equivalent to the list type defined there; values of one are treated as values of the other transparently.

Note: WebAssembly semantics are defined in terms of an abstract store, representing the state of the WebAssembly abstract machine. WebAssembly operations take a store and return an updated store.

Each agent has an associated store. When a new agent is created, its associated store is set to the result of store_init().

Note: In this specification, no WebAssembly-related objects, memory or addresses can be shared among agents in an agent cluster. In a future version of WebAssembly, this may change.

Elements of the WebAssembly store may be identified with JavaScript values. In particular, each WebAssembly memory instance with a corresponding Memory object is identified with a JavaScript Data Block; modifications to this Data Block are identified to updating the agent’s store to a store which reflects those changes, and vice versa.

Note: There are several WebAssembly objects that may have a corresponding JavaScript object. The correspondence is stored in a per-agent mapping from WebAssembly addresses to JavaScript objects. This mapping is used to ensure that, for a given agent, there exists at most one JavaScript object for a particular WebAssembly address. However, this property does not hold for shared objects.

Each agent is associated with the following ordered maps:

• The Memory object cache, mapping memory addresses to Memory objects.

• The Table object cache, mapping table addresses to Table objects.

• The Exported Function cache, mapping function addresses to Exported Function objects.

• The Global object cache, mapping global addresses to Global objects.

• The Extern value cache, mapping extern addresses to values.

dictionary WebAssemblyInstantiatedSource {
    required Module module;
    required Instance instance;
};

[Exposed=*]
namespace WebAssembly {
    boolean validate(BufferSource bytes);
    Promise<Module> compile(BufferSource bytes);

    Promise<WebAssemblyInstantiatedSource> instantiate(
        BufferSource bytes, optional object importObject);

    Promise<Instance> instantiate(
        Module moduleObject, optional object importObject);
};

The

method, when invoked, performs the following steps:

1. Let stableBytes be a copy of the bytes held by the buffer bytes.

2. Compile stableBytes as a WebAssembly module and store the results as module.

3. If module is error, return false.

4. Return true.

A Module object represents a single WebAssembly module. Each Module object has the following internal slots:

• [[Module]] : a WebAssembly module

• [[Bytes]] : the source bytes of [[Module]].

To

from a module

and source bytes

, perform the following steps:

1. Let moduleObject be a new Module object.

2. Set moduleObject.[[Module]] to module.

3. Set moduleObject.[[Bytes]] to bytes.

4. Return moduleObject.

To

from a WebAssembly module

from imports object

, perform the following steps:

1. If module.imports is not empty, and importObject is undefined, throw a TypeError exception.

2. Let imports be « ».

3. For each (moduleName, componentName, externtype) of module_imports(module),

   1. Let o be ? Get(importObject, moduleName).

   2. If o is not an Object, throw a TypeError exception.

   3. Let v be ? Get(o, componentName).

   4. If externtype is of the form func functype,

      1. If IsCallable(v) is false, throw a LinkError exception.

      2. If v has a [[FunctionAddress]] internal slot, and therefore is an Exported Function,

         1. Let funcaddr be the value of v’s [[FunctionAddress]] internal slot.

      3. Otherwise,

         1. Create a host function from v and functype, and let funcaddr be the result.

         2. Let index be the number of external functions in imports. This value index is known as the index of the host function funcaddr.

      4. Let externfunc be the external value func funcaddr.

      5. Append externfunc to imports.

   5. If externtype is of the form global mut valtype,

      1. If v is a Number or v is a BigInt,

         1. If valtype is i64 and v is a Number,

            1. Throw a LinkError exception.

         2. If valtype is not i64 and v is a BigInt,

            1. Throw a LinkError exception.

         3. If valtype is v128,

            1. Throw a LinkError exception.

         4. Let value be ToWebAssemblyValue(v, valtype).

         5. Let store be the surrounding agent’s associated store.

         6. Let (store, globaladdr) be global_alloc(store, const valtype, value).

         7. Set the surrounding agent’s associated store to store.

      2. Otherwise, if v implements Global,

         1. Let globaladdr be v.[[Global]].

      3. Otherwise,

         1. Throw a LinkError exception.

      4. Let externglobal be global globaladdr.

      5. Append externglobal to imports.

   6. If externtype is of the form mem memtype,

      1. If v does not implement Memory, throw a LinkError exception.

      2. Let externmem be the external value mem v.[[Memory]].

      3. Append externmem to imports.

   7. If externtype is of the form table tabletype,

      1. If v does not implement Table, throw a LinkError exception.

      2. Let tableaddr be v.[[Table]].

      3. Let externtable be the external value table tableaddr.

      4. Append externtable to imports.

4. Return imports.

Note: This algorithm only verifies the right kind of JavaScript values are passed. The verification of WebAssembly type requirements is deferred to the "instantiate the core of a WebAssembly module" algorithm.

To

from a WebAssembly module

and instance

, perform the following steps:

1. Let exportsObject be ! OrdinaryObjectCreate(null).

2. For each (name, externtype) of module_exports(module),

   1. Let externval be instance_export(instance, name).

   2. Assert: externval is not error.

   3. If externtype is of the form func functype,

      1. Assert: externval is of the form func funcaddr.

      2. Let func funcaddr be externval.

      3. Let func be the result of creating a new Exported Function from funcaddr.

      4. Let value be func.

   4. If externtype is of the form global mut globaltype,

      1. Assert: externval is of the form global globaladdr.

      2. Let global globaladdr be externval.

      3. Let global be a new Global object created from globaladdr.

      4. Let value be global.

   5. If externtype is of the form mem memtype,

      1. Assert: externval is of the form mem memaddr.

      2. Let mem memaddr be externval.

      3. Let memory be a new Memory object created from memaddr.

      4. Let value be memory.

   6. If externtype is of the form table tabletype,

      1. Assert: externval is of the form table tableaddr.

      2. Let table tableaddr be externval.

      3. Let table be a new Table object created from tableaddr.

      4. Let value be table.

   7. Let status be ! CreateDataProperty(exportsObject, name, value).

   8. Assert: status is true.

   Note: the validity and uniqueness checks performed during WebAssembly module validation ensure that each property name is valid and no properties are defined twice.

3. Perform ! SetIntegrityLevel(exportsObject, "frozen").

4. Return exportsObject.

To

from a WebAssembly module

and instance

, perform the following steps:

1. Create an exports object from module and instance and let exportsObject be the result.

2. Set instanceObject.[[Instance]] to instance.

3. Set instanceObject.[[Exports]] to exportsObject.

To

from a module

and imports

, perform the following steps:

1. Let store be the surrounding agent’s associated store.

2. Let result be module_instantiate(store, module, imports).

3. If result is error, throw an appropriate exception type:

   • A LinkError exception for most cases which occur during linking.

   • If the error came when running the start function, throw a RuntimeError for most errors which occur from WebAssembly, or the error object propagated from inner ECMAScript code.

   • Another error type if appropriate, for example an out-of-memory exception, as documented in the WebAssembly error mapping.

4. Let (store, instance) be result.

5. Set the surrounding agent’s associated store to store.

6. Return instance.

To

from a

and imports

, perform the following steps:

1. Let promise be a new promise.

2. Let module be moduleObject.[[Module]].

3. Read the imports of module with imports importObject, and let imports be the result. If this operation throws an exception, catch it, reject promise with the exception, and return promise.

4. Run the following steps in parallel:

   1. Queue a task to perform the following steps: Note: Implementation-specific work may be performed here.

      1. Instantiate the core of a WebAssembly module module with imports, and let instance be the result. If this throws an exception, catch it, reject promise with the exception, and terminate these substeps.

      2. Let instanceObject be a new Instance.

      3. Initialize instanceObject from module and instance. If this throws an exception, catch it, reject promise with the exception, and terminate these substeps.

      4. Resolve promise with instanceObject.

5. Return promise.

Note: A follow-on streaming API is documented in the WebAssembly Web API.

enum ImportExportKind {
  "function",
  "table",
  "memory",
  "global"
};

dictionary ModuleExportDescriptor {
  required USVString name;
  required ImportExportKind kind;
  // Note: Other fields such as signature may be added in the future.
};

dictionary ModuleImportDescriptor {
  required USVString module;
  required USVString name;
  required ImportExportKind kind;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Module {
  constructor(BufferSource bytes);
  static sequence<ModuleExportDescriptor> exports(Module moduleObject);
  static sequence<ModuleImportDescriptor> imports(Module moduleObject);
  static sequence<ArrayBuffer> customSections(Module moduleObject, DOMString sectionName);
};

The

is

• "function" if type is of the form func functype

• "table" if type is of the form table tabletype

• "memory" if type is of the form mem memtype

• "global" if type is of the form global globaltype

The

method, when invoked, performs the following steps:

1. Let bytes be moduleObject.[[Bytes]].

2. Let customSections be « ».

3. For each custom section customSection of bytes, interpreted according to the module grammar,

   1. Let name be the name of customSection, decoded as UTF-8.

   2. Assert: name is not failure (moduleObject.[[Module]] is valid).

   3. If name equals sectionName as string values,

      1. Append a new ArrayBuffer containing a copy of the bytes in bytes for the range matched by this customsec production to customSections.

4. Return customSections.

The

constructor, when invoked, performs the following steps:

1. Let stableBytes be a copy of the bytes held by the buffer bytes.

2. Compile the WebAssembly module stableBytes and store the result as module.

3. If module is error, throw a CompileError exception.

4. Set this.[[Module]] to module.

5. Set this.[[Bytes]] to stableBytes.

Note: Some implementations enforce a size limitation on bytes. Use of this API is discouraged, in favor of asynchronous APIs.

[LegacyNamespace=WebAssembly, Exposed=*]
interface Instance {
  constructor(Module module, optional object importObject);
  readonly attribute object exports;
};

The

constructor, when invoked, runs the following steps:

1. Let module be module.[[Module]].

2. Read the imports of module with imports importObject, and let imports be the result.

3. Instantiate the core of a WebAssembly module module with imports, and let instance be the result.

4. Initialize this from module and instance.

Note: The use of this synchronous API is discouraged, as some implementations sometimes do long-running compilation work when instantiating.

The getter of the

attribute of

returns

.[[Exports]].

dictionary MemoryDescriptor {
  required [EnforceRange] unsigned long initial;
  [EnforceRange] unsigned long maximum;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Memory {
  constructor(MemoryDescriptor descriptor);
  unsigned long grow([EnforceRange] unsigned long delta);
  ArrayBuffer toFixedLengthBuffer();
  ArrayBuffer toResizableBuffer();
  readonly attribute ArrayBuffer buffer;
};

A Memory object represents a single memory instance which can be simultaneously referenced by multiple Instance objects. Each Memory object has the following internal slots:

• [[Memory]] : a memory address

• [[BufferObject]] : an ArrayBuffer whose Data Block is identified with the above memory address

To

from a

, perform the following steps:

1. Let block be a Data Block which is identified with the underlying memory of memaddr.

2. Let buffer be a new ArrayBuffer with the internal slots [[ArrayBufferData]], [[ArrayBufferByteLength]], and [[ArrayBufferDetachKey]].

3. Set buffer.[[ArrayBufferData]] to block.

4. Set buffer.[[ArrayBufferByteLength]] to the length of block.

5. Set buffer.[[ArrayBufferDetachKey]] to "WebAssembly.Memory".

6. Return buffer.

To

from a

and a

, perform the following steps:

1. Let block be a Data Block which is identified with the underlying memory of memaddr.

2. Let length be the length of block.

3. If maxsize > (65536 × 65536),

   1. Throw a RangeError exception.

4. Let buffer be a new ArrayBuffer with the internal slots [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferMaxByteLength]], and [[ArrayBufferDetachKey]].

5. Set buffer.[[ArrayBufferData]] to block.

6. Set buffer.[[ArrayBufferByteLength]] to length.

7. Set buffer.[[ArrayBufferMaxByteLength]] is maxsize.

8. Set buffer.[[ArrayBufferDetachKey]] to "WebAssembly.Memory".

9. Return buffer.

The

method, when invoked, performs the following steps:

1. Let memaddr be this.[[Memory]].

2. Return the result of growing the memory buffer associated with memaddr by delta.

Immediately after a WebAssembly memory.grow instruction executes, perform the following steps:

The

method, when invoked, performs the following steps:

1. Let buffer be this.[[BufferObject]].

2. If IsFixedLengthArrayBuffer(buffer) is true, return buffer.

3. Let memaddr be this.[[Memory]].

4. Let fixedBuffer be the result of creating a fixed length memory buffer from memaddr.

5. Perform ! DetachArrayBuffer(buffer, "WebAssembly.Memory").

6. Set this.[[BufferObject]] to fixedBuffer.

7. Return fixedBuffer.

The

method, when invoked, performs the following steps:

1. Let buffer be this.[[BufferObject]].

2. If IsFixedLengthArrayBuffer(buffer) is false, return buffer.

3. Let memaddr be this.[[Memory]].

4. Let store be the surrounding agent’s associated store.

5. Let memtype be mem_type(store, memaddr).

6. If memtype has a max,

   1. Let maxsize be the max value in memtype.

7. Otherwise,

   1. Let maxsize be 65536 × 65536.

8. Let resizableBuffer be the result of creating a resizable memory buffer from memaddr and maxsize.

9. Perform ! DetachArrayBuffer(buffer, "WebAssembly.Memory").

10. Set this.[[BufferObject]] to resizableBuffer.

11. Return resizableBuffer.

ArrayBuffer objects returned by a Memory object must have a size that is a multiple of a WebAssembly page size (the constant 65536). For this reason HostResizeArrayBuffer is redefined as follows.

The abstract operation HostResizeArrayBuffer takes arguments buffer (an ArrayBuffer) and newLength. It performs the following steps when called.

1. If buffer.[[ArrayBufferDetachKey]] is "WebAssembly.Memory",

   1. Let map be the surrounding agent’s associated Memory object cache.

   2. Assert: buffer is the [[BufferObject]] of exactly one value in map.

   3. For each memaddr → mem in map,

      1. If SameValue(mem.[[BufferObject]], buffer) is true,

         1. Assert: buffer.[[ArrayBufferByteLength]] modulo 65536 is 0.

         2. Let lengthDelta be newLength - buffer.[[ArrayBufferByteLength]].

         3. If lengthDelta < 0 or lengthDelta modulo 65536 is not 0,

            1. Throw a RangeError exception.

         4. Let delta be lengthDelta ÷ 65536.

         5. Grow the memory buffer associated with memaddr by delta.

   4. Return handled .

2. Otherwise, return unhandled .

The getter of the

attribute of

returns

.[[BufferObject]].

enum TableKind {
  "externref",
  "anyfunc",
  // Note: More values may be added in future iterations,
  // e.g., typed function references, typed GC references
};

dictionary TableDescriptor {
  required TableKind element;
  required [EnforceRange] unsigned long initial;
  [EnforceRange] unsigned long maximum;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Table {
  constructor(TableDescriptor descriptor, optional any value);
  unsigned long grow([EnforceRange] unsigned long delta, optional any value);
  any get([EnforceRange] unsigned long index);
  undefined set([EnforceRange] unsigned long index, optional any value);
  readonly attribute unsigned long length;
};

A Table object represents a single table instance which can be simultaneously referenced by multiple Instance objects. Each Table object has a [[Table]] internal slot, which is a table address.

The

constructor, when invoked, performs the following steps:

1. Let elementType be ToValueType(descriptor["element"]).

2. If elementType is not a reftype,

   1. Throw a TypeError exception.

3. Let initial be descriptor["initial"].

4. If descriptor["maximum"] exists, let maximum be descriptor["maximum"]; otherwise, let maximum be empty.

5. Let type be the table type { min initial, max maximum } elementType.

6. If type is not valid, throw a RangeError exception.

   Note: Because tables may have up to 2³² - 1 elements in validation, the checks for min ≤ 2³² - 1 and max ≤ 2³² - 1 in limits validation cannot fail.

7. If value is missing,

   1. Let ref be DefaultValue(elementType).

8. Otherwise,

   1. Let ref be ? ToWebAssemblyValue(value, elementType).

9. Let store be the surrounding agent’s associated store.

10. Let (store, tableaddr) be table_alloc(store, type, ref). If allocation fails, throw a RangeError exception.

11. Set the surrounding agent’s associated store to store.

12. Initialize this from tableaddr.

The

method, when invoked, performs the following steps:

1. Let tableaddr be this.[[Table]].

2. Let store be the surrounding agent’s associated store.

3. Let initialSize be table_size(store, tableaddr).

4. Let (limits, elementType) be table_type(tableaddr).

5. If value is missing,

   1. Let ref be DefaultValue(elementType).

6. Otherwise,

   1. Let ref be ? ToWebAssemblyValue(value, elementType).

7. Let result be table_grow(store, tableaddr, delta, ref).

8. If result is error, throw a RangeError exception.

   Note: The above exception can happen due to either insufficient memory or an invalid size parameter.

9. Set the surrounding agent’s associated store to result.

10. Return initialSize.

The

method, when invoked, performs the following steps:

1. Let tableaddr be this.[[Table]].

2. Let (limits, elementType) be table_type(tableaddr).

3. If value is missing,

   1. Let ref be DefaultValue(elementType).

4. Otherwise,

   1. Let ref be ? ToWebAssemblyValue(value, elementType).

5. Let store be the surrounding agent’s associated store.

6. Let store be table_write(store, tableaddr, index, ref).

7. If store is error, throw a RangeError exception.

8. Set the surrounding agent’s associated store to store.

enum ValueType {
  "i32",
  "i64",
  "f32",
  "f64",
  "v128",
  "externref",
  "anyfunc",
};

Note: this type may be extended with additional cases in future versions of WebAssembly.

dictionary GlobalDescriptor {
  required ValueType value;
  boolean mutable = false;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Global {
  constructor(GlobalDescriptor descriptor, optional any v);
  any valueOf();
  attribute any value;
};

A Global object represents a single global instance which can be simultaneously referenced by multiple Instance objects. Each Global object has one internal slot:

• [[Global]] : a global address

The algorithm

(

) performs the following steps:

1. If s equals "i32", return i32.

2. If s equals "i64", return i64.

3. If s equals "f32", return f32.

4. If s equals "f64", return f64.

5. If s equals "v128", return v128.

6. If s equals "anyfunc", return funcref.

7. If s equals "externref", return externref.

8. Assert: This step is not reached.

The

constructor, when invoked, performs the following steps:

1. Let mutable be descriptor["mutable"].

2. Let valuetype be ToValueType(descriptor["value"]).

3. If valuetype is v128,

   1. Throw a TypeError exception.

4. If v is missing,

   1. Let value be DefaultValue(valuetype).

5. Otherwise,

   1. Let value be ToWebAssemblyValue(v, valuetype).

6. If mutable is true, let globaltype be var valuetype; otherwise, let globaltype be const valuetype.

7. Let store be the current agent’s associated store.

8. Let (store, globaladdr) be global_alloc(store, globaltype, value).

9. Set the current agent’s associated store to store.

10. Initialize this from globaladdr.

The algorithm

(

) performs the following steps:

1. Let store be the current agent’s associated store.

2. Let globaladdr be global.[[Global]].

3. Let globaltype be global_type(store, globaladdr).

4. If globaltype is of the form mut v128, throw a TypeError.

5. Let value be global_read(store, globaladdr).

6. Return ToJSValue(value).

The getter of the

attribute of

, when invoked, performs the following steps:

1. Return GetGlobalValue(this).

The setter of the value attribute of Global, when invoked, performs the following steps:

1. Let store be the current agent’s associated store.

2. Let globaladdr be this.[[Global]].

3. Let mut valuetype be global_type(store, globaladdr).

4. If valuetype is v128, throw a TypeError.

5. If mut is const, throw a TypeError.

6. Let value be ToWebAssemblyValue(the given value, valuetype).

7. Let store be global_write(store, globaladdr, value).

8. If store is error, throw a RangeError exception.

9. Set the current agent’s associated store to store.

The

method, when invoked, performs the following steps:

1. Return GetGlobalValue(this).

A WebAssembly function is made available in JavaScript as an Exported Function. Exported Functions are Built-in Function Objects which are not constructors, and which have a [[FunctionAddress]] internal slot. This slot holds a function address relative to the surrounding agent’s associated store.

The

is found by performing the following steps:

1. Let store be the surrounding agent’s associated store.

2. Let funcinst be store.funcs[funcaddr].

3. If funcinst is of the form {type functype, hostcode hostfunc},

   1. Assert: hostfunc is a JavaScript object and IsCallable(hostfunc) is true.

   2. Let index be the index of the host function funcaddr.

4. Otherwise,

   1. Let moduleinst be funcinst.module.

   2. Assert: funcaddr is contained in moduleinst.funcaddrs.

   3. Let index be the index of moduleinst.funcaddrs where funcaddr is found.

5. Return ! ToString(index).

To

with

and a

of JavaScript arguments

, perform the following steps:

1. Let store be the surrounding agent’s associated store.

2. Let functype be func_type(store, funcaddr).

3. Let [parameters] → [results] be functype.

4. If parameters or results contain v128, throw a TypeError.

   Note: the above error is thrown each time the [[Call]] method is invoked.

5. Let args be « ».

6. Let i be 0.

7. For each t of parameters,

   1. If argValues’s size > i, let arg be argValues[i].

   2. Otherwise, let arg be undefined.

   3. Append ToWebAssemblyValue(arg, t) to args.

   4. Set i to i + 1.

8. Let (store, ret) be the result of func_invoke(store, funcaddr, args).

9. Set the surrounding agent’s associated store to store.

10. If ret is error, throw an exception. This exception should be a WebAssembly RuntimeError exception, unless otherwise indicated by the WebAssembly error mapping.

11. Let outArity be the size of ret.

12. If outArity is 0, return undefined.

13. Otherwise, if outArity is 1, return ToJSValue(ret[0]).

14. Otherwise,

    1. Let values be « ».

    2. For each r of ret,

       1. Append ToJSValue(r) to values.

    3. Return CreateArrayFromList(values).

Note: Calling an Exported Function executes in the [[Realm]] of the callee Exported Function, as per the definition of built-in function objects.

Note: Exported Functions do not have a [[Construct]] method and thus it is not possible to call one with the new operator.

To

from the JavaScript object

, type

, and

of

, perform the following steps:

1. Let [parameters] → [results] be functype.

2. If parameters or results contain v128, throw a TypeError.

3. Let jsArguments be « ».

4. For each arg of arguments,

   1. Append ! ToJSValue(arg) to jsArguments.

5. Let ret be ? Call(func, undefined, jsArguments).

6. Let resultsSize be results’s size.

7. If resultsSize is 0, return « ».

8. Otherwise, if resultsSize is 1, return « ? ToWebAssemblyValue(ret, results[0]) ».

9. Otherwise,

   1. Let method be ? GetMethod(ret, %Symbol.iterator%).

   2. If method is undefined, throw a TypeError.

   3. Let values be ? IteratorToList(? GetIteratorFromMethod(ret, method)).

   4. Let wasmValues be a new, empty list.

   5. If values’s size is not resultsSize, throw a TypeError exception.

   6. For each value and resultType in values and results, paired linearly,

      1. Append ToWebAssemblyValue(value, resultType) to wasmValues.

   7. Return wasmValues.

The algorithm

(

) coerces a

to a JavaScript value by performing the following steps:

1. Assert: w is not of the form v128.const v128.

2. If w is of the form i64.const i64,

   1. Let v be signed_64(i64).

   2. Return ℤ(v interpreted as a mathematical value).

3. If w is of the form i32.const i32, return 𝔽(signed_32(i32 interpreted as a mathematical value)).

4. If w is of the form f32.const f32,

   1. If f32 is +∞ or −∞, return +∞_𝔽 or -∞_𝔽, respectively.

   2. If f32 is nan, return NaN.

   3. Return 𝔽(f32 interpreted as a mathematical value).

5. If w is of the form f64.const f64,

   1. If f64 is +∞ or −∞, return +∞_𝔽 or -∞_𝔽, respectively.

   2. If f64 is nan, return NaN.

   3. Return 𝔽(f64 interpreted as a mathematical value).

6. If w is of the form ref.null t, return null.

7. If w is of the form ref.func funcaddr, return the result of creating a new Exported Function from funcaddr.

8. If w is of the form ref.extern externaddr, return the result of retrieving an extern value from externaddr.

Note: Number values which are equal to NaN may have various observable NaN payloads; see NumericToRawBytes for details.

The algorithm

(

,

) coerces a JavaScript value to a

by performing the following steps:

1. Assert: type is not v128.

2. If type is i64,

   1. Let i64 be ? ToBigInt64(v).

   2. Return i64.const i64.

3. If type is i32,

   1. Let i32 be ? ToInt32(v).

   2. Return i32.const i32.

4. If type is f32,

   1. Let number be ? ToNumber(v).

   2. If number is NaN,

      1. Let n be an implementation-defined integer such that canon₃₂ ≤ n < 2^signif(32).

      2. Let f32 be nan(n).

   3. Otherwise,

      1. Let f32 be number rounded to the nearest representable value using IEEE 754-2019 round to nearest, ties to even mode. [IEEE-754]

   4. Return f32.const f32.

5. If type is f64,

   1. Let number be ? ToNumber(v).

   2. If number is NaN,

      1. Let n be an implementation-defined integer such that canon₆₄ ≤ n < 2^signif(64).

      2. Let f64 be nan(n).

   3. Otherwise,

      1. Let f64 be number.

   4. Return f64.const f64.

6. If type is funcref,

   1. If v is null,

      1. Return ref.null funcref.

   2. If v is an Exported Function,

      1. Let funcaddr be the value of v’s [[FunctionAddress]] internal slot.

      2. Return ref.func funcaddr.

   3. Throw a TypeError.

7. If type is externref,

   1. If v is null,

      1. Return ref.null externref.

   2. Let map be the surrounding agent’s associated extern value cache.

   3. If a extern address externaddr exists such that map[externaddr] is the same as v,

      1. Return ref.extern externaddr.

   4. Let extern address externaddr be the smallest address such that map[externaddr] exists is false.

   5. Set map[externaddr] to v.

   6. Return ref.extern externaddr.

8. Assert: This step is not reached.

WebAssembly defines the following Error classes: CompileError, LinkError, and RuntimeError.

Note: This defines CompileError, LinkError, and RuntimeError classes on the WebAssembly namespace, which are produced by the APIs defined in this specification. They expose the same interface as native JavaScript errors like TypeError and RangeError.

Note: It is not currently possible to define this behavior using Web IDL.

Running WebAssembly programs encounter certain events which halt execution of the WebAssembly code. WebAssembly code (currently) has no way to catch these conditions and thus an exception will necessarily propagate to the enclosing non-WebAssembly caller (whether it is a browser, JavaScript or another runtime system) where it is handled like a normal JavaScript exception.

If WebAssembly calls JavaScript via import and the JavaScript throws an exception, the exception is propagated through the WebAssembly activation to the enclosing caller.

Because JavaScript exceptions can be handled, and JavaScript can continue to call WebAssembly exports after a trap has been handled, traps do not, in general, prevent future execution.

Whenever a stack overflow occurs in WebAssembly code, the same class of exception is thrown as for a stack overflow in JavaScript. The particular exception here is implementation-defined in both cases.

Note: ECMAScript doesn’t specify any sort of behavior on stack overflow; implementations have been observed to throw RangeError, InternalError or Error. Any is valid here.

Whenever validation, compilation or instantiation run out of memory, the same class of exception is thrown as for out of memory conditions in JavaScript. The particular exception here is implementation-defined in both cases.

Note: ECMAScript doesn’t specify any sort of behavior on out-of-memory conditions; implementations have been observed to throw OOMError and to crash. Either is valid here.

A failed allocation of a large table or memory may either result in

• a RangeError, as specified in the Memory grow() and Table grow() operations

• returning -1 as the memory.grow instruction

• UA-specific OOM behavior as described in this section.

In a future revision, we may reconsider more reliable and recoverable errors for allocations of large amounts of memory.

See Issue 879 for further discussion.

The WebAssembly core specification allows an implementation to define limits on the syntactic structure of the module. While each embedding of WebAssembly may choose to define its own limits, for predictability the standard WebAssembly JavaScript Interface described in this document defines the following exact limits. An implementation must reject a module that exceeds one of the following limits with a CompileError: In practice, an implementation may run out of resources for valid modules below these limits.

• The maximum size of a module is 1,073,741,824 bytes (1 GiB).
• The maximum number of types defined in the types section is 1,000,000.
• The maximum number of functions defined in a module is 1,000,000.
• The maximum number of imports declared in a module is 100,000.
• The maximum number of exports declared in a module is 100,000.
• The maximum number of globals defined in a module is 1,000,000.
• The maximum number of data segments defined in a module is 100,000.
• The maximum number of tables, including declared or imported tables, is 100,000.
• The maximum size of a table is 10,000,000.
• The maximum number of table entries in any table initialization is 10,000,000.
• The maximum number of memories, including declared or imported memories, is 1.
• The maximum number of parameters to any function or block is 1,000.
• The maximum number of return values for any function or block is 1,000.
• The maximum size of a function body, including locals declarations, is 7,654,321 bytes.
• The maximum number of locals declared in a function, including implicitly declared as parameters, is 50,000.

An implementation must throw a RuntimeError if one of the following limits is exceeded during runtime: In practice, an implementation may run out of resources for valid modules below these limits.

• The maximum size of a table is 10,000,000.
• The maximum number of pages of a memory is 65,536.

This section is non-normative.

This document defines a host environment for WebAssembly. It enables a WebAssembly instance to import JavaScript objects and functions from an import object, but otherwise provides no access to the embedding environment. Thus a WebAssembly instance is bound to the same constraints as JavaScript.

This section is non-normative.

Since the original release 1.0 of the WebAssembly specification, a number of proposals for extensions have been integrated. The following sections provide an overview of what has changed.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.3