[wasm] Initial emscripten 3.1.30 support

src/mono/CMakeLists.txt

@@ -233,6 +233,7 @@ elseif(CLR_CMAKE_HOST_OS STREQUAL "emscripten")
   add_definitions(-D_THREAD_SAFE)
   add_compile_options(-Wno-strict-prototypes)
   add_compile_options(-Wno-unused-but-set-variable)
+  add_compile_options(-Wno-single-bit-bitfield-constant-conversion)
   set(DISABLE_EXECUTABLES 1)
   # FIXME: Is there a cmake option for this ?
   set(DISABLE_SHARED_LIBS 1)

src/mono/wasm/emscripten-version.txt

@@ -1 +1 @@
-3.1.12
+3.1.30

src/mono/wasm/runtime/assets.ts

@@ -121,17 +121,17 @@ export async function mono_download_assets(): Promise<void> {
         // and we are not awating it here
         Promise.all(promises_of_asset_instantiation).then(() => {
             allAssetsInMemory.promise_control.resolve();
-        }).catch(err => {
-            Module.printErr("MONO_WASM: Error in mono_download_assets: " + err);
-            abort_startup(err, true);
+        }).catch(e => {
+            Module.err("MONO_WASM: Error in mono_download_assets: " + e);
+            abort_startup(e, true);
         });
         // OPTIMIZATION explained:
         // we do it this way so that we could allocate memory immediately after asset is downloaded (and after onRuntimeInitialized which happened already)
         // spreading in time
         // rather than to block all downloads after onRuntimeInitialized or block onRuntimeInitialized after all downloads are done. That would create allocation burst.
-    } catch (err: any) {
-        Module.printErr("MONO_WASM: Error in mono_download_assets: " + err);
-        throw err;
+    } catch (e: any) {
+        Module.err("MONO_WASM: Error in mono_download_assets: " + e);
+        throw e;
     }
 }
 
@@ -283,7 +283,7 @@ async function start_asset_download_sources(asset: AssetEntryInternal): Promise<
         err.status = response.status;
         throw err;
     } else {
-        Module.print(`MONO_WASM: optional download '${response.url}' for ${asset.name} failed ${response.status} ${response.statusText}`);
+        Module.out(`MONO_WASM: optional download '${response.url}' for ${asset.name} failed ${response.status} ${response.statusText}`);
         return undefined;
     }
 }
@@ -425,7 +425,7 @@ function _instantiate_asset(asset: AssetEntry, url: string, bytes: Uint8Array) {
     }
     else if (asset.behavior === "icu") {
         if (!mono_wasm_load_icu_data(offset!))
-            Module.printErr(`MONO_WASM: Error loading ICU asset ${asset.name}`);
+            Module.err(`MONO_WASM: Error loading ICU asset ${asset.name}`);
     }
     else if (asset.behavior === "resource") {
         cwraps.mono_wasm_add_satellite_assembly(virtualName, asset.culture || "", offset!, bytes.length);

src/mono/wasm/runtime/dotnet.d.ts

@@ -45,8 +45,8 @@ declare interface EmscriptenModule {
     HEAPF64: Float64Array;
     _malloc(size: number): VoidPtr;
     _free(ptr: VoidPtr): void;
-    print(message: string): void;
-    printErr(message: string): void;
+    out(message: string): void;
+    err(message: string): void;
     ccall<T>(ident: string, returnType?: string | null, argTypes?: string[], args?: any[], opts?: any): T;
     cwrap<T extends Function>(ident: string, returnType: string, argTypes?: string[], opts?: any): T;
     cwrap<T extends Function>(ident: string, ...args: any[]): T;

src/mono/wasm/runtime/es6/dotnet.es6.lib.js

@@ -28,15 +28,15 @@ if (${usePThreads}) {
     __dotnet_replacement_PThread.threadInitTLS = PThread.threadInitTLS;
     __dotnet_replacement_PThread.allocateUnusedWorker = PThread.allocateUnusedWorker;
 }
-let __dotnet_replacements = {scriptUrl: import.meta.url, fetch: globalThis.fetch, require, updateGlobalBufferAndViews, pthreadReplacements: __dotnet_replacement_PThread};
+let __dotnet_replacements = {scriptUrl: import.meta.url, fetch: globalThis.fetch, require, updateMemoryViews, pthreadReplacements: __dotnet_replacement_PThread};
 if (ENVIRONMENT_IS_NODE) {
     __dotnet_replacements.requirePromise = import(/* webpackIgnore: true */'module').then(mod => mod.createRequire(import.meta.url));
 }
 let __dotnet_exportedAPI = __dotnet_runtime.__initializeImportsAndExports(
     { isGlobal:false, isNode:ENVIRONMENT_IS_NODE, isWorker:ENVIRONMENT_IS_WORKER, isShell:ENVIRONMENT_IS_SHELL, isWeb:ENVIRONMENT_IS_WEB, isPThread:${isPThread}, quit_, ExitStatus, requirePromise:__dotnet_replacements.requirePromise },
     { mono:MONO, binding:BINDING, internal:INTERNAL, module:Module, marshaled_imports: IMPORTS },
     __dotnet_replacements, __callbackAPI);
-updateGlobalBufferAndViews = __dotnet_replacements.updateGlobalBufferAndViews;
+    updateMemoryViews = __dotnet_replacements.updateMemoryViews;
 var fetch = __dotnet_replacements.fetch;
 _scriptDir = __dirname = scriptDirectory = __dotnet_replacements.scriptDirectory;
 if (ENVIRONMENT_IS_NODE) {

src/mono/wasm/runtime/exports-internal.ts

@@ -18,7 +18,7 @@ import { getOptions, applyOptions } from "./jiterpreter-support";
 export function export_internal(): any {
     return {
         // tests
-        mono_wasm_exit: (exit_code: number) => { Module.printErr("MONO_WASM: early exit " + exit_code); },
+        mono_wasm_exit: (exit_code: number) => { Module.err("MONO_WASM: early exit " + exit_code); },
         mono_wasm_enable_on_demand_gc: cwraps.mono_wasm_enable_on_demand_gc,
         mono_wasm_profiler_init_aot: cwraps.mono_wasm_profiler_init_aot,
         mono_wasm_profiler_init_browser: cwraps.mono_wasm_profiler_init_browser,

src/mono/wasm/runtime/exports.ts

@@ -68,11 +68,11 @@ function initializeImportsAndExports(
         module.configSrc = "./mono-config.json";
     }
 
-    if (!module.print) {
-        module.print = console.log.bind(console);
+    if (!module.out) {
+        module.out = console.log.bind(console);
     }
-    if (!module.printErr) {
-        module.printErr = console.error.bind(console);
+    if (!module.err) {
+        module.err = console.error.bind(console);
     }
 
     if (typeof module.disableDotnet6Compatibility === "undefined") {

src/mono/wasm/runtime/http.ts

@@ -24,7 +24,7 @@ export function http_wasm_abort_response(res: ResponseExtension): void {
     if (res.__reader) {
         res.__reader.cancel().catch((err) => {
             if (err && err.name !== "AbortError") {
-                Module.printErr("MONO_WASM: Error in http_wasm_abort_response: " + err);
+                Module.err("MONO_WASM: Error in http_wasm_abort_response: " + err);
             }
             // otherwise, it's expected
         });

src/mono/wasm/runtime/icu.ts

@@ -48,7 +48,7 @@ export function mono_wasm_globalization_init(): void {
             invariantMode = true;
         } else {
             const msg = "invariant globalization mode is inactive and no ICU data archives were loaded";
-            Module.printErr(`MONO_WASM: ERROR: ${msg}`);
+            Module.err(`MONO_WASM: ERROR: ${msg}`);
             throw new Error(msg);
         }
     }

src/mono/wasm/runtime/invoke-cs.ts

@@ -91,7 +91,7 @@ export function mono_wasm_bind_cs_function(fully_qualified_name: MonoStringRef,
         wrap_no_error_root(is_exception, resultRoot);
     }
     catch (ex: any) {
-        Module.printErr(ex.toString());
+        Module.err(ex.toString());
         wrap_error_root(is_exception, ex, resultRoot);
     } finally {
         resultRoot.release();

src/mono/wasm/runtime/invoke-js.ts

@@ -90,7 +90,7 @@ export function mono_wasm_bind_js_function(function_name: MonoStringRef, module_
         endMeasure(mark, MeasuredBlock.bindJsFunction, js_function_name);
     } catch (ex: any) {
         setI32_unchecked(function_js_handle, 0);
-        Module.printErr(ex.toString());
+        Module.err(ex.toString());
         wrap_error_root(is_exception, ex, resultRoot);
     } finally {
         resultRoot.release();

src/mono/wasm/runtime/memory.ts

@@ -11,7 +11,6 @@ import cwraps, { I52Error } from "./cwraps";
 const alloca_stack: Array<VoidPtr> = [];
 const alloca_buffer_size = 32 * 1024;
 let alloca_base: VoidPtr, alloca_offset: VoidPtr, alloca_limit: VoidPtr;
-let HEAPI64: BigInt64Array = <any>null;
 
 function _ensure_allocated(): void {
     if (alloca_base)
@@ -140,7 +139,7 @@ export function setI64Big(offset: MemOffset, value: bigint): void {
     mono_assert(typeof value === "bigint", () => `Value is not an bigint: ${value} (${typeof (value)})`);
     mono_assert(value >= min_int64_big && value <= max_int64_big, () => `Overflow: value ${value} is out of ${min_int64_big} ${max_int64_big} range`);
 
-    HEAPI64[<any>offset >>> 3] = value;
+    Module.HEAP64[<any>offset >>> 3] = value;
 }
 
 export function setF32(offset: MemOffset, value: number): void {
@@ -204,7 +203,7 @@ export function getU52(offset: MemOffset): number {
 
 export function getI64Big(offset: MemOffset): bigint {
     mono_assert(is_bigint_supported, "BigInt is not supported.");
-    return HEAPI64[<any>offset >>> 3];
+    return Module.HEAP64[<any>offset >>> 3];
 }
 
 export function getF32(offset: MemOffset): number {
@@ -217,11 +216,11 @@ export function getF64(offset: MemOffset): number {
 
 let max_int64_big: BigInt;
 let min_int64_big: BigInt;
-export function afterUpdateGlobalBufferAndViews(buffer: ArrayBufferLike): void {
+export function afterUpdateMemoryViews(): void {
     if (is_bigint_supported) {
+        // TODO: why do we need to initialize these on memory change?
         max_int64_big = BigInt("9223372036854775807");
         min_int64_big = BigInt("-9223372036854775808");
-        HEAPI64 = new BigInt64Array(buffer);
     }
 }
 

src/mono/wasm/runtime/polyfills.ts

@@ -4,7 +4,7 @@
 import BuildConfiguration from "consts:configuration";
 import MonoWasmThreads from "consts:monoWasmThreads";
 import { ENVIRONMENT_IS_NODE, ENVIRONMENT_IS_SHELL, ENVIRONMENT_IS_WEB, ENVIRONMENT_IS_WORKER, INTERNAL, Module, runtimeHelpers } from "./imports";
-import { afterUpdateGlobalBufferAndViews } from "./memory";
+import { afterUpdateMemoryViews } from "./memory";
 import { replaceEmscriptenPThreadLibrary } from "./pthreads/shared/emscripten-replacements";
 import { DotnetModuleConfigImports, EarlyReplacements } from "./types";
 import { TypedArray } from "./types/emscripten";
@@ -181,10 +181,10 @@ export function init_polyfills(replacements: EarlyReplacements): void {
     }
 
     // memory
-    const originalUpdateGlobalBufferAndViews = replacements.updateGlobalBufferAndViews;
-    replacements.updateGlobalBufferAndViews = (buffer: ArrayBufferLike) => {
-        originalUpdateGlobalBufferAndViews(buffer);
-        afterUpdateGlobalBufferAndViews(buffer);
+    const originalUpdateMemoryViews = replacements.updateMemoryViews;
+    replacements.updateMemoryViews = () => {
+        originalUpdateMemoryViews();
+        afterUpdateMemoryViews();
     };
 }
 

src/mono/wasm/runtime/run.ts

@@ -111,11 +111,11 @@ function set_exit_code_and_quit_now(exit_code: number, reason?: any): void {
         if (reason && !(reason instanceof runtimeHelpers.ExitStatus)) {
             if (!runtimeHelpers.config.logExitCode) {
                 if (reason instanceof Error)
-                    Module.printErr(mono_wasm_stringify_as_error_with_stack(reason));
+                    Module.err(mono_wasm_stringify_as_error_with_stack(reason));
                 else if (typeof reason == "string")
-                    Module.printErr(reason);
+                    Module.err(reason);
                 else
-                    Module.printErr(JSON.stringify(reason));
+                    Module.err(JSON.stringify(reason));
             }
         }
         else {

src/mono/wasm/runtime/startup.ts

@@ -100,7 +100,7 @@ function instantiateWasm(
     // this is called so early that even Module exports like addRunDependency don't exist yet
 
     if (!Module.configSrc && !Module.config && !userInstantiateWasm) {
-        Module.print("MONO_WASM: configSrc nor config was specified");
+        Module.out("MONO_WASM: configSrc nor config was specified");
     }
     if (Module.config) {
         config = runtimeHelpers.config = Module.config as MonoConfig;
@@ -389,10 +389,10 @@ async function mono_wasm_after_user_runtime_initialized(): Promise<void> {
 
 
 function _print_error(message: string, err: any): void {
-    Module.printErr(`${message}: ${JSON.stringify(err)}`);
+    Module.err(`${message}: ${JSON.stringify(err)}`);
     if (err.stack) {
-        Module.printErr("MONO_WASM: Stacktrace: \n");
-        Module.printErr(err.stack);
+        Module.err("MONO_WASM: Stacktrace: \n");
+        Module.err(err.stack);
     }
 }
 

src/mono/wasm/runtime/types.ts

@@ -361,7 +361,7 @@ export type EarlyReplacements = {
     require: any,
     requirePromise: Promise<Function>,
     noExitRuntime: boolean,
-    updateGlobalBufferAndViews: Function,
+    updateMemoryViews: Function,
     pthreadReplacements: PThreadReplacements | undefined | null
     scriptDirectory: string;
     scriptUrl: string

src/mono/wasm/runtime/types/emscripten.ts

@@ -26,6 +26,7 @@ export declare interface EmscriptenModule {
     HEAP8: Int8Array,
     HEAP16: Int16Array;
     HEAP32: Int32Array;
+    HEAP64: BigInt64Array;
     HEAPU8: Uint8Array;
     HEAPU16: Uint16Array;
     HEAPU32: Uint32Array;
@@ -37,8 +38,8 @@ export declare interface EmscriptenModule {
     _free(ptr: VoidPtr): void;
 
     // this should match emcc -s EXPORTED_RUNTIME_METHODS
-    print(message: string): void;
-    printErr(message: string): void;
+    out(message: string): void;
+    err(message: string): void;
     ccall<T>(ident: string, returnType?: string | null, argTypes?: string[], args?: any[], opts?: any): T;
     cwrap<T extends Function>(ident: string, returnType: string, argTypes?: string[], opts?: any): T;
     cwrap<T extends Function>(ident: string, ...args: any[]): T;

src/mono/wasm/wasm.proj

@@ -117,7 +117,8 @@
 
     <ItemGroup>
       <EmccExportedRuntimeMethod Include="FS" />
-      <EmccExportedRuntimeMethod Include="print" />
+      <EmccExportedRuntimeMethod Include="out" />
+      <EmccExportedRuntimeMethod Include="err" />
       <EmccExportedRuntimeMethod Include="ccall" />
       <EmccExportedRuntimeMethod Include="cwrap" />
       <EmccExportedRuntimeMethod Include="setValue" />

src/native/libs/CMakeLists.txt

@@ -156,6 +156,8 @@ if (CLR_CMAKE_TARGET_UNIX OR CLR_CMAKE_TARGET_BROWSER OR CLR_CMAKE_TARGET_WASI)
         add_compile_options(-Wno-typedef-redefinition)
         add_compile_options(-Wno-c11-extensions)
         add_compile_options(-Wno-thread-safety-analysis)
+        add_compile_options(-Wno-unsafe-buffer-usage)
+        add_compile_options(-Wno-cast-function-type-strict)
     endif ()
 
     add_subdirectory(System.Native)