chore: Remove wasm64 feature flag (#6354)

The wasm64 feature has been enabled for a long time and all tests etc
already expect it to be enabled. Removing the flag as it's not needed
anymore.

The bulk of changes are in tests/fuzzers to remove enabling the flag in
the config.

Author: dsarlis

rs/config/src/embedders.rs

@@ -124,8 +124,6 @@ pub struct FeatureFlags {
     /// If this flag is enabled, then the output of the `debug_print` system-api
     /// call will be skipped based on heuristics.
     pub rate_limiting_of_debug_prints: FlagStatus,
-    /// Indicates whether the support for 64 bit main memory is enabled
-    pub wasm64: FlagStatus,
     /// Collect a backtrace from the canister when it panics.
     pub canister_backtrace: FlagStatus,
     /// If this flag is enabled, then the environment variables are supported.
@@ -136,7 +134,6 @@ impl FeatureFlags {
     const fn const_default() -> Self {
         Self {
             rate_limiting_of_debug_prints: FlagStatus::Enabled,
-            wasm64: FlagStatus::Enabled,
             canister_backtrace: FlagStatus::Enabled,
             environment_variables: FlagStatus::Disabled,
         }

rs/drun/src/main.rs

@@ -61,8 +61,7 @@ async fn drun_main() -> Result<(), String> {
         hypervisor_config.rate_limiting_of_heap_delta = FlagStatus::Disabled;
         hypervisor_config.rate_limiting_of_instructions = FlagStatus::Disabled;
         // For testing enhanced orthogonal persistence in Motoko,
-        // enable Wasm Memory64 and re-configure the main memory capacity.
-        hypervisor_config.embedders_config.feature_flags.wasm64 = FlagStatus::Enabled;
+        // re-configure the main memory capacity.
         hypervisor_config.embedders_config.max_wasm64_memory_size = MAIN_MEMORY_CAPACITY;
         // Disable trap backtrace in `drun` to have less implementation-specific test outputs.
         hypervisor_config

rs/embedders/benches/embedders_bench/src/lib.rs

@@ -56,7 +56,6 @@ fn initialize_execution_test(
         .with_slice_instruction_limit(LARGE_INSTRUCTION_LIMIT);
 
     if is_wasm64 {
-        test = test.with_wasm64();
         // Set memory size to 8 GiB for Wasm64.
         test = test.with_max_wasm64_memory_size(NumBytes::from(8 * 1024 * 1024 * 1024));
     }

rs/embedders/fuzz/src/compile.rs

@@ -1,5 +1,6 @@
-use crate::ic_wasm::{generate_exports, ic_embedders_config, ic_wasm_config};
+use crate::ic_wasm::{generate_exports, ic_wasm_config};
 use arbitrary::{Arbitrary, Result, Unstructured};
+use ic_config::embedders::Config as EmbeddersConfig;
 use ic_embedders::{wasm_utils::compile, WasmtimeEmbedder};
 use ic_logger::replica_logger::no_op_logger;
 use ic_wasm_types::BinaryEncodedWasm;
@@ -10,17 +11,15 @@ use wasm_smith::{Config, MemoryOffsetChoices, Module};
 #[derive(Debug)]
 pub struct MaybeInvalidModule {
     pub module: Module,
-    pub memory64_enabled: bool,
 }
 
 const MAX_PARALLEL_EXECUTIONS: usize = 4;
 
 impl<'a> Arbitrary<'a> for MaybeInvalidModule {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         let mut config = if u.ratio(1, 2)? {
-            let memory64_enabled = u.ratio(2, 3)?;
-            let mut config = ic_wasm_config(ic_embedders_config(memory64_enabled));
-            config.exports = generate_exports(ic_embedders_config(memory64_enabled), u)?;
+            let mut config = ic_wasm_config(EmbeddersConfig::default());
+            config.exports = generate_exports(EmbeddersConfig::default(), u)?;
             config.min_data_segments = 2;
             config.max_data_segments = 10;
             config
@@ -31,7 +30,6 @@ impl<'a> Arbitrary<'a> for MaybeInvalidModule {
         config.memory_offset_choices = MemoryOffsetChoices(40, 20, 40);
         Ok(MaybeInvalidModule {
             module: Module::new(config.clone(), u)?,
-            memory64_enabled: config.memory64_enabled,
         })
     }
 }
@@ -46,24 +44,21 @@ pub fn run_fuzzer(bytes: &[u8]) {
     // 33% - Wasm with arbitrary wasm-smith config + maybe invalid functions
     // 33% - IC compliant wasm + maybe invalid functions
 
-    // Only used w/ random bytes
-    let memory64_enabled = u.ratio(1, 2).unwrap_or(false);
-
     let wasm = if u.ratio(1, 3).unwrap_or(false)
         || bytes.len() < <MaybeInvalidModule as Arbitrary>::size_hint(0).0
     {
-        config = ic_embedders_config(memory64_enabled);
+        config = EmbeddersConfig::default();
         raw_wasm_bytes(bytes)
     } else {
         let data = <MaybeInvalidModule as Arbitrary>::arbitrary_take_rest(u);
 
         match data {
             Ok(data) => {
-                config = ic_embedders_config(data.memory64_enabled);
+                config = EmbeddersConfig::default();
                 data.module.to_bytes()
             }
             Err(_) => {
-                config = ic_embedders_config(memory64_enabled);
+                config = EmbeddersConfig::default();
                 raw_wasm_bytes(bytes)
             }
         }

rs/embedders/fuzz/src/differential.rs

@@ -1,4 +1,5 @@
-use crate::ic_wasm::{ic_embedders_config, ICWasmModule};
+use crate::ic_wasm::ICWasmModule;
+use ic_config::embedders::Config as EmbeddersConfig;
 use ic_embedders::InstanceRunResult;
 use ic_interfaces::execution_environment::HypervisorResult;
 use ic_interfaces::execution_environment::SystemApi;
@@ -20,7 +21,6 @@ type DeterministicExecutionResult = Vec<(
 pub fn run_fuzzer(module: ICWasmModule) {
     let wasm = module.module.to_bytes();
     let wasm_methods: BTreeSet<WasmMethod> = module.exported_functions;
-    let memory64_enabled = module.config.memory64_enabled;
 
     if wasm_methods.is_empty() {
         return;
@@ -41,7 +41,7 @@ pub fn run_fuzzer(module: ICWasmModule) {
                 let wasm = wasm.clone();
                 let wasm_methods = wasm_methods.clone();
 
-                async move { execute_wasm(wasm, wasm_methods, memory64_enabled) }
+                async move { execute_wasm(wasm, wasm_methods) }
             })
         })
         .collect::<Vec<_>>();
@@ -121,13 +121,9 @@ fn equal(first: DeterministicExecutionResult, second: DeterministicExecutionResu
 }
 
 #[inline(always)]
-fn execute_wasm(
-    wasm: Vec<u8>,
-    wasm_methods: BTreeSet<WasmMethod>,
-    memory64_enabled: bool,
-) -> DeterministicExecutionResult {
+fn execute_wasm(wasm: Vec<u8>, wasm_methods: BTreeSet<WasmMethod>) -> DeterministicExecutionResult {
     let mut result = vec![];
-    let config = ic_embedders_config(memory64_enabled);
+    let config = EmbeddersConfig::default();
     let instance_result = WasmtimeInstanceBuilder::new()
         .with_wasm(wasm)
         .with_config(config)

rs/embedders/fuzz/src/ic_wasm.rs

@@ -2,7 +2,6 @@ use crate::imports::{system_api_imports, SystemApiImportStore};
 use crate::special_int::SpecialInt;
 use arbitrary::{Arbitrary, Result, Unstructured};
 use ic_config::embedders::Config as EmbeddersConfig;
-use ic_config::flag_status::FlagStatus;
 use ic_embedders::wasm_utils::validation::{
     RESERVED_SYMBOLS, WASM_FUNCTION_SIZE_LIMIT, WASM_VALID_SYSTEM_FUNCTIONS,
 };
@@ -22,9 +21,9 @@ use wasmparser::*;
 
 lazy_static! {
     static ref SYSTEM_API_IMPORTS_WASM32: SystemApiImportStore =
-        system_api_imports(ic_embedders_config(false));
+        system_api_imports(EmbeddersConfig::default());
     static ref SYSTEM_API_IMPORTS_WASM64: SystemApiImportStore =
-        system_api_imports(ic_embedders_config(true));
+        system_api_imports(EmbeddersConfig::default());
 }
 
 const CANISTER_EXPORT_FUNCTION_PREFIX: &[&str] = &[
@@ -48,8 +47,7 @@ pub struct ICWasmModule {
 
 impl<'a> Arbitrary<'a> for ICWasmModule {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        let memory64_enabled = u.ratio(2, 3)?;
-        let embedder_config = ic_embedders_config(memory64_enabled);
+        let embedder_config = EmbeddersConfig::default();
         let exports = generate_exports(embedder_config.clone(), u)?;
         let mut config = ic_wasm_config(embedder_config);
         config.exports = exports;
@@ -249,7 +247,6 @@ impl ICWasmModule {
 }
 
 pub fn ic_wasm_config(embedder_config: EmbeddersConfig) -> Config {
-    let memory64_enabled = embedder_config.feature_flags.wasm64 == FlagStatus::Enabled;
     Config {
         min_funcs: 10,
         min_exports: 10,
@@ -266,32 +263,18 @@ pub fn ic_wasm_config(embedder_config: EmbeddersConfig) -> Config {
         bulk_memory_enabled: true,
         reference_types_enabled: true,
         simd_enabled: true,
-        memory64_enabled,
+        memory64_enabled: true,
 
         threads_enabled: false,
         relaxed_simd_enabled: false,
         canonicalize_nans: false,
         exceptions_enabled: false,
 
-        available_imports: Some(if memory64_enabled {
-            SYSTEM_API_IMPORTS_WASM64.module.to_vec()
-        } else {
-            SYSTEM_API_IMPORTS_WASM32.module.to_vec()
-        }),
+        available_imports: Some(SYSTEM_API_IMPORTS_WASM64.module.to_vec()),
         ..Default::default()
     }
 }
 
-pub fn ic_embedders_config(memory64_enabled: bool) -> EmbeddersConfig {
-    let mut config = EmbeddersConfig::default();
-    if memory64_enabled {
-        config.feature_flags.wasm64 = FlagStatus::Enabled;
-    } else {
-        config.feature_flags.wasm64 = FlagStatus::Disabled;
-    }
-    config
-}
-
 fn get_persisted_global(g: wasmparser::Global) -> Option<Global> {
     match (
         g.ty.content_type,

rs/embedders/fuzz/src/imports.rs

@@ -4,7 +4,6 @@ use crate::wasm_executor::{
     get_execution_parameters, get_system_state, MAX_SUBNET_AVAILABLE_MEMORY,
 };
 use ic_config::embedders::Config as EmbeddersConfig;
-use ic_config::flag_status::FlagStatus;
 use ic_embedders::{
     wasm_utils::instrumentation::WasmMemoryType,
     wasmtime_embedder::{
@@ -64,26 +63,13 @@ pub(crate) fn system_api_imports(config: EmbeddersConfig) -> SystemApiImportStor
     );
     let mut linker: wasmtime::Linker<StoreData> = wasmtime::Linker::new(&engine);
 
-    match config.feature_flags.wasm64 {
-        FlagStatus::Enabled => {
-            linker::syscalls::<u64>(
-                &mut linker,
-                config.feature_flags,
-                config.stable_memory_dirty_page_limit,
-                config.stable_memory_accessed_page_limit,
-                WasmMemoryType::Wasm64,
-            );
-        }
-        FlagStatus::Disabled => {
-            linker::syscalls::<u32>(
-                &mut linker,
-                config.feature_flags,
-                config.stable_memory_dirty_page_limit,
-                config.stable_memory_accessed_page_limit,
-                WasmMemoryType::Wasm32,
-            );
-        }
-    }
+    linker::syscalls::<u64>(
+        &mut linker,
+        config.feature_flags,
+        config.stable_memory_dirty_page_limit,
+        config.stable_memory_accessed_page_limit,
+        WasmMemoryType::Wasm64,
+    );
 
     // to avoid store move
     let mut system_api_imports: Vec<(&str, &str, wasmtime::Func)> = linker

rs/embedders/fuzz/src/wasm_executor.rs

@@ -1,7 +1,7 @@
-use crate::ic_wasm::{ic_embedders_config, ICWasmModule};
+use crate::ic_wasm::ICWasmModule;
 use ic_config::{
-    execution_environment::Config as HypervisorConfig, flag_status::FlagStatus,
-    subnet_config::SchedulerConfig,
+    embedders::Config as EmbeddersConfig, execution_environment::Config as HypervisorConfig,
+    flag_status::FlagStatus, subnet_config::SchedulerConfig,
 };
 use ic_cycles_account_manager::ResourceSaturation;
 use ic_embedders::{
@@ -59,7 +59,7 @@ pub fn run_fuzzer(module: ICWasmModule) {
     let wasm_methods: BTreeSet<WasmMethod> = module.exported_functions;
 
     let log = no_op_logger();
-    let embedder_config = ic_embedders_config(module.config.memory64_enabled);
+    let embedder_config = EmbeddersConfig::default();
     let metrics_registry = MetricsRegistry::new();
     let fd_factory = Arc::new(TestPageAllocatorFileDescriptorImpl::new());
 

rs/embedders/fuzz/src/wasmtime.rs

@@ -1,4 +1,5 @@
-use crate::ic_wasm::{ic_embedders_config, ICWasmModule};
+use crate::ic_wasm::ICWasmModule;
+use ic_config::embedders::Config as EmbeddersConfig;
 use ic_test_utilities_embedders::WasmtimeInstanceBuilder;
 use ic_types::methods::{FuncRef, WasmMethod};
 use libfuzzer_sys::Corpus;
@@ -9,7 +10,7 @@ pub fn run_fuzzer(module: ICWasmModule) -> Corpus {
     let wasm = module.module.to_bytes();
     let wasm_methods: BTreeSet<WasmMethod> = module.exported_functions;
 
-    let config = ic_embedders_config(module.config.memory64_enabled);
+    let config = EmbeddersConfig::default();
 
     let instance_result = WasmtimeInstanceBuilder::new()
         .with_wasm(wasm)

rs/embedders/fuzz/src/ws2wasm.rs

@@ -1,13 +1,14 @@
 use arbitrary::{Arbitrary, Unstructured};
 use clap::Parser;
+use ic_config::embedders::Config as EmbeddersConfig;
 use ic_logger::replica_logger::no_op_logger;
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;
 use std::path::PathBuf;
 use std::sync::Arc;
-use wasm_fuzzers::ic_wasm::{ic_embedders_config, ICWasmModule};
+use wasm_fuzzers::ic_wasm::ICWasmModule;
 use wasmprinter::print_bytes;
 
 use ic_embedders::{
@@ -56,7 +57,7 @@ fn main() -> io::Result<()> {
 
     let instrumentation = CommandLineArgs::parse().inst;
     if instrumentation {
-        let config = ic_embedders_config(module.config.memory64_enabled);
+        let config = EmbeddersConfig::default();
         let decoded = decode_wasm(config.wasm_max_size, Arc::new(wasm))
             .expect("failed to decode canister module");
         let embedder = WasmtimeEmbedder::new(config, no_op_logger());