diff --git a/src/checker.rs b/src/checker.rs
index fe97fb0..323c66b 100644
--- a/src/checker.rs
+++ b/src/checker.rs
@@ -191,7 +191,7 @@ impl CheckerValue {
                 CheckerValue::Reg(r1, ref1)
             }
             _ => {
-                log::trace!("{:?} and {:?} meet to Conflicted", self, other);
+                trace!("{:?} and {:?} meet to Conflicted", self, other);
                 CheckerValue::Conflicted
             }
         }
@@ -322,7 +322,7 @@ impl CheckerState {
                         .get(alloc)
                         .cloned()
                         .unwrap_or(Default::default());
-                    log::trace!(
+                    trace!(
                         "checker: checkinst {:?}: op {:?}, alloc {:?}, checker value {:?}",
                         checkinst,
                         op,
@@ -339,7 +339,7 @@ impl CheckerState {
                         .get(&alloc)
                         .cloned()
                         .unwrap_or(Default::default());
-                    log::trace!(
+                    trace!(
                         "checker: checkinst {:?}: safepoint slot {}, checker value {:?}",
                         checkinst,
                         alloc,
@@ -372,7 +372,7 @@ impl CheckerState {
                     .get(&from)
                     .cloned()
                     .unwrap_or(Default::default());
-                log::trace!(
+                trace!(
                     "checker: checkinst {:?} updating: move {:?} -> {:?} val {:?}",
                     checkinst,
                     from,
@@ -534,7 +534,7 @@ impl<'a, F: Function> Checker<'a, F> {
     /// Build the list of checker instructions based on the given func
     /// and allocation results.
     pub fn prepare(&mut self, out: &Output) {
-        log::trace!("checker: out = {:?}", out);
+        trace!("checker: out = {:?}", out);
         // Preprocess safepoint stack-maps into per-inst vecs.
         let mut safepoint_slots: HashMap<Inst, Vec<Allocation>> = HashMap::new();
         for &(progpoint, slot) in &out.safepoint_slots {
@@ -591,13 +591,13 @@ impl<'a, F: Function> Checker<'a, F> {
                 allocs,
                 clobbers,
             };
-            log::trace!("checker: adding inst {:?}", checkinst);
+            trace!("checker: adding inst {:?}", checkinst);
             self.bb_insts.get_mut(&block).unwrap().push(checkinst);
         }
     }
 
     fn handle_edit(&mut self, block: Block, edit: &Edit) {
-        log::trace!("checker: adding edit {:?}", edit);
+        trace!("checker: adding edit {:?}", edit);
         match edit {
             &Edit::Move { from, to } => {
                 self.bb_insts
@@ -628,10 +628,10 @@ impl<'a, F: Function> Checker<'a, F> {
             let block = queue.pop_front().unwrap();
             queue_set.remove(&block);
             let mut state = self.bb_in.get(&block).cloned().unwrap();
-            log::trace!("analyze: block {} has state {:?}", block.index(), state);
+            trace!("analyze: block {} has state {:?}", block.index(), state);
             for inst in self.bb_insts.get(&block).unwrap() {
                 state.update(inst, self);
-                log::trace!("analyze: inst {:?} -> state {:?}", inst, state);
+                trace!("analyze: inst {:?} -> state {:?}", inst, state);
             }
 
             for &succ in self.f.block_succs(block) {
@@ -640,7 +640,7 @@ impl<'a, F: Function> Checker<'a, F> {
                 new_state.meet_with(cur_succ_in);
                 let changed = &new_state != cur_succ_in;
                 if changed {
-                    log::trace!(
+                    trace!(
                         "analyze: block {} state changed from {:?} to {:?}; pushing onto queue",
                         succ.index(),
                         cur_succ_in,
@@ -665,12 +665,12 @@ impl<'a, F: Function> Checker<'a, F> {
             let mut state = input.clone();
             for inst in self.bb_insts.get(block).unwrap() {
                 if let Err(e) = state.check(InstPosition::Before, inst) {
-                    log::trace!("Checker error: {:?}", e);
+                    trace!("Checker error: {:?}", e);
                     errors.push(e);
                 }
                 state.update(inst, self);
                 if let Err(e) = state.check(InstPosition::After, inst) {
-                    log::trace!("Checker error: {:?}", e);
+                    trace!("Checker error: {:?}", e);
                     errors.push(e);
                 }
             }
@@ -689,20 +689,20 @@ impl<'a, F: Function> Checker<'a, F> {
         self.analyze();
         let result = self.find_errors();
 
-        log::trace!("=== CHECKER RESULT ===");
+        trace!("=== CHECKER RESULT ===");
         fn print_state(state: &CheckerState) {
             let mut s = vec![];
             for (alloc, state) in &state.allocations {
                 s.push(format!("{} := {}", alloc, state));
             }
-            log::trace!("    {{ {} }}", s.join(", "))
+            trace!("    {{ {} }}", s.join(", "))
         }
         for vreg in self.f.reftype_vregs() {
-            log::trace!("  REF: {}", vreg);
+            trace!("  REF: {}", vreg);
         }
         for bb in 0..self.f.num_blocks() {
             let bb = Block::new(bb);
-            log::trace!("block{}:", bb.index());
+            trace!("block{}:", bb.index());
             let insts = self.bb_insts.get(&bb).unwrap();
             let mut state = self.bb_in.get(&bb).unwrap().clone();
             print_state(&state);
@@ -714,7 +714,7 @@ impl<'a, F: Function> Checker<'a, F> {
                         ref allocs,
                         ref clobbers,
                     } => {
-                        log::trace!(
+                        trace!(
                             "  inst{}: {:?} ({:?}) clobbers:{:?}",
                             inst.index(),
                             operands,
@@ -723,17 +723,17 @@ impl<'a, F: Function> Checker<'a, F> {
                         );
                     }
                     &CheckerInst::Move { from, into } => {
-                        log::trace!("    {} -> {}", from, into);
+                        trace!("    {} -> {}", from, into);
                     }
                     &CheckerInst::DefAlloc { alloc, vreg } => {
-                        log::trace!("    defalloc: {}:{}", vreg, alloc);
+                        trace!("    defalloc: {}:{}", vreg, alloc);
                     }
                     &CheckerInst::Safepoint { ref allocs, .. } => {
                         let mut slotargs = vec![];
                         for &slot in allocs {
                             slotargs.push(format!("{}", slot));
                         }
-                        log::trace!("    safepoint: {}", slotargs.join(", "));
+                        trace!("    safepoint: {}", slotargs.join(", "));
                     }
                 }
                 state.update(inst, &self);
diff --git a/src/ion/dump.rs b/src/ion/dump.rs
index e7a8ed7..d57d59c 100644
--- a/src/ion/dump.rs
+++ b/src/ion/dump.rs
@@ -5,16 +5,16 @@ use crate::{Block, Function, ProgPoint};
 
 impl<'a, F: Function> Env<'a, F> {
     pub fn dump_state(&self) {
-        log::trace!("Bundles:");
+        trace!("Bundles:");
         for (i, b) in self.bundles.iter().enumerate() {
-            log::trace!(
+            trace!(
                 "bundle{}: spillset={:?} alloc={:?}",
                 i,
                 b.spillset,
                 b.allocation
             );
             for entry in &b.ranges {
-                log::trace!(
+                trace!(
                     " * range {:?} -- {:?}: range{}",
                     entry.range.from,
                     entry.range.to,
@@ -22,11 +22,11 @@ impl<'a, F: Function> Env<'a, F> {
                 );
             }
         }
-        log::trace!("VRegs:");
+        trace!("VRegs:");
         for (i, v) in self.vregs.iter().enumerate() {
-            log::trace!("vreg{}:", i);
+            trace!("vreg{}:", i);
             for entry in &v.ranges {
-                log::trace!(
+                trace!(
                     " * range {:?} -- {:?}: range{}",
                     entry.range.from,
                     entry.range.to,
@@ -34,9 +34,9 @@ impl<'a, F: Function> Env<'a, F> {
                 );
             }
         }
-        log::trace!("Ranges:");
+        trace!("Ranges:");
         for (i, r) in self.ranges.iter().enumerate() {
-            log::trace!(
+            trace!(
                 "range{}: range={:?} vreg={:?} bundle={:?} weight={:?}",
                 i,
                 r.range,
@@ -45,7 +45,7 @@ impl<'a, F: Function> Env<'a, F> {
                 r.uses_spill_weight(),
             );
             for u in &r.uses {
-                log::trace!(" * use at {:?} (slot {}): {:?}", u.pos, u.slot, u.operand);
+                trace!(" * use at {:?} (slot {}): {:?}", u.pos, u.slot, u.operand);
             }
         }
     }
diff --git a/src/ion/liveranges.rs b/src/ion/liveranges.rs
index 91dda00..7676a2f 100644
--- a/src/ion/liveranges.rs
+++ b/src/ion/liveranges.rs
@@ -179,7 +179,7 @@ impl<'a, F: Function> Env<'a, F> {
     ///
     /// Returns the liverange that contains the given range.
     pub fn add_liverange_to_vreg(&mut self, vreg: VRegIndex, range: CodeRange) -> LiveRangeIndex {
-        log::trace!("add_liverange_to_vreg: vreg {:?} range {:?}", vreg, range);
+        trace!("add_liverange_to_vreg: vreg {:?} range {:?}", vreg, range);
 
         // Invariant: as we are building liveness information, we
         // *always* process instructions bottom-to-top, and as a
@@ -246,7 +246,7 @@ impl<'a, F: Function> Env<'a, F> {
         );
         u.weight = weight.to_bits();
 
-        log::trace!(
+        trace!(
             "insert use {:?} into lr {:?} with weight {:?}",
             u,
             into,
@@ -262,7 +262,7 @@ impl<'a, F: Function> Env<'a, F> {
         // Update stats.
         let range_weight = self.ranges[into.index()].uses_spill_weight() + weight;
         self.ranges[into.index()].set_uses_spill_weight(range_weight);
-        log::trace!(
+        trace!(
             "  -> now range has weight {:?}",
             self.ranges[into.index()].uses_spill_weight(),
         );
@@ -282,7 +282,7 @@ impl<'a, F: Function> Env<'a, F> {
     }
 
     pub fn add_liverange_to_preg(&mut self, range: CodeRange, reg: PReg) {
-        log::trace!("adding liverange to preg: {:?} to {}", range, reg);
+        trace!("adding liverange to preg: {:?} to {}", range, reg);
         let preg_idx = PRegIndex::new(reg.index());
         self.pregs[preg_idx.index()]
             .allocations
@@ -316,12 +316,12 @@ impl<'a, F: Function> Env<'a, F> {
             workqueue_set.remove(&block);
             let insns = self.func.block_insns(block);
 
-            log::trace!("computing liveins for block{}", block.index());
+            trace!("computing liveins for block{}", block.index());
 
             self.stats.livein_iterations += 1;
 
             let mut live = self.liveouts[block.index()].clone();
-            log::trace!(" -> initial liveout set: {:?}", live);
+            trace!(" -> initial liveout set: {:?}", live);
 
             // Include outgoing blockparams in the initial live set.
             if self.func.is_branch(insns.last()) {
@@ -342,7 +342,7 @@ impl<'a, F: Function> Env<'a, F> {
                     for op in self.func.inst_operands(inst) {
                         if op.pos() == *pos {
                             let was_live = live.get(op.vreg().vreg());
-                            log::trace!("op {:?} was_live = {}", op, was_live);
+                            trace!("op {:?} was_live = {}", op, was_live);
                             match op.kind() {
                                 OperandKind::Use | OperandKind::Mod => {
                                     live.set(op.vreg().vreg(), true);
@@ -368,7 +368,7 @@ impl<'a, F: Function> Env<'a, F> {
                 }
             }
 
-            log::trace!("computed liveins at block{}: {:?}", block.index(), live);
+            trace!("computed liveins at block{}: {:?}", block.index(), live);
             self.liveins[block.index()] = live;
         }
 
@@ -380,7 +380,7 @@ impl<'a, F: Function> Env<'a, F> {
             .next()
             .is_some()
         {
-            log::trace!(
+            trace!(
                 "non-empty liveins to entry block: {:?}",
                 self.liveins[self.func.entry_block().index()]
             );
@@ -449,7 +449,7 @@ impl<'a, F: Function> Env<'a, F> {
                     from: self.cfginfo.block_entry[block.index()],
                     to: self.cfginfo.block_exit[block.index()].next(),
                 };
-                log::trace!(
+                trace!(
                     "vreg {:?} live at end of block --> create range {:?}",
                     VRegIndex::new(vreg),
                     range
@@ -499,7 +499,7 @@ impl<'a, F: Function> Env<'a, F> {
                     // We can completely skip the move if it is
                     // trivial (vreg to same vreg).
                     if src.vreg() != dst.vreg() {
-                        log::trace!(" -> move inst{}: src {} -> dst {}", inst.index(), src, dst);
+                        trace!(" -> move inst{}: src {} -> dst {}", inst.index(), src, dst);
 
                         debug_assert_eq!(src.class(), dst.class());
                         debug_assert_eq!(src.kind(), OperandKind::Use);
@@ -561,9 +561,7 @@ impl<'a, F: Function> Env<'a, F> {
                         else if self.vregs[src.vreg().vreg()].is_pinned
                             || self.vregs[dst.vreg().vreg()].is_pinned
                         {
-                            log::trace!(
-                                " -> exactly one of src/dst is pinned; converting to ghost use"
-                            );
+                            trace!(" -> exactly one of src/dst is pinned; converting to ghost use");
                             let (preg, vreg, pinned_vreg, kind, pos, progpoint) =
                                 if self.vregs[src.vreg().vreg()].is_pinned {
                                     // Source is pinned: this is a def on the dst with a pinned preg.
@@ -589,7 +587,7 @@ impl<'a, F: Function> Env<'a, F> {
                             let constraint = OperandConstraint::FixedReg(preg);
                             let operand = Operand::new(vreg, constraint, kind, pos);
 
-                            log::trace!(
+                            trace!(
                                 concat!(
                                     " -> preg {:?} vreg {:?} kind {:?} ",
                                     "pos {:?} progpoint {:?} constraint {:?} operand {:?}"
@@ -616,9 +614,9 @@ impl<'a, F: Function> Env<'a, F> {
                                     VRegIndex::new(vreg.vreg()),
                                     CodeRange { from, to },
                                 );
-                                log::trace!("   -> dead; created LR");
+                                trace!("   -> dead; created LR");
                             }
-                            log::trace!("  -> LR {:?}", lr);
+                            trace!("  -> LR {:?}", lr);
 
                             self.insert_use_into_liverange(
                                 lr,
@@ -652,7 +650,7 @@ impl<'a, F: Function> Env<'a, F> {
                             // (this is the last use), start it
                             // before.
                             if kind == OperandKind::Def {
-                                log::trace!(" -> src on pinned vreg {:?}", pinned_vreg);
+                                trace!(" -> src on pinned vreg {:?}", pinned_vreg);
                                 // The *other* vreg is a def, so the pinned-vreg
                                 // mention is a use. If already live,
                                 // end the existing LR just *after*
@@ -666,7 +664,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 if live.get(pinned_vreg.vreg()) {
                                     let pinned_lr = vreg_ranges[pinned_vreg.vreg()];
                                     let orig_start = self.ranges[pinned_lr.index()].range.from;
-                                    log::trace!(
+                                    trace!(
                                         " -> live with LR {:?}; truncating to start at {:?}",
                                         pinned_lr,
                                         progpoint.next()
@@ -680,7 +678,7 @@ impl<'a, F: Function> Env<'a, F> {
                                         },
                                     );
                                     vreg_ranges[pinned_vreg.vreg()] = new_lr;
-                                    log::trace!(" -> created LR {:?} with remaining range from {:?} to {:?}", new_lr, orig_start, progpoint);
+                                    trace!(" -> created LR {:?} with remaining range from {:?} to {:?}", new_lr, orig_start, progpoint);
 
                                     // Add an edit right now to indicate that at
                                     // this program point, the given
@@ -714,10 +712,7 @@ impl<'a, F: Function> Env<'a, F> {
                                         );
                                         vreg_ranges[pinned_vreg.vreg()] = new_lr;
                                         live.set(pinned_vreg.vreg(), true);
-                                        log::trace!(
-                                            " -> was not live; created new LR {:?}",
-                                            new_lr
-                                        );
+                                        trace!(" -> was not live; created new LR {:?}", new_lr);
                                     }
 
                                     // Add an edit right now to indicate that at
@@ -734,7 +729,7 @@ impl<'a, F: Function> Env<'a, F> {
                                     );
                                 }
                             } else {
-                                log::trace!(" -> dst on pinned vreg {:?}", pinned_vreg);
+                                trace!(" -> dst on pinned vreg {:?}", pinned_vreg);
                                 // The *other* vreg is a use, so the pinned-vreg
                                 // mention is a def. Truncate its LR
                                 // just *after* the `progpoint`
@@ -742,7 +737,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 if live.get(pinned_vreg.vreg()) {
                                     let pinned_lr = vreg_ranges[pinned_vreg.vreg()];
                                     self.ranges[pinned_lr.index()].range.from = progpoint.next();
-                                    log::trace!(
+                                    trace!(
                                         " -> was live with LR {:?}; truncated start to {:?}",
                                         pinned_lr,
                                         progpoint.next()
@@ -842,14 +837,14 @@ impl<'a, F: Function> Env<'a, F> {
                                     VRegIndex::new(dst.vreg().vreg()),
                                     CodeRange { from, to },
                                 );
-                                log::trace!(" -> invalid LR for def; created {:?}", dst_lr);
+                                trace!(" -> invalid LR for def; created {:?}", dst_lr);
                             }
-                            log::trace!(" -> has existing LR {:?}", dst_lr);
+                            trace!(" -> has existing LR {:?}", dst_lr);
                             // Trim the LR to start here.
                             if self.ranges[dst_lr.index()].range.from
                                 == self.cfginfo.block_entry[block.index()]
                             {
-                                log::trace!(" -> started at block start; trimming to {:?}", pos);
+                                trace!(" -> started at block start; trimming to {:?}", pos);
                                 self.ranges[dst_lr.index()].range.from = pos;
                             }
                             self.ranges[dst_lr.index()].set_flag(LiveRangeFlag::StartsAtDef);
@@ -876,7 +871,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 vreg_ranges[src.vreg().vreg()]
                             };
 
-                            log::trace!(" -> src LR {:?}", src_lr);
+                            trace!(" -> src LR {:?}", src_lr);
 
                             // Add to live-set.
                             let src_is_dead_after_move = !live.get(src.vreg().vreg());
@@ -929,7 +924,7 @@ impl<'a, F: Function> Env<'a, F> {
                             continue;
                         }
 
-                        log::trace!(
+                        trace!(
                             "processing inst{} operand at {:?}: {:?}",
                             inst.index(),
                             pos,
@@ -938,14 +933,14 @@ impl<'a, F: Function> Env<'a, F> {
 
                         match operand.kind() {
                             OperandKind::Def | OperandKind::Mod => {
-                                log::trace!("Def of {} at {:?}", operand.vreg(), pos);
+                                trace!("Def of {} at {:?}", operand.vreg(), pos);
 
                                 // Fill in vreg's actual data.
                                 self.vreg_regs[operand.vreg().vreg()] = operand.vreg();
 
                                 // Get or create the LiveRange.
                                 let mut lr = vreg_ranges[operand.vreg().vreg()];
-                                log::trace!(" -> has existing LR {:?}", lr);
+                                trace!(" -> has existing LR {:?}", lr);
                                 // If there was no liverange (dead def), create a trivial one.
                                 if !live.get(operand.vreg().vreg()) {
                                     let from = match operand.kind() {
@@ -962,7 +957,7 @@ impl<'a, F: Function> Env<'a, F> {
                                         VRegIndex::new(operand.vreg().vreg()),
                                         CodeRange { from, to },
                                     );
-                                    log::trace!(" -> invalid; created {:?}", lr);
+                                    trace!(" -> invalid; created {:?}", lr);
                                     vreg_ranges[operand.vreg().vreg()] = lr;
                                     live.set(operand.vreg().vreg(), true);
                                 }
@@ -979,10 +974,7 @@ impl<'a, F: Function> Env<'a, F> {
                                     if self.ranges[lr.index()].range.from
                                         == self.cfginfo.block_entry[block.index()]
                                     {
-                                        log::trace!(
-                                            " -> started at block start; trimming to {:?}",
-                                            pos
-                                        );
+                                        trace!(" -> started at block start; trimming to {:?}", pos);
                                         self.ranges[lr.index()].range.from = pos;
                                     }
 
@@ -1011,7 +1003,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 }
                                 debug_assert!(lr.is_valid());
 
-                                log::trace!("Use of {:?} at {:?} -> {:?}", operand, pos, lr,);
+                                trace!("Use of {:?} at {:?} -> {:?}", operand, pos, lr,);
 
                                 self.insert_use_into_liverange(lr, Use::new(operand, pos, i as u8));
 
@@ -1023,11 +1015,11 @@ impl<'a, F: Function> Env<'a, F> {
                 }
 
                 if self.func.requires_refs_on_stack(inst) {
-                    log::trace!("inst{} is safepoint", inst.index());
+                    trace!("inst{} is safepoint", inst.index());
                     self.safepoints.push(inst);
                     for vreg in live.iter() {
                         if let Some(safepoints) = self.safepoints_per_vreg.get_mut(&vreg) {
-                            log::trace!("vreg v{} live at safepoint inst{}", vreg, inst.index());
+                            trace!("vreg v{} live at safepoint inst{}", vreg, inst.index());
                             safepoints.insert(inst);
                         }
                     }
@@ -1124,7 +1116,7 @@ impl<'a, F: Function> Env<'a, F> {
                         OperandPos::Early,
                     );
 
-                    log::trace!(
+                    trace!(
                         "Safepoint-induced stack use of {:?} at {:?} -> {:?}",
                         operand,
                         pos,
@@ -1154,8 +1146,8 @@ impl<'a, F: Function> Env<'a, F> {
         self.prog_move_srcs.sort_unstable_by_key(|(pos, _)| *pos);
         self.prog_move_dsts.sort_unstable_by_key(|(pos, _)| *pos);
 
-        log::trace!("prog_move_srcs = {:?}", self.prog_move_srcs);
-        log::trace!("prog_move_dsts = {:?}", self.prog_move_dsts);
+        trace!("prog_move_srcs = {:?}", self.prog_move_srcs);
+        trace!("prog_move_dsts = {:?}", self.prog_move_dsts);
 
         self.stats.initial_liverange_count = self.ranges.len();
         self.stats.blockparam_ins_count = self.blockparam_ins.len();
@@ -1177,7 +1169,7 @@ impl<'a, F: Function> Env<'a, F> {
             for range_idx in 0..self.vregs[vreg].ranges.len() {
                 let entry = self.vregs[vreg].ranges[range_idx];
                 let range = entry.index;
-                log::trace!(
+                trace!(
                     "multi-fixed-reg cleanup: vreg {:?} range {:?}",
                     VRegIndex::new(vreg),
                     range,
@@ -1246,7 +1238,7 @@ impl<'a, F: Function> Env<'a, F> {
                         if let OperandConstraint::FixedReg(preg) = u.operand.constraint() {
                             let vreg_idx = VRegIndex::new(u.operand.vreg().vreg());
                             let preg_idx = PRegIndex::new(preg.index());
-                            log::trace!(
+                            trace!(
                                 "at pos {:?}, vreg {:?} has fixed constraint to preg {:?}",
                                 u.pos,
                                 vreg_idx,
@@ -1265,7 +1257,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 continue;
                             }
 
-                            log::trace!(" -> duplicate; switching to constraint Any");
+                            trace!(" -> duplicate; switching to constraint Any");
                             self.multi_fixed_reg_fixups.push(MultiFixedRegFixup {
                                 pos: u.pos,
                                 from_slot: source_slot,
@@ -1279,11 +1271,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 u.operand.kind(),
                                 u.operand.pos(),
                             );
-                            log::trace!(
-                                " -> extra clobber {} at inst{}",
-                                preg,
-                                u.pos.inst().index()
-                            );
+                            trace!(" -> extra clobber {} at inst{}", preg, u.pos.inst().index());
                             extra_clobbers.push((preg, u.pos.inst()));
                         }
                     }
diff --git a/src/ion/merge.rs b/src/ion/merge.rs
index 3649f61..89ec386 100644
--- a/src/ion/merge.rs
+++ b/src/ion/merge.rs
@@ -25,7 +25,7 @@ impl<'a, F: Function> Env<'a, F> {
             // Merge bundle into self -- trivial merge.
             return true;
         }
-        log::trace!(
+        trace!(
             "merging from bundle{} to bundle{}",
             from.index(),
             to.index()
@@ -35,7 +35,7 @@ impl<'a, F: Function> Env<'a, F> {
         let from_rc = self.spillsets[self.bundles[from.index()].spillset.index()].class;
         let to_rc = self.spillsets[self.bundles[to.index()].spillset.index()].class;
         if from_rc != to_rc {
-            log::trace!(" -> mismatching reg classes");
+            trace!(" -> mismatching reg classes");
             return false;
         }
 
@@ -43,7 +43,7 @@ impl<'a, F: Function> Env<'a, F> {
         if self.bundles[from.index()].allocation.is_some()
             || self.bundles[to.index()].allocation.is_some()
         {
-            log::trace!("one of the bundles is already assigned (pinned)");
+            trace!("one of the bundles is already assigned (pinned)");
             return false;
         }
 
@@ -70,7 +70,7 @@ impl<'a, F: Function> Env<'a, F> {
         while idx_from < ranges_from.len() && idx_to < ranges_to.len() {
             range_count += 1;
             if range_count > 200 {
-                log::trace!(
+                trace!(
                     "reached merge complexity (range_count = {}); exiting",
                     range_count
                 );
@@ -84,7 +84,7 @@ impl<'a, F: Function> Env<'a, F> {
                 idx_from += 1;
             } else {
                 // Overlap -- cannot merge.
-                log::trace!(
+                trace!(
                     " -> overlap between {:?} and {:?}, exiting",
                     ranges_from[idx_from].index,
                     ranges_to[idx_to].index
@@ -100,12 +100,12 @@ impl<'a, F: Function> Env<'a, F> {
             || self.bundles[to.index()].cached_fixed()
         {
             if self.merge_bundle_requirements(from, to).is_err() {
-                log::trace!(" -> conflicting requirements; aborting merge");
+                trace!(" -> conflicting requirements; aborting merge");
                 return false;
             }
         }
 
-        log::trace!(" -> committing to merge");
+        trace!(" -> committing to merge");
 
         // If we reach here, then the bundles do not overlap -- merge
         // them!  We do this with a merge-sort-like scan over both
@@ -113,13 +113,13 @@ impl<'a, F: Function> Env<'a, F> {
         // `to` when we're done.
         if ranges_from.is_empty() {
             // `from` bundle is empty -- trivial merge.
-            log::trace!(" -> from bundle{} is empty; trivial merge", from.index());
+            trace!(" -> from bundle{} is empty; trivial merge", from.index());
             return true;
         }
         if ranges_to.is_empty() {
             // `to` bundle is empty -- just move the list over from
             // `from` and set `bundle` up-link on all ranges.
-            log::trace!(" -> to bundle{} is empty; trivial merge", to.index());
+            trace!(" -> to bundle{} is empty; trivial merge", to.index());
             let list = std::mem::replace(&mut self.bundles[from.index()].ranges, smallvec![]);
             for entry in &list {
                 self.ranges[entry.index.index()].bundle = to;
@@ -149,7 +149,7 @@ impl<'a, F: Function> Env<'a, F> {
             return true;
         }
 
-        log::trace!(
+        trace!(
             "merging: ranges_from = {:?} ranges_to = {:?}",
             ranges_from,
             ranges_to
@@ -170,7 +170,7 @@ impl<'a, F: Function> Env<'a, F> {
             .sort_unstable_by_key(|entry| entry.range.from);
 
         if self.annotations_enabled {
-            log::trace!("merging: merged = {:?}", self.bundles[to.index()].ranges);
+            trace!("merging: merged = {:?}", self.bundles[to.index()].ranges);
             let mut last_range = None;
             for i in 0..self.bundles[to.index()].ranges.len() {
                 let entry = self.bundles[to.index()].ranges[i];
@@ -192,7 +192,7 @@ impl<'a, F: Function> Env<'a, F> {
                     );
                 }
 
-                log::trace!(
+                trace!(
                     " -> merged result for bundle{}: range{}",
                     to.index(),
                     entry.index.index(),
@@ -225,7 +225,7 @@ impl<'a, F: Function> Env<'a, F> {
 
     pub fn merge_vreg_bundles(&mut self) {
         // Create a bundle for every vreg, initially.
-        log::trace!("merge_vreg_bundles: creating vreg bundles");
+        trace!("merge_vreg_bundles: creating vreg bundles");
         for vreg in 0..self.vregs.len() {
             let vreg = VRegIndex::new(vreg);
             if self.vregs[vreg.index()].ranges.is_empty() {
@@ -251,9 +251,9 @@ impl<'a, F: Function> Env<'a, F> {
 
             let bundle = self.create_bundle();
             self.bundles[bundle.index()].ranges = self.vregs[vreg.index()].ranges.clone();
-            log::trace!("vreg v{} gets bundle{}", vreg.index(), bundle.index());
+            trace!("vreg v{} gets bundle{}", vreg.index(), bundle.index());
             for entry in &self.bundles[bundle.index()].ranges {
-                log::trace!(
+                trace!(
                     " -> with LR range{}: {:?}",
                     entry.index.index(),
                     entry.range
@@ -314,7 +314,7 @@ impl<'a, F: Function> Env<'a, F> {
                         continue;
                     }
 
-                    log::trace!(
+                    trace!(
                         "trying to merge reused-input def: src {} to dst {}",
                         src_vreg,
                         dst_vreg
@@ -335,7 +335,7 @@ impl<'a, F: Function> Env<'a, F> {
             let BlockparamOut {
                 from_vreg, to_vreg, ..
             } = self.blockparam_outs[i];
-            log::trace!(
+            trace!(
                 "trying to merge blockparam v{} with input v{}",
                 to_vreg.index(),
                 from_vreg.index()
@@ -345,7 +345,7 @@ impl<'a, F: Function> Env<'a, F> {
             let from_bundle =
                 self.ranges[self.vregs[from_vreg.index()].ranges[0].index.index()].bundle;
             debug_assert!(from_bundle.is_valid());
-            log::trace!(
+            trace!(
                 " -> from bundle{} to bundle{}",
                 from_bundle.index(),
                 to_bundle.index()
@@ -356,10 +356,10 @@ impl<'a, F: Function> Env<'a, F> {
         // Attempt to merge move srcs/dsts.
         for i in 0..self.prog_move_merges.len() {
             let (src, dst) = self.prog_move_merges[i];
-            log::trace!("trying to merge move src LR {:?} to dst LR {:?}", src, dst);
+            trace!("trying to merge move src LR {:?} to dst LR {:?}", src, dst);
             let src = self.resolve_merged_lr(src);
             let dst = self.resolve_merged_lr(dst);
-            log::trace!(
+            trace!(
                 "resolved LR-construction merging chains: move-merge is now src LR {:?} to dst LR {:?}",
                 src,
                 dst
@@ -395,7 +395,7 @@ impl<'a, F: Function> Env<'a, F> {
             }
         }
 
-        log::trace!("done merging bundles");
+        trace!("done merging bundles");
     }
 
     pub fn resolve_merged_lr(&self, mut lr: LiveRangeIndex) -> LiveRangeIndex {
@@ -419,14 +419,14 @@ impl<'a, F: Function> Env<'a, F> {
 
     pub fn queue_bundles(&mut self) {
         for bundle in 0..self.bundles.len() {
-            log::trace!("enqueueing bundle{}", bundle);
+            trace!("enqueueing bundle{}", bundle);
             if self.bundles[bundle].ranges.is_empty() {
-                log::trace!(" -> no ranges; skipping");
+                trace!(" -> no ranges; skipping");
                 continue;
             }
             let bundle = LiveBundleIndex::new(bundle);
             let prio = self.compute_bundle_prio(bundle);
-            log::trace!(" -> prio {}", prio);
+            trace!(" -> prio {}", prio);
             self.bundles[bundle.index()].prio = prio;
             self.recompute_bundle_properties(bundle);
             self.allocation_queue
diff --git a/src/ion/moves.rs b/src/ion/moves.rs
index c6da9d9..0002cb5 100644
--- a/src/ion/moves.rs
+++ b/src/ion/moves.rs
@@ -54,7 +54,7 @@ impl<'a, F: Function> Env<'a, F> {
         to_alloc: Allocation,
         to_vreg: Option<VReg>,
     ) {
-        log::trace!(
+        trace!(
             "insert_move: pos {:?} prio {:?} from_alloc {:?} to_alloc {:?}",
             pos,
             prio,
@@ -89,16 +89,16 @@ impl<'a, F: Function> Env<'a, F> {
     }
 
     pub fn get_alloc_for_range(&self, range: LiveRangeIndex) -> Allocation {
-        log::trace!("get_alloc_for_range: {:?}", range);
+        trace!("get_alloc_for_range: {:?}", range);
         let bundle = self.ranges[range.index()].bundle;
-        log::trace!(" -> bundle: {:?}", bundle);
+        trace!(" -> bundle: {:?}", bundle);
         let bundledata = &self.bundles[bundle.index()];
-        log::trace!(" -> allocation {:?}", bundledata.allocation);
+        trace!(" -> allocation {:?}", bundledata.allocation);
         if bundledata.allocation != Allocation::none() {
             bundledata.allocation
         } else {
-            log::trace!(" -> spillset {:?}", bundledata.spillset);
-            log::trace!(
+            trace!(" -> spillset {:?}", bundledata.spillset);
+            trace!(
                 " -> spill slot {:?}",
                 self.spillsets[bundledata.spillset.index()].slot
             );
@@ -107,9 +107,9 @@ impl<'a, F: Function> Env<'a, F> {
     }
 
     pub fn apply_allocations_and_insert_moves(&mut self) {
-        log::trace!("apply_allocations_and_insert_moves");
-        log::trace!("blockparam_ins: {:?}", self.blockparam_ins);
-        log::trace!("blockparam_outs: {:?}", self.blockparam_outs);
+        trace!("apply_allocations_and_insert_moves");
+        trace!("blockparam_ins: {:?}", self.blockparam_ins);
+        trace!("blockparam_outs: {:?}", self.blockparam_outs);
 
         // Now that all splits are done, we can pay the cost once to
         // sort VReg range lists and update with the final ranges.
@@ -205,7 +205,7 @@ impl<'a, F: Function> Env<'a, F> {
                     .map(|preg| Allocation::reg(preg))
                     .unwrap_or_else(|| self.get_alloc_for_range(entry.index));
                 let range = entry.range;
-                log::trace!(
+                trace!(
                     "apply_allocations: vreg {:?} LR {:?} with range {:?} has alloc {:?} (pinned {:?})",
                     vreg,
                     entry.index,
@@ -272,7 +272,7 @@ impl<'a, F: Function> Env<'a, F> {
                         && !self.is_start_of_block(range.from)
                         && !first_is_def
                     {
-                        log::trace!(
+                        trace!(
                             "prev LR {} abuts LR {} in same block; moving {} -> {} for v{}",
                             prev.index(),
                             entry.index.index(),
@@ -306,9 +306,9 @@ impl<'a, F: Function> Env<'a, F> {
                         if range.to < self.cfginfo.block_exit[block.index()].next() {
                             break;
                         }
-                        log::trace!("examining block with end in range: block{}", block.index());
+                        trace!("examining block with end in range: block{}", block.index());
                         for &succ in self.func.block_succs(block) {
-                            log::trace!(
+                            trace!(
                                 " -> has succ block {} with entry {:?}",
                                 succ.index(),
                                 self.cfginfo.block_entry[succ.index()]
@@ -316,9 +316,9 @@ impl<'a, F: Function> Env<'a, F> {
                             if range.contains_point(self.cfginfo.block_entry[succ.index()]) {
                                 continue;
                             }
-                            log::trace!(" -> out of this range, requires half-move if live");
+                            trace!(" -> out of this range, requires half-move if live");
                             if self.is_live_in(succ, vreg) {
-                                log::trace!("  -> live at input to succ, adding halfmove");
+                                trace!("  -> live at input to succ, adding halfmove");
                                 half_moves.push(HalfMove {
                                     key: half_move_key(block, succ, vreg, HalfMoveKind::Source),
                                     alloc,
@@ -329,7 +329,7 @@ impl<'a, F: Function> Env<'a, F> {
                         // Scan forward in `blockparam_outs`, adding all
                         // half-moves for outgoing values to blockparams
                         // in succs.
-                        log::trace!(
+                        trace!(
                             "scanning blockparam_outs for v{} block{}: blockparam_out_idx = {}",
                             vreg.index(),
                             block.index(),
@@ -346,7 +346,7 @@ impl<'a, F: Function> Env<'a, F> {
                                 break;
                             }
                             if (from_vreg, from_block) == (vreg, block) {
-                                log::trace!(
+                                trace!(
                                     " -> found: from v{} block{} to v{} block{}",
                                     from_vreg.index(),
                                     from_block.index(),
@@ -398,7 +398,7 @@ impl<'a, F: Function> Env<'a, F> {
                         }
 
                         // Add half-moves for blockparam inputs.
-                        log::trace!(
+                        trace!(
                             "scanning blockparam_ins at vreg {} block {}: blockparam_in_idx = {}",
                             vreg.index(),
                             block.index(),
@@ -423,7 +423,7 @@ impl<'a, F: Function> Env<'a, F> {
                                     ),
                                     alloc,
                                 });
-                                log::trace!(
+                                trace!(
                                     "match: blockparam_in: v{} in block{} from block{} into {}",
                                     to_vreg.index(),
                                     to_block.index(),
@@ -454,7 +454,7 @@ impl<'a, F: Function> Env<'a, F> {
                             continue;
                         }
 
-                        log::trace!(
+                        trace!(
                             "scanning preds at vreg {} block {} for ends outside the range",
                             vreg.index(),
                             block.index()
@@ -463,7 +463,7 @@ impl<'a, F: Function> Env<'a, F> {
                         // Now find any preds whose ends are not in the
                         // same range, and insert appropriate moves.
                         for &pred in self.func.block_preds(block) {
-                            log::trace!(
+                            trace!(
                                 "pred block {} has exit {:?}",
                                 pred.index(),
                                 self.cfginfo.block_exit[pred.index()]
@@ -471,7 +471,7 @@ impl<'a, F: Function> Env<'a, F> {
                             if range.contains_point(self.cfginfo.block_exit[pred.index()]) {
                                 continue;
                             }
-                            log::trace!(" -> requires half-move");
+                            trace!(" -> requires half-move");
                             half_moves.push(HalfMove {
                                 key: half_move_key(pred, block, vreg, HalfMoveKind::Dest),
                                 alloc,
@@ -504,7 +504,7 @@ impl<'a, F: Function> Env<'a, F> {
                 // Scan over def/uses and apply allocations.
                 for use_idx in 0..self.ranges[entry.index.index()].uses.len() {
                     let usedata = self.ranges[entry.index.index()].uses[use_idx];
-                    log::trace!("applying to use: {:?}", usedata);
+                    trace!("applying to use: {:?}", usedata);
                     debug_assert!(range.contains_point(usedata.pos));
                     let inst = usedata.pos.inst();
                     let slot = usedata.slot;
@@ -533,7 +533,7 @@ impl<'a, F: Function> Env<'a, F> {
                 // covers only prev inst's After; so includes move
                 // srcs to (exclusive) inst.
                 let move_src_end = (vreg, range.to.inst());
-                log::trace!(
+                trace!(
                     "vreg {:?} range {:?}: looking for program-move sources from {:?} to {:?}",
                     vreg,
                     range,
@@ -543,13 +543,13 @@ impl<'a, F: Function> Env<'a, F> {
                 while prog_move_src_idx < self.prog_move_srcs.len()
                     && self.prog_move_srcs[prog_move_src_idx].0 < move_src_start
                 {
-                    log::trace!(" -> skipping idx {}", prog_move_src_idx);
+                    trace!(" -> skipping idx {}", prog_move_src_idx);
                     prog_move_src_idx += 1;
                 }
                 while prog_move_src_idx < self.prog_move_srcs.len()
                     && self.prog_move_srcs[prog_move_src_idx].0 < move_src_end
                 {
-                    log::trace!(
+                    trace!(
                         " -> setting idx {} ({:?}) to alloc {:?}",
                         prog_move_src_idx,
                         self.prog_move_srcs[prog_move_src_idx].0,
@@ -576,7 +576,7 @@ impl<'a, F: Function> Env<'a, F> {
                 } else {
                     (vreg, range.to.inst().next())
                 };
-                log::trace!(
+                trace!(
                     "vreg {:?} range {:?}: looking for program-move dests from {:?} to {:?}",
                     vreg,
                     range,
@@ -586,13 +586,13 @@ impl<'a, F: Function> Env<'a, F> {
                 while prog_move_dst_idx < self.prog_move_dsts.len()
                     && self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_start
                 {
-                    log::trace!(" -> skipping idx {}", prog_move_dst_idx);
+                    trace!(" -> skipping idx {}", prog_move_dst_idx);
                     prog_move_dst_idx += 1;
                 }
                 while prog_move_dst_idx < self.prog_move_dsts.len()
                     && self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_end
                 {
-                    log::trace!(
+                    trace!(
                         " -> setting idx {} ({:?}) to alloc {:?}",
                         prog_move_dst_idx,
                         self.prog_move_dsts[prog_move_dst_idx].0,
@@ -610,7 +610,7 @@ impl<'a, F: Function> Env<'a, F> {
         // from-vreg) tuple, find the from-alloc and all the
         // to-allocs, and insert moves on the block edge.
         half_moves.sort_unstable_by_key(|h| h.key);
-        log::trace!("halfmoves: {:?}", half_moves);
+        trace!("halfmoves: {:?}", half_moves);
         self.stats.halfmoves_count = half_moves.len();
 
         let mut i = 0;
@@ -633,7 +633,7 @@ impl<'a, F: Function> Env<'a, F> {
             }
             let last_dest = i;
 
-            log::trace!(
+            trace!(
                 "halfmove match: src {:?} dests {:?}",
                 src,
                 &half_moves[first_dest..last_dest]
@@ -712,7 +712,7 @@ impl<'a, F: Function> Env<'a, F> {
         for fixup in std::mem::replace(&mut self.multi_fixed_reg_fixups, vec![]) {
             let from_alloc = self.get_alloc(fixup.pos.inst(), fixup.from_slot as usize);
             let to_alloc = Allocation::reg(PReg::from_index(fixup.to_preg.index()));
-            log::trace!(
+            trace!(
                 "multi-fixed-move constraint at {:?} from {} to {} for v{}",
                 fixup.pos,
                 from_alloc,
@@ -787,7 +787,7 @@ impl<'a, F: Function> Env<'a, F> {
                     input_reused.push(input_idx);
                     let input_alloc = self.get_alloc(inst, input_idx);
                     let output_alloc = self.get_alloc(inst, output_idx);
-                    log::trace!(
+                    trace!(
                         "reuse-input inst {:?}: output {} has alloc {:?}, input {} has alloc {:?}",
                         inst,
                         output_idx,
@@ -834,7 +834,7 @@ impl<'a, F: Function> Env<'a, F> {
         for (&((_, from_inst), from_alloc), &((to_vreg, to_inst), to_alloc)) in
             prog_move_srcs.iter().zip(prog_move_dsts.iter())
         {
-            log::trace!(
+            trace!(
                 "program move at inst {:?}: alloc {:?} -> {:?} (v{})",
                 from_inst,
                 from_alloc,
@@ -971,14 +971,14 @@ impl<'a, F: Function> Env<'a, F> {
                 // that can be done one at a time.
                 let scratch = self.env.scratch_by_class[regclass as u8 as usize];
                 let mut parallel_moves = ParallelMoves::new(Allocation::reg(scratch));
-                log::trace!(
+                trace!(
                     "parallel moves at pos {:?} prio {:?}",
                     pos_prio.pos,
                     pos_prio.prio
                 );
                 for m in moves {
                     if (m.from_alloc != m.to_alloc) || m.to_vreg.is_some() {
-                        log::trace!(" {} -> {}", m.from_alloc, m.to_alloc,);
+                        trace!(" {} -> {}", m.from_alloc, m.to_alloc,);
                         parallel_moves.add(m.from_alloc, m.to_alloc, m.to_vreg);
                     }
                 }
@@ -1009,7 +1009,7 @@ impl<'a, F: Function> Env<'a, F> {
 
                 let mut scratch_used_yet = false;
                 for (src, dst, to_vreg) in resolved {
-                    log::trace!("  resolved: {} -> {} ({:?})", src, dst, to_vreg);
+                    trace!("  resolved: {} -> {} ({:?})", src, dst, to_vreg);
                     let action = redundant_moves.process_move(src, dst, to_vreg);
                     if !action.elide {
                         if dst == Allocation::reg(scratch) {
@@ -1060,11 +1060,11 @@ impl<'a, F: Function> Env<'a, F> {
                             self.add_move_edit(pos_prio, src, dst, to_vreg);
                         }
                     } else {
-                        log::trace!("    -> redundant move elided");
+                        trace!("    -> redundant move elided");
                     }
                     #[cfg(feature = "checker")]
                     if let Some((alloc, vreg)) = action.def_alloc {
-                        log::trace!(
+                        trace!(
                             "     -> converted to DefAlloc: alloc {} vreg {}",
                             alloc,
                             vreg
@@ -1076,7 +1076,7 @@ impl<'a, F: Function> Env<'a, F> {
 
             #[cfg(feature = "checker")]
             for m in &self_moves {
-                log::trace!(
+                trace!(
                     "self move at pos {:?} prio {:?}: {} -> {} to_vreg {:?}",
                     pos_prio.pos,
                     pos_prio.prio,
@@ -1087,7 +1087,7 @@ impl<'a, F: Function> Env<'a, F> {
                 let action = redundant_moves.process_move(m.from_alloc, m.to_alloc, m.to_vreg);
                 debug_assert!(action.elide);
                 if let Some((alloc, vreg)) = action.def_alloc {
-                    log::trace!(" -> DefAlloc: alloc {} vreg {}", alloc, vreg);
+                    trace!(" -> DefAlloc: alloc {} vreg {}", alloc, vreg);
                     self.edits.push((pos_prio, Edit::DefAlloc { alloc, vreg }));
                 }
             }
diff --git a/src/ion/process.rs b/src/ion/process.rs
index 8b5a7a8..48c0381 100644
--- a/src/ion/process.rs
+++ b/src/ion/process.rs
@@ -62,7 +62,7 @@ impl<'a, F: Function> Env<'a, F> {
         // `AllocRegResult::ConflictHighCost`.
         max_allowable_cost: Option<u32>,
     ) -> AllocRegResult {
-        log::trace!("try_to_allocate_bundle_to_reg: {:?} -> {:?}", bundle, reg);
+        trace!("try_to_allocate_bundle_to_reg: {:?} -> {:?}", bundle, reg);
         let mut conflicts = smallvec![];
         let mut conflict_set = FxHashSet::default();
         let mut max_conflict_weight = 0;
@@ -89,7 +89,7 @@ impl<'a, F: Function> Env<'a, F> {
             .btree
             .range(from_key..)
             .peekable();
-        log::trace!(
+        trace!(
             "alloc map for {:?} in range {:?}..: {:?}",
             reg,
             from_key,
@@ -98,19 +98,19 @@ impl<'a, F: Function> Env<'a, F> {
         let mut first_conflict: Option<ProgPoint> = None;
 
         'ranges: for entry in bundle_ranges {
-            log::trace!(" -> range LR {:?}: {:?}", entry.index, entry.range);
+            trace!(" -> range LR {:?}: {:?}", entry.index, entry.range);
             let key = LiveRangeKey::from_range(&entry.range);
 
             let mut skips = 0;
             'alloc: loop {
-                log::trace!("  -> PReg range {:?}", preg_range_iter.peek());
+                trace!("  -> PReg range {:?}", preg_range_iter.peek());
 
                 // Advance our BTree traversal until it is >= this bundle
                 // range (i.e., skip PReg allocations in the BTree that
                 // are completely before this bundle range).
 
                 if preg_range_iter.peek().is_some() && *preg_range_iter.peek().unwrap().0 < key {
-                    log::trace!(
+                    trace!(
                         "Skipping PReg range {:?}",
                         preg_range_iter.peek().unwrap().0
                     );
@@ -135,13 +135,13 @@ impl<'a, F: Function> Env<'a, F> {
 
                 // If there are no more PReg allocations, we're done!
                 if preg_range_iter.peek().is_none() {
-                    log::trace!(" -> no more PReg allocations; so no conflict possible!");
+                    trace!(" -> no more PReg allocations; so no conflict possible!");
                     break 'ranges;
                 }
 
                 // If the current PReg range is beyond this range, there is no conflict; continue.
                 if *preg_range_iter.peek().unwrap().0 > key {
-                    log::trace!(
+                    trace!(
                         " -> next PReg allocation is at {:?}; moving to next VReg range",
                         preg_range_iter.peek().unwrap().0
                     );
@@ -153,13 +153,13 @@ impl<'a, F: Function> Env<'a, F> {
                 debug_assert_eq!(preg_key, key); // Assert that this range overlaps.
                 let preg_range = preg_range_iter.next().unwrap().1;
 
-                log::trace!(" -> btree contains range {:?} that overlaps", preg_range);
+                trace!(" -> btree contains range {:?} that overlaps", preg_range);
                 if preg_range.is_valid() {
-                    log::trace!("   -> from vreg {:?}", self.ranges[preg_range.index()].vreg);
+                    trace!("   -> from vreg {:?}", self.ranges[preg_range.index()].vreg);
                     // range from an allocated bundle: find the bundle and add to
                     // conflicts list.
                     let conflict_bundle = self.ranges[preg_range.index()].bundle;
-                    log::trace!("   -> conflict bundle {:?}", conflict_bundle);
+                    trace!("   -> conflict bundle {:?}", conflict_bundle);
                     if !conflict_set.contains(&conflict_bundle) {
                         conflicts.push(conflict_bundle);
                         conflict_set.insert(conflict_bundle);
@@ -170,7 +170,7 @@ impl<'a, F: Function> Env<'a, F> {
                         if max_allowable_cost.is_some()
                             && max_conflict_weight > max_allowable_cost.unwrap()
                         {
-                            log::trace!("   -> reached high cost, retrying early");
+                            trace!("   -> reached high cost, retrying early");
                             return AllocRegResult::ConflictHighCost;
                         }
                     }
@@ -182,7 +182,7 @@ impl<'a, F: Function> Env<'a, F> {
                         )));
                     }
                 } else {
-                    log::trace!("   -> conflict with fixed reservation");
+                    trace!("   -> conflict with fixed reservation");
                     // range from a direct use of the PReg (due to clobber).
                     return AllocRegResult::ConflictWithFixed(
                         max_conflict_weight,
@@ -198,7 +198,7 @@ impl<'a, F: Function> Env<'a, F> {
 
         // We can allocate! Add our ranges to the preg's BTree.
         let preg = PReg::from_index(reg.index());
-        log::trace!("  -> bundle {:?} assigned to preg {:?}", bundle, preg);
+        trace!("  -> bundle {:?} assigned to preg {:?}", bundle, preg);
         self.bundles[bundle.index()].allocation = Allocation::reg(preg);
         for entry in &self.bundles[bundle.index()].ranges {
             self.pregs[reg.index()]
@@ -211,7 +211,7 @@ impl<'a, F: Function> Env<'a, F> {
     }
 
     pub fn evict_bundle(&mut self, bundle: LiveBundleIndex) {
-        log::trace!(
+        trace!(
             "evicting bundle {:?}: alloc {:?}",
             bundle,
             self.bundles[bundle.index()].allocation
@@ -219,7 +219,7 @@ impl<'a, F: Function> Env<'a, F> {
         let preg = match self.bundles[bundle.index()].allocation.as_reg() {
             Some(preg) => preg,
             None => {
-                log::trace!(
+                trace!(
                     "  -> has no allocation! {:?}",
                     self.bundles[bundle.index()].allocation
                 );
@@ -229,14 +229,14 @@ impl<'a, F: Function> Env<'a, F> {
         let preg_idx = PRegIndex::new(preg.index());
         self.bundles[bundle.index()].allocation = Allocation::none();
         for entry in &self.bundles[bundle.index()].ranges {
-            log::trace!(" -> removing LR {:?} from reg {:?}", entry.index, preg_idx);
+            trace!(" -> removing LR {:?} from reg {:?}", entry.index, preg_idx);
             self.pregs[preg_idx.index()]
                 .allocations
                 .btree
                 .remove(&LiveRangeKey::from_range(&entry.range));
         }
         let prio = self.bundles[bundle.index()].prio;
-        log::trace!(" -> prio {}; back into queue", prio);
+        trace!(" -> prio {}; back into queue", prio);
         self.allocation_queue
             .insert(bundle, prio as usize, PReg::invalid());
     }
@@ -246,22 +246,22 @@ impl<'a, F: Function> Env<'a, F> {
     }
 
     pub fn maximum_spill_weight_in_bundle_set(&self, bundles: &LiveBundleVec) -> u32 {
-        log::trace!("maximum_spill_weight_in_bundle_set: {:?}", bundles);
+        trace!("maximum_spill_weight_in_bundle_set: {:?}", bundles);
         let m = bundles
             .iter()
             .map(|&b| {
                 let w = self.bundles[b.index()].cached_spill_weight();
-                log::trace!("bundle{}: {}", b.index(), w);
+                trace!("bundle{}: {}", b.index(), w);
                 w
             })
             .max()
             .unwrap_or(0);
-        log::trace!(" -> max: {}", m);
+        trace!(" -> max: {}", m);
         m
     }
 
     pub fn recompute_bundle_properties(&mut self, bundle: LiveBundleIndex) {
-        log::trace!("recompute bundle properties: bundle {:?}", bundle);
+        trace!("recompute bundle properties: bundle {:?}", bundle);
 
         let minimal;
         let mut fixed = false;
@@ -273,18 +273,18 @@ impl<'a, F: Function> Env<'a, F> {
         self.bundles[bundle.index()].prio = self.compute_bundle_prio(bundle);
 
         if first_range_data.vreg.is_invalid() {
-            log::trace!("  -> no vreg; minimal and fixed");
+            trace!("  -> no vreg; minimal and fixed");
             minimal = true;
             fixed = true;
         } else {
             for u in &first_range_data.uses {
-                log::trace!("  -> use: {:?}", u);
+                trace!("  -> use: {:?}", u);
                 if let OperandConstraint::FixedReg(_) = u.operand.constraint() {
-                    log::trace!("  -> fixed use at {:?}: {:?}", u.pos, u.operand);
+                    trace!("  -> fixed use at {:?}: {:?}", u.pos, u.operand);
                     fixed = true;
                 }
                 if let OperandConstraint::Stack = u.operand.constraint() {
-                    log::trace!("  -> stack use at {:?}: {:?}", u.pos, u.operand);
+                    trace!("  -> stack use at {:?}: {:?}", u.pos, u.operand);
                     stack = true;
                 }
                 if stack && fixed {
@@ -295,7 +295,7 @@ impl<'a, F: Function> Env<'a, F> {
             // that it could cover just one ProgPoint,
             // i.e. X.Before..X.After, or two ProgPoints,
             // i.e. X.Before..X+1.Before.
-            log::trace!("  -> first range has range {:?}", first_range_data.range);
+            trace!("  -> first range has range {:?}", first_range_data.range);
             let bundle_start = self.bundles[bundle.index()]
                 .ranges
                 .first()
@@ -304,22 +304,22 @@ impl<'a, F: Function> Env<'a, F> {
                 .from;
             let bundle_end = self.bundles[bundle.index()].ranges.last().unwrap().range.to;
             minimal = bundle_start.inst() == bundle_end.prev().inst();
-            log::trace!("  -> minimal: {}", minimal);
+            trace!("  -> minimal: {}", minimal);
         }
 
         let spill_weight = if minimal {
             if fixed {
-                log::trace!("  -> fixed and minimal");
+                trace!("  -> fixed and minimal");
                 MINIMAL_FIXED_BUNDLE_SPILL_WEIGHT
             } else {
-                log::trace!("  -> non-fixed and minimal");
+                trace!("  -> non-fixed and minimal");
                 MINIMAL_BUNDLE_SPILL_WEIGHT
             }
         } else {
             let mut total = SpillWeight::zero();
             for entry in &self.bundles[bundle.index()].ranges {
                 let range_data = &self.ranges[entry.index.index()];
-                log::trace!(
+                trace!(
                     "  -> uses spill weight: +{:?}",
                     range_data.uses_spill_weight()
                 );
@@ -328,7 +328,7 @@ impl<'a, F: Function> Env<'a, F> {
 
             if self.bundles[bundle.index()].prio > 0 {
                 let final_weight = (total.to_f32() as u32) / self.bundles[bundle.index()].prio;
-                log::trace!(
+                trace!(
                     " -> dividing by prio {}; final weight {}",
                     self.bundles[bundle.index()].prio,
                     final_weight
@@ -356,7 +356,7 @@ impl<'a, F: Function> Env<'a, F> {
         let mut w = SpillWeight::zero();
         for u in &rangedata.uses {
             w = w + SpillWeight::from_bits(u.weight);
-            log::trace!("range{}: use {:?}", range.index(), u);
+            trace!("range{}: use {:?}", range.index(), u);
         }
         rangedata.set_uses_spill_weight(w);
         if rangedata.uses.len() > 0 && rangedata.uses[0].operand.kind() == OperandKind::Def {
@@ -397,7 +397,7 @@ impl<'a, F: Function> Env<'a, F> {
         reg_hint: PReg,
     ) {
         self.stats.splits += 1;
-        log::trace!(
+        trace!(
             "split bundle {:?} at {:?} and requeue with reg hint (for first part) {:?}",
             bundle,
             split_at,
@@ -435,7 +435,7 @@ impl<'a, F: Function> Env<'a, F> {
                     break 'outer;
                 }
             }
-            log::trace!(" -> first use loc is {:?}", first_use);
+            trace!(" -> first use loc is {:?}", first_use);
             split_at = match first_use {
                 Some(pos) => {
                     if pos.inst() == bundle_start.inst() {
@@ -455,7 +455,7 @@ impl<'a, F: Function> Env<'a, F> {
                         .next(),
                 ),
             };
-            log::trace!(
+            trace!(
                 "split point is at bundle start; advancing to {:?}",
                 split_at
             );
@@ -477,7 +477,7 @@ impl<'a, F: Function> Env<'a, F> {
         // which LR we need to split down the middle, then update the
         // current bundle, create a new one, and (re)-queue both.
 
-        log::trace!(" -> LRs: {:?}", self.bundles[bundle.index()].ranges);
+        trace!(" -> LRs: {:?}", self.bundles[bundle.index()].ranges);
 
         let mut last_lr_in_old_bundle_idx = 0; // last LR-list index in old bundle
         let mut first_lr_in_new_bundle_idx = 0; // first LR-list index in new bundle
@@ -492,11 +492,11 @@ impl<'a, F: Function> Env<'a, F> {
             }
         }
 
-        log::trace!(
+        trace!(
             " -> last LR in old bundle: LR {:?}",
             self.bundles[bundle.index()].ranges[last_lr_in_old_bundle_idx]
         );
-        log::trace!(
+        trace!(
             " -> first LR in new bundle: LR {:?}",
             self.bundles[bundle.index()].ranges[first_lr_in_new_bundle_idx]
         );
@@ -523,7 +523,7 @@ impl<'a, F: Function> Env<'a, F> {
                 to: new_lr_list[0].range.to,
             });
             self.ranges[new_lr.index()].vreg = self.ranges[orig_lr.index()].vreg;
-            log::trace!(" -> splitting LR {:?} into {:?}", orig_lr, new_lr);
+            trace!(" -> splitting LR {:?} into {:?}", orig_lr, new_lr);
             let first_use = self.ranges[orig_lr.index()]
                 .uses
                 .iter()
@@ -560,7 +560,7 @@ impl<'a, F: Function> Env<'a, F> {
         }
 
         let new_bundle = self.create_bundle();
-        log::trace!(" -> creating new bundle {:?}", new_bundle);
+        trace!(" -> creating new bundle {:?}", new_bundle);
         self.bundles[new_bundle.index()].spillset = spillset;
         for entry in &new_lr_list {
             self.ranges[entry.index.index()].bundle = new_bundle;
@@ -582,7 +582,7 @@ impl<'a, F: Function> Env<'a, F> {
                 let spill = self
                     .get_or_create_spill_bundle(bundle, /* create_if_absent = */ true)
                     .unwrap();
-                log::trace!(
+                trace!(
                     " -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}",
                     bundle,
                     entry.index,
@@ -627,13 +627,13 @@ impl<'a, F: Function> Env<'a, F> {
                     range,
                     index: empty_lr,
                 });
-                log::trace!(
+                trace!(
                     " -> bundle {:?} range {:?}: last use implies split point {:?}",
                     bundle,
                     entry.index,
                     split
                 );
-                log::trace!(
+                trace!(
                     " -> moving trailing empty region to new spill bundle {:?} with new LR {:?}",
                     spill,
                     empty_lr
@@ -652,7 +652,7 @@ impl<'a, F: Function> Env<'a, F> {
                 let spill = self
                     .get_or_create_spill_bundle(new_bundle, /* create_if_absent = */ true)
                     .unwrap();
-                log::trace!(
+                trace!(
                     " -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}",
                     new_bundle,
                     entry.index,
@@ -697,13 +697,13 @@ impl<'a, F: Function> Env<'a, F> {
                     range,
                     index: empty_lr,
                 });
-                log::trace!(
+                trace!(
                     " -> bundle {:?} range {:?}: first use implies split point {:?}",
                     bundle,
                     entry.index,
                     first_use,
                 );
-                log::trace!(
+                trace!(
                     " -> moving leading empty region to new spill bundle {:?} with new LR {:?}",
                     spill,
                     empty_lr
@@ -741,7 +741,7 @@ impl<'a, F: Function> Env<'a, F> {
         if self.pregs[hint_reg.index()].is_stack {
             hint_reg = PReg::invalid();
         }
-        log::trace!("process_bundle: bundle {:?} hint {:?}", bundle, hint_reg,);
+        trace!("process_bundle: bundle {:?} hint {:?}", bundle, hint_reg,);
 
         let req = match self.compute_requirement(bundle) {
             Ok(req) => req,
@@ -786,7 +786,7 @@ impl<'a, F: Function> Env<'a, F> {
         let mut attempts = 0;
         loop {
             attempts += 1;
-            log::trace!("attempt {}, req {:?}", attempts, req);
+            trace!("attempt {}, req {:?}", attempts, req);
             debug_assert!(attempts < 100 * self.func.num_insts());
 
             let fixed_preg = match req {
@@ -836,7 +836,7 @@ impl<'a, F: Function> Env<'a, F> {
             ) {
                 self.stats.process_bundle_reg_probes_any += 1;
                 let preg_idx = PRegIndex::new(preg.index());
-                log::trace!("trying preg {:?}", preg_idx);
+                trace!("trying preg {:?}", preg_idx);
 
                 let scan_limit_cost = match (
                     lowest_cost_evict_conflict_cost,
@@ -848,13 +848,13 @@ impl<'a, F: Function> Env<'a, F> {
                 match self.try_to_allocate_bundle_to_reg(bundle, preg_idx, scan_limit_cost) {
                     AllocRegResult::Allocated(alloc) => {
                         self.stats.process_bundle_reg_success_any += 1;
-                        log::trace!(" -> allocated to any {:?}", preg_idx);
+                        trace!(" -> allocated to any {:?}", preg_idx);
                         self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint =
                             alloc.as_reg().unwrap();
                         return Ok(());
                     }
                     AllocRegResult::Conflict(bundles, first_conflict_point) => {
-                        log::trace!(
+                        trace!(
                             " -> conflict with bundles {:?}, first conflict at {:?}",
                             bundles,
                             first_conflict_point
@@ -887,7 +887,7 @@ impl<'a, F: Function> Env<'a, F> {
                         }
                     }
                     AllocRegResult::ConflictWithFixed(max_cost, point) => {
-                        log::trace!(" -> conflict with fixed alloc; cost of other bundles up to point is {}, conflict at {:?}", max_cost, point);
+                        trace!(" -> conflict with fixed alloc; cost of other bundles up to point is {}, conflict at {:?}", max_cost, point);
 
                         let loop_depth = self.cfginfo.approx_loop_depth
                             [self.cfginfo.insn_block[point.inst().index()].index()];
@@ -919,12 +919,12 @@ impl<'a, F: Function> Env<'a, F> {
             // any with current bundle assignments. Hence, we will need
             // to either split or attempt to evict some bundles.
 
-            log::trace!(
+            trace!(
                 " -> lowest cost evict: set {:?}, cost {:?}",
                 lowest_cost_evict_conflict_set,
                 lowest_cost_evict_conflict_cost,
             );
-            log::trace!(
+            trace!(
                 " -> lowest cost split: cost {:?}, point {:?}, reg {:?}",
                 lowest_cost_split_conflict_cost,
                 lowest_cost_split_conflict_point,
@@ -938,7 +938,7 @@ impl<'a, F: Function> Env<'a, F> {
             );
 
             let our_spill_weight = self.bundle_spill_weight(bundle);
-            log::trace!(" -> our spill weight: {}", our_spill_weight);
+            trace!(" -> our spill weight: {}", our_spill_weight);
 
             // We detect the "too-many-live-registers" case here and
             // return an error cleanly, rather than panicking, because
@@ -953,7 +953,7 @@ impl<'a, F: Function> Env<'a, F> {
                 if let Requirement::Register = req {
                     // Check if this is a too-many-live-registers situation.
                     let range = self.bundles[bundle.index()].ranges[0].range;
-                    log::trace!("checking for too many live regs");
+                    trace!("checking for too many live regs");
                     let mut min_bundles_assigned = 0;
                     let mut fixed_assigned = 0;
                     let mut total_regs = 0;
@@ -961,7 +961,7 @@ impl<'a, F: Function> Env<'a, F> {
                         .iter()
                         .chain(self.env.non_preferred_regs_by_class[class as u8 as usize].iter())
                     {
-                        log::trace!(" -> PR {:?}", preg);
+                        trace!(" -> PR {:?}", preg);
                         let start = LiveRangeKey::from_range(&CodeRange {
                             from: range.from.prev(),
                             to: range.from.prev(),
@@ -976,19 +976,19 @@ impl<'a, F: Function> Env<'a, F> {
                             }
                             if lr.is_valid() {
                                 if self.minimal_bundle(self.ranges[lr.index()].bundle) {
-                                    log::trace!("  -> min bundle {:?}", lr);
+                                    trace!("  -> min bundle {:?}", lr);
                                     min_bundles_assigned += 1;
                                 } else {
-                                    log::trace!("  -> non-min bundle {:?}", lr);
+                                    trace!("  -> non-min bundle {:?}", lr);
                                 }
                             } else {
-                                log::trace!("  -> fixed bundle");
+                                trace!("  -> fixed bundle");
                                 fixed_assigned += 1;
                             }
                         }
                         total_regs += 1;
                     }
-                    log::trace!(
+                    trace!(
                         " -> total {}, fixed {}, min {}",
                         total_regs,
                         fixed_assigned,
@@ -1020,7 +1020,7 @@ impl<'a, F: Function> Env<'a, F> {
                     || lowest_cost_evict_conflict_cost.is_none()
                     || our_spill_weight <= lowest_cost_evict_conflict_cost.unwrap())
             {
-                log::trace!(
+                trace!(
                     " -> deciding to split: our spill weight is {}",
                     self.bundle_spill_weight(bundle)
                 );
@@ -1053,7 +1053,7 @@ impl<'a, F: Function> Env<'a, F> {
                 // Evict all bundles in `conflicting bundles` and try again.
                 self.stats.evict_bundle_event += 1;
                 for &bundle in &lowest_cost_evict_conflict_set.unwrap() {
-                    log::trace!(" -> evicting {:?}", bundle);
+                    trace!(" -> evicting {:?}", bundle);
                     self.evict_bundle(bundle);
                     self.stats.evict_bundle_count += 1;
                 }
diff --git a/src/ion/redundant_moves.rs b/src/ion/redundant_moves.rs
index 217d995..5a0f192 100644
--- a/src/ion/redundant_moves.rs
+++ b/src/ion/redundant_moves.rs
@@ -41,13 +41,13 @@ impl RedundantMoveEliminator {
             .map(|&p| p)
             .unwrap_or(RedundantMoveState::None);
 
-        log::trace!(
+        trace!(
             "     -> redundant move tracker: from {} to {} to_vreg {:?}",
             from,
             to,
             to_vreg
         );
-        log::trace!(
+        trace!(
             "       -> from_state {:?} to_state {:?}",
             from_state,
             to_state
@@ -69,29 +69,29 @@ impl RedundantMoveEliminator {
             RedundantMoveState::Orig(r) => Some(r),
             _ => None,
         };
-        log::trace!("      -> src_vreg {:?}", src_vreg);
+        trace!("      -> src_vreg {:?}", src_vreg);
         let dst_vreg = to_vreg.or(src_vreg);
-        log::trace!("      -> dst_vreg {:?}", dst_vreg);
+        trace!("      -> dst_vreg {:?}", dst_vreg);
         let existing_dst_vreg = match to_state {
             RedundantMoveState::Copy(_, opt_r) => opt_r,
             RedundantMoveState::Orig(r) => Some(r),
             _ => None,
         };
-        log::trace!("      -> existing_dst_vreg {:?}", existing_dst_vreg);
+        trace!("      -> existing_dst_vreg {:?}", existing_dst_vreg);
 
         let elide = match (from_state, to_state) {
             (_, RedundantMoveState::Copy(orig_alloc, _)) if orig_alloc == from => true,
             (RedundantMoveState::Copy(new_alloc, _), _) if new_alloc == to => true,
             _ => false,
         };
-        log::trace!("      -> elide {}", elide);
+        trace!("      -> elide {}", elide);
 
         let def_alloc = if dst_vreg != existing_dst_vreg && dst_vreg.is_some() {
             Some((to, dst_vreg.unwrap()))
         } else {
             None
         };
-        log::trace!("      -> def_alloc {:?}", def_alloc);
+        trace!("      -> def_alloc {:?}", def_alloc);
 
         // Invalidate all existing copies of `to` if `to` actually changed value.
         if !elide {
@@ -102,7 +102,7 @@ impl RedundantMoveEliminator {
         if from.is_reg() || to.is_reg() {
             self.allocs
                 .insert(to, RedundantMoveState::Copy(from, dst_vreg));
-            log::trace!(
+            trace!(
                 "     -> create mapping {} -> {:?}",
                 to,
                 RedundantMoveState::Copy(from, dst_vreg)
@@ -121,16 +121,16 @@ impl RedundantMoveEliminator {
     }
 
     pub fn clear(&mut self) {
-        log::trace!("   redundant move eliminator cleared");
+        trace!("   redundant move eliminator cleared");
         self.allocs.clear();
         self.reverse_allocs.clear();
     }
 
     pub fn clear_alloc(&mut self, alloc: Allocation) {
-        log::trace!("   redundant move eliminator: clear {:?}", alloc);
+        trace!("   redundant move eliminator: clear {:?}", alloc);
         if let Some(ref mut existing_copies) = self.reverse_allocs.get_mut(&alloc) {
             for to_inval in existing_copies.iter() {
-                log::trace!("     -> clear existing copy: {:?}", to_inval);
+                trace!("     -> clear existing copy: {:?}", to_inval);
                 if let Some(val) = self.allocs.get_mut(to_inval) {
                     match val {
                         RedundantMoveState::Copy(_, Some(vreg)) => {
diff --git a/src/ion/requirement.rs b/src/ion/requirement.rs
index c14cc38..1d830b6 100644
--- a/src/ion/requirement.rs
+++ b/src/ion/requirement.rs
@@ -71,21 +71,21 @@ impl<'a, F: Function> Env<'a, F> {
         bundle: LiveBundleIndex,
     ) -> Result<Requirement, RequirementConflictAt> {
         let mut req = Requirement::Any;
-        log::trace!("compute_requirement: {:?}", bundle);
+        trace!("compute_requirement: {:?}", bundle);
         let ranges = &self.bundles[bundle.index()].ranges;
         for entry in ranges {
-            log::trace!(" -> LR {:?}", entry.index);
+            trace!(" -> LR {:?}", entry.index);
             for u in &self.ranges[entry.index.index()].uses {
-                log::trace!("  -> use {:?}", u);
+                trace!("  -> use {:?}", u);
                 let r = self.requirement_from_operand(u.operand);
                 req = req.merge(r).map_err(|_| {
-                    log::trace!("     -> conflict");
+                    trace!("     -> conflict");
                     RequirementConflictAt(u.pos)
                 })?;
-                log::trace!("     -> req {:?}", req);
+                trace!("     -> req {:?}", req);
             }
         }
-        log::trace!(" -> final: {:?}", req);
+        trace!(" -> final: {:?}", req);
         Ok(req)
     }
 
diff --git a/src/ion/spill.rs b/src/ion/spill.rs
index 18607a7..2600cdb 100644
--- a/src/ion/spill.rs
+++ b/src/ion/spill.rs
@@ -20,7 +20,7 @@ use crate::{Allocation, Function, SpillSlot};
 
 impl<'a, F: Function> Env<'a, F> {
     pub fn try_allocating_regs_for_spilled_bundles(&mut self) {
-        log::trace!("allocating regs for spilled bundles");
+        trace!("allocating regs for spilled bundles");
         for i in 0..self.spilled_bundles.len() {
             let bundle = self.spilled_bundles[i]; // don't borrow self
 
@@ -38,7 +38,7 @@ impl<'a, F: Function> Env<'a, F> {
             for preg in
                 RegTraversalIter::new(self.env, class, hint, PReg::invalid(), bundle.index(), None)
             {
-                log::trace!("trying bundle {:?} to preg {:?}", bundle, preg);
+                trace!("trying bundle {:?} to preg {:?}", bundle, preg);
                 let preg_idx = PRegIndex::new(preg.index());
                 if let AllocRegResult::Allocated(_) =
                     self.try_to_allocate_bundle_to_reg(bundle, preg_idx, None)
@@ -49,7 +49,7 @@ impl<'a, F: Function> Env<'a, F> {
                 }
             }
             if !success {
-                log::trace!(
+                trace!(
                     "spilling bundle {:?}: marking spillset {:?} as required",
                     bundle,
                     self.bundles[bundle.index()].spillset
@@ -87,14 +87,14 @@ impl<'a, F: Function> Env<'a, F> {
         for i in 0..self.spillsets[spillset.index()].vregs.len() {
             // don't borrow self
             let vreg = self.spillsets[spillset.index()].vregs[i];
-            log::trace!(
+            trace!(
                 "spillslot {:?} alloc'ed to spillset {:?}: vreg {:?}",
                 spillslot,
                 spillset,
                 vreg,
             );
             for entry in &self.vregs[vreg.index()].ranges {
-                log::trace!(
+                trace!(
                     "spillslot {:?} getting range {:?} from LR {:?} from vreg {:?}",
                     spillslot,
                     entry.range,
@@ -111,7 +111,7 @@ impl<'a, F: Function> Env<'a, F> {
 
     pub fn allocate_spillslots(&mut self) {
         for spillset in 0..self.spillsets.len() {
-            log::trace!("allocate spillslot: {}", spillset);
+            trace!("allocate spillslot: {}", spillset);
             let spillset = SpillSetIndex::new(spillset);
             if !self.spillsets[spillset.index()].required {
                 continue;
@@ -196,7 +196,7 @@ impl<'a, F: Function> Env<'a, F> {
             self.spillslots[i].alloc = self.allocate_spillslot(self.spillslots[i].class);
         }
 
-        log::trace!("spillslot allocator done");
+        trace!("spillslot allocator done");
     }
 
     pub fn allocate_spillslot(&mut self, class: RegClass) -> Allocation {
diff --git a/src/ion/stackmap.rs b/src/ion/stackmap.rs
index f8cd471..517de15 100644
--- a/src/ion/stackmap.rs
+++ b/src/ion/stackmap.rs
@@ -30,10 +30,10 @@ impl<'a, F: Function> Env<'a, F> {
         // safepoints; and for each safepoint in the current range,
         // emit the allocation into the `safepoint_slots` list.
 
-        log::trace!("safepoints_per_vreg = {:?}", self.safepoints_per_vreg);
+        trace!("safepoints_per_vreg = {:?}", self.safepoints_per_vreg);
 
         for vreg in self.func.reftype_vregs() {
-            log::trace!("generating safepoint info for vreg {}", vreg);
+            trace!("generating safepoint info for vreg {}", vreg);
             let vreg = VRegIndex::new(vreg.vreg());
             let mut safepoints: Vec<ProgPoint> = self
                 .safepoints_per_vreg
@@ -43,19 +43,19 @@ impl<'a, F: Function> Env<'a, F> {
                 .map(|&inst| ProgPoint::before(inst))
                 .collect();
             safepoints.sort_unstable();
-            log::trace!(" -> live over safepoints: {:?}", safepoints);
+            trace!(" -> live over safepoints: {:?}", safepoints);
 
             let mut safepoint_idx = 0;
             for entry in &self.vregs[vreg.index()].ranges {
                 let range = entry.range;
                 let alloc = self.get_alloc_for_range(entry.index);
-                log::trace!(" -> range {:?}: alloc {}", range, alloc);
+                trace!(" -> range {:?}: alloc {}", range, alloc);
                 while safepoint_idx < safepoints.len() && safepoints[safepoint_idx] < range.to {
                     if safepoints[safepoint_idx] < range.from {
                         safepoint_idx += 1;
                         continue;
                     }
-                    log::trace!("    -> covers safepoint {:?}", safepoints[safepoint_idx]);
+                    trace!("    -> covers safepoint {:?}", safepoints[safepoint_idx]);
 
                     self.safepoint_slots
                         .push((safepoints[safepoint_idx], alloc));
@@ -66,6 +66,6 @@ impl<'a, F: Function> Env<'a, F> {
 
         self.safepoint_slots
             .sort_unstable_by_key(|(progpoint, slot)| u64_key(progpoint.to_index(), slot.bits()));
-        log::trace!("final safepoint slots info: {:?}", self.safepoint_slots);
+        trace!("final safepoint slots info: {:?}", self.safepoint_slots);
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 6226f08..3946508 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,6 +12,16 @@
 
 #![allow(dead_code)]
 
+// Even when trace logging is disabled, the trace macro has a significant
+// performance cost so we disable it in release builds.
+macro_rules! trace {
+    ($($tt:tt)*) => {
+        if cfg!(debug_assertions) {
+            ::log::trace!($($tt)*);
+        }
+    };
+}
+
 pub(crate) mod cfg;
 pub(crate) mod domtree;
 pub mod indexset;