Method process_segment

src/internal/move_resolver.rs:1050–1129

(&mut self, segment: &ValueSegment, alloc: Option<Allocation>)

    }

    fn process_segment(&mut self, segment: &ValueSegment, alloc: Option<Allocation>) {
        trace!(
            "Processing segment {} ({}) with allocation {alloc:?}",
            segment.live_range, segment.value
        );

        self.live_in = None;
        self.fixed_def = None;
        for component in segment.components(self.uses, self.func) {
            match component {
                // Emit a destination half-move when this value is live-in from another
                // segment.
                ValueSegmentComponent::LiveIn { inst } => {
                    debug_assert_eq!(segment.live_range.from.slot(), Slot::Boundary);

                    let first_block = self.func.inst_block(inst);
                    if inst == self.func.block_insts(first_block).from {
                        self.handle_block_live_in(inst, first_block, segment, alloc);
                    } else {
                        trace!("-> split livein");

                        // If the segment's live range ends here then we don't need a
                        // destination half move. Any uses with no live range (fixed/tied)
                        // will use the incoming values directly from self.live_in.
                        if segment.live_range.to != inst.slot(Slot::Boundary) {
                            self.move_resolver.emit_dest_half_move(
                                MovePosition::early(inst),
                                segment.value,
                                alloc.expect("split live range must have an allocation"),
                            );
                        }
                        self.live_in = Some((
                            inst,
                            LiveInKind::Single {
                                from_same_segment: false,
                            },
                        ));
                    }
                }

                ValueSegmentComponent::Use { u } => {
                    trace!("-> {} {}", u.pos, u.kind);
                    self.handle_use(&u, segment, alloc);
                }

                ValueSegmentComponent::BlockBoundary { prev, next } => {
                    trace!("Segment crosses block bounary between {prev} and {next}");
                    let terminator = self.func.block_insts(prev).last();
                    self.handle_block_live_out(terminator, prev, segment, alloc);
                    self.handle_block_live_in(terminator.next(), next, segment, alloc);
                }

                // Emit a source half-move if the value is live-out to another segment.
                ValueSegmentComponent::LiveOut { inst } => {
                    let last_block = self.func.inst_block(inst.prev());
                    if inst == self.func.block_insts(last_block).to {
                        self.handle_block_live_out(inst.prev(), last_block, segment, alloc);
                    } else {