wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/regalloc2-0.8.1/src/ion/requirement.rs

@@ -1,174 +0,0 @@
-/*
- * This file was initially derived from the files
- * `js/src/jit/BacktrackingAllocator.h` and
- * `js/src/jit/BacktrackingAllocator.cpp` in Mozilla Firefox, and was
- * originally licensed under the Mozilla Public License 2.0. We
- * subsequently relicensed it to Apache-2.0 WITH LLVM-exception (see
- * https://github.com/bytecodealliance/regalloc2/issues/7).
- *
- * Since the initial port, the design has been substantially evolved
- * and optimized.
- */
-
-//! Requirements computation.
-
-use super::{Env, LiveBundleIndex};
-use crate::{Function, Inst, Operand, OperandConstraint, PReg, ProgPoint};
-
-pub struct RequirementConflict;
-
-#[derive(Clone, Copy, Debug)]
-pub enum RequirementConflictAt {
-    /// A transition from a stack-constrained to a reg-constrained
-    /// segment. The suggested split point is late, to keep the
-    /// intervening region with the stackslot (which is cheaper).
-    StackToReg(ProgPoint),
-    /// A transition from a reg-constraint to a stack-constrained
-    /// segment. Mirror of above: the suggested split point is early
-    /// (just after the last register use).
-    RegToStack(ProgPoint),
-    /// Any other transition. The suggested split point is late (just
-    /// before the conflicting use), but the split will also trim the
-    /// ends and create a split bundle, so the intervening region will
-    /// not appear with either side. This is probably for the best
-    /// when e.g. the two sides of the split are both constrained to
-    /// different physical registers: the part in the middle should be
-    /// constrained to neither.
-    Other(ProgPoint),
-}
-
-impl RequirementConflictAt {
-    #[inline(always)]
-    pub fn should_trim_edges_around_split(self) -> bool {
-        match self {
-            RequirementConflictAt::RegToStack(..) | RequirementConflictAt::StackToReg(..) => false,
-            RequirementConflictAt::Other(..) => true,
-        }
-    }
-
-    #[inline(always)]
-    pub fn suggested_split_point(self) -> ProgPoint {
-        match self {
-            RequirementConflictAt::RegToStack(pt)
-            | RequirementConflictAt::StackToReg(pt)
-            | RequirementConflictAt::Other(pt) => pt,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Requirement {
-    FixedReg(PReg),
-    FixedStack(PReg),
-    Register,
-    Stack,
-    Any,
-}
-impl Requirement {
-    #[inline(always)]
-    pub fn merge(self, other: Requirement) -> Result<Requirement, RequirementConflict> {
-        match (self, other) {
-            (other, Requirement::Any) | (Requirement::Any, other) => Ok(other),
-            (Requirement::Register, Requirement::Register) => Ok(self),
-            (Requirement::Stack, Requirement::Stack) => Ok(self),
-            (Requirement::Register, Requirement::FixedReg(preg))
-            | (Requirement::FixedReg(preg), Requirement::Register) => {
-                Ok(Requirement::FixedReg(preg))
-            }
-            (Requirement::Stack, Requirement::FixedStack(preg))
-            | (Requirement::FixedStack(preg), Requirement::Stack) => {
-                Ok(Requirement::FixedStack(preg))
-            }
-            (Requirement::FixedReg(a), Requirement::FixedReg(b)) if a == b => Ok(self),
-            (Requirement::FixedStack(a), Requirement::FixedStack(b)) if a == b => Ok(self),
-            _ => Err(RequirementConflict),
-        }
-    }
-
-    #[inline(always)]
-    pub fn is_stack(self) -> bool {
-        match self {
-            Requirement::Stack | Requirement::FixedStack(..) => true,
-            Requirement::Register | Requirement::FixedReg(..) => false,
-            Requirement::Any => false,
-        }
-    }
-
-    #[inline(always)]
-    pub fn is_reg(self) -> bool {
-        match self {
-            Requirement::Register | Requirement::FixedReg(..) => true,
-            Requirement::Stack | Requirement::FixedStack(..) => false,
-            Requirement::Any => false,
-        }
-    }
-}
-
-impl<'a, F: Function> Env<'a, F> {
-    #[inline(always)]
-    pub fn requirement_from_operand(&self, op: Operand) -> Requirement {
-        match op.constraint() {
-            OperandConstraint::FixedReg(preg) => {
-                if self.pregs[preg.index()].is_stack {
-                    Requirement::FixedStack(preg)
-                } else {
-                    Requirement::FixedReg(preg)
-                }
-            }
-            OperandConstraint::Reg | OperandConstraint::Reuse(_) => Requirement::Register,
-            OperandConstraint::Stack => Requirement::Stack,
-            OperandConstraint::Any => Requirement::Any,
-        }
-    }
-
-    pub fn compute_requirement(
-        &self,
-        bundle: LiveBundleIndex,
-    ) -> Result<Requirement, RequirementConflictAt> {
-        let mut req = Requirement::Any;
-        let mut last_pos = ProgPoint::before(Inst::new(0));
-        trace!("compute_requirement: {:?}", bundle);
-        let ranges = &self.bundles[bundle.index()].ranges;
-        for entry in ranges {
-            trace!(" -> LR {:?}: {:?}", entry.index, entry.range);
-            for u in &self.ranges[entry.index.index()].uses {
-                trace!("  -> use {:?}", u);
-                let r = self.requirement_from_operand(u.operand);
-                req = req.merge(r).map_err(|_| {
-                    trace!("     -> conflict");
-                    if req.is_stack() && r.is_reg() {
-                        // Suggested split point just before the reg (i.e., late split).
-                        RequirementConflictAt::StackToReg(u.pos)
-                    } else if req.is_reg() && r.is_stack() {
-                        // Suggested split point just after the stack
-                        // (i.e., early split). Note that splitting
-                        // with a use *right* at the beginning is
-                        // interpreted by `split_and_requeue_bundle`
-                        // as splitting off the first use.
-                        RequirementConflictAt::RegToStack(last_pos)
-                    } else {
-                        RequirementConflictAt::Other(u.pos)
-                    }
-                })?;
-                last_pos = u.pos;
-                trace!("     -> req {:?}", req);
-            }
-        }
-        trace!(" -> final: {:?}", req);
-        Ok(req)
-    }
-
-    pub fn merge_bundle_requirements(
-        &self,
-        a: LiveBundleIndex,
-        b: LiveBundleIndex,
-    ) -> Result<Requirement, RequirementConflict> {
-        let req_a = self
-            .compute_requirement(a)
-            .map_err(|_| RequirementConflict)?;
-        let req_b = self
-            .compute_requirement(b)
-            .map_err(|_| RequirementConflict)?;
-        req_a.merge(req_b)
-    }
-}

data/ext/cargo-vendor/regalloc2-0.8.1/src/ion/spill.rs

@@ -1,198 +0,0 @@
-/*
- * This file was initially derived from the files
- * `js/src/jit/BacktrackingAllocator.h` and
- * `js/src/jit/BacktrackingAllocator.cpp` in Mozilla Firefox, and was
- * originally licensed under the Mozilla Public License 2.0. We
- * subsequently relicensed it to Apache-2.0 WITH LLVM-exception (see
- * https://github.com/bytecodealliance/regalloc2/issues/7).
- *
- * Since the initial port, the design has been substantially evolved
- * and optimized.
- */
-
-//! Spillslot allocation.
-
-use super::{
-    AllocRegResult, Env, LiveRangeKey, LiveRangeSet, PReg, PRegIndex, RegTraversalIter,
-    SpillSetIndex, SpillSlotData, SpillSlotIndex, SpillSlotList,
-};
-use crate::{Allocation, Function, SpillSlot};
-use smallvec::smallvec;
-
-impl<'a, F: Function> Env<'a, F> {
-    pub fn try_allocating_regs_for_spilled_bundles(&mut self) {
-        trace!("allocating regs for spilled bundles");
-        for i in 0..self.spilled_bundles.len() {
-            let bundle = self.spilled_bundles[i]; // don't borrow self
-
-            if self.bundles[bundle.index()].ranges.is_empty() {
-                continue;
-            }
-
-            let class = self.spillsets[self.bundles[bundle.index()].spillset.index()].class;
-            let hint = self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint;
-
-            // This may be an empty-range bundle whose ranges are not
-            // sorted; sort all range-lists again here.
-            self.bundles[bundle.index()]
-                .ranges
-                .sort_unstable_by_key(|entry| entry.range.from);
-
-            let mut success = false;
-            self.stats.spill_bundle_reg_probes += 1;
-            for preg in
-                RegTraversalIter::new(self.env, class, hint, PReg::invalid(), bundle.index(), None)
-            {
-                trace!("trying bundle {:?} to preg {:?}", bundle, preg);
-                let preg_idx = PRegIndex::new(preg.index());
-                if let AllocRegResult::Allocated(_) =
-                    self.try_to_allocate_bundle_to_reg(bundle, preg_idx, None)
-                {
-                    self.stats.spill_bundle_reg_success += 1;
-                    success = true;
-                    break;
-                }
-            }
-            if !success {
-                trace!(
-                    "spilling bundle {:?}: marking spillset {:?} as required",
-                    bundle,
-                    self.bundles[bundle.index()].spillset
-                );
-                self.spillsets[self.bundles[bundle.index()].spillset.index()].required = true;
-            }
-        }
-    }
-
-    pub fn spillslot_can_fit_spillset(
-        &mut self,
-        spillslot: SpillSlotIndex,
-        spillset: SpillSetIndex,
-    ) -> bool {
-        for &vreg in &self.spillsets[spillset.index()].vregs {
-            for entry in &self.vregs[vreg.index()].ranges {
-                if self.spillslots[spillslot.index()]
-                    .ranges
-                    .btree
-                    .contains_key(&LiveRangeKey::from_range(&entry.range))
-                {
-                    return false;
-                }
-            }
-        }
-        true
-    }
-
-    pub fn allocate_spillset_to_spillslot(
-        &mut self,
-        spillset: SpillSetIndex,
-        spillslot: SpillSlotIndex,
-    ) {
-        self.spillsets[spillset.index()].slot = spillslot;
-
-        for vreg in &self.spillsets[spillset.index()].vregs {
-            trace!(
-                "spillslot {:?} alloc'ed to spillset {:?}: vreg {:?}",
-                spillslot,
-                spillset,
-                vreg,
-            );
-            for entry in &self.vregs[vreg.index()].ranges {
-                trace!(
-                    "spillslot {:?} getting range {:?} from LR {:?} from vreg {:?}",
-                    spillslot,
-                    entry.range,
-                    entry.index,
-                    vreg,
-                );
-                self.spillslots[spillslot.index()]
-                    .ranges
-                    .btree
-                    .insert(LiveRangeKey::from_range(&entry.range), entry.index);
-            }
-        }
-    }
-
-    pub fn allocate_spillslots(&mut self) {
-        const MAX_ATTEMPTS: usize = 10;
-
-        for spillset in 0..self.spillsets.len() {
-            trace!("allocate spillslot: {}", spillset);
-            let spillset = SpillSetIndex::new(spillset);
-            if !self.spillsets[spillset.index()].required {
-                continue;
-            }
-            // Get or create the spillslot list for this size.
-            let size = self.spillsets[spillset.index()].size as usize;
-            if size >= self.slots_by_size.len() {
-                self.slots_by_size.resize(
-                    size + 1,
-                    SpillSlotList {
-                        slots: smallvec![],
-                        probe_start: 0,
-                    },
-                );
-            }
-            // Try a few existing spillslots.
-            let mut i = self.slots_by_size[size].probe_start;
-            let mut success = false;
-            // Never probe the same element more than once: limit the
-            // attempt count to the number of slots in existence.
-            for _attempt in 0..core::cmp::min(self.slots_by_size[size].slots.len(), MAX_ATTEMPTS) {
-                // Note: this indexing of `slots` is always valid
-                // because either the `slots` list is empty and the
-                // iteration limit above consequently means we don't
-                // run this loop at all, or else `probe_start` is
-                // in-bounds (because it is made so below when we add
-                // a slot, and it always takes on the last index `i`
-                // after this loop).
-                let spillslot = self.slots_by_size[size].slots[i];
-
-                if self.spillslot_can_fit_spillset(spillslot, spillset) {
-                    self.allocate_spillset_to_spillslot(spillset, spillslot);
-                    success = true;
-                    self.slots_by_size[size].probe_start = i;
-                    break;
-                }
-
-                i = self.slots_by_size[size].next_index(i);
-            }
-
-            if !success {
-                // Allocate a new spillslot.
-                let spillslot = SpillSlotIndex::new(self.spillslots.len());
-                self.spillslots.push(SpillSlotData {
-                    ranges: LiveRangeSet::new(),
-                    alloc: Allocation::none(),
-                    slots: size as u32,
-                });
-                self.slots_by_size[size].slots.push(spillslot);
-                self.slots_by_size[size].probe_start = self.slots_by_size[size].slots.len() - 1;
-
-                self.allocate_spillset_to_spillslot(spillset, spillslot);
-            }
-        }
-
-        // Assign actual slot indices to spillslots.
-        for i in 0..self.spillslots.len() {
-            self.spillslots[i].alloc = self.allocate_spillslot(self.spillslots[i].slots);
-        }
-
-        trace!("spillslot allocator done");
-    }
-
-    pub fn allocate_spillslot(&mut self, size: u32) -> Allocation {
-        let mut offset = self.num_spillslots;
-        // Align up to `size`.
-        debug_assert!(size.is_power_of_two());
-        offset = (offset + size - 1) & !(size - 1);
-        let slot = if self.func.multi_spillslot_named_by_last_slot() {
-            offset + size - 1
-        } else {
-            offset
-        };
-        offset += size;
-        self.num_spillslots = offset;
-        Allocation::stack(SpillSlot::new(slot as usize))
-    }
-}

data/ext/cargo-vendor/regalloc2-0.8.1/src/ion/stackmap.rs

@@ -1,74 +0,0 @@
-/*
- * This file was initially derived from the files
- * `js/src/jit/BacktrackingAllocator.h` and
- * `js/src/jit/BacktrackingAllocator.cpp` in Mozilla Firefox, and was
- * originally licensed under the Mozilla Public License 2.0. We
- * subsequently relicensed it to Apache-2.0 WITH LLVM-exception (see
- * https://github.com/bytecodealliance/regalloc2/issues/7).
- *
- * Since the initial port, the design has been substantially evolved
- * and optimized.
- */
-
-//! Stackmap computation.
-
-use alloc::vec::Vec;
-
-use super::{Env, ProgPoint, VRegIndex};
-use crate::{ion::data_structures::u64_key, Function};
-
-impl<'a, F: Function> Env<'a, F> {
-    pub fn compute_stackmaps(&mut self) {
-        // For each ref-typed vreg, iterate through ranges and find
-        // safepoints in-range. Add the SpillSlot to the stackmap.
-
-        if self.func.reftype_vregs().is_empty() {
-            return;
-        }
-
-        // Given `safepoints_per_vreg` from the liveness computation,
-        // all we have to do is, for each vreg in this map, step
-        // through the LiveRanges along with a sorted list of
-        // safepoints; and for each safepoint in the current range,
-        // emit the allocation into the `safepoint_slots` list.
-
-        trace!("safepoints_per_vreg = {:?}", self.safepoints_per_vreg);
-
-        for vreg in self.func.reftype_vregs() {
-            trace!("generating safepoint info for vreg {}", vreg);
-            let vreg = VRegIndex::new(vreg.vreg());
-            let mut safepoints: Vec<ProgPoint> = self
-                .safepoints_per_vreg
-                .get(&vreg.index())
-                .unwrap()
-                .iter()
-                .map(|&inst| ProgPoint::before(inst))
-                .collect();
-            safepoints.sort_unstable();
-            trace!(" -> live over safepoints: {:?}", safepoints);
-
-            let mut safepoint_idx = 0;
-            for entry in &self.vregs[vreg.index()].ranges {
-                let range = entry.range;
-                let alloc = self.get_alloc_for_range(entry.index);
-                trace!(" -> range {:?}: alloc {}", range, alloc);
-                while safepoint_idx < safepoints.len() && safepoints[safepoint_idx] < range.to {
-                    if safepoints[safepoint_idx] < range.from {
-                        safepoint_idx += 1;
-                        continue;
-                    }
-
-                    trace!("    -> covers safepoint {:?}", safepoints[safepoint_idx]);
-
-                    self.safepoint_slots
-                        .push((safepoints[safepoint_idx], alloc));
-                    safepoint_idx += 1;
-                }
-            }
-        }
-
-        self.safepoint_slots
-            .sort_unstable_by_key(|(progpoint, slot)| u64_key(progpoint.to_index(), slot.bits()));
-        trace!("final safepoint slots info: {:?}", self.safepoint_slots);
-    }
-}