From 5dc082c80eda6101bf362c3f2f0536dd18648e69 Mon Sep 17 00:00:00 2001 From: Tomasz Andrzejak Date: Wed, 4 Mar 2026 16:57:45 +0100 Subject: [PATCH] chore: add clippy lints --- .github/workflows/ci.yml | 2 + Cargo.toml | 20 +++++ src/constant_offsets.rs | 21 ++--- src/dce.rs | 19 ++-- src/directive.rs | 6 +- src/escape.rs | 19 ++-- src/eval.rs | 186 ++++++++++++--------------------------- src/filter.rs | 6 +- src/intrinsics.rs | 2 +- src/main.rs | 4 +- src/state.rs | 6 +- src/value.rs | 4 +- 12 files changed, 117 insertions(+), 178 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2aa4b79..7171b5f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -19,6 +19,8 @@ jobs: run: cargo build --verbose - name: Run tests run: cargo test --verbose + - name: Run clippy + run: cargo clippy rustfmt: runs-on: ubuntu-latest diff --git a/Cargo.toml b/Cargo.toml index 33542a1..09d33eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,3 +25,23 @@ bincode = "1.3.3" sha2 = "0.10.8" sqlite = "0.36.0" serde = { version = "1.0.197", features = ["derive"] } + +[lints.clippy] +# The default set of lints in Clippy is viewed as "too noisy" right now so +# they're all turned off by default. Selective lints are then enabled below as +# necessary. +all = { level = 'allow', priority = -1 } +clone_on_copy = 'warn' +map_clone = 'warn' +uninlined_format_args = 'warn' +unnecessary_to_owned = 'warn' +manual_strip = 'warn' +useless_conversion = 'warn' +unnecessary_mut_passed = 'warn' +unnecessary_fallible_conversions = 'warn' +unnecessary_cast = 'warn' +allow_attributes_without_reason = 'warn' +from_over_into = 'warn' +redundant_field_names = 'warn' +multiple_bound_locations = 'warn' +extra_unused_type_parameters = 'warn' diff --git a/src/constant_offsets.rs b/src/constant_offsets.rs index 9ca382d..eefce8a 100644 --- a/src/constant_offsets.rs +++ b/src/constant_offsets.rs @@ -59,7 +59,7 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { } while let Some(block) = workqueue.pop_front() { - log::trace!("processing {}", block); + log::trace!("processing {block}"); workqueue_set.remove(&block); for &inst in &func.blocks[block].insts { @@ -75,7 +75,7 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { ValueDef::Operator(op, args, tys) if tys.len() == 1 => { let args = &func.arg_pool[*args]; - log::trace!(" -> args = {:?}", args); + log::trace!(" -> args = {args:?}"); match op { Operator::I32Const { value } => { @@ -231,10 +231,7 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { offset_base_const.insert(value, k); offset_base.insert(value, add); log::trace!( - "created common base {} (and const {}) associated with offset-from value {}", - k, - add, - value + "created common base {k} (and const {add}) associated with offset-from value {value}" ); } else { offset_base.insert(value, value); @@ -244,7 +241,7 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { // Now, for each value that's an Offset, rewrite it to an add // instruction. for (block, block_def) in func.blocks.entries_mut() { - log::trace!("rewriting in block {}", block); + log::trace!("rewriting in block {block}"); let mut computed_offsets: FxHashMap = FxHashMap::default(); let mut new_insts = vec![]; @@ -265,13 +262,13 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { let args = &func.arg_pool[*args]; let tys = *tys; let addr = args[0]; - log::trace!("load/store with addr {}", addr); + log::trace!("load/store with addr {addr}"); if let AbsValue::Offset(base, this_offset) = values[addr] { - log::trace!("inst {} is a load/store with addr that is offset from base {}; pushing offset into instruction", inst, base); + log::trace!("inst {inst} is a load/store with addr that is offset from base {base}; pushing offset into instruction"); // Update the offset embedded in the Operator // and use the `base` value instead as the // address arg. - let mut op = op.clone(); + let mut op = *op; let mut args = args.iter().cloned().collect::>(); let common_base = *offset_base.get(&base).unwrap(); let offset = *min_offset_from.get(&base).unwrap(); @@ -326,12 +323,12 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) { let add = func.values.push(ValueDef::Operator(op, args, i32_ty)); func.source_locs[k] = func.source_locs[inst]; func.source_locs[add] = func.source_locs[inst]; - log::trace!(" -> recomputed as {}", add); + log::trace!(" -> recomputed as {add}"); new_insts.push(add); add } }); - log::trace!(" -> rewrite to {}", computed_offset); + log::trace!(" -> rewrite to {computed_offset}"); func.values[inst] = ValueDef::Alias(computed_offset); } else { new_insts.push(inst); diff --git a/src/dce.rs b/src/dce.rs index bb90d76..1d5e0d4 100644 --- a/src/dce.rs +++ b/src/dce.rs @@ -48,7 +48,7 @@ fn scan_block(func: &FunctionBody, block: Block, used: &mut FxHashSet) -> changed }; - log::trace!("DCE: scanning {}", block); + log::trace!("DCE: scanning {block}"); let mut changed = false; func.blocks[block].terminator.visit_targets(|target| { @@ -57,10 +57,7 @@ fn scan_block(func: &FunctionBody, block: Block, used: &mut FxHashSet) -> for (&arg, &(_, param)) in target.args.iter().zip(succ_params.iter()) { if used.contains(¶m) { log::trace!( - " -> succ blockparam {} is used; marking arg {} used from term on {}", - param, - arg, - block, + " -> succ blockparam {param} is used; marking arg {arg} used from term on {block}", ); changed |= mark_used(used, arg); } @@ -68,12 +65,12 @@ fn scan_block(func: &FunctionBody, block: Block, used: &mut FxHashSet) -> }); match &func.blocks[block].terminator { Terminator::CondBr { cond: value, .. } | Terminator::Select { value, .. } => { - log::trace!(" -> marking branch input {} used", value); + log::trace!(" -> marking branch input {value} used"); changed |= mark_used(used, *value); } Terminator::Return { values } => { for &value in values { - log::trace!(" -> marking return value {} used", value); + log::trace!(" -> marking return value {value} used"); changed |= mark_used(used, value); } } @@ -87,7 +84,7 @@ fn scan_block(func: &FunctionBody, block: Block, used: &mut FxHashSet) -> } ValueDef::PickOutput(value, ..) => { if used.contains(&inst) { - log::trace!(" -> marking pick-output src {} used", value); + log::trace!(" -> marking pick-output src {value} used"); changed |= mark_used(used, *value); } } @@ -97,7 +94,7 @@ fn scan_block(func: &FunctionBody, block: Block, used: &mut FxHashSet) -> } if used.contains(&inst) { for &arg in &func.arg_pool[*args] { - log::trace!(" -> marking arg {} used from {}", arg, inst); + log::trace!(" -> marking arg {arg} used from {inst}"); changed |= mark_used(used, arg); } } @@ -118,7 +115,7 @@ pub(crate) fn run(func: &mut FunctionBody, cfg: &CFGInfo) { // unreachable block can branch to an unreachable block). for (block, block_def) in func.blocks.entries_mut() { if cfg.rpo_pos[block].is_none() { - log::trace!("removing unreachable block {}", block); + log::trace!("removing unreachable block {block}"); block_def.insts.clear(); block_def.params.clear(); block_def.terminator = Terminator::Unreachable; @@ -135,7 +132,7 @@ pub(crate) fn run(func: &mut FunctionBody, cfg: &CFGInfo) { for &block in cfg.rpo.values().rev() { changed |= scan_block(func, block, &mut used); } - log::trace!("done with all blocks; changed = {}", changed); + log::trace!("done with all blocks; changed = {changed}"); if !changed { break; } diff --git a/src/directive.rs b/src/directive.rs index 21239e2..fb66b46 100644 --- a/src/directive.rs +++ b/src/directive.rs @@ -74,7 +74,7 @@ pub(crate) fn collect(module: &Module, im: &mut Image) -> anyhow::Result heap, @@ -115,7 +115,7 @@ fn decode_weval_req(im: &Image, heap: Memory, head: u32) -> anyhow::Result anyhow::bail!("Invalid type: {}", ty), + _ => anyhow::bail!("Invalid type: {ty}"), } } else { (AbstractValue::Runtime(None), None, 16) diff --git a/src/escape.rs b/src/escape.rs index 01451ef..7699edf 100644 --- a/src/escape.rs +++ b/src/escape.rs @@ -28,32 +28,28 @@ fn shadow_stack_escapes(func: &FunctionBody, cfg: &CFGInfo) -> EscapeAnalysisRes | &ValueDef::Operator(Operator::GlobalSet { global_index }, _, _) if global_index.index() == 0 => { - log::trace!("tainted because global.get/set: {}", inst); + log::trace!("tainted because global.get/set: {inst}"); tainted.insert(inst); } &ValueDef::Operator(Operator::I32Add, args, _) | &ValueDef::Operator(Operator::I32Sub, args, _) => { let args = &func.arg_pool[args]; if args.iter().any(|arg| tainted.contains(arg)) { - log::trace!("tainted because of arg: {}", inst); + log::trace!("tainted because of arg: {inst}"); tainted.insert(inst); } } &ValueDef::Operator(_, args, _) => { let args = &func.arg_pool[args]; if args.iter().any(|arg| tainted.contains(arg)) { - log::trace!("shadow stack escape due to inst {}", inst); + log::trace!("shadow stack escape due to inst {inst}"); return EscapeAnalysisResult::Escapes; } } &ValueDef::PickOutput(val, _, _) | &ValueDef::Alias(val) if tainted.contains(&val) => { - log::trace!( - "taint on {} propagates to {} because of alias or pick", - val, - inst - ); + log::trace!("taint on {val} propagates to {inst} because of alias or pick"); tainted.insert(inst); } _ => {} @@ -63,10 +59,7 @@ fn shadow_stack_escapes(func: &FunctionBody, cfg: &CFGInfo) -> EscapeAnalysisRes match &func.blocks[block].terminator { &Terminator::CondBr { cond, .. } | &Terminator::Select { value: cond, .. } => { if tainted.contains(&cond) { - log::trace!( - "taint on input to conditional branch causes escape: {}", - cond - ); + log::trace!("taint on input to conditional branch causes escape: {cond}"); return EscapeAnalysisResult::Escapes; } } @@ -111,7 +104,7 @@ fn shadow_stack_escapes(func: &FunctionBody, cfg: &CFGInfo) -> EscapeAnalysisRes pub(crate) fn remove_shadow_stack_if_non_escaping(func: &mut FunctionBody, cfg: &CFGInfo) { if let EscapeAnalysisResult::NonEscaping(values_to_remove) = shadow_stack_escapes(func, &cfg) { - log::trace!("removing shadow stack operations: {:?}", values_to_remove); + log::trace!("removing shadow stack operations: {values_to_remove:?}"); let ty_u32 = func.type_pool.single(Type::I32); let const_zero = func.values.push(ValueDef::Operator( Operator::I32Const { value: 0 }, diff --git a/src/eval.rs b/src/eval.rs index bdb60de..18b9099 100644 --- a/src/eval.rs +++ b/src/eval.rs @@ -79,7 +79,7 @@ pub(crate) fn partially_evaluate<'a>( cache: &Cache, ) -> anyhow::Result> { let intrinsics = Intrinsics::find(&module); - log::trace!("intrinsics: {:?}", intrinsics); + log::trace!("intrinsics: {intrinsics:?}"); // Sort directives by out-address, and remove duplicates. let mut directives = directives.to_vec(); @@ -194,7 +194,7 @@ pub(crate) fn partially_evaluate<'a>( .cloned() .collect::>(); live.sort(); - writeln!(&mut s, "# {}: {:?}", block, live).unwrap(); + writeln!(&mut s, "# {block}: {live:?}").unwrap(); } writeln!(&mut s, "").unwrap(); writeln!(&mut s, "{}", body.display_verbose("", Some(&module))).unwrap(); @@ -211,7 +211,7 @@ pub(crate) fn partially_evaluate<'a>( }; Some(Ok((Cow::Borrowed(directive), decl, ir, false))) } else { - log::warn!("Failed to weval for directive {:?}", directive); + log::warn!("Failed to weval for directive {directive:?}"); None } }) @@ -255,7 +255,7 @@ pub(crate) fn partially_evaluate<'a>( if func_table.max.is_some() && table_idx >= func_table.max.unwrap() { func_table.max = Some(table_idx + 1); } - log::info!("New func index {} -> table index {}", func, table_idx); + log::info!("New func index {func} -> table index {table_idx}"); if let Some(path) = &output_ir { let mut specialized_ir_file = path.clone(); @@ -276,7 +276,7 @@ pub(crate) fn partially_evaluate<'a>( // Update the `weval_is_wevaled` flag, if it exists and is exported. if let Some(is_wevaled) = find_global_data_by_exported_func(&module, "weval.is.wevaled") { - log::info!("updating `is_wevaled` flag at {:#x} to 1", is_wevaled); + log::info!("updating `is_wevaled` flag at {is_wevaled:#x} to 1"); im.write_u32(heap, is_wevaled, 1)?; } @@ -305,8 +305,8 @@ fn partially_evaluate_func( let orig_name = module.funcs[directive.func].name(); let sig = module.funcs[directive.func].sig(); - log::info!("Specializing: {:?}", directive); - log::info!("Args: {:?}", directive_args); + log::info!("Specializing: {directive:?}"); + log::info!("Args: {directive_args:?}"); log::debug!("body:\n{}", generic.display("| ", Some(module))); // Build the evaluator. @@ -354,7 +354,7 @@ fn partially_evaluate_func( return Ok(None); } - let name = format!("{} (specialized)", orig_name); + let name = format!("{orig_name} (specialized)"); let cfg = CFGInfo::new(&evaluator.func); crate::escape::remove_shadow_stack_if_non_escaping(&mut evaluator.func, &cfg); evaluator.func.optimize(&waffle::OptOptions { @@ -373,7 +373,7 @@ fn partially_evaluate_func( accumulate_stats_from_func(&mut evaluator.stats, &evaluator.func); - log::info!("Specialization of {:?} done", directive); + log::info!("Specialization of {directive:?} done"); log::debug!( "Adding func:\n{}", evaluator.func.display_verbose("| ", Some(module)) @@ -394,17 +394,13 @@ fn split_blocks_at_intrinsic_calls(func: &mut FunctionBody, intrinsics: &Intrins if Some(*function_index) == intrinsics.specialize_value || Some(*function_index) == intrinsics.pop_context { - log::trace!( - "Splitting from block {} at weval intrinsic for inst {}", - block, - inst - ); + log::trace!("Splitting from block {block} at weval intrinsic for inst {inst}"); // Split the block here! Split *after* the call // (the `i + 1`). let split_insts = func.blocks[block].insts.split_off(i + 1); let new_block = func.blocks.push(BlockDef::default()); - log::trace!(" -> new block: {}", new_block); + log::trace!(" -> new block: {new_block}"); func.blocks[new_block].insts = split_insts; let term = std::mem::take(&mut func.blocks[block].terminator); func.blocks[new_block].terminator = term; @@ -482,7 +478,7 @@ fn find_cut_blocks( let changed = new != current; highest_same_ctx_ancestor[succ] = new; - log::trace!("highest same-context ancestor for {}: {}", succ, new); + log::trace!("highest same-context ancestor for {succ}: {new}"); if changed { if queue_set.insert(succ) { queue.push(succ); @@ -491,7 +487,7 @@ fn find_cut_blocks( }); } - log::trace!("cut blocks = {:?}", blocks); + log::trace!("cut blocks = {blocks:?}"); blocks } @@ -607,12 +603,7 @@ impl<'a> Evaluator<'a> { // recomputing a specialization with an existing output. self.func.blocks[new_block].insts.clear(); - log::trace!( - "evaluate_block: orig {} ctx {} new {}", - orig_block, - ctx, - new_block - ); + log::trace!("evaluate_block: orig {orig_block} ctx {ctx} new {new_block}"); debug_assert_eq!(self.block_map.get(&(ctx, orig_block)), Some(&new_block)); // Create program-point state. @@ -622,7 +613,7 @@ impl<'a> Evaluator<'a> { pending_specialize: None, flow: self.state.block_entry[new_block].clone(), }; - log::trace!(" -> state = {:?}", state); + log::trace!(" -> state = {state:?}"); state.flow.update_at_block_entry( &mut self.reg_map, @@ -632,13 +623,7 @@ impl<'a> Evaluator<'a> { .or_insert_with(|| { let param = self.func.add_placeholder(ty); log::trace!( - "new blockparam {} of ty {:?} for reg slot {:?} on block {} (ctx {} orig {})", - param, - ty, - regslot, - new_block, - ctx, - orig_block, + "new blockparam {param} of ty {ty:?} for reg slot {regslot:?} on block {new_block} (ctx {ctx} orig {orig_block})", ); param }) @@ -676,12 +661,7 @@ impl<'a> Evaluator<'a> { new_block: Block, orig_val: Value, ) -> (Value, AbstractValue) { - log::trace!( - "using value {} at block {} in context {}", - orig_val, - orig_block, - context - ); + log::trace!("using value {orig_val} at block {orig_block} in context {context}"); if let Some(&val) = self.value_map.get(&(context, orig_val)) { if self.cfg.def_block[orig_val] != orig_block { self.value_dep_blocks @@ -690,14 +670,11 @@ impl<'a> Evaluator<'a> { .insert(new_block); } let abs = &self.state.values[val]; - log::trace!(" -> found abstract value {:?} at context {}", abs, context); - log::trace!(" -> runtime value {}", val); + log::trace!(" -> found abstract value {abs:?} at context {context}"); + log::trace!(" -> runtime value {val}"); return (val, abs.clone()); } - panic!( - "Could not find value for {} in context {}", - orig_val, context - ); + panic!("Could not find value for {orig_val} in context {context}"); } fn def_value( @@ -709,23 +686,14 @@ impl<'a> Evaluator<'a> { abs: AbstractValue, ) -> bool { log::debug!( - "defining val {} in block {} context {} with specialized val {} abs {:?}", - orig_val, - block, - context, - val, - abs + "defining val {orig_val} in block {block} context {context} with specialized val {val} abs {abs:?}" ); self.value_map.insert((context, orig_val), val); let val_abs = &mut self.state.values[val]; let updated = AbstractValue::meet(val_abs, &abs); let changed = updated != *val_abs; log::debug!( - " -> meet: cur {:?} input {:?} result {:?} (changed: {})", - val_abs, - abs, - updated, - changed, + " -> meet: cur {val_abs:?} input {abs:?} result {updated:?} (changed: {changed})", ); *val_abs = updated; @@ -760,7 +728,7 @@ impl<'a> Evaluator<'a> { // Reused below for each instruction. let mut arg_abs_values = vec![]; - log::trace!("evaluate_block_body: {}: state {:?}", orig_block, state); + log::trace!("evaluate_block_body: {orig_block}: state {state:?}"); for &inst in &self.generic.blocks[orig_block].insts { let input_ctx = state.context; @@ -794,9 +762,9 @@ impl<'a> Evaluator<'a> { arg_abs_values.clear(); let mut arg_values = self.func.arg_pool.allocate(args.len(), Value::invalid()); for (i, &arg) in args_slice.iter().enumerate() { - log::trace!(" * arg {}", arg); + log::trace!(" * arg {arg}"); let arg = self.generic.resolve_alias(arg); - log::trace!(" -> resolves to arg {}", arg); + log::trace!(" -> resolves to arg {arg}"); let (val, abs) = self.use_value(state.context, orig_block, new_block, arg); arg_abs_values.push(abs); self.func.arg_pool[arg_values][i] = val; @@ -903,8 +871,8 @@ impl<'a> Evaluator<'a> { fn context_desc(&self, ctx: Context) -> String { match self.state.contexts.leaf_element(ctx) { ContextElem::Root => "root".to_owned(), - ContextElem::Loop(pc) => format!("PC {:?}", pc), - ContextElem::Specialized(index, val) => format!("Specialization of {}: {}", index, val), + ContextElem::Loop(pc) => format!("PC {pc:?}"), + ContextElem::Specialized(index, val) => format!("Specialization of {index}: {val}"), } } @@ -922,18 +890,13 @@ impl<'a> Evaluator<'a> { context, self.context_desc(context) ); - log::debug!( - "create_block: orig_block {} context {} -> {}", - orig_block, - context, - block - ); + log::debug!("create_block: orig_block {orig_block} context {context} -> {block}"); self.func.blocks[block] .params .reserve(self.generic.blocks[orig_block].params.len()); for &(ty, param) in &self.generic.blocks[orig_block].params { let new_param = self.func.add_blockparam(block, ty); - log::trace!(" -> blockparam {} maps to {}", param, new_param); + log::trace!(" -> blockparam {param} maps to {new_param}"); self.value_map.insert((context, param), new_param); } self.block_map.insert((context, orig_block), block); @@ -957,7 +920,7 @@ impl<'a> Evaluator<'a> { state.context ); - log::trace!(" -> new context {}", target_context); + log::trace!(" -> new context {target_context}"); log::trace!( "target_block: from orig {} ctx {} to {} ctx {}", @@ -970,7 +933,7 @@ impl<'a> Evaluator<'a> { match self.block_map.entry((target_context, target)) { HashEntry::Vacant(_) => { let block = self.create_block(target, target_context, state.flow.clone()); - log::trace!(" -> created block {}", block); + log::trace!(" -> created block {block}"); self.block_map.insert((target_context, target), block); self.queue_set.insert((target, target_context)); self.queue.push_back((target, target_context, block)); @@ -978,7 +941,7 @@ impl<'a> Evaluator<'a> { } HashEntry::Occupied(o) => { let target_specialized = *o.get(); - log::trace!(" -> already existing block {}", target_specialized); + log::trace!(" -> already existing block {target_specialized}"); let changed = self.meet_into_block_entry( target, target_context, @@ -1050,12 +1013,7 @@ impl<'a> Evaluator<'a> { { if index == blockparam { log::trace!( - "Specialized context into block {} context {}: index {} becomes val {} from generic {}", - target_block, - target_ctx, - index, - val, - orig_arg, + "Specialized context into block {target_block} context {target_ctx}: index {index} becomes val {val} from generic {orig_arg}", ); AbstractValue::Concrete(WasmVal::I32(val)) } else { @@ -1163,7 +1121,7 @@ impl<'a> Evaluator<'a> { Some(new_context), ContextElem::Specialized(target_specialized_value, i), ); - log::trace!(" -> created new context {} for index {}", c, i); + log::trace!(" -> created new context {c} for index {i}"); self.evaluate_block_target(orig_block, new_block, state, c, target) }) .collect(); @@ -1269,12 +1227,7 @@ impl<'a> Evaluator<'a> { state: &mut PointState, ) -> anyhow::Result { log::debug!( - "abstract eval of {} {}: op {:?} abs {:?} state {:?}", - orig_block, - orig_inst, - op, - abs, - state + "abstract eval of {orig_block} {orig_inst}: op {op:?} abs {abs:?} state {state:?}" ); debug_assert_eq!(abs.len(), values.len()); @@ -1291,14 +1244,14 @@ impl<'a> Evaluator<'a> { state, ); if intrinsic_result.is_handled() { - log::debug!(" -> intrinsic: {:?}", intrinsic_result); + log::debug!(" -> intrinsic: {intrinsic_result:?}"); return Ok(intrinsic_result); } let reg_result = self.abstract_eval_regs(orig_inst, new_block, op, abs, values, tys, state)?; if reg_result.is_handled() { - log::debug!(" -> specialization regs: {:?}", reg_result); + log::debug!(" -> specialization regs: {reg_result:?}"); return Ok(reg_result); } @@ -1315,7 +1268,7 @@ impl<'a> Evaluator<'a> { } }; - log::debug!(" -> result: {:?}", ret); + log::debug!(" -> result: {ret:?}"); Ok(EvalResult::Normal(ret)) } @@ -1343,13 +1296,13 @@ impl<'a> Evaluator<'a> { .contexts .create(Some(instantaneous_context), ContextElem::Loop(pc)); state.pending_context = Some(child); - log::trace!("push context (pc {:?}): now {}", pc, child); + log::trace!("push context (pc {pc:?}): now {child}"); EvalResult::Elide } else if Some(function_index) == self.intrinsics.pop_context { let instantaneous_context = state.pending_context.unwrap_or(state.context); let parent = self.state.contexts.pop_one_loop(instantaneous_context); state.pending_context = Some(parent); - log::trace!("pop context: now {}", parent); + log::trace!("pop context: now {parent}"); EvalResult::Elide } else if Some(function_index) == self.intrinsics.update_context { log::trace!("update context at {}: PC is {:?}", orig_values[0], abs[0]); @@ -1364,7 +1317,7 @@ impl<'a> Evaluator<'a> { } else { panic!("PC is a runtime value: {:?}", abs[0]); }; - log::trace!("update context: now {:?}", pending_context); + log::trace!("update context: now {pending_context:?}"); state.pending_context = pending_context; EvalResult::Elide } else if Some(function_index) == self.intrinsics.context_bucket { @@ -1376,17 +1329,14 @@ impl<'a> Evaluator<'a> { let lo = abs[1].as_const_u32().unwrap(); let hi = abs[2].as_const_u32().unwrap(); log::trace!( - "Creating pending-specialize state for index {} lo {} hi {}", - orig_inst, - lo, - hi + "Creating pending-specialize state for index {orig_inst} lo {lo} hi {hi}" ); state.pending_specialize = Some((orig_inst, lo, hi)); EvalResult::Alias(abs[0].clone(), self.func.arg_pool[values][0]) } else if Some(function_index) == self.intrinsics.abort_specialization { let line_num = abs[0].as_const_u32().unwrap_or(0); let fatal = abs[1].as_const_u32().unwrap_or(0); - log::trace!("abort-specialization point: line {}", line_num); + log::trace!("abort-specialization point: line {line_num}"); if fatal != 0 { panic!("Specialization reached a point it shouldn't have!"); } @@ -1424,7 +1374,7 @@ impl<'a> Evaluator<'a> { .unwrap(); let line = abs[1].as_const_u32().unwrap(); let val = abs[2].clone(); - log::info!("print: line {}: {}: {:?}", line, message, val); + log::info!("print: line {line}: {message}: {val:?}"); EvalResult::Elide } else if Some(function_index) == self.intrinsics.read_specialization_global { let index = abs[0].as_const_u32().unwrap() as usize; @@ -1435,11 +1385,7 @@ impl<'a> Evaluator<'a> { &[Type::I64], ); let state = self.state.specialization_globals[index].clone(); - log::trace!( - "read_specialization_global: index {}: state = {:?}", - index, - state - ); + log::trace!("read_specialization_global: index {index}: state = {state:?}"); EvalResult::Alias(state, value) } else if Some(function_index) == self.intrinsics.push_stack { let stackptr = self.func.arg_pool[values][0]; @@ -1449,7 +1395,7 @@ impl<'a> Evaluator<'a> { value, state.flow.stack, ); - log::trace!("push_stack: value {} stackptr {}", value, stackptr); + log::trace!("push_stack: value {value} stackptr {stackptr}"); state.flow.stack.insert( 0, ( @@ -1547,7 +1493,7 @@ impl<'a> Evaluator<'a> { }; self.stats.virtstack_writes += 1; if let Some((addr, data)) = state.flow.stack.get_mut(idx as usize) { - log::trace!("write_stack: value {} stackptr {}", value, stackptr); + log::trace!("write_stack: value {value} stackptr {stackptr}"); *addr = addr_value; *data = data_value; } else if idx == 0 && state.flow.stack.is_empty() { @@ -1574,7 +1520,7 @@ impl<'a> Evaluator<'a> { for (addr, data) in state.flow.stack.drain(..) { let addr = addr.value().unwrap(); let data = data.value().unwrap(); - log::trace!("sync_stack: value {} stackptr {}", addr, data); + log::trace!("sync_stack: value {addr} stackptr {data}"); self.func.add_op( new_block, Operator::I64Store { @@ -1593,7 +1539,7 @@ impl<'a> Evaluator<'a> { for (_, (addr, data)) in std::mem::take(&mut state.flow.locals) { let addr = addr.value().unwrap(); let data = data.value().unwrap(); - log::trace!("sync_stack: local addr {} data {}", addr, data); + log::trace!("sync_stack: local addr {addr} data {data}"); self.func.add_op( new_block, Operator::I64Store { @@ -1679,22 +1625,18 @@ impl<'a> Evaluator<'a> { if Some(function_index) == self.intrinsics.read_reg => { let idx = abs[0].as_const_u64().expect("Non-constant register number"); - log::trace!("load from specialization reg {}", idx); + log::trace!("load from specialization reg {idx}"); let slot = RegSlot::Register(idx as u32); match state.flow.regs.get(&slot) { Some(RegValue::Value { data, abs, .. }) => { - log::trace!(" -> have value {} with abs {:?}", data, abs); + log::trace!(" -> have value {data} with abs {abs:?}"); return Ok(EvalResult::Alias(abs.clone(), *data)); } Some(v) => { - anyhow::bail!( - "Specialization register {} in bad state {:?} at read", - idx, - v - ); + anyhow::bail!("Specialization register {idx} in bad state {v:?} at read"); } None => { - anyhow::bail!("Specialization register {} not set", idx); + anyhow::bail!("Specialization register {idx} not set"); } } } @@ -1858,7 +1800,7 @@ impl<'a> Evaluator<'a> { .unwrap(); let val = mem.read_size(offset, size)?; let val = AbstractValue::Concrete(WasmVal::I32(conv(val))); - log::trace!(" -> produces {:?}", val); + log::trace!(" -> produces {val:?}"); Ok(val) } @@ -1899,7 +1841,7 @@ impl<'a> Evaluator<'a> { .unwrap(); let val = mem.read_size(offset, size)?; let val = AbstractValue::Concrete(WasmVal::I64(conv(val))); - log::trace!(" -> produces {:?}", val); + log::trace!(" -> produces {val:?}"); Ok(val) } @@ -2229,11 +2171,7 @@ impl<'a> Evaluator<'a> { let val_blockparam = self.func.add_blockparam(block, ty); let orig_val = *self.reg_map.get(&(ctx, orig_block, idx)).ok_or_else(|| { anyhow::anyhow!( - "placeholder val not found for reg idx {:?} at block {} (ctx {} orig {})", - idx, - block, - ctx, - orig_block, + "placeholder val not found for reg idx {idx:?} at block {block} (ctx {ctx} orig {orig_block})", ) })?; self.func.set_alias(orig_val, val_blockparam); @@ -2303,12 +2241,7 @@ impl<'a> Evaluator<'a> { for i in succ_min_depth..pred_depth { let addr = pred_state.stack[i].0.value().unwrap(); let data = pred_state.stack[i].1.value().unwrap(); - log::trace!( - "spilling {} back to real stack memory: addr {} data {}", - i, - addr, - data - ); + log::trace!("spilling {i} back to real stack memory: addr {addr} data {data}"); self.func.add_op( block, Operator::I64Store { @@ -2339,10 +2272,7 @@ impl<'a> Evaluator<'a> { let addr = addr.value().unwrap(); let data = data.value().unwrap(); log::trace!( - "spilling local {} back to real locals memory: addr {} data {}", - local, - addr, - data + "spilling local {local} back to real locals memory: addr {addr} data {data}" ); self.func.add_op( block, diff --git a/src/filter.rs b/src/filter.rs index cb12753..a656436 100644 --- a/src/filter.rs +++ b/src/filter.rs @@ -189,7 +189,7 @@ impl Rewrite { out_func_idx += 1; } } - ty => anyhow::bail!("import type {:?} not supported", ty), + ty => anyhow::bail!("import type {ty:?} not supported"), } } @@ -208,7 +208,7 @@ impl Rewrite { wasmparser::ValType::F32 => wasm_encoder::ValType::F32, wasmparser::ValType::F64 => wasm_encoder::ValType::F64, wasmparser::ValType::V128 => wasm_encoder::ValType::V128, - ty => panic!("Unsupported global type: {:?}", ty), + ty => panic!("Unsupported global type: {ty:?}"), }; let ty = wasm_encoder::GlobalType { val_type, @@ -236,7 +236,7 @@ impl Rewrite { } wasmparser::Operator::End => {} op => { - panic!("Unsupported operator in global initializer: {:?}", op) + panic!("Unsupported operator in global initializer: {op:?}") } } } diff --git a/src/intrinsics.rs b/src/intrinsics.rs index d19332b..2fa7569 100644 --- a/src/intrinsics.rs +++ b/src/intrinsics.rs @@ -152,7 +152,7 @@ pub(crate) fn find_global_data_by_exported_func(module: &Module, name: &str) -> // I32Add of a global (the GOT memory base) and an I32Const. let extract_const_value = |value| match &body.values[value] { - ValueDef::Operator(Operator::I32Const { value }, _, _) => Some(*value as u32), + ValueDef::Operator(Operator::I32Const { value }, _, _) => Some(*value), ValueDef::Operator(Operator::I32Add, args, _) => { let args = &body.arg_pool[*args]; match (&body.values[args[0]], &body.values[args[1]]) { diff --git a/src/main.rs b/src/main.rs index d660f26..2b8a156 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,4 +1,4 @@ -#![allow(dead_code)] +#![allow(dead_code, reason = "")] use std::path::PathBuf; use structopt::StructOpt; @@ -205,7 +205,7 @@ pub fn weval( // Collect directives. let directives = directive::collect(&module, &mut im)?; - log::debug!("Directives: {:?}", directives); + log::debug!("Directives: {directives:?}"); // Make sure IR output directory exists. if let Some(dir) = &output_ir { diff --git a/src/state.rs b/src/state.rs index 68abfd2..bd3ad97 100644 --- a/src/state.rs +++ b/src/state.rs @@ -69,7 +69,7 @@ impl Contexts { Entry::Occupied(o) => *o.get(), Entry::Vacant(v) => { let id = self.contexts.push((parent, elem.clone())); - log::trace!("create context: {}: parent {} leaf {:?}", id, parent, elem); + log::trace!("create context: {id}: parent {parent} leaf {elem:?}"); *v.insert(id) } } @@ -175,7 +175,7 @@ impl RegValue { abs: AbstractValue::meet(abs, abs1), }, _ => { - panic!("Values {:?} and {:?} meeting to Conflict", a, b); + panic!("Values {a:?} and {b:?} meeting to Conflict"); } } } @@ -242,7 +242,7 @@ fn map_meet_with< *val = bot.clone(); changed |= old != *val; } else { - to_remove.push(k.clone()); + to_remove.push(*k); changed = true; } } diff --git a/src/value.rs b/src/value.rs index cef7acd..1c69980 100644 --- a/src/value.rs +++ b/src/value.rs @@ -43,8 +43,8 @@ impl std::convert::TryFrom for WasmVal { type Error = (); fn try_from(op: waffle::Operator) -> Result { match op { - waffle::Operator::I32Const { value } => Ok(WasmVal::I32(value as u32)), - waffle::Operator::I64Const { value } => Ok(WasmVal::I64(value as u64)), + waffle::Operator::I32Const { value } => Ok(WasmVal::I32(value)), + waffle::Operator::I64Const { value } => Ok(WasmVal::I64(value)), waffle::Operator::F32Const { value } => Ok(WasmVal::F32(value)), waffle::Operator::F64Const { value } => Ok(WasmVal::F64(value)), _ => Err(()),