fix(cranelift-backend) Remove broken (and useless?) debug code.

This debug code is broken (it doesn't compile). It can be assumed
nobody uses it, and can be considered as dead code. As such, this PR
removes it.

lib/clif-backend/src/code.rs

@@ -128,166 +128,6 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
             .state
             .initialize(&builder.func.signature, exit_block);
 
-        #[cfg(feature = "debug")]
-        {
-            use cranelift_codegen::cursor::{Cursor, FuncCursor};
-            use cranelift_codegen::ir::InstBuilder;
-            let entry_ebb = func.layout.entry_block().unwrap();
-            let ebb = func.dfg.make_ebb();
-            func.layout.insert_ebb(ebb, entry_ebb);
-            let mut pos = FuncCursor::new(&mut func).at_first_insertion_point(ebb);
-            let params = pos.func.dfg.ebb_params(entry_ebb).to_vec();
-
-            let new_ebb_params: Vec<_> = params
-                .iter()
-                .map(|&param| {
-                    pos.func
-                        .dfg
-                        .append_ebb_param(ebb, pos.func.dfg.value_type(param))
-                })
-                .collect();
-
-            let start_debug = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("strtdbug");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let end_debug = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![ir::AbiParam::special(
-                        ir::types::I64,
-                        ir::ArgumentPurpose::VMContext,
-                    )],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("enddbug");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let i32_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("i32print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let i64_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::I64),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("i64print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let f32_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::F32),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("f32print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let f64_print = {
-                let signature = pos.func.import_signature(ir::Signature {
-                    call_conv: self.target_config().default_call_conv,
-                    params: vec![
-                        ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
-                        ir::AbiParam::new(ir::types::F64),
-                    ],
-                    returns: vec![],
-                });
-
-                let name = ir::ExternalName::testcase("f64print");
-
-                pos.func.import_function(ir::ExtFuncData {
-                    name,
-                    signature,
-                    colocated: false,
-                })
-            };
-
-            let vmctx = pos
-                .func
-                .special_param(ir::ArgumentPurpose::VMContext)
-                .expect("missing vmctx parameter");
-
-            let func_index = pos.ins().iconst(
-                ir::types::I32,
-                func_index.index() as i64 + self.module.info.imported_functions.len() as i64,
-            );
-
-            pos.ins().call(start_debug, &[vmctx, func_index]);
-
-            for param in new_ebb_params.iter().cloned() {
-                match pos.func.dfg.value_type(param) {
-                    ir::types::I32 => pos.ins().call(i32_print, &[vmctx, param]),
-                    ir::types::I64 => pos.ins().call(i64_print, &[vmctx, param]),
-                    ir::types::F32 => pos.ins().call(f32_print, &[vmctx, param]),
-                    ir::types::F64 => pos.ins().call(f64_print, &[vmctx, param]),
-                    _ => unimplemented!(),
-                };
-            }
-
-            pos.ins().call(end_debug, &[vmctx]);
-
-            pos.ins().jump(entry_ebb, new_ebb_params.as_slice());
-        }
-
         self.functions.push(func_env);
         Ok(self.functions.last_mut().unwrap())
     }

lib/clif-backend/src/resolver.rs

@@ -1,32 +1,31 @@
-use crate::{cache::BackendCache, trampoline::Trampolines};
 use crate::{
+    cache::BackendCache,
     libcalls,
     relocation::{
         ExternalRelocation, LibCall, LocalRelocation, LocalTrapSink, Reloc, RelocSink,
         RelocationType, TrapSink, VmCall, VmCallKind,
     },
     signal::HandlerData,
+    trampoline::Trampolines,
 };
-use rayon::prelude::*;
-
 use byteorder::{ByteOrder, LittleEndian};
 use cranelift_codegen::{
     binemit::{Stackmap, StackmapSink},
     ir, isa, Context,
 };
+use rayon::prelude::*;
 use std::{
     mem,
     ptr::{write_unaligned, NonNull},
     sync::Arc,
 };
-
-use wasmer_runtime_core::cache::Error as CacheError;
 use wasmer_runtime_core::{
     self,
     backend::{
         sys::{Memory, Protect},
         SigRegistry,
     },
+    cache::Error as CacheError,
     error::{CompileError, CompileResult},
     module::ModuleInfo,
     structures::{Map, SliceMap, TypedIndex},
@@ -250,17 +249,9 @@ impl FuncResolverBuilder {
                         #[cfg(not(target_os = "windows"))]
                         LibCall::Probestack => __rust_probestack as isize,
                     },
-                    RelocationType::Intrinsic(ref name) => match name.as_str() {
+                    RelocationType::Intrinsic(ref name) => Err(CompileError::InternalError {
-                        "i32print" => i32_print as isize,
-                        "i64print" => i64_print as isize,
-                        "f32print" => f32_print as isize,
-                        "f64print" => f64_print as isize,
-                        "strtdbug" => start_debug as isize,
-                        "enddbug" => end_debug as isize,
-                        _ => Err(CompileError::InternalError {
                         msg: format!("unexpected intrinsic: {}", name),
                     })?,
-                    },
                     RelocationType::VmCall(vmcall) => match vmcall {
                         VmCall::Local(kind) => match kind {
                             VmCallKind::StaticMemoryGrow | VmCallKind::SharedStaticMemoryGrow => {
@@ -371,28 +362,3 @@ impl FuncResolver {
 fn round_up(n: usize, multiple: usize) -> usize {
     (n + multiple - 1) & !(multiple - 1)
 }
-
-extern "C" fn i32_print(_ctx: &mut vm::Ctx, n: i32) {
-    eprint!(" i32: {},", n);
-}
-extern "C" fn i64_print(_ctx: &mut vm::Ctx, n: i64) {
-    eprint!(" i64: {},", n);
-}
-extern "C" fn f32_print(_ctx: &mut vm::Ctx, n: f32) {
-    eprint!(" f32: {},", n);
-}
-extern "C" fn f64_print(_ctx: &mut vm::Ctx, n: f64) {
-    eprint!(" f64: {},", n);
-}
-extern "C" fn start_debug(ctx: &mut vm::Ctx, func_index: u32) {
-    if let Some(symbol_map) = unsafe { ctx.borrow_symbol_map() } {
-        if let Some(fn_name) = symbol_map.get(&func_index) {
-            eprint!("func ({} ({})), args: [", fn_name, func_index);
-            return;
-        }
-    }
-    eprint!("func ({}), args: [", func_index);
-}
-extern "C" fn end_debug(_ctx: &mut vm::Ctx) {
-    eprintln!(" ]");
-}