wasmtime 20.0.2 → 21.0.1

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

@@ -0,0 +1,252 @@
+use crate::debug::transform::AddressTransform;
+use gimli::constants;
+use gimli::read;
+use gimli::{Reader, UnitSectionOffset};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug)]
+pub struct Dependencies {
+    edges: HashMap<UnitSectionOffset, HashSet<UnitSectionOffset>>,
+    roots: HashSet<UnitSectionOffset>,
+}
+
+impl Dependencies {
+    fn new() -> Dependencies {
+        Dependencies {
+            edges: HashMap::new(),
+            roots: HashSet::new(),
+        }
+    }
+
+    fn add_edge(&mut self, a: UnitSectionOffset, b: UnitSectionOffset) {
+        use std::collections::hash_map::Entry;
+        match self.edges.entry(a) {
+            Entry::Occupied(mut o) => {
+                o.get_mut().insert(b);
+            }
+            Entry::Vacant(v) => {
+                let mut set = HashSet::new();
+                set.insert(b);
+                v.insert(set);
+            }
+        }
+    }
+
+    fn add_root(&mut self, root: UnitSectionOffset) {
+        self.roots.insert(root);
+    }
+
+    pub fn get_reachable(&self) -> HashSet<UnitSectionOffset> {
+        let mut reachable = self.roots.clone();
+        let mut queue = Vec::new();
+        for i in self.roots.iter() {
+            if let Some(deps) = self.edges.get(i) {
+                for j in deps {
+                    if reachable.contains(j) {
+                        continue;
+                    }
+                    reachable.insert(*j);
+                    queue.push(*j);
+                }
+            }
+        }
+        while let Some(i) = queue.pop() {
+            if let Some(deps) = self.edges.get(&i) {
+                for j in deps {
+                    if reachable.contains(j) {
+                        continue;
+                    }
+                    reachable.insert(*j);
+                    queue.push(*j);
+                }
+            }
+        }
+        reachable
+    }
+}
+
+pub fn build_dependencies<R: Reader<Offset = usize>>(
+    dwarf: &read::Dwarf<R>,
+    dwp: &Option<read::DwarfPackage<R>>,
+    at: &AddressTransform,
+) -> read::Result<Dependencies> {
+    let mut deps = Dependencies::new();
+    let mut units = dwarf.units();
+    while let Some(unit) = units.next()? {
+        build_unit_dependencies(unit, dwarf, dwp, at, &mut deps)?;
+    }
+    Ok(deps)
+}
+
+fn build_unit_dependencies<R: Reader<Offset = usize>>(
+    header: read::UnitHeader<R>,
+    dwarf: &read::Dwarf<R>,
+    dwp: &Option<read::DwarfPackage<R>>,
+    at: &AddressTransform,
+    deps: &mut Dependencies,
+) -> read::Result<()> {
+    let unit = dwarf.unit(header)?;
+    let mut tree = unit.entries_tree(None)?;
+    let root = tree.root()?;
+    build_die_dependencies(root, dwarf, &unit, at, deps)?;
+
+    if let Some(dwarf_package) = dwp {
+        if let Some(dwo_id) = unit.dwo_id {
+            if let Some(cu) = dwarf_package.find_cu(dwo_id, dwarf)? {
+                if let Some(unit_header) = cu.debug_info.units().next()? {
+                    build_unit_dependencies(unit_header, &cu, &None, at, deps)?;
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn has_die_back_edge<R: Reader<Offset = usize>>(die: &read::DebuggingInformationEntry<R>) -> bool {
+    match die.tag() {
+        constants::DW_TAG_variable
+        | constants::DW_TAG_constant
+        | constants::DW_TAG_inlined_subroutine
+        | constants::DW_TAG_lexical_block
+        | constants::DW_TAG_label
+        | constants::DW_TAG_with_stmt
+        | constants::DW_TAG_try_block
+        | constants::DW_TAG_catch_block
+        | constants::DW_TAG_template_type_parameter
+        | constants::DW_TAG_enumerator
+        | constants::DW_TAG_member
+        | constants::DW_TAG_variant_part
+        | constants::DW_TAG_variant
+        | constants::DW_TAG_formal_parameter => true,
+        _ => false,
+    }
+}
+
+fn has_valid_code_range<R: Reader<Offset = usize>>(
+    die: &read::DebuggingInformationEntry<R>,
+    dwarf: &read::Dwarf<R>,
+    unit: &read::Unit<R>,
+    at: &AddressTransform,
+) -> read::Result<bool> {
+    match die.tag() {
+        constants::DW_TAG_subprogram => {
+            if let Some(ranges_attr) = die.attr_value(constants::DW_AT_ranges)? {
+                let offset = match ranges_attr {
+                    read::AttributeValue::RangeListsRef(val) => {
+                        dwarf.ranges_offset_from_raw(unit, val)
+                    }
+                    read::AttributeValue::DebugRngListsIndex(index) => {
+                        dwarf.ranges_offset(unit, index)?
+                    }
+                    _ => return Ok(false),
+                };
+                let mut has_valid_base = if let Some(read::AttributeValue::Addr(low_pc)) =
+                    die.attr_value(constants::DW_AT_low_pc)?
+                {
+                    Some(at.can_translate_address(low_pc))
+                } else {
+                    None
+                };
+                let mut it = dwarf.ranges.raw_ranges(offset, unit.encoding())?;
+                while let Some(range) = it.next()? {
+                    // If at least one of the range addresses can be converted,
+                    // declaring code range as valid.
+                    match range {
+                        read::RawRngListEntry::AddressOrOffsetPair { .. }
+                            if has_valid_base.is_some() =>
+                        {
+                            if has_valid_base.unwrap() {
+                                return Ok(true);
+                            }
+                        }
+                        read::RawRngListEntry::StartEnd { begin, .. }
+                        | read::RawRngListEntry::StartLength { begin, .. }
+                        | read::RawRngListEntry::AddressOrOffsetPair { begin, .. } => {
+                            if at.can_translate_address(begin) {
+                                return Ok(true);
+                            }
+                        }
+                        read::RawRngListEntry::StartxEndx { begin, .. }
+                        | read::RawRngListEntry::StartxLength { begin, .. } => {
+                            let addr = dwarf.address(unit, begin)?;
+                            if at.can_translate_address(addr) {
+                                return Ok(true);
+                            }
+                        }
+                        read::RawRngListEntry::BaseAddress { addr } => {
+                            has_valid_base = Some(at.can_translate_address(addr));
+                        }
+                        read::RawRngListEntry::BaseAddressx { addr } => {
+                            let addr = dwarf.address(unit, addr)?;
+                            has_valid_base = Some(at.can_translate_address(addr));
+                        }
+                        read::RawRngListEntry::OffsetPair { .. } => (),
+                    }
+                }
+                return Ok(false);
+            } else if let Some(low_pc) = die.attr_value(constants::DW_AT_low_pc)? {
+                if let read::AttributeValue::Addr(a) = low_pc {
+                    return Ok(at.can_translate_address(a));
+                } else if let read::AttributeValue::DebugAddrIndex(i) = low_pc {
+                    let a = dwarf.debug_addr.get_address(4, unit.addr_base, i)?;
+                    return Ok(at.can_translate_address(a));
+                }
+            }
+        }
+        _ => (),
+    }
+    Ok(false)
+}
+
+fn build_die_dependencies<R: Reader<Offset = usize>>(
+    die: read::EntriesTreeNode<R>,
+    dwarf: &read::Dwarf<R>,
+    unit: &read::Unit<R>,
+    at: &AddressTransform,
+    deps: &mut Dependencies,
+) -> read::Result<()> {
+    let entry = die.entry();
+    let offset = entry.offset().to_unit_section_offset(unit);
+    let mut attrs = entry.attrs();
+    while let Some(attr) = attrs.next()? {
+        build_attr_dependencies(&attr, offset, dwarf, unit, at, deps)?;
+    }
+
+    let mut children = die.children();
+    while let Some(child) = children.next()? {
+        let child_entry = child.entry();
+        let child_offset = child_entry.offset().to_unit_section_offset(unit);
+        deps.add_edge(child_offset, offset);
+        if has_die_back_edge(child_entry) {
+            deps.add_edge(offset, child_offset);
+        }
+        if has_valid_code_range(child_entry, dwarf, unit, at)? {
+            deps.add_root(child_offset);
+        }
+        build_die_dependencies(child, dwarf, unit, at, deps)?;
+    }
+    Ok(())
+}
+
+fn build_attr_dependencies<R: Reader<Offset = usize>>(
+    attr: &read::Attribute<R>,
+    offset: UnitSectionOffset,
+    _dwarf: &read::Dwarf<R>,
+    unit: &read::Unit<R>,
+    _at: &AddressTransform,
+    deps: &mut Dependencies,
+) -> read::Result<()> {
+    match attr.value() {
+        read::AttributeValue::UnitRef(val) => {
+            let ref_offset = val.to_unit_section_offset(unit);
+            deps.add_edge(offset, ref_offset);
+        }
+        read::AttributeValue::DebugInfoRef(val) => {
+            let ref_offset = UnitSectionOffset::DebugInfoOffset(val);
+            deps.add_edge(offset, ref_offset);
+        }
+        _ => (),
+    }
+    Ok(())
+}

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

@@ -0,0 +1,320 @@
+use super::address_transform::AddressTransform;
+use super::expression::{compile_expression, CompiledExpression, FunctionFrameInfo};
+use super::range_info_builder::RangeInfoBuilder;
+use super::refs::{PendingDebugInfoRefs, PendingUnitRefs};
+use super::{DebugInputContext, Reader, TransformError};
+use anyhow::{bail, Error};
+use cranelift_codegen::isa::TargetIsa;
+use gimli::{write, AttributeValue, DebugLineOffset, DebuggingInformationEntry, Unit};
+
+#[derive(Debug)]
+pub(crate) enum FileAttributeContext<'a> {
+    Root(Option<DebugLineOffset>),
+    Children {
+        file_map: &'a [write::FileId],
+        file_index_base: u64,
+        frame_base: Option<&'a CompiledExpression>,
+    },
+}
+
+fn is_exprloc_to_loclist_allowed(attr_name: gimli::constants::DwAt) -> bool {
+    match attr_name {
+        gimli::DW_AT_location
+        | gimli::DW_AT_string_length
+        | gimli::DW_AT_return_addr
+        | gimli::DW_AT_data_member_location
+        | gimli::DW_AT_frame_base
+        | gimli::DW_AT_segment
+        | gimli::DW_AT_static_link
+        | gimli::DW_AT_use_location
+        | gimli::DW_AT_vtable_elem_location => true,
+        _ => false,
+    }
+}
+
+pub(crate) fn clone_die_attributes<'a, R>(
+    dwarf: &gimli::Dwarf<R>,
+    unit: &Unit<R, R::Offset>,
+    entry: &DebuggingInformationEntry<R>,
+    context: &DebugInputContext<R>,
+    addr_tr: &'a AddressTransform,
+    frame_info: Option<&FunctionFrameInfo>,
+    out_unit: &mut write::Unit,
+    current_scope_id: write::UnitEntryId,
+    subprogram_range_builder: Option<RangeInfoBuilder>,
+    scope_ranges: Option<&Vec<(u64, u64)>>,
+    cu_low_pc: u64,
+    out_strings: &mut write::StringTable,
+    pending_die_refs: &mut PendingUnitRefs,
+    pending_di_refs: &mut PendingDebugInfoRefs,
+    file_context: FileAttributeContext<'a>,
+    isa: &dyn TargetIsa,
+) -> Result<(), Error>
+where
+    R: Reader,
+{
+    let unit_encoding = unit.encoding();
+
+    let range_info = if let Some(subprogram_range_builder) = subprogram_range_builder {
+        subprogram_range_builder
+    } else {
+        // FIXME for CU: currently address_transform operate on a single
+        // function range, and when CU spans multiple ranges the
+        // transformation may be incomplete.
+        RangeInfoBuilder::from(dwarf, unit, entry, context, cu_low_pc)?
+    };
+    range_info.build(addr_tr, out_unit, current_scope_id);
+
+    let mut attrs = entry.attrs();
+    while let Some(attr) = attrs.next()? {
+        let attr_value = match attr.value() {
+            AttributeValue::Addr(_) | AttributeValue::DebugAddrIndex(_)
+                if attr.name() == gimli::DW_AT_low_pc =>
+            {
+                continue;
+            }
+            AttributeValue::Udata(_) if attr.name() == gimli::DW_AT_high_pc => {
+                continue;
+            }
+            AttributeValue::RangeListsRef(_) if attr.name() == gimli::DW_AT_ranges => {
+                continue;
+            }
+            AttributeValue::DebugAddrBase(_) | AttributeValue::DebugStrOffsetsBase(_) => {
+                continue;
+            }
+
+            AttributeValue::Addr(u) => {
+                let addr = addr_tr.translate(u).unwrap_or(write::Address::Constant(0));
+                write::AttributeValue::Address(addr)
+            }
+            AttributeValue::DebugAddrIndex(i) => {
+                let u = context.debug_addr.get_address(4, unit.addr_base, i)?;
+                let addr = addr_tr.translate(u).unwrap_or(write::Address::Constant(0));
+                write::AttributeValue::Address(addr)
+            }
+            AttributeValue::Block(d) => write::AttributeValue::Block(d.to_slice()?.into_owned()),
+            AttributeValue::Udata(u) => write::AttributeValue::Udata(u),
+            AttributeValue::Data1(d) => write::AttributeValue::Data1(d),
+            AttributeValue::Data2(d) => write::AttributeValue::Data2(d),
+            AttributeValue::Data4(d) => write::AttributeValue::Data4(d),
+            AttributeValue::Sdata(d) => write::AttributeValue::Sdata(d),
+            AttributeValue::Flag(f) => write::AttributeValue::Flag(f),
+            AttributeValue::DebugLineRef(line_program_offset) => {
+                if let FileAttributeContext::Root(o) = file_context {
+                    if o != Some(line_program_offset) {
+                        return Err(TransformError("invalid debug_line offset").into());
+                    }
+                    write::AttributeValue::LineProgramRef
+                } else {
+                    return Err(TransformError("unexpected debug_line index attribute").into());
+                }
+            }
+            AttributeValue::FileIndex(i) => {
+                if let FileAttributeContext::Children {
+                    file_map,
+                    file_index_base,
+                    ..
+                } = file_context
+                {
+                    write::AttributeValue::FileIndex(Some(file_map[(i - file_index_base) as usize]))
+                } else {
+                    return Err(TransformError("unexpected file index attribute").into());
+                }
+            }
+            AttributeValue::DebugStrRef(_) | AttributeValue::DebugStrOffsetsIndex(_) => {
+                let s = dwarf
+                    .attr_string(unit, attr.value().clone())?
+                    .to_string_lossy()?
+                    .into_owned();
+                write::AttributeValue::StringRef(out_strings.add(s))
+            }
+            AttributeValue::RangeListsRef(r) => {
+                let r = dwarf.ranges_offset_from_raw(unit, r);
+                let range_info = RangeInfoBuilder::from_ranges_ref(unit, r, context, cu_low_pc)?;
+                let range_list_id = range_info.build_ranges(addr_tr, &mut out_unit.ranges);
+                write::AttributeValue::RangeListRef(range_list_id)
+            }
+            AttributeValue::LocationListsRef(r) => {
+                let low_pc = 0;
+                let mut locs = context.loclists.locations(
+                    r,
+                    unit_encoding,
+                    low_pc,
+                    &context.debug_addr,
+                    unit.addr_base,
+                )?;
+                let frame_base =
+                    if let FileAttributeContext::Children { frame_base, .. } = file_context {
+                        frame_base
+                    } else {
+                        None
+                    };
+
+                let mut result: Option<Vec<_>> = None;
+                while let Some(loc) = locs.next()? {
+                    if let Some(expr) = compile_expression(&loc.data, unit_encoding, frame_base)? {
+                        let chunk = expr
+                            .build_with_locals(
+                                &[(loc.range.begin, loc.range.end)],
+                                addr_tr,
+                                frame_info,
+                                isa,
+                            )
+                            .filter(|i| {
+                                // Ignore empty range
+                                if let Ok((_, 0, _)) = i {
+                                    false
+                                } else {
+                                    true
+                                }
+                            })
+                            .map(|i| {
+                                i.map(|(start, len, expr)| write::Location::StartLength {
+                                    begin: start,
+                                    length: len,
+                                    data: expr,
+                                })
+                            })
+                            .collect::<Result<Vec<_>, _>>()?;
+                        match &mut result {
+                            Some(r) => r.extend(chunk),
+                            x @ None => *x = Some(chunk),
+                        }
+                    } else {
+                        // FIXME _expr contains invalid expression
+                        continue; // ignore entry
+                    }
+                }
+                if result.is_none() {
+                    continue; // no valid locations
+                }
+                let list_id = out_unit.locations.add(write::LocationList(result.unwrap()));
+                write::AttributeValue::LocationListRef(list_id)
+            }
+            AttributeValue::Exprloc(_) if attr.name() == gimli::DW_AT_frame_base => {
+                // We do not really "rewrite" the frame base so much as replace it outright.
+                // References to it through the DW_OP_fbreg opcode will be expanded below.
+                let mut cfa = write::Expression::new();
+                cfa.op(gimli::DW_OP_call_frame_cfa);
+                write::AttributeValue::Exprloc(cfa)
+            }
+            AttributeValue::Exprloc(ref expr) => {
+                let frame_base =
+                    if let FileAttributeContext::Children { frame_base, .. } = file_context {
+                        frame_base
+                    } else {
+                        None
+                    };
+                if let Some(expr) = compile_expression(expr, unit_encoding, frame_base)? {
+                    if expr.is_simple() {
+                        if let Some(expr) = expr.build() {
+                            write::AttributeValue::Exprloc(expr)
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        // Conversion to loclist is required.
+                        if let Some(scope_ranges) = scope_ranges {
+                            let exprs = expr
+                                .build_with_locals(scope_ranges, addr_tr, frame_info, isa)
+                                .collect::<Result<Vec<_>, _>>()?;
+                            if exprs.is_empty() {
+                                continue;
+                            }
+                            let found_single_expr = {
+                                // Micro-optimization all expressions alike, use one exprloc.
+                                let mut found_expr: Option<write::Expression> = None;
+                                for (_, _, expr) in &exprs {
+                                    if let Some(ref prev_expr) = found_expr {
+                                        if expr == prev_expr {
+                                            continue; // the same expression
+                                        }
+                                        found_expr = None;
+                                        break;
+                                    }
+                                    found_expr = Some(expr.clone())
+                                }
+                                found_expr
+                            };
+                            if let Some(expr) = found_single_expr {
+                                write::AttributeValue::Exprloc(expr)
+                            } else if is_exprloc_to_loclist_allowed(attr.name()) {
+                                // Converting exprloc to loclist.
+                                let mut locs = Vec::new();
+                                for (begin, length, data) in exprs {
+                                    if length == 0 {
+                                        // Ignore empty range
+                                        continue;
+                                    }
+                                    locs.push(write::Location::StartLength {
+                                        begin,
+                                        length,
+                                        data,
+                                    });
+                                }
+                                let list_id = out_unit.locations.add(write::LocationList(locs));
+                                write::AttributeValue::LocationListRef(list_id)
+                            } else {
+                                continue;
+                            }
+                        } else {
+                            continue;
+                        }
+                    }
+                } else {
+                    // FIXME _expr contains invalid expression
+                    continue; // ignore attribute
+                }
+            }
+            AttributeValue::Encoding(e) => write::AttributeValue::Encoding(e),
+            AttributeValue::DecimalSign(e) => write::AttributeValue::DecimalSign(e),
+            AttributeValue::Endianity(e) => write::AttributeValue::Endianity(e),
+            AttributeValue::Accessibility(e) => write::AttributeValue::Accessibility(e),
+            AttributeValue::Visibility(e) => write::AttributeValue::Visibility(e),
+            AttributeValue::Virtuality(e) => write::AttributeValue::Virtuality(e),
+            AttributeValue::Language(e) => write::AttributeValue::Language(e),
+            AttributeValue::AddressClass(e) => write::AttributeValue::AddressClass(e),
+            AttributeValue::IdentifierCase(e) => write::AttributeValue::IdentifierCase(e),
+            AttributeValue::CallingConvention(e) => write::AttributeValue::CallingConvention(e),
+            AttributeValue::Inline(e) => write::AttributeValue::Inline(e),
+            AttributeValue::Ordering(e) => write::AttributeValue::Ordering(e),
+            AttributeValue::UnitRef(offset) => {
+                pending_die_refs.insert(current_scope_id, attr.name(), offset);
+                continue;
+            }
+            AttributeValue::DebugInfoRef(offset) => {
+                pending_di_refs.insert(current_scope_id, attr.name(), offset);
+                continue;
+            }
+            AttributeValue::String(d) => write::AttributeValue::String(d.to_slice()?.into_owned()),
+            a => bail!("Unexpected attribute: {:?}", a),
+        };
+        let current_scope = out_unit.get_mut(current_scope_id);
+        current_scope.set(attr.name(), attr_value);
+    }
+    Ok(())
+}
+
+pub(crate) fn clone_attr_string<R>(
+    attr_value: &AttributeValue<R>,
+    form: gimli::DwForm,
+    unit: &Unit<R, R::Offset>,
+    dwarf: &gimli::Dwarf<R>,
+    out_strings: &mut write::StringTable,
+) -> Result<write::LineString, Error>
+where
+    R: Reader,
+{
+    let content = dwarf
+        .attr_string(unit, attr_value.clone())?
+        .to_string_lossy()?
+        .into_owned();
+    Ok(match form {
+        gimli::DW_FORM_strp => {
+            let id = out_strings.add(content);
+            write::LineString::StringRef(id)
+        }
+        gimli::DW_FORM_string => write::LineString::String(content.into()),
+        _ => bail!("DW_FORM_line_strp or other not supported"),
+    })
+}