Ensure symbol names are cleaned up and have function indexes

Filter symbol names to include only characters that are usually used
for function names, and that might be produced by name mangling.
Replace everything else with a question mark (and all repeated question
marks by a single one), and then truncate to a length of 96 characters.

This should be enough to not only avoid passing user-controlled strings
to tools such as "perf" and "objdump", and make it easier to
disambiguate symbols that might have the same name but different
indices.

crates/wasmtime/src/compile.rs

@@ -346,6 +346,9 @@ struct CompileInputs<'a> {
 }
 
 impl<'a> CompileInputs<'a> {
+    /// Maximum length of symbols generated in objects.
+    const MAX_SYMBOL_LEN: usize = 96;
+
     fn push_input(&mut self, f: impl FnOnce(&dyn Compiler) -> Result<CompileOutput> + Send + 'a) {
         self.inputs.push(Box::new(f));
     }
@@ -419,6 +422,28 @@ impl<'a> CompileInputs<'a> {
         ret
     }
 
+    fn clean_symbol(name: String) -> String {
+        // Just to be on the safe side, avoid passing user-provided data to tools
+        // like "perf" or "objdump", and filter the name.
+        let mut cleaned = String::with_capacity(name.len());
+        for c in name.chars().map(|c| {
+            if c.is_alphanumeric() || r"<>[]_-:@$".contains(c) {
+                c
+            } else {
+                '?'
+            }
+        }) {
+            cleaned.push(c);
+        }
+
+        let (cleaned, _) = cleaned
+            .trim_matches('?')
+            .trim_end_matches('?')
+            .split_at(Self::MAX_SYMBOL_LEN);
+
+        cleaned.to_string()
+    }
+
     fn collect_inputs_in_translations(
         &mut self,
         types: &'a ModuleTypesBuilder,
@@ -442,16 +467,18 @@ impl<'a> CompileInputs<'a> {
                         .func_names
                         .get(&func_index)
                     {
-                        Some(name) => format!("wasm[{}]::{}", module.as_u32(), name),
-                        None => format!(
-                            "wasm[{}]::function[{}]",
+                        Some(name) => format!(
+                            "wasm[{}]::func[{}]::{}",
                             module.as_u32(),
-                            func_index.as_u32()
+                            func_index.as_u32(),
+                            name
                         ),
+                        None => format!("wasm[{}]::func[{}]", module.as_u32(), func_index.as_u32()),
                     };
+
                     Ok(CompileOutput {
                         key: CompileKey::wasm_function(module, def_func_index),
-                        symbol,
+                        symbol: Self::clean_symbol(symbol),
                         function: CompiledFunction::Function(function),
                         info: Some(info),
                     })