Align symbol names with --emit-clif (#10947)

* Align symbol names with `--emit-clif`

This commit fixes two issues: (1) is that `--emit-clif` generates file
names that are different from symbol names and (2) is that `--emit-clif`
for components today has collisions on filenames which means that output
files can get corrupted. Currently (2) is causing spurious failures in
CI due to the test added in #10939 being the first test with a component
and functions in modules where they clash to emit the same file.

* Fix typo

* Fix tests

* Fix tests on Windows

Can't use `:` in filenames on Windows

prtest:full

Author: alexcrichton

crates/cranelift/src/compiler.rs

@@ -187,6 +187,7 @@ impl wasmtime_environ::Compiler for Compiler {
         func_index: DefinedFuncIndex,
         input: FunctionBodyData<'_>,
         types: &ModuleTypesBuilder,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         let isa = &*self.isa;
         let module = &translation.module;
@@ -275,10 +276,7 @@ impl wasmtime_environ::Compiler for Compiler {
             &mut func_env,
         )?;
 
-        let func = compiler.finish_with_info(
-            Some((&body, &self.tunables)),
-            &format!("wasm_func_{}", func_index.as_u32()),
-        )?;
+        let func = compiler.finish_with_info(Some((&body, &self.tunables)), symbol)?;
 
         let timing = cranelift_codegen::timing::take_current();
         log::debug!("{:?} translated in {:?}", func_index, timing.total());
@@ -295,6 +293,7 @@ impl wasmtime_environ::Compiler for Compiler {
         translation: &ModuleTranslation<'_>,
         types: &ModuleTypesBuilder,
         def_func_index: DefinedFuncIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         let func_index = translation.module.func_index(def_func_index);
         let sig = translation.module.functions[func_index]
@@ -363,14 +362,15 @@ impl wasmtime_environ::Compiler for Compiler {
         builder.finalize();
 
         Ok(CompiledFunctionBody {
-            code: Box::new(compiler.finish(&format!("array_to_wasm_{}", func_index.as_u32(),))?),
+            code: Box::new(compiler.finish(symbol)?),
             needs_gc_heap: false,
         })
     }
 
     fn compile_wasm_to_array_trampoline(
         &self,
         wasm_func_ty: &WasmFuncType,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         let isa = &*self.isa;
         let pointer_type = isa.pointer_type();
@@ -436,7 +436,7 @@ impl wasmtime_environ::Compiler for Compiler {
         builder.finalize();
 
         Ok(CompiledFunctionBody {
-            code: Box::new(compiler.finish(&format!("wasm_to_array_trampoline_{wasm_func_ty}"))?),
+            code: Box::new(compiler.finish(&symbol)?),
             needs_gc_heap: false,
         })
     }
@@ -586,6 +586,7 @@ impl wasmtime_environ::Compiler for Compiler {
     fn compile_wasm_to_builtin(
         &self,
         index: BuiltinFunctionIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         let isa = &*self.isa;
         let ptr_size = isa.pointer_bytes();
@@ -656,7 +657,7 @@ impl wasmtime_environ::Compiler for Compiler {
         builder.finalize();
 
         Ok(CompiledFunctionBody {
-            code: Box::new(compiler.finish(&format!("wasm_to_builtin_{}", index.name()))?),
+            code: Box::new(compiler.finish(&symbol)?),
             needs_gc_heap: false,
         })
     }
@@ -974,14 +975,14 @@ impl FunctionCompiler<'_> {
         (builder, block0)
     }
 
-    fn finish(self, clif_filename: &str) -> Result<CompiledFunction, CompileError> {
-        self.finish_with_info(None, clif_filename)
+    fn finish(self, symbol: &str) -> Result<CompiledFunction, CompileError> {
+        self.finish_with_info(None, symbol)
     }
 
     fn finish_with_info(
         mut self,
         body_and_tunables: Option<(&FunctionBody<'_>, &Tunables)>,
-        clif_filename: &str,
+        symbol: &str,
     ) -> Result<CompiledFunction, CompileError> {
         let context = &mut self.cx.codegen_context;
         let isa = &*self.compiler.isa;
@@ -997,7 +998,7 @@ impl FunctionCompiler<'_> {
         if let Some(path) = &self.compiler.clif_dir {
             use std::io::Write;
 
-            let mut path = path.join(clif_filename);
+            let mut path = path.join(symbol.replace(":", "-"));
             path.set_extension("clif");
 
             let mut output = std::fs::File::create(path).unwrap();

crates/cranelift/src/compiler/component.rs

@@ -1454,6 +1454,7 @@ impl ComponentCompiler for Compiler {
         types: &ComponentTypesBuilder,
         index: TrampolineIndex,
         tunables: &Tunables,
+        symbol: &str,
     ) -> Result<AllCallFunc<CompiledFunctionBody>> {
         let compile = |abi: Abi| -> Result<_> {
             let mut compiler = self.function_compiler();
@@ -1497,11 +1498,12 @@ impl ComponentCompiler for Compiler {
 
             c.translate(&component.trampolines[index]);
             c.builder.finalize();
-
+            let symbol = match abi {
+                Abi::Wasm => format!("{symbol}_wasm_call"),
+                Abi::Array => format!("{symbol}_array_call"),
+            };
             Ok(CompiledFunctionBody {
-                code: Box::new(
-                    compiler.finish(&format!("component_trampoline_{}_{abi:?}", index.as_u32()))?,
-                ),
+                code: Box::new(compiler.finish(&symbol)?),
                 needs_gc_heap: false,
             })
         };

crates/environ/src/compile/mod.rs

@@ -200,6 +200,7 @@ pub trait Compiler: Send + Sync {
         index: DefinedFuncIndex,
         data: FunctionBodyData<'_>,
         types: &ModuleTypesBuilder,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError>;
 
     /// Compile a trampoline for an array-call host function caller calling the
@@ -212,6 +213,7 @@ pub trait Compiler: Send + Sync {
         translation: &ModuleTranslation<'_>,
         types: &ModuleTypesBuilder,
         index: DefinedFuncIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError>;
 
     /// Compile a trampoline for a Wasm caller calling a array callee with the
@@ -222,6 +224,7 @@ pub trait Compiler: Send + Sync {
     fn compile_wasm_to_array_trampoline(
         &self,
         wasm_func_ty: &WasmFuncType,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError>;
 
     /// Creates a trampoline that can be used to call Wasmtime's implementation
@@ -236,6 +239,7 @@ pub trait Compiler: Send + Sync {
     fn compile_wasm_to_builtin(
         &self,
         index: BuiltinFunctionIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError>;
 
     /// Returns the list of relocations required for a function from one of the

crates/environ/src/component/compiler.rs

@@ -16,5 +16,6 @@ pub trait ComponentCompiler: Send + Sync {
         types: &ComponentTypesBuilder,
         trampoline: TrampolineIndex,
         tunables: &Tunables,
+        symbol: &str,
     ) -> Result<AllCallFunc<CompiledFunctionBody>>;
 }

crates/wasmtime/src/compile.rs

@@ -381,14 +381,15 @@ impl<'a> CompileInputs<'a> {
 
         for (idx, trampoline) in component.trampolines.iter() {
             ret.push_input(move |compiler| {
+                let symbol = trampoline.symbol_name();
                 Ok(CompileOutput {
                     key: CompileKey::trampoline(idx),
-                    symbol: trampoline.symbol_name(),
                     function: compiler
                         .component_compiler()
-                        .compile_trampoline(component, types, idx, tunables)
-                        .with_context(|| format!("failed to compile {}", trampoline.symbol_name()))?
+                        .compile_trampoline(component, types, idx, tunables, &symbol)
+                        .with_context(|| format!("failed to compile {symbol}"))?
                         .into(),
+                    symbol,
                     start_srcloc: FilePos::default(),
                 })
             });
@@ -405,7 +406,7 @@ impl<'a> CompileInputs<'a> {
                 ret.push_input(move |compiler| {
                     let symbol = "resource_drop_trampoline".to_string();
                     let function = compiler
-                        .compile_wasm_to_array_trampoline(types[sig].unwrap_func())
+                        .compile_wasm_to_array_trampoline(types[sig].unwrap_func(), &symbol)
                         .with_context(|| format!("failed to compile `{symbol}`"))?;
                     Ok(CompileOutput {
                         key: CompileKey::resource_drop_wasm_to_array_trampoline(),
@@ -487,7 +488,7 @@ impl<'a> CompileInputs<'a> {
                     let offset = data.original_position();
                     let start_srcloc = FilePos::new(u32::try_from(offset).unwrap());
                     let function = compiler
-                        .compile_function(translation, def_func_index, func_body, types)
+                        .compile_function(translation, def_func_index, func_body, types, &symbol)
                         .with_context(|| format!("failed to compile: {symbol}"))?;
 
                     Ok(CompileOutput {
@@ -508,7 +509,12 @@ impl<'a> CompileInputs<'a> {
                             func_index.as_u32()
                         );
                         let trampoline = compiler
-                            .compile_array_to_wasm_trampoline(translation, types, def_func_index)
+                            .compile_array_to_wasm_trampoline(
+                                translation,
+                                types,
+                                def_func_index,
+                                &symbol,
+                            )
                             .with_context(|| format!("failed to compile: {symbol}"))?;
                         Ok(CompileOutput {
                             key: CompileKey::array_to_wasm_trampoline(module, def_func_index),
@@ -534,7 +540,7 @@ impl<'a> CompileInputs<'a> {
                     trampoline_type_index.as_u32()
                 );
                 let trampoline = compiler
-                    .compile_wasm_to_array_trampoline(trampoline_func_ty)
+                    .compile_wasm_to_array_trampoline(trampoline_func_ty, &symbol)
                     .with_context(|| format!("failed to compile: {symbol}"))?;
                 Ok(CompileOutput {
                     key: CompileKey::wasm_to_array_trampoline(trampoline_type_index),
@@ -579,7 +585,7 @@ fn compile_required_builtins(engine: &Engine, raw_outputs: &mut Vec<CompileOutpu
         Box::new(move |compiler: &dyn Compiler| {
             let symbol = format!("wasmtime_builtin_{}", builtin.name());
             let trampoline = compiler
-                .compile_wasm_to_builtin(builtin)
+                .compile_wasm_to_builtin(builtin, &symbol)
                 .with_context(|| format!("failed to compile `{symbol}`"))?;
             Ok(CompileOutput {
                 key: CompileKey::wasm_to_builtin_trampoline(builtin),

crates/winch/src/compiler.rs

@@ -95,6 +95,7 @@ impl wasmtime_environ::Compiler for Compiler {
         index: DefinedFuncIndex,
         data: FunctionBodyData<'_>,
         types: &ModuleTypesBuilder,
+        _symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         let index = translation.module.func_index(index);
         let sig = translation.module.functions[index]
@@ -144,17 +145,19 @@ impl wasmtime_environ::Compiler for Compiler {
         translation: &ModuleTranslation<'_>,
         types: &ModuleTypesBuilder,
         index: DefinedFuncIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         self.trampolines
-            .compile_array_to_wasm_trampoline(translation, types, index)
+            .compile_array_to_wasm_trampoline(translation, types, index, symbol)
     }
 
     fn compile_wasm_to_array_trampoline(
         &self,
         wasm_func_ty: &wasmtime_environ::WasmFuncType,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
         self.trampolines
-            .compile_wasm_to_array_trampoline(wasm_func_ty)
+            .compile_wasm_to_array_trampoline(wasm_func_ty, symbol)
     }
 
     fn append_code(
@@ -234,8 +237,9 @@ impl wasmtime_environ::Compiler for Compiler {
     fn compile_wasm_to_builtin(
         &self,
         index: BuiltinFunctionIndex,
+        symbol: &str,
     ) -> Result<CompiledFunctionBody, CompileError> {
-        self.trampolines.compile_wasm_to_builtin(index)
+        self.trampolines.compile_wasm_to_builtin(index, symbol)
     }
 
     fn compiled_function_relocation_targets<'a>(

tests/disas.rs

@@ -221,7 +221,7 @@ impl Test {
                     let entry = entry.context("failed to iterate over tempdir")?;
                     let path = entry.path();
                     if let Some(name) = path.file_name().and_then(|s| s.to_str()) {
-                        let filter = self.config.filter.as_deref().unwrap_or("wasm_func_");
+                        let filter = self.config.filter.as_deref().unwrap_or("wasm[0]--function");
                         if !name.contains(filter) {
                             continue;
                         }

tests/disas/component-model/enum.wat

@@ -1,6 +1,6 @@
 ;;! target = "riscv64"
 ;;! test = 'optimize'
-;;! filter = 'wasm_func_1'
+;;! filter = 'wasm[2]--function[1]'
 
 (component
   (type $a (enum "a" "b" "c"))

tests/disas/riscv64-component-builtins.wat

@@ -1,6 +1,6 @@
 ;;! target = "riscv64"
 ;;! test = 'optimize'
-;;! filter = 'component_trampoline_0_Wasm'
+;;! filter = 'component-resource-drop[0]_wasm_call'
 
 (component
   (type $a (resource (rep i32)))