wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-cranelift-21.0.1/src/debug/transform/expression.rs

@@ -0,0 +1,1248 @@
+#![allow(trivial_numeric_casts)]
+
+use super::address_transform::AddressTransform;
+use crate::debug::ModuleMemoryOffset;
+use anyhow::{Context, Error, Result};
+use cranelift_codegen::ir::ValueLabel;
+use cranelift_codegen::isa::TargetIsa;
+use cranelift_codegen::LabelValueLoc;
+use cranelift_codegen::ValueLabelsRanges;
+use cranelift_wasm::get_vmctx_value_label;
+use gimli::{write, Expression, Operation, Reader, ReaderOffset};
+use std::cmp::PartialEq;
+use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
+use wasmtime_environ::{DefinedFuncIndex, EntityRef};
+
+#[derive(Debug)]
+pub struct FunctionFrameInfo<'a> {
+    pub value_ranges: &'a ValueLabelsRanges,
+    pub memory_offset: ModuleMemoryOffset,
+}
+
+impl<'a> FunctionFrameInfo<'a> {
+    fn vmctx_memory_offset(&self) -> Option<i64> {
+        match self.memory_offset {
+            ModuleMemoryOffset::Defined(x) => Some(x as i64),
+            ModuleMemoryOffset::Imported(_) => {
+                // TODO implement memory offset for imported memory
+                None
+            }
+            ModuleMemoryOffset::None => None,
+        }
+    }
+}
+
+struct ExpressionWriter(write::EndianVec<gimli::RunTimeEndian>);
+
+impl ExpressionWriter {
+    pub fn new() -> Self {
+        let endian = gimli::RunTimeEndian::Little;
+        let writer = write::EndianVec::new(endian);
+        ExpressionWriter(writer)
+    }
+
+    pub fn write_op(&mut self, op: gimli::DwOp) -> write::Result<()> {
+        self.write_u8(op.0 as u8)
+    }
+
+    pub fn write_op_reg(&mut self, reg: u16) -> write::Result<()> {
+        if reg < 32 {
+            self.write_u8(gimli::constants::DW_OP_reg0.0 as u8 + reg as u8)
+        } else {
+            self.write_op(gimli::constants::DW_OP_regx)?;
+            self.write_uleb128(reg.into())
+        }
+    }
+
+    pub fn write_op_breg(&mut self, reg: u16) -> write::Result<()> {
+        if reg < 32 {
+            self.write_u8(gimli::constants::DW_OP_breg0.0 as u8 + reg as u8)
+        } else {
+            self.write_op(gimli::constants::DW_OP_bregx)?;
+            self.write_uleb128(reg.into())
+        }
+    }
+
+    pub fn write_u8(&mut self, b: u8) -> write::Result<()> {
+        write::Writer::write_u8(&mut self.0, b)
+    }
+
+    pub fn write_u32(&mut self, b: u32) -> write::Result<()> {
+        write::Writer::write_u32(&mut self.0, b)
+    }
+
+    pub fn write_uleb128(&mut self, i: u64) -> write::Result<()> {
+        write::Writer::write_uleb128(&mut self.0, i)
+    }
+
+    pub fn write_sleb128(&mut self, i: i64) -> write::Result<()> {
+        write::Writer::write_sleb128(&mut self.0, i)
+    }
+
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into_vec()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum CompiledExpressionPart {
+    // Untranslated DWARF expression.
+    Code(Vec<u8>),
+    // The wasm-local DWARF operator. The label points to `ValueLabel`.
+    // The trailing field denotes that the operator was last in sequence,
+    // and it is the DWARF location (not a pointer).
+    Local {
+        label: ValueLabel,
+        trailing: bool,
+    },
+    // Dereference is needed.
+    Deref,
+    // Jumping in the expression.
+    Jump {
+        conditionally: bool,
+        target: JumpTargetMarker,
+    },
+    // Floating landing pad.
+    LandingPad(JumpTargetMarker),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompiledExpression {
+    parts: Vec<CompiledExpressionPart>,
+    need_deref: bool,
+}
+
+impl CompiledExpression {
+    pub fn vmctx() -> CompiledExpression {
+        CompiledExpression::from_label(get_vmctx_value_label())
+    }
+
+    pub fn from_label(label: ValueLabel) -> CompiledExpression {
+        CompiledExpression {
+            parts: vec![CompiledExpressionPart::Local {
+                label,
+                trailing: true,
+            }],
+            need_deref: false,
+        }
+    }
+}
+
+fn translate_loc(
+    loc: LabelValueLoc,
+    isa: &dyn TargetIsa,
+    add_stack_value: bool,
+) -> Result<Option<Vec<u8>>> {
+    Ok(match loc {
+        LabelValueLoc::Reg(r) => {
+            let machine_reg = isa.map_regalloc_reg_to_dwarf(r)?;
+            let mut writer = ExpressionWriter::new();
+            if add_stack_value {
+                writer.write_op_reg(machine_reg)?;
+            } else {
+                writer.write_op_breg(machine_reg)?;
+                writer.write_sleb128(0)?;
+            }
+            Some(writer.into_vec())
+        }
+        LabelValueLoc::CFAOffset(off) => {
+            let mut writer = ExpressionWriter::new();
+            writer.write_op(gimli::constants::DW_OP_fbreg)?;
+            writer.write_sleb128(off)?;
+            if !add_stack_value {
+                writer.write_op(gimli::constants::DW_OP_deref)?;
+            }
+            return Ok(Some(writer.into_vec()));
+        }
+    })
+}
+
+fn append_memory_deref(
+    buf: &mut Vec<u8>,
+    frame_info: &FunctionFrameInfo,
+    vmctx_loc: LabelValueLoc,
+    isa: &dyn TargetIsa,
+) -> Result<bool> {
+    let mut writer = ExpressionWriter::new();
+    // FIXME for imported memory
+    match vmctx_loc {
+        LabelValueLoc::Reg(r) => {
+            let reg = isa.map_regalloc_reg_to_dwarf(r)?;
+            writer.write_op_breg(reg)?;
+            let memory_offset = match frame_info.vmctx_memory_offset() {
+                Some(offset) => offset,
+                None => {
+                    return Ok(false);
+                }
+            };
+            writer.write_sleb128(memory_offset)?;
+        }
+        LabelValueLoc::CFAOffset(off) => {
+            writer.write_op(gimli::constants::DW_OP_fbreg)?;
+            writer.write_sleb128(off)?;
+            writer.write_op(gimli::constants::DW_OP_deref)?;
+            writer.write_op(gimli::constants::DW_OP_consts)?;
+            let memory_offset = match frame_info.vmctx_memory_offset() {
+                Some(offset) => offset,
+                None => {
+                    return Ok(false);
+                }
+            };
+            writer.write_sleb128(memory_offset)?;
+            writer.write_op(gimli::constants::DW_OP_plus)?;
+        }
+    }
+    writer.write_op(gimli::constants::DW_OP_deref)?;
+    writer.write_op(gimli::constants::DW_OP_swap)?;
+    writer.write_op(gimli::constants::DW_OP_const4u)?;
+    writer.write_u32(0xffff_ffff)?;
+    writer.write_op(gimli::constants::DW_OP_and)?;
+    writer.write_op(gimli::constants::DW_OP_plus)?;
+    buf.extend(writer.into_vec());
+    Ok(true)
+}
+
+impl CompiledExpression {
+    pub fn is_simple(&self) -> bool {
+        if let [CompiledExpressionPart::Code(_)] = self.parts.as_slice() {
+            true
+        } else {
+            self.parts.is_empty()
+        }
+    }
+
+    pub fn build(&self) -> Option<write::Expression> {
+        if let [CompiledExpressionPart::Code(code)] = self.parts.as_slice() {
+            return Some(write::Expression::raw(code.to_vec()));
+        }
+        // locals found, not supported
+        None
+    }
+
+    pub fn build_with_locals<'a>(
+        &'a self,
+        scope: &'a [(u64, u64)], // wasm ranges
+        addr_tr: &'a AddressTransform,
+        frame_info: Option<&'a FunctionFrameInfo>,
+        isa: &'a dyn TargetIsa,
+    ) -> impl Iterator<Item = Result<(write::Address, u64, write::Expression)>> + 'a {
+        enum BuildWithLocalsResult<'a> {
+            Empty,
+            Simple(
+                Box<dyn Iterator<Item = (write::Address, u64)> + 'a>,
+                Vec<u8>,
+            ),
+            Ranges(
+                Box<dyn Iterator<Item = Result<(DefinedFuncIndex, usize, usize, Vec<u8>)>> + 'a>,
+            ),
+        }
+        impl Iterator for BuildWithLocalsResult<'_> {
+            type Item = Result<(write::Address, u64, write::Expression)>;
+            fn next(&mut self) -> Option<Self::Item> {
+                match self {
+                    BuildWithLocalsResult::Empty => None,
+                    BuildWithLocalsResult::Simple(it, code) => it
+                        .next()
+                        .map(|(addr, len)| Ok((addr, len, write::Expression::raw(code.to_vec())))),
+                    BuildWithLocalsResult::Ranges(it) => it.next().map(|r| {
+                        r.map(|(func_index, start, end, code_buf)| {
+                            (
+                                write::Address::Symbol {
+                                    symbol: func_index.index(),
+                                    addend: start as i64,
+                                },
+                                (end - start) as u64,
+                                write::Expression::raw(code_buf),
+                            )
+                        })
+                    }),
+                }
+            }
+        }
+
+        if scope.is_empty() {
+            return BuildWithLocalsResult::Empty;
+        }
+
+        // If it a simple DWARF code, no need in locals processing. Just translate
+        // the scope ranges.
+        if let [CompiledExpressionPart::Code(code)] = self.parts.as_slice() {
+            return BuildWithLocalsResult::Simple(
+                Box::new(scope.iter().flat_map(move |(wasm_start, wasm_end)| {
+                    addr_tr.translate_ranges(*wasm_start, *wasm_end)
+                })),
+                code.clone(),
+            );
+        }
+
+        let vmctx_label = get_vmctx_value_label();
+
+        // Some locals are present, preparing and divided ranges based on the scope
+        // and frame_info data.
+        let mut ranges_builder = ValueLabelRangesBuilder::new(scope, addr_tr, frame_info);
+        for p in self.parts.iter() {
+            match p {
+                CompiledExpressionPart::Code(_)
+                | CompiledExpressionPart::Jump { .. }
+                | CompiledExpressionPart::LandingPad { .. } => (),
+                CompiledExpressionPart::Local { label, .. } => ranges_builder.process_label(*label),
+                CompiledExpressionPart::Deref => ranges_builder.process_label(vmctx_label),
+            }
+        }
+        if self.need_deref {
+            ranges_builder.process_label(vmctx_label);
+        }
+        let ranges = ranges_builder.into_ranges();
+
+        return BuildWithLocalsResult::Ranges(Box::new(
+            ranges
+                .into_iter()
+                .map(
+                    move |CachedValueLabelRange {
+                              func_index,
+                              start,
+                              end,
+                              label_location,
+                          }| {
+                        // build expression
+                        let mut code_buf = Vec::new();
+                        let mut jump_positions = Vec::new();
+                        let mut landing_positions = HashMap::new();
+
+                        macro_rules! deref {
+                            () => {
+                                if let (Some(vmctx_loc), Some(frame_info)) =
+                                    (label_location.get(&vmctx_label), frame_info)
+                                {
+                                    if !append_memory_deref(
+                                        &mut code_buf,
+                                        frame_info,
+                                        *vmctx_loc,
+                                        isa,
+                                    )? {
+                                        return Ok(None);
+                                    }
+                                } else {
+                                    return Ok(None);
+                                }
+                            };
+                        }
+                        for part in &self.parts {
+                            match part {
+                                CompiledExpressionPart::Code(c) => {
+                                    code_buf.extend_from_slice(c.as_slice())
+                                }
+                                CompiledExpressionPart::LandingPad(marker) => {
+                                    landing_positions.insert(marker.clone(), code_buf.len());
+                                }
+                                CompiledExpressionPart::Jump {
+                                    conditionally,
+                                    target,
+                                } => {
+                                    code_buf.push(
+                                        match conditionally {
+                                            true => gimli::constants::DW_OP_bra,
+                                            false => gimli::constants::DW_OP_skip,
+                                        }
+                                        .0 as u8,
+                                    );
+                                    code_buf.push(!0);
+                                    code_buf.push(!0); // these will be relocated below
+                                    jump_positions.push((target.clone(), code_buf.len()));
+                                }
+                                CompiledExpressionPart::Local { label, trailing } => {
+                                    let loc =
+                                        *label_location.get(&label).context("label_location")?;
+                                    if let Some(expr) = translate_loc(loc, isa, *trailing)? {
+                                        code_buf.extend_from_slice(&expr)
+                                    } else {
+                                        return Ok(None);
+                                    }
+                                }
+                                CompiledExpressionPart::Deref => deref!(),
+                            }
+                        }
+                        if self.need_deref {
+                            deref!();
+                        }
+
+                        for (marker, new_from) in jump_positions {
+                            // relocate jump targets
+                            let new_to = landing_positions[&marker];
+                            let new_diff = new_to as isize - new_from as isize;
+                            // FIXME: use encoding? LittleEndian for now...
+                            code_buf[new_from - 2..new_from]
+                                .copy_from_slice(&(new_diff as i16).to_le_bytes());
+                        }
+                        Ok(Some((func_index, start, end, code_buf)))
+                    },
+                )
+                .filter_map(Result::transpose),
+        ));
+    }
+}
+
+fn is_old_expression_format(buf: &[u8]) -> bool {
+    // Heuristic to detect old variable expression format without DW_OP_fbreg:
+    // DW_OP_plus_uconst op must be present, but not DW_OP_fbreg.
+    if buf.contains(&(gimli::constants::DW_OP_fbreg.0 as u8)) {
+        // Stop check if DW_OP_fbreg exist.
+        return false;
+    }
+    buf.contains(&(gimli::constants::DW_OP_plus_uconst.0 as u8))
+}
+
+pub fn compile_expression<R>(
+    expr: &Expression<R>,
+    encoding: gimli::Encoding,
+    frame_base: Option<&CompiledExpression>,
+) -> Result<Option<CompiledExpression>, Error>
+where
+    R: Reader,
+{
+    // Bail when `frame_base` is complicated.
+    if let Some(expr) = frame_base {
+        if expr.parts.iter().any(|p| match p {
+            CompiledExpressionPart::Jump { .. } => true,
+            _ => false,
+        }) {
+            return Ok(None);
+        }
+    }
+
+    // jump_targets key is offset in buf starting from the end
+    // (see also `unread_bytes` below)
+    let mut jump_targets: HashMap<u64, JumpTargetMarker> = HashMap::new();
+    let mut pc = expr.0.clone();
+
+    let buf = expr.0.to_slice()?;
+    let mut parts = Vec::new();
+    macro_rules! push {
+        ($part:expr) => {{
+            let part = $part;
+            if let (CompiledExpressionPart::Code(cc2), Some(CompiledExpressionPart::Code(cc1))) =
+                (&part, parts.last_mut())
+            {
+                cc1.extend_from_slice(cc2);
+            } else {
+                parts.push(part)
+            }
+        }};
+    }
+    let mut need_deref = false;
+    if is_old_expression_format(&buf) && frame_base.is_some() {
+        // Still supporting old DWARF variable expressions without fbreg.
+        parts.extend_from_slice(&frame_base.unwrap().parts);
+        if let Some(CompiledExpressionPart::Local { trailing, .. }) = parts.last_mut() {
+            *trailing = false;
+        }
+        need_deref = frame_base.unwrap().need_deref;
+    }
+    let mut code_chunk = Vec::new();
+    macro_rules! flush_code_chunk {
+        () => {
+            if !code_chunk.is_empty() {
+                push!(CompiledExpressionPart::Code(code_chunk));
+                code_chunk = Vec::new();
+                let _ = code_chunk; // suppresses warning for final flush
+            }
+        };
+    }
+
+    // Find all landing pads by scanning bytes, do not care about
+    // false location at this moment.
+    // Looks hacky but it is fast; does not need to be really exact.
+    if buf.len() > 2 {
+        for i in 0..buf.len() - 2 {
+            let op = buf[i];
+            if op == gimli::constants::DW_OP_bra.0 || op == gimli::constants::DW_OP_skip.0 {
+                // TODO fix for big-endian
+                let offset = i16::from_le_bytes([buf[i + 1], buf[i + 2]]);
+                let origin = i + 3;
+                // Discarding out-of-bounds jumps (also some of falsely detected ops)
+                if (offset >= 0 && offset as usize + origin <= buf.len())
+                    || (offset < 0 && -offset as usize <= origin)
+                {
+                    let target = buf.len() as isize - origin as isize - offset as isize;
+                    jump_targets.insert(target as u64, JumpTargetMarker::new());
+                }
+            }
+        }
+    }
+
+    while !pc.is_empty() {
+        let unread_bytes = pc.len().into_u64();
+        if let Some(marker) = jump_targets.get(&unread_bytes) {
+            flush_code_chunk!();
+            parts.push(CompiledExpressionPart::LandingPad(marker.clone()));
+        }
+
+        need_deref = true;
+
+        let pos = pc.offset_from(&expr.0).into_u64() as usize;
+        let op = Operation::parse(&mut pc, encoding)?;
+        match op {
+            Operation::FrameOffset { offset } => {
+                // Expand DW_OP_fbreg into frame location and DW_OP_plus_uconst.
+                if frame_base.is_some() {
+                    // Add frame base expressions.
+                    flush_code_chunk!();
+                    parts.extend_from_slice(&frame_base.unwrap().parts);
+                }
+                if let Some(CompiledExpressionPart::Local { trailing, .. }) = parts.last_mut() {
+                    // Reset local trailing flag.
+                    *trailing = false;
+                }
+                // Append DW_OP_plus_uconst part.
+                let mut writer = ExpressionWriter::new();
+                writer.write_op(gimli::constants::DW_OP_plus_uconst)?;
+                writer.write_uleb128(offset as u64)?;
+                code_chunk.extend(writer.into_vec());
+                continue;
+            }
+            Operation::Drop { .. }
+            | Operation::Pick { .. }
+            | Operation::Swap { .. }
+            | Operation::Rot { .. }
+            | Operation::Nop { .. }
+            | Operation::UnsignedConstant { .. }
+            | Operation::SignedConstant { .. }
+            | Operation::ConstantIndex { .. }
+            | Operation::PlusConstant { .. }
+            | Operation::Abs { .. }
+            | Operation::And { .. }
+            | Operation::Or { .. }
+            | Operation::Xor { .. }
+            | Operation::Shl { .. }
+            | Operation::Plus { .. }
+            | Operation::Minus { .. }
+            | Operation::Div { .. }
+            | Operation::Mod { .. }
+            | Operation::Mul { .. }
+            | Operation::Neg { .. }
+            | Operation::Not { .. }
+            | Operation::Lt { .. }
+            | Operation::Gt { .. }
+            | Operation::Le { .. }
+            | Operation::Ge { .. }
+            | Operation::Eq { .. }
+            | Operation::Ne { .. }
+            | Operation::TypedLiteral { .. }
+            | Operation::Convert { .. }
+            | Operation::Reinterpret { .. }
+            | Operation::Piece { .. } => (),
+            Operation::Bra { target } | Operation::Skip { target } => {
+                flush_code_chunk!();
+                let arc_to = (pc.len().into_u64() as isize - target as isize) as u64;
+                let marker = match jump_targets.get(&arc_to) {
+                    Some(m) => m.clone(),
+                    None => {
+                        // Marker not found: probably out of bounds.
+                        return Ok(None);
+                    }
+                };
+                push!(CompiledExpressionPart::Jump {
+                    conditionally: match op {
+                        Operation::Bra { .. } => true,
+                        _ => false,
+                    },
+                    target: marker,
+                });
+                continue;
+            }
+            Operation::StackValue => {
+                need_deref = false;
+
+                // Find extra stack_value, that follow wasm-local operators,
+                // and mark such locals with special flag.
+                if let (Some(CompiledExpressionPart::Local { trailing, .. }), true) =
+                    (parts.last_mut(), code_chunk.is_empty())
+                {
+                    *trailing = true;
+                    continue;
+                }
+            }
+            Operation::Deref { .. } => {
+                flush_code_chunk!();
+                push!(CompiledExpressionPart::Deref);
+                // Don't re-enter the loop here (i.e. continue), because the
+                // DW_OP_deref still needs to be kept.
+            }
+            Operation::WasmLocal { index } => {
+                flush_code_chunk!();
+                let label = ValueLabel::from_u32(index as u32);
+                push!(CompiledExpressionPart::Local {
+                    label,
+                    trailing: false,
+                });
+                continue;
+            }
+            Operation::Shr { .. } | Operation::Shra { .. } => {
+                // Insert value normalisation part.
+                // The semantic value is 32 bits (TODO: check unit)
+                // but the target architecture is 64-bits. So we'll
+                // clean out the upper 32 bits (in a sign-correct way)
+                // to avoid contamination of the result with randomness.
+                let mut writer = ExpressionWriter::new();
+                writer.write_op(gimli::constants::DW_OP_plus_uconst)?;
+                writer.write_uleb128(32)?; // increase shift amount
+                writer.write_op(gimli::constants::DW_OP_swap)?;
+                writer.write_op(gimli::constants::DW_OP_const1u)?;
+                writer.write_u8(32)?;
+                writer.write_op(gimli::constants::DW_OP_shl)?;
+                writer.write_op(gimli::constants::DW_OP_swap)?;
+                code_chunk.extend(writer.into_vec());
+                // Don't re-enter the loop here (i.e. continue), because the
+                // DW_OP_shr* still needs to be kept.
+            }
+            Operation::Address { .. }
+            | Operation::AddressIndex { .. }
+            | Operation::Call { .. }
+            | Operation::Register { .. }
+            | Operation::RegisterOffset { .. }
+            | Operation::CallFrameCFA
+            | Operation::PushObjectAddress
+            | Operation::TLS
+            | Operation::ImplicitValue { .. }
+            | Operation::ImplicitPointer { .. }
+            | Operation::EntryValue { .. }
+            | Operation::ParameterRef { .. } => {
+                return Ok(None);
+            }
+            Operation::WasmGlobal { index: _ } | Operation::WasmStack { index: _ } => {
+                // TODO support those two
+                return Ok(None);
+            }
+        }
+        let chunk = &buf[pos..pc.offset_from(&expr.0).into_u64() as usize];
+        code_chunk.extend_from_slice(chunk);
+    }
+
+    flush_code_chunk!();
+    if let Some(marker) = jump_targets.get(&0) {
+        parts.push(CompiledExpressionPart::LandingPad(marker.clone()));
+    }
+
+    Ok(Some(CompiledExpression { parts, need_deref }))
+}
+
+#[derive(Debug, Clone)]
+struct CachedValueLabelRange {
+    func_index: DefinedFuncIndex,
+    start: usize,
+    end: usize,
+    label_location: HashMap<ValueLabel, LabelValueLoc>,
+}
+
+struct ValueLabelRangesBuilder<'a, 'b> {
+    ranges: Vec<CachedValueLabelRange>,
+    frame_info: Option<&'a FunctionFrameInfo<'b>>,
+    processed_labels: HashSet<ValueLabel>,
+}
+
+impl<'a, 'b> ValueLabelRangesBuilder<'a, 'b> {
+    pub fn new(
+        scope: &[(u64, u64)], // wasm ranges
+        addr_tr: &'a AddressTransform,
+        frame_info: Option<&'a FunctionFrameInfo<'b>>,
+    ) -> Self {
+        let mut ranges = Vec::new();
+        for (wasm_start, wasm_end) in scope {
+            if let Some((func_index, tr)) = addr_tr.translate_ranges_raw(*wasm_start, *wasm_end) {
+                ranges.extend(tr.into_iter().map(|(start, end)| CachedValueLabelRange {
+                    func_index,
+                    start,
+                    end,
+                    label_location: HashMap::new(),
+                }));
+            }
+        }
+        ranges.sort_unstable_by(|a, b| a.start.cmp(&b.start));
+        ValueLabelRangesBuilder {
+            ranges,
+            frame_info,
+            processed_labels: HashSet::new(),
+        }
+    }
+
+    fn process_label(&mut self, label: ValueLabel) {
+        if self.processed_labels.contains(&label) {
+            return;
+        }
+        self.processed_labels.insert(label);
+
+        let value_ranges = match self.frame_info.and_then(|fi| fi.value_ranges.get(&label)) {
+            Some(value_ranges) => value_ranges,
+            None => {
+                return;
+            }
+        };
+
+        let ranges = &mut self.ranges;
+        for value_range in value_ranges {
+            let range_start = value_range.start as usize;
+            let range_end = value_range.end as usize;
+            let loc = value_range.loc;
+            if range_start == range_end {
+                continue;
+            }
+            assert!(range_start < range_end);
+
+            // Find acceptable scope of ranges to intersect with.
+            let i = match ranges.binary_search_by(|s| s.start.cmp(&range_start)) {
+                Ok(i) => i,
+                Err(i) => {
+                    if i > 0 && range_start < ranges[i - 1].end {
+                        i - 1
+                    } else {
+                        i
+                    }
+                }
+            };
+            let j = match ranges.binary_search_by(|s| s.start.cmp(&range_end)) {
+                Ok(i) | Err(i) => i,
+            };
+            // Starting from the end, intersect (range_start..range_end) with
+            // self.ranges array.
+            for i in (i..j).rev() {
+                if range_end <= ranges[i].start || ranges[i].end <= range_start {
+                    continue;
+                }
+                if range_end < ranges[i].end {
+                    // Cutting some of the range from the end.
+                    let mut tail = ranges[i].clone();
+                    ranges[i].end = range_end;
+                    tail.start = range_end;
+                    ranges.insert(i + 1, tail);
+                }
+                assert!(ranges[i].end <= range_end);
+                if range_start <= ranges[i].start {
+                    ranges[i].label_location.insert(label, loc);
+                    continue;
+                }
+                // Cutting some of the range from the start.
+                let mut tail = ranges[i].clone();
+                ranges[i].end = range_start;
+                tail.start = range_start;
+                tail.label_location.insert(label, loc);
+                ranges.insert(i + 1, tail);
+            }
+        }
+    }
+
+    pub fn into_ranges(self) -> impl Iterator<Item = CachedValueLabelRange> {
+        // Ranges with not-enough labels are discarded.
+        let processed_labels_len = self.processed_labels.len();
+        self.ranges
+            .into_iter()
+            .filter(move |r| r.label_location.len() == processed_labels_len)
+    }
+}
+
+/// Marker for tracking incoming jumps.
+/// Different when created new, and the same when cloned.
+#[derive(Clone, Eq)]
+struct JumpTargetMarker(Rc<u32>);
+
+impl JumpTargetMarker {
+    fn new() -> JumpTargetMarker {
+        // Create somewhat unique hash data -- using part of
+        // the pointer of the RcBox.
+        let mut rc = Rc::new(0);
+        let hash_data = rc.as_ref() as *const u32 as usize as u32;
+        *Rc::get_mut(&mut rc).unwrap() = hash_data;
+        JumpTargetMarker(rc)
+    }
+}
+
+impl PartialEq for JumpTargetMarker {
+    fn eq(&self, other: &JumpTargetMarker) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl Hash for JumpTargetMarker {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        hasher.write_u32(*self.0);
+    }
+}
+impl std::fmt::Debug for JumpTargetMarker {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
+        write!(
+            f,
+            "JumpMarker<{:08x}>",
+            self.0.as_ref() as *const u32 as usize
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        compile_expression, AddressTransform, CompiledExpression, CompiledExpressionPart,
+        FunctionFrameInfo, JumpTargetMarker, ValueLabel, ValueLabelsRanges,
+    };
+    use crate::CompiledFunctionMetadata;
+    use gimli::{constants, Encoding, EndianSlice, Expression, RunTimeEndian};
+    use wasmtime_environ::FilePos;
+
+    macro_rules! dw_op {
+        (DW_OP_WASM_location) => {
+            0xed
+        };
+        ($i:literal) => {
+            $i
+        };
+        ($d:ident) => {
+            constants::$d.0 as u8
+        };
+        ($e:expr) => {
+            $e as u8
+        };
+    }
+
+    macro_rules! expression {
+        ($($t:tt),*) => {
+            Expression(EndianSlice::new(
+                &[$(dw_op!($t)),*],
+                RunTimeEndian::Little,
+            ))
+        }
+    }
+
+    fn find_jump_targets<'a>(ce: &'a CompiledExpression) -> Vec<&'a JumpTargetMarker> {
+        ce.parts
+            .iter()
+            .filter_map(|p| {
+                if let CompiledExpressionPart::LandingPad(t) = p {
+                    Some(t)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>()
+    }
+
+    static DWARF_ENCODING: Encoding = Encoding {
+        address_size: 4,
+        format: gimli::Format::Dwarf32,
+        version: 4,
+    };
+
+    #[test]
+    fn test_debug_expression_jump_target() {
+        let m1 = JumpTargetMarker::new();
+        let m2 = JumpTargetMarker::new();
+        assert!(m1 != m2);
+        assert!(m1 == m1.clone());
+
+        // Internal hash_data test (theoretically can fail intermittently).
+        assert!(m1.0 != m2.0);
+    }
+
+    #[test]
+    fn test_debug_parse_expressions() {
+        use cranelift_entity::EntityRef;
+
+        let (val1, val3, val20) = (ValueLabel::new(1), ValueLabel::new(3), ValueLabel::new(20));
+
+        let e = expression!(DW_OP_WASM_location, 0x0, 20, DW_OP_stack_value);
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![CompiledExpressionPart::Local {
+                    label: val20,
+                    trailing: true
+                }],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_WASM_location,
+            0x0,
+            1,
+            DW_OP_plus_uconst,
+            0x10,
+            DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Local {
+                        label: val1,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![35, 16, 159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(DW_OP_WASM_location, 0x0, 3, DW_OP_stack_value);
+        let fe = compile_expression(&e, DWARF_ENCODING, None).expect("non-error");
+        let e = expression!(DW_OP_fbreg, 0x12);
+        let ce = compile_expression(&e, DWARF_ENCODING, fe.as_ref())
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Local {
+                        label: val3,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![35, 18])
+                ],
+                need_deref: true,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_WASM_location,
+            0x0,
+            1,
+            DW_OP_plus_uconst,
+            5,
+            DW_OP_deref,
+            DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Local {
+                        label: val1,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![35, 5]),
+                    CompiledExpressionPart::Deref,
+                    CompiledExpressionPart::Code(vec![6, 159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_WASM_location,
+            0x0,
+            1,
+            DW_OP_lit16,
+            DW_OP_shra,
+            DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Local {
+                        label: val1,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![64, 35, 32, 22, 8, 32, 36, 22, 38, 159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_lit1,
+            DW_OP_dup,
+            DW_OP_WASM_location,
+            0x0,
+            1,
+            DW_OP_and,
+            DW_OP_bra,
+            5,
+            0, // --> pointer
+            DW_OP_swap,
+            DW_OP_shr,
+            DW_OP_skip,
+            2,
+            0, // --> done
+            // pointer:
+            DW_OP_plus,
+            DW_OP_deref,
+            // done:
+            DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        let targets = find_jump_targets(&ce);
+        assert_eq!(targets.len(), 2);
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Code(vec![49, 18]),
+                    CompiledExpressionPart::Local {
+                        label: val1,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![26]),
+                    CompiledExpressionPart::Jump {
+                        conditionally: true,
+                        target: targets[0].clone(),
+                    },
+                    CompiledExpressionPart::Code(vec![22, 35, 32, 22, 8, 32, 36, 22, 37]),
+                    CompiledExpressionPart::Jump {
+                        conditionally: false,
+                        target: targets[1].clone(),
+                    },
+                    CompiledExpressionPart::LandingPad(targets[0].clone()), // capture from
+                    CompiledExpressionPart::Code(vec![34]),
+                    CompiledExpressionPart::Deref,
+                    CompiledExpressionPart::Code(vec![6]),
+                    CompiledExpressionPart::LandingPad(targets[1].clone()), // capture to
+                    CompiledExpressionPart::Code(vec![159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_lit1,
+            DW_OP_dup,
+            DW_OP_bra,
+            2,
+            0, // --> target
+            DW_OP_deref,
+            DW_OP_lit0,
+            // target:
+            DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        let targets = find_jump_targets(&ce);
+        assert_eq!(targets.len(), 1);
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Code(vec![49, 18]),
+                    CompiledExpressionPart::Jump {
+                        conditionally: true,
+                        target: targets[0].clone(),
+                    },
+                    CompiledExpressionPart::Deref,
+                    CompiledExpressionPart::Code(vec![6, 48]),
+                    CompiledExpressionPart::LandingPad(targets[0].clone()), // capture to
+                    CompiledExpressionPart::Code(vec![159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(
+            DW_OP_lit1,
+            /* loop */ DW_OP_dup,
+            DW_OP_lit25,
+            DW_OP_ge,
+            DW_OP_bra,
+            5,
+            0, // --> done
+            DW_OP_plus_uconst,
+            1,
+            DW_OP_skip,
+            (-11 as i8),
+            (!0), // --> loop
+            /* done */ DW_OP_stack_value
+        );
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        let targets = find_jump_targets(&ce);
+        assert_eq!(targets.len(), 2);
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Code(vec![49]),
+                    CompiledExpressionPart::LandingPad(targets[0].clone()),
+                    CompiledExpressionPart::Code(vec![18, 73, 42]),
+                    CompiledExpressionPart::Jump {
+                        conditionally: true,
+                        target: targets[1].clone(),
+                    },
+                    CompiledExpressionPart::Code(vec![35, 1]),
+                    CompiledExpressionPart::Jump {
+                        conditionally: false,
+                        target: targets[0].clone(),
+                    },
+                    CompiledExpressionPart::LandingPad(targets[1].clone()),
+                    CompiledExpressionPart::Code(vec![159])
+                ],
+                need_deref: false,
+            }
+        );
+
+        let e = expression!(DW_OP_WASM_location, 0x0, 1, DW_OP_plus_uconst, 5);
+        let ce = compile_expression(&e, DWARF_ENCODING, None)
+            .expect("non-error")
+            .expect("expression");
+        assert_eq!(
+            ce,
+            CompiledExpression {
+                parts: vec![
+                    CompiledExpressionPart::Local {
+                        label: val1,
+                        trailing: false
+                    },
+                    CompiledExpressionPart::Code(vec![35, 5])
+                ],
+                need_deref: true,
+            }
+        );
+    }
+
+    fn create_mock_address_transform() -> AddressTransform {
+        use crate::FunctionAddressMap;
+        use cranelift_entity::PrimaryMap;
+        use wasmtime_environ::InstructionAddressMap;
+        use wasmtime_environ::WasmFileInfo;
+
+        let mut module_map = PrimaryMap::new();
+        let code_section_offset: u32 = 100;
+        let func = CompiledFunctionMetadata {
+            address_map: FunctionAddressMap {
+                instructions: vec![
+                    InstructionAddressMap {
+                        srcloc: FilePos::new(code_section_offset + 12),
+                        code_offset: 5,
+                    },
+                    InstructionAddressMap {
+                        srcloc: FilePos::default(),
+                        code_offset: 8,
+                    },
+                    InstructionAddressMap {
+                        srcloc: FilePos::new(code_section_offset + 17),
+                        code_offset: 15,
+                    },
+                    InstructionAddressMap {
+                        srcloc: FilePos::default(),
+                        code_offset: 23,
+                    },
+                ]
+                .into(),
+                start_srcloc: FilePos::new(code_section_offset + 10),
+                end_srcloc: FilePos::new(code_section_offset + 20),
+                body_offset: 0,
+                body_len: 30,
+            },
+            ..Default::default()
+        };
+        module_map.push(&func);
+        let fi = WasmFileInfo {
+            code_section_offset: code_section_offset.into(),
+            funcs: Vec::new(),
+            imported_func_count: 0,
+            path: None,
+        };
+        AddressTransform::new(&module_map, &fi)
+    }
+
+    fn create_mock_value_ranges() -> (ValueLabelsRanges, (ValueLabel, ValueLabel, ValueLabel)) {
+        use cranelift_codegen::{LabelValueLoc, ValueLocRange};
+        use cranelift_entity::EntityRef;
+        use std::collections::HashMap;
+        let mut value_ranges = HashMap::new();
+        let value_0 = ValueLabel::new(0);
+        let value_1 = ValueLabel::new(1);
+        let value_2 = ValueLabel::new(2);
+        value_ranges.insert(
+            value_0,
+            vec![ValueLocRange {
+                loc: LabelValueLoc::CFAOffset(0),
+                start: 0,
+                end: 25,
+            }],
+        );
+        value_ranges.insert(
+            value_1,
+            vec![ValueLocRange {
+                loc: LabelValueLoc::CFAOffset(0),
+                start: 5,
+                end: 30,
+            }],
+        );
+        value_ranges.insert(
+            value_2,
+            vec![
+                ValueLocRange {
+                    loc: LabelValueLoc::CFAOffset(0),
+                    start: 0,
+                    end: 10,
+                },
+                ValueLocRange {
+                    loc: LabelValueLoc::CFAOffset(0),
+                    start: 20,
+                    end: 30,
+                },
+            ],
+        );
+        (value_ranges, (value_0, value_1, value_2))
+    }
+
+    #[test]
+    fn test_debug_value_range_builder() {
+        use super::ValueLabelRangesBuilder;
+        use crate::debug::ModuleMemoryOffset;
+        use wasmtime_environ::{DefinedFuncIndex, EntityRef};
+
+        let addr_tr = create_mock_address_transform();
+        let (value_ranges, value_labels) = create_mock_value_ranges();
+        let fi = FunctionFrameInfo {
+            memory_offset: ModuleMemoryOffset::None,
+            value_ranges: &value_ranges,
+        };
+
+        // No value labels, testing if entire function range coming through.
+        let builder = ValueLabelRangesBuilder::new(&[(10, 20)], &addr_tr, Some(&fi));
+        let ranges = builder.into_ranges().collect::<Vec<_>>();
+        assert_eq!(ranges.len(), 1);
+        assert_eq!(ranges[0].func_index, DefinedFuncIndex::new(0));
+        assert_eq!(ranges[0].start, 0);
+        assert_eq!(ranges[0].end, 30);
+
+        // Two labels (val0@0..25 and val1@5..30), their common lifetime intersect at 5..25.
+        let mut builder = ValueLabelRangesBuilder::new(&[(10, 20)], &addr_tr, Some(&fi));
+        builder.process_label(value_labels.0);
+        builder.process_label(value_labels.1);
+        let ranges = builder.into_ranges().collect::<Vec<_>>();
+        assert_eq!(ranges.len(), 1);
+        assert_eq!(ranges[0].start, 5);
+        assert_eq!(ranges[0].end, 25);
+
+        // Adds val2 with complex lifetime @0..10 and @20..30 to the previous test, and
+        // also narrows range.
+        let mut builder = ValueLabelRangesBuilder::new(&[(11, 17)], &addr_tr, Some(&fi));
+        builder.process_label(value_labels.0);
+        builder.process_label(value_labels.1);
+        builder.process_label(value_labels.2);
+        let ranges = builder.into_ranges().collect::<Vec<_>>();
+        // Result is two ranges @5..10 and @20..23
+        assert_eq!(ranges.len(), 2);
+        assert_eq!(ranges[0].start, 5);
+        assert_eq!(ranges[0].end, 10);
+        assert_eq!(ranges[1].start, 20);
+        assert_eq!(ranges[1].end, 23);
+    }
+}