wasmtime 20.0.2 → 21.0.1

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

@@ -1,239 +0,0 @@
-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>,
-    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, at, &mut deps)?;
-    }
-    Ok(deps)
-}
-
-fn build_unit_dependencies<R: Reader<Offset = usize>>(
-    header: read::UnitHeader<R>,
-    dwarf: &read::Dwarf<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)?;
-    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-20.0.2/src/debug/transform/attr.rs

@@ -1,345 +0,0 @@
-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, DebugLineStr, DebugStr, DebugStrOffsets,
-    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(str_offset) => {
-                let s = context.debug_str.get_str(str_offset)?.to_slice()?.to_vec();
-                write::AttributeValue::StringRef(out_strings.add(s))
-            }
-            AttributeValue::DebugStrOffsetsIndex(i) => {
-                let str_offset = context.debug_str_offsets.get_str_offset(
-                    gimli::Format::Dwarf32,
-                    unit.str_offsets_base,
-                    i,
-                )?;
-                let s = context.debug_str.get_str(str_offset)?.to_slice()?.to_vec();
-                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>,
-    debug_str: &DebugStr<R>,
-    debug_str_offsets: &DebugStrOffsets<R>,
-    debug_line_str: &DebugLineStr<R>,
-    out_strings: &mut write::StringTable,
-) -> Result<write::LineString, Error>
-where
-    R: Reader,
-{
-    let content = match attr_value {
-        AttributeValue::DebugStrRef(str_offset) => {
-            debug_str.get_str(*str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::DebugStrOffsetsIndex(i) => {
-            let str_offset = debug_str_offsets.get_str_offset(
-                gimli::Format::Dwarf32,
-                unit.str_offsets_base,
-                *i,
-            )?;
-            debug_str.get_str(str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::DebugLineStrRef(str_offset) => {
-            debug_line_str.get_str(*str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::String(b) => b.to_slice()?.to_vec(),
-        v => bail!("Unexpected attribute value: {:?}", v),
-    };
-    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),
-        _ => bail!("DW_FORM_line_strp or other not supported"),
-    })
-}