Method isolate_group_uses

src/internal/allocator/split.rs:1090–1224

Isolates all group uses in the given register group by splitting them off into minimal segments that only cover a single instruction (or part of one) and are therefore always allocatable. The remaining live range pieces are collected into a separate non-group virtual register for each original group member, which can then be split as normal.

(&mut self, group: VirtRegGroup)

    /// virtual register for each original group member, which can then be split
    /// as normal.
    fn isolate_group_uses(&mut self, group: VirtRegGroup) {
        self.invalidate_operand_group_mapping(group);

        // Find any group uses and split them into minimal segments
        let splitter = &mut self.allocator.splitter;
        splitter.minimal_segments.clear();
        splitter.new_vregs.clear();
        for group_index in 0..self.virt_regs.group_members(group).len() {
            splitter.segments.clear();
            let vreg = self.virt_regs.group_members(group)[group_index];
            let value_set = self.virt_regs[vreg].value_set;
            trace!("Isolating group uses in {vreg}");
            stat!(self.stats, isolated_group_vregs);
            for &segment in self.virt_regs.segments(vreg) {
                let mut segment = segment;
                'outer: loop {
                    for &u in &self.uses[segment.use_list] {
                        match u.kind {
                            UseKind::GroupClassUse {
                                slot: _,
                                class: _,
                                group_index: use_group_index,
                            }
                            | UseKind::GroupClassDef {
                                slot: _,
                                class: _,
                                group_index: use_group_index,
                            } => {
                                debug_assert_eq!(use_group_index as usize, group_index);
                            }
                            UseKind::ClassUse { .. }
                            | UseKind::ClassDef { .. }
                            | UseKind::FixedDef { .. }
                            | UseKind::FixedUse { .. }
                            | UseKind::TiedUse { .. }
                            | UseKind::ConstraintConflict { .. }
                            | UseKind::BlockparamIn { .. }
                            | UseKind::BlockparamOut { .. } => continue,
                        };

                        trace!("Splitting around group use {}: {}", u.pos, u.kind);

                        // If there is a live range segment with no uses before
                        // this use, collect that segment for the non-group
                        // portion.
                        if u.pos != segment.live_range.from.round_to_prev_inst().inst() {
                            let (before, after) = segment.split_at(u.pos, self.uses, self.hints);
                            splitter.segments.push(before);
                            segment = after;
                        }

                        if u.pos.next() == segment.live_range.to.round_to_next_inst().inst() {
                            // If this use is on the last instruction of the segment
                            // then split off the rest of the segment into a
                            // minimal segment.
                            trace!(
                                "Generating minimal segment for {} at {}",
                                segment.value, segment.live_range