From 3e1b2552dde24772a7bfd0cf427b70523c718428 Mon Sep 17 00:00:00 2001 From: SingleAccretion Date: Thu, 31 Oct 2024 02:31:18 +0300 Subject: [PATCH 1/4] Add very basic logging to the debug info transform The DI transform is a kind of compiler and logging is a very good way to gain insight into compilers. --- crates/cranelift/src/debug.rs | 21 ++ .../transform/debug_transform_logging.rs | 241 ++++++++++++++++++ crates/cranelift/src/debug/transform/mod.rs | 6 + crates/cranelift/src/debug/transform/unit.rs | 67 +++-- 4 files changed, 311 insertions(+), 24 deletions(-) create mode 100644 crates/cranelift/src/debug/transform/debug_transform_logging.rs diff --git a/crates/cranelift/src/debug.rs b/crates/cranelift/src/debug.rs index 542a07092270..28bb1565dd5f 100644 --- a/crates/cranelift/src/debug.rs +++ b/crates/cranelift/src/debug.rs @@ -1,6 +1,7 @@ //! Debug utils for WebAssembly using Cranelift. use crate::CompiledFunctionMetadata; +use core::fmt; use cranelift_codegen::isa::TargetIsa; use object::write::SymbolId; use std::collections::HashMap; @@ -171,6 +172,26 @@ impl<'a> Compilation<'a> { } } +impl<'a> fmt::Debug for Compilation<'a> { + // Sample output: '[#0: OneModule, #1: TwoModule, #3]'. + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "[")?; + let mut is_first_module = true; + for (i, translation) in self.translations { + if !is_first_module { + write!(f, ", ")?; + } else { + is_first_module = false; + } + write!(f, "#{}", i.as_u32())?; + if let Some(name) = translation.debuginfo.name_section.module_name { + write!(f, ": {name}")?; + } + } + write!(f, "]") + } +} + pub use write_debuginfo::{emit_dwarf, DwarfSectionRelocTarget}; mod gc; diff --git a/crates/cranelift/src/debug/transform/debug_transform_logging.rs b/crates/cranelift/src/debug/transform/debug_transform_logging.rs new file mode 100644 index 000000000000..d70ea62218ad --- /dev/null +++ b/crates/cranelift/src/debug/transform/debug_transform_logging.rs @@ -0,0 +1,241 @@ +use crate::debug::Reader; +use core::fmt; +use gimli::{write, AttributeValue, DebuggingInformationEntry, Dwarf, LittleEndian, Unit}; + +macro_rules! dbi_log { + ($($tt:tt)*) => { + #[cfg(debug_assertions)] + ::log::trace!(target: "debug-info-transform", $($tt)*); + }; +} +pub(crate) use dbi_log; + +pub struct CompileUnitSummary<'a> { + unit: &'a Unit, usize>, +} + +impl<'a> fmt::Debug for CompileUnitSummary<'a> { + // Sample output: '[#0: OneModule, #1: TwoModule, #3]'. + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let unit = self.unit; + let offs: usize = unit.header.offset().as_debug_info_offset().unwrap().0; + write!(f, "0x{offs:08x} [")?; + let comp_dir = match unit.comp_dir { + Some(dir) => &dir.to_string_lossy(), + None => "None", + }; + write!(f, "\"{comp_dir}\"")?; + let name = match unit.name { + Some(name) => &name.to_string_lossy(), + None => "None", + }; + write!(f, ", \"{name}\"]") + } +} + +pub fn log_get_cu_summary<'a>(unit: &'a Unit, usize>) -> CompileUnitSummary<'a> { + CompileUnitSummary { unit } +} + +struct DieDetailedSummary<'a> { + dwarf: &'a Dwarf>, + unit: &'a Unit, usize>, + die: &'a DebuggingInformationEntry<'a, 'a, Reader<'a>>, +} + +pub fn log_begin_input_die( + dwarf: &Dwarf>, + unit: &Unit, usize>, + die: &DebuggingInformationEntry>, + depth: isize, +) { + dbi_log!( + "=== Begin DIE at 0x{:08x} (depth = {}):\n{:?}", + die.offset().0, + depth, + DieDetailedSummary { dwarf, unit, die } + ); +} + +impl<'a> fmt::Debug for DieDetailedSummary<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let die = self.die; + let unit = self.unit; + let dwarf = self.dwarf; + write!(f, "{}\n", die.tag())?; + + let mut attrs = die.attrs(); + while let Some(attr) = attrs.next().unwrap_or(None) { + write!(f, " {} (", attr.name())?; + let attr_value = attr.value(); + match attr_value { + AttributeValue::Addr(addr) => { + write!(f, "{addr:08x}") + } + AttributeValue::DebugAddrIndex(index) => { + if let Some(addr) = dwarf.address(unit, index).ok() { + write!(f, "{addr:08x}") + } else { + write!(f, "", index.0) + } + } + AttributeValue::Block(d) => write!(f, "{d:?}"), + AttributeValue::Udata(d) => write!(f, "{d}"), + AttributeValue::Data1(d) => write!(f, "{d}"), + AttributeValue::Data2(d) => write!(f, "{d}"), + AttributeValue::Data4(d) => write!(f, "{d}"), + AttributeValue::Data8(d) => write!(f, "{d}"), + AttributeValue::Sdata(d) => write!(f, "{d}"), + AttributeValue::Flag(d) => write!(f, "{d}"), + AttributeValue::DebugLineRef(offset) => write!(f, "0x{:08x}", offset.0), + AttributeValue::FileIndex(index) => write!(f, "0x{index:08x}"), + AttributeValue::String(_) + | AttributeValue::DebugStrRef(_) + | AttributeValue::DebugStrOffsetsIndex(_) => { + if let Ok(s) = dwarf.attr_string(unit, attr_value) { + write!(f, "\"{}\"", &s.to_string_lossy()) + } else { + write!(f, "") + } + } + AttributeValue::RangeListsRef(_) | AttributeValue::DebugRngListsIndex(_) => { + let _ = dwarf.attr_ranges_offset(unit, attr_value); + write!(f, "") + } + AttributeValue::LocationListsRef(_) | AttributeValue::DebugLocListsIndex(_) => { + let _ = dwarf.attr_locations_offset(unit, attr_value); + write!(f, "") + } + AttributeValue::Exprloc(_) => { + write!(f, "") + } + AttributeValue::Encoding(value) => write!(f, "{value}"), + AttributeValue::DecimalSign(value) => write!(f, "{value}"), + AttributeValue::Endianity(value) => write!(f, "{value}"), + AttributeValue::Accessibility(value) => write!(f, "{value}"), + AttributeValue::Visibility(value) => write!(f, "{value}"), + AttributeValue::Virtuality(value) => write!(f, "{value}"), + AttributeValue::Language(value) => write!(f, "{value}"), + AttributeValue::AddressClass(value) => write!(f, "{value}"), + AttributeValue::IdentifierCase(value) => write!(f, "{value}"), + AttributeValue::CallingConvention(value) => write!(f, "{value}"), + AttributeValue::Inline(value) => write!(f, "{value}"), + AttributeValue::Ordering(value) => write!(f, "{value}"), + AttributeValue::UnitRef(offset) => write!(f, "0x{:08x}", offset.0), + AttributeValue::DebugInfoRef(offset) => write!(f, "0x{:08x}", offset.0), + unexpected_attr => write!(f, ""), + }?; + write!(f, ")\n")?; + } + Ok(()) + } +} + +struct OutDieDetailedSummary<'a> { + die_id: write::UnitEntryId, + unit: &'a write::Unit, + strings: &'a write::StringTable, +} + +impl<'a> fmt::Debug for OutDieDetailedSummary<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let die = self.unit.get(self.die_id); + write!(f, "{}\n", die.tag())?; + for attr in die.attrs() { + write!(f, " {} (", attr.name())?; + let attr_value = attr.get(); + match attr_value { + write::AttributeValue::Address(addr) => match addr { + write::Address::Constant(addr_value) => write!(f, "{addr_value:08x}"), + write::Address::Symbol { symbol, addend } => { + write!(f, "symbol #{symbol}+{addend}") + } + }, + write::AttributeValue::Block(d) => { + write!(f, "{:?}", Reader::new(d.as_slice(), LittleEndian)) + } + write::AttributeValue::Udata(d) => write!(f, "{d}"), + write::AttributeValue::Data1(d) => write!(f, "{d}"), + write::AttributeValue::Data2(d) => write!(f, "{d}"), + write::AttributeValue::Data4(d) => write!(f, "{d}"), + write::AttributeValue::Data8(d) => write!(f, "{d}"), + write::AttributeValue::Sdata(d) => write!(f, "{d}"), + write::AttributeValue::Flag(d) => write!(f, "{d}"), + write::AttributeValue::LineProgramRef => write!(f, "LineProgramRef"), + write::AttributeValue::FileIndex(index) => match index { + Some(id) => write!(f, "{id:?}"), + None => write!(f, ""), + }, + write::AttributeValue::String(s) => { + write!(f, "\"{}\"", &String::from_utf8_lossy(s)) + } + write::AttributeValue::StringRef(id) => { + write!(f, "\"{}\"", &String::from_utf8_lossy(self.strings.get(*id))) + } + write::AttributeValue::RangeListRef(_) => { + write!(f, "") + } + write::AttributeValue::LocationListRef(_) => { + write!(f, "") + } + write::AttributeValue::Exprloc(_) => { + write!(f, "") + } + write::AttributeValue::Encoding(value) => write!(f, "{value}"), + write::AttributeValue::DecimalSign(value) => write!(f, "{value}"), + write::AttributeValue::Endianity(value) => write!(f, "{value}"), + write::AttributeValue::Accessibility(value) => write!(f, "{value}"), + write::AttributeValue::Visibility(value) => write!(f, "{value}"), + write::AttributeValue::Virtuality(value) => write!(f, "{value}"), + write::AttributeValue::Language(value) => write!(f, "{value}"), + write::AttributeValue::AddressClass(value) => write!(f, "{value}"), + write::AttributeValue::IdentifierCase(value) => write!(f, "{value}"), + write::AttributeValue::CallingConvention(value) => write!(f, "{value}"), + write::AttributeValue::Inline(value) => write!(f, "{value}"), + write::AttributeValue::Ordering(value) => write!(f, "{value}"), + write::AttributeValue::UnitRef(unit_ref) => write!(f, "{unit_ref:?}>"), + write::AttributeValue::DebugInfoRef(reference) => match reference { + write::Reference::Symbol(index) => write!(f, "symbol #{index}>"), + write::Reference::Entry(unit_id, die_id) => { + write!(f, "{die_id:?} in {unit_id:?}>") + } + }, + unexpected_attr => write!(f, ""), + }?; + write!(f, ")\n")?; + } + Ok(()) + } +} + +pub fn log_end_output_die( + input_die: &DebuggingInformationEntry>, + die_id: write::UnitEntryId, + unit: &write::Unit, + strings: &write::StringTable, + depth: isize, +) { + dbi_log!( + "=== End DIE at 0x{:08x} (depth = {}):\n{:?}", + input_die.offset().0, + depth, + OutDieDetailedSummary { + die_id, + unit, + strings + } + ); +} + +pub fn log_end_output_die_skipped( + input_die: &DebuggingInformationEntry>, + reason: &str, + depth: isize, +) { + dbi_log!( + "=== End DIE at 0x{:08x} (depth = {}):\n Skipped as {}\n", + input_die.offset().0, + depth, + reason + ); +} diff --git a/crates/cranelift/src/debug/transform/mod.rs b/crates/cranelift/src/debug/transform/mod.rs index b9a813ac7987..6dac4038b28b 100644 --- a/crates/cranelift/src/debug/transform/mod.rs +++ b/crates/cranelift/src/debug/transform/mod.rs @@ -1,3 +1,4 @@ +use self::debug_transform_logging::dbi_log; use self::refs::DebugInfoRefsMap; use self::simulate::generate_simulated_dwarf; use self::unit::clone_unit; @@ -16,6 +17,7 @@ pub use address_transform::AddressTransform; mod address_transform; mod attr; +mod debug_transform_logging; mod expression; mod line_program; mod range_info_builder; @@ -141,6 +143,8 @@ pub fn transform_dwarf( isa: &dyn TargetIsa, compilation: &mut Compilation<'_>, ) -> Result { + dbi_log!("Commencing DWARF transform for {:?}", compilation); + let mut transforms = PrimaryMap::new(); for (i, _) in compilation.translations.iter() { transforms.push(AddressTransform::new(compilation, i)); @@ -176,6 +180,8 @@ pub fn transform_dwarf( let mut translated = HashSet::new(); for (module, translation) in compilation.translations.iter() { + dbi_log!("[== Transforming CUs for module #{} ==]", module.as_u32()); + let addr_tr = &transforms[module]; let di = &translation.debuginfo; let context = DebugInputContext { diff --git a/crates/cranelift/src/debug/transform/unit.rs b/crates/cranelift/src/debug/transform/unit.rs index 1a2292b9050d..d1837133b534 100644 --- a/crates/cranelift/src/debug/transform/unit.rs +++ b/crates/cranelift/src/debug/transform/unit.rs @@ -1,5 +1,9 @@ use super::address_transform::AddressTransform; use super::attr::{clone_die_attributes, FileAttributeContext}; +use super::debug_transform_logging::{ + dbi_log, log_begin_input_die, log_end_output_die, log_end_output_die_skipped, + log_get_cu_summary, +}; use super::expression::compile_expression; use super::line_program::clone_line_program; use super::range_info_builder::RangeInfoBuilder; @@ -269,7 +273,9 @@ pub(crate) fn clone_unit( let dwarf = split_dwarf.unwrap_or(skeleton_dwarf); let unit = split_unit.unwrap_or(skeleton_unit); let mut entries = unit.entries(); - let (mut comp_unit, unit_id, file_map, file_index_base, wp_die_id, vmctx_die_id) = + dbi_log!("Cloning CU {:?}", log_get_cu_summary(unit)); + + let (mut out_unit, out_unit_id, file_map, file_index_base, wp_die_id, vmctx_die_id) = if let Some((depth_delta, entry)) = entries.next_dfs()? { assert_eq!(depth_delta, 0); let (out_line_program, debug_line_offset, file_map, file_index_base) = @@ -283,11 +289,12 @@ pub(crate) fn clone_unit( )?; if entry.tag() == gimli::DW_TAG_compile_unit { - let unit_id = out_units.add(write::Unit::new(out_encoding, out_line_program)); - let comp_unit = out_units.get_mut(unit_id); + log_begin_input_die(dwarf, unit, entry, 0); + let out_unit_id = out_units.add(write::Unit::new(out_encoding, out_line_program)); + let out_unit = out_units.get_mut(out_unit_id); - let root_id = comp_unit.root(); - die_ref_map.insert(entry.offset(), root_id); + let out_root_id = out_unit.root(); + die_ref_map.insert(entry.offset(), out_root_id); clone_die_attributes( dwarf, @@ -295,8 +302,8 @@ pub(crate) fn clone_unit( entry, addr_tr, None, - comp_unit, - root_id, + out_unit, + out_root_id, None, None, out_strings, @@ -313,8 +320,8 @@ pub(crate) fn clone_unit( skeleton_entry, addr_tr, None, - comp_unit, - root_id, + out_unit, + out_root_id, None, None, out_strings, @@ -327,12 +334,13 @@ pub(crate) fn clone_unit( } let (wp_die_id, vmctx_die_id) = - add_internal_types(comp_unit, root_id, out_strings, memory_offset); + add_internal_types(out_unit, out_root_id, out_strings, memory_offset); - stack.push(root_id); + log_end_output_die(entry, out_root_id, out_unit, out_strings, 0); + stack.push(out_root_id); ( - comp_unit, - unit_id, + out_unit, + out_unit_id, file_map, file_index_base, wp_die_id, @@ -341,16 +349,22 @@ pub(crate) fn clone_unit( } else { // Can happen when the DWARF is split and we dont have the package/dwo files. // This is a better user experience than errorring. + dbi_log!("... skipped: split DW_TAG_compile_unit entry missing"); return Ok(None); // empty: } } else { + dbi_log!("... skipped: empty CU (no DW_TAG_compile_unit entry)"); return Ok(None); // empty }; + let mut current_depth = 0; let mut skip_at_depth = None; let mut current_frame_base = InheritedAttr::new(); let mut current_value_range = InheritedAttr::new(); let mut current_scope_ranges = InheritedAttr::new(); while let Some((depth_delta, entry)) = entries.next_dfs()? { + current_depth += depth_delta; + log_begin_input_die(dwarf, unit, entry, current_depth); + // If `skip_at_depth` is `Some` then we previously decided to skip over // a node and all it's children. Let A be the last node processed, B be // the first node skipped, C be previous node, and D the current node. @@ -362,6 +376,7 @@ pub(crate) fn clone_unit( // if D is below B continue to skip if new_depth > 0 { skip_at_depth = Some((new_depth, cached)); + log_end_output_die_skipped(entry, "unreachable", current_depth); continue; } // otherwise process D with `depth_delta` being the difference from A to D @@ -380,6 +395,7 @@ pub(crate) fn clone_unit( // Here B = C so `depth` is 0. A is the previous node so `cached` = // `depth_delta`. skip_at_depth = Some((0, depth_delta)); + log_end_output_die_skipped(entry, "unreachable", current_depth); continue; } @@ -440,7 +456,7 @@ pub(crate) fn clone_unit( let die_id = replace_pointer_type( *parent, pointer_kind, - comp_unit, + out_unit, wp_die_id, entry, unit, @@ -451,14 +467,15 @@ pub(crate) fn clone_unit( stack.push(die_id); assert_eq!(stack.len(), new_stack_len); die_ref_map.insert(entry.offset(), die_id); + log_end_output_die(entry, die_id, out_unit, out_strings, current_depth); continue; } - let die_id = comp_unit.add(*parent, entry.tag()); + let out_die_id = out_unit.add(*parent, entry.tag()); - stack.push(die_id); + stack.push(out_die_id); assert_eq!(stack.len(), new_stack_len); - die_ref_map.insert(entry.offset(), die_id); + die_ref_map.insert(entry.offset(), out_die_id); clone_die_attributes( dwarf, @@ -466,8 +483,8 @@ pub(crate) fn clone_unit( entry, addr_tr, current_value_range.top(), - &mut comp_unit, - die_id, + &mut out_unit, + out_die_id, range_builder, current_scope_ranges.top(), out_strings, @@ -487,7 +504,7 @@ pub(crate) fn clone_unit( // using the DW_AT_endianity attribute, so that the debugger will // be able to correctly access them. if entry.tag() == gimli::DW_TAG_base_type && isa.endianness() == Endianness::Big { - let current_scope = comp_unit.get_mut(die_id); + let current_scope = out_unit.get_mut(out_die_id); current_scope.set( gimli::DW_AT_endianity, write::AttributeValue::Endianity(gimli::DW_END_little), @@ -496,8 +513,8 @@ pub(crate) fn clone_unit( if entry.tag() == gimli::DW_TAG_subprogram && !current_scope_ranges.is_empty() { append_vmctx_info( - comp_unit, - die_id, + out_unit, + out_die_id, vmctx_die_id, addr_tr, current_value_range.top(), @@ -506,7 +523,9 @@ pub(crate) fn clone_unit( isa, )?; } + + log_end_output_die(entry, out_die_id, out_unit, out_strings, current_depth); } - die_ref_map.patch(pending_die_refs, comp_unit); - Ok(Some((unit_id, die_ref_map, pending_di_refs))) + die_ref_map.patch(pending_die_refs, out_unit); + Ok(Some((out_unit_id, die_ref_map, pending_di_refs))) } From 9c74a4545c6c9f9b8af432e4e48e173cfbfaec4b Mon Sep 17 00:00:00 2001 From: SingleAccretion Date: Thu, 31 Oct 2024 18:40:42 +0300 Subject: [PATCH 2/4] Fix C&P --- crates/cranelift/src/debug/transform/debug_transform_logging.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/cranelift/src/debug/transform/debug_transform_logging.rs b/crates/cranelift/src/debug/transform/debug_transform_logging.rs index d70ea62218ad..960caf7fd469 100644 --- a/crates/cranelift/src/debug/transform/debug_transform_logging.rs +++ b/crates/cranelift/src/debug/transform/debug_transform_logging.rs @@ -15,7 +15,6 @@ pub struct CompileUnitSummary<'a> { } impl<'a> fmt::Debug for CompileUnitSummary<'a> { - // Sample output: '[#0: OneModule, #1: TwoModule, #3]'. fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let unit = self.unit; let offs: usize = unit.header.offset().as_debug_info_offset().unwrap().0; From 2bdaabdc1592a296c936ed6862835b5eb12b30ac Mon Sep 17 00:00:00 2001 From: SingleAccretion Date: Thu, 31 Oct 2024 23:58:29 +0300 Subject: [PATCH 3/4] Bubble the "trace-log" feature up the dependency tree And switch logging macros to always be enabled in debug. Verified "trace-log" **does not** show up when running 'cargo tree -f "{p} {f}" -e features,normal,build' --- Cargo.toml | 1 + cranelift/codegen/src/lib.rs | 5 ++--- crates/cranelift/Cargo.toml | 1 + .../cranelift/src/debug/transform/debug_transform_logging.rs | 2 +- crates/wasmtime/Cargo.toml | 3 +++ 5 files changed, 8 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f1122821b28d..021ea9b7e8b7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -410,6 +410,7 @@ all-arch = ["wasmtime/all-arch"] winch = ["wasmtime/winch"] pulley = ["wasmtime/pulley"] wmemcheck = ["wasmtime/wmemcheck"] +trace-log = ["wasmtime/trace-log"] memory-protection-keys = ["wasmtime-cli-flags/memory-protection-keys"] # This feature, when enabled, will statically compile out all logging statements diff --git a/cranelift/codegen/src/lib.rs b/cranelift/codegen/src/lib.rs index 475014e0f550..d7188e973d59 100644 --- a/cranelift/codegen/src/lib.rs +++ b/cranelift/codegen/src/lib.rs @@ -97,9 +97,8 @@ pub mod incremental_cache; #[macro_export] macro_rules! trace { ($($tt:tt)*) => { - if cfg!(feature = "trace-log") { - ::log::trace!($($tt)*); - } + #[cfg(any(feature = "trace-log", debug_assertions))] + ::log::trace!($($tt)*); }; } diff --git a/crates/cranelift/Cargo.toml b/crates/cranelift/Cargo.toml index 8fcc96cfa5f4..6cadc68cbbf6 100644 --- a/crates/cranelift/Cargo.toml +++ b/crates/cranelift/Cargo.toml @@ -37,6 +37,7 @@ itertools = "0.12" all-arch = ["cranelift-codegen/all-arch"] host-arch = ["cranelift-codegen/host-arch"] pulley = ["cranelift-codegen/pulley"] +trace-log = ["cranelift-codegen/trace-log"] component-model = ["wasmtime-environ/component-model"] incremental-cache = ["cranelift-codegen/incremental-cache"] wmemcheck = ["wasmtime-environ/wmemcheck"] diff --git a/crates/cranelift/src/debug/transform/debug_transform_logging.rs b/crates/cranelift/src/debug/transform/debug_transform_logging.rs index 960caf7fd469..cf72c50d5f64 100644 --- a/crates/cranelift/src/debug/transform/debug_transform_logging.rs +++ b/crates/cranelift/src/debug/transform/debug_transform_logging.rs @@ -4,7 +4,7 @@ use gimli::{write, AttributeValue, DebuggingInformationEntry, Dwarf, LittleEndia macro_rules! dbi_log { ($($tt:tt)*) => { - #[cfg(debug_assertions)] + #[cfg(any(feature = "trace-log", debug_assertions))] ::log::trace!(target: "debug-info-transform", $($tt)*); }; } diff --git a/crates/wasmtime/Cargo.toml b/crates/wasmtime/Cargo.toml index bd10631b44a7..2b00f6ff8845 100644 --- a/crates/wasmtime/Cargo.toml +++ b/crates/wasmtime/Cargo.toml @@ -205,6 +205,9 @@ wmemcheck = [ "std", ] +# Enables detailed internal compiler logging via WASMTIME_LOG +trace-log = ["wasmtime-cranelift?/trace-log"] + # Enables support for demangling WebAssembly function names at runtime in # errors such as backtraces. demangle = ["wasmtime-environ/demangle", "std"] From feedf2eb7aab3bf52bfd94e8f7f1c24c687a5a8c Mon Sep 17 00:00:00 2001 From: SingleAccretion Date: Tue, 5 Nov 2024 00:04:55 +0300 Subject: [PATCH 4/4] Fix dead code warnings --- cranelift/codegen/src/lib.rs | 5 +++-- .../cranelift/src/debug/transform/debug_transform_logging.rs | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/cranelift/codegen/src/lib.rs b/cranelift/codegen/src/lib.rs index d7188e973d59..cfdee28adef0 100644 --- a/cranelift/codegen/src/lib.rs +++ b/cranelift/codegen/src/lib.rs @@ -97,8 +97,9 @@ pub mod incremental_cache; #[macro_export] macro_rules! trace { ($($tt:tt)*) => { - #[cfg(any(feature = "trace-log", debug_assertions))] - ::log::trace!($($tt)*); + if cfg!(any(feature = "trace-log", debug_assertions)) { + ::log::trace!($($tt)*); + } }; } diff --git a/crates/cranelift/src/debug/transform/debug_transform_logging.rs b/crates/cranelift/src/debug/transform/debug_transform_logging.rs index cf72c50d5f64..8bb9fbb16f36 100644 --- a/crates/cranelift/src/debug/transform/debug_transform_logging.rs +++ b/crates/cranelift/src/debug/transform/debug_transform_logging.rs @@ -4,8 +4,9 @@ use gimli::{write, AttributeValue, DebuggingInformationEntry, Dwarf, LittleEndia macro_rules! dbi_log { ($($tt:tt)*) => { - #[cfg(any(feature = "trace-log", debug_assertions))] - ::log::trace!(target: "debug-info-transform", $($tt)*); + if cfg!(any(feature = "trace-log", debug_assertions)) { + ::log::trace!(target: "debug-info-transform", $($tt)*); + } }; } pub(crate) use dbi_log;