|
1 | | -use std::iter; |
| 1 | +use std::{iter, usize}; |
2 | 2 |
|
| 3 | +use rustc_const_eval::const_eval::mk_eval_cx_for_const_val; |
| 4 | +use rustc_index::bit_set::BitSet; |
3 | 5 | use rustc_index::IndexSlice; |
4 | 6 | use rustc_middle::mir::patch::MirPatch; |
5 | 7 | use rustc_middle::mir::*; |
| 8 | +use rustc_middle::ty; |
6 | 9 | use rustc_middle::ty::layout::{IntegerExt, TyAndLayout}; |
| 10 | +use rustc_middle::ty::util::Discr; |
7 | 11 | use rustc_middle::ty::{ParamEnv, ScalarInt, Ty, TyCtxt}; |
| 12 | +use rustc_mir_dataflow::impls::{borrowed_locals, MaybeTransitiveLiveLocals}; |
| 13 | +use rustc_mir_dataflow::Analysis; |
8 | 14 | use rustc_target::abi::Integer; |
9 | 15 | use rustc_type_ir::TyKind::*; |
10 | 16 |
|
@@ -48,6 +54,10 @@ impl<'tcx> MirPass<'tcx> for MatchBranchSimplification { |
48 | 54 | should_cleanup = true; |
49 | 55 | continue; |
50 | 56 | } |
| 57 | + if simplify_to_copy(tcx, body, bb_idx, param_env).is_some() { |
| 58 | + should_cleanup = true; |
| 59 | + continue; |
| 60 | + } |
51 | 61 | } |
52 | 62 |
|
53 | 63 | if should_cleanup { |
@@ -515,3 +525,202 @@ impl<'tcx> SimplifyMatch<'tcx> for SimplifyToExp { |
515 | 525 | } |
516 | 526 | } |
517 | 527 | } |
| 528 | + |
| 529 | +/// This is primarily used to merge these copy statements that simplified the canonical enum clone method by GVN. |
| 530 | +/// The GVN simplified |
| 531 | +/// ```ignore (syntax-highlighting-only) |
| 532 | +/// match a { |
| 533 | +/// Foo::A(x) => Foo::A(*x), |
| 534 | +/// Foo::B => Foo::B |
| 535 | +/// } |
| 536 | +/// ``` |
| 537 | +/// to |
| 538 | +/// ```ignore (syntax-highlighting-only) |
| 539 | +/// match a { |
| 540 | +/// Foo::A(_x) => a, // copy a |
| 541 | +/// Foo::B => Foo::B |
| 542 | +/// } |
| 543 | +/// ``` |
| 544 | +/// This function will simplify into a copy statement. |
| 545 | +fn simplify_to_copy<'tcx>( |
| 546 | + tcx: TyCtxt<'tcx>, |
| 547 | + body: &mut Body<'tcx>, |
| 548 | + switch_bb_idx: BasicBlock, |
| 549 | + param_env: ParamEnv<'tcx>, |
| 550 | +) -> Option<()> { |
| 551 | + let bbs = &body.basic_blocks; |
| 552 | + // Check if the copy source matches the following pattern. |
| 553 | + // _2 = discriminant(*_1); // "*_1" is the expected the copy source. |
| 554 | + // switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1]; |
| 555 | + let &Statement { |
| 556 | + kind: StatementKind::Assign(box (discr_place, Rvalue::Discriminant(expected_src_place))), |
| 557 | + .. |
| 558 | + } = bbs[switch_bb_idx].statements.last()? |
| 559 | + else { |
| 560 | + return None; |
| 561 | + }; |
| 562 | + let expected_src_ty = expected_src_place.ty(body.local_decls(), tcx); |
| 563 | + if !expected_src_ty.ty.is_enum() || expected_src_ty.variant_index.is_some() { |
| 564 | + return None; |
| 565 | + } |
| 566 | + let targets = match bbs[switch_bb_idx].terminator().kind { |
| 567 | + TerminatorKind::SwitchInt { ref discr, ref targets, .. } |
| 568 | + if discr.place() == Some(discr_place) => |
| 569 | + { |
| 570 | + targets |
| 571 | + } |
| 572 | + _ => return None, |
| 573 | + }; |
| 574 | + // We require that the possible target blocks all be distinct. |
| 575 | + if !targets.is_distinct() { |
| 576 | + return None; |
| 577 | + } |
| 578 | + if !bbs[targets.otherwise()].is_empty_unreachable() { |
| 579 | + return None; |
| 580 | + } |
| 581 | + // Check that destinations are identical, and if not, then don't optimize this block. |
| 582 | + let mut target_iter = targets.iter(); |
| 583 | + let first_terminator_kind = &bbs[target_iter.next().unwrap().1].terminator().kind; |
| 584 | + if !target_iter |
| 585 | + .all(|(_, other_target)| first_terminator_kind == &bbs[other_target].terminator().kind) |
| 586 | + { |
| 587 | + return None; |
| 588 | + } |
| 589 | + |
| 590 | + let borrowed_locals = borrowed_locals(body); |
| 591 | + let mut live = None; |
| 592 | + let mut expected_dest_place = None; |
| 593 | + for (index, target_bb) in targets.iter() { |
| 594 | + let stmts = &bbs[target_bb].statements; |
| 595 | + if stmts.is_empty() { |
| 596 | + return None; |
| 597 | + } |
| 598 | + if let [Statement { kind: StatementKind::Assign(box (place, rvalue)), .. }] = |
| 599 | + bbs[target_bb].statements.as_slice() |
| 600 | + { |
| 601 | + let dest_ty = place.ty(body.local_decls(), tcx); |
| 602 | + if dest_ty.ty != expected_src_ty.ty || dest_ty.variant_index.is_some() { |
| 603 | + return None; |
| 604 | + } |
| 605 | + let ty::Adt(def, _) = dest_ty.ty.kind() else { |
| 606 | + return None; |
| 607 | + }; |
| 608 | + if *expected_dest_place.get_or_insert(*place) != *place { |
| 609 | + return None; |
| 610 | + } |
| 611 | + match rvalue { |
| 612 | + // Check if `_3 = const Foo::B` can be transformed to `_3 = copy *_1`. |
| 613 | + Rvalue::Use(Operand::Constant(box constant)) |
| 614 | + if let Const::Val(const_, ty) = constant.const_ => |
| 615 | + { |
| 616 | + let (ecx, op) = |
| 617 | + mk_eval_cx_for_const_val(tcx.at(constant.span), param_env, const_, ty)?; |
| 618 | + let variant = ecx.read_discriminant(&op).ok()?; |
| 619 | + if !def.variants()[variant].fields.is_empty() { |
| 620 | + return None; |
| 621 | + } |
| 622 | + let Discr { val, .. } = ty.discriminant_for_variant(tcx, variant)?; |
| 623 | + if val != index { |
| 624 | + return None; |
| 625 | + } |
| 626 | + } |
| 627 | + Rvalue::Use(Operand::Copy(src_place)) if *src_place == expected_src_place => {} |
| 628 | + // Check if `_3 = Foo::B` can be transformed to `_3 = copy *_1`. |
| 629 | + Rvalue::Aggregate(box AggregateKind::Adt(_, variant_index, _, _, None), fields) |
| 630 | + if fields.is_empty() |
| 631 | + && let Some(Discr { val, .. }) = |
| 632 | + expected_src_ty.ty.discriminant_for_variant(tcx, *variant_index) |
| 633 | + && val == index => {} |
| 634 | + _ => return None, |
| 635 | + } |
| 636 | + } else { |
| 637 | + // If the BB contains more than one statement, we have to check if these statements can be ignored. |
| 638 | + let mut lived_stmts: BitSet<usize> = |
| 639 | + BitSet::new_filled(bbs[target_bb].statements.len()); |
| 640 | + let mut dest_place = None; |
| 641 | + for (statement_index, statement) in bbs[target_bb].statements.iter().enumerate().rev() { |
| 642 | + let loc = Location { block: target_bb, statement_index }; |
| 643 | + if let StatementKind::Assign(assign) = &statement.kind { |
| 644 | + if !assign.1.is_safe_to_remove() { |
| 645 | + return None; |
| 646 | + } |
| 647 | + } |
| 648 | + match &statement.kind { |
| 649 | + StatementKind::Assign(box (place, _)) |
| 650 | + | StatementKind::SetDiscriminant { place: box place, .. } |
| 651 | + | StatementKind::Deinit(box place) => { |
| 652 | + if place.is_indirect() || borrowed_locals.contains(place.local) { |
| 653 | + return None; |
| 654 | + } |
| 655 | + let live = live.get_or_insert_with(|| { |
| 656 | + MaybeTransitiveLiveLocals::new(&borrowed_locals) |
| 657 | + .into_engine(tcx, body) |
| 658 | + .iterate_to_fixpoint() |
| 659 | + .into_results_cursor(body) |
| 660 | + }); |
| 661 | + live.seek_before_primary_effect(loc); |
| 662 | + if !live.get().contains(place.local) { |
| 663 | + lived_stmts.remove(statement_index); |
| 664 | + } else if matches!( |
| 665 | + &statement.kind, |
| 666 | + StatementKind::Assign(box (_, Rvalue::Use(Operand::Copy(_)))) |
| 667 | + ) && dest_place.is_none() |
| 668 | + { |
| 669 | + // There is only one statement that cannot be ignored that can be used as an expected copy statement. |
| 670 | + dest_place = Some(*place); |
| 671 | + } else { |
| 672 | + return None; |
| 673 | + } |
| 674 | + } |
| 675 | + StatementKind::StorageLive(_) |
| 676 | + | StatementKind::StorageDead(_) |
| 677 | + | StatementKind::Nop => (), |
| 678 | + |
| 679 | + StatementKind::Retag(_, _) |
| 680 | + | StatementKind::Coverage(_) |
| 681 | + | StatementKind::Intrinsic(_) |
| 682 | + | StatementKind::ConstEvalCounter |
| 683 | + | StatementKind::PlaceMention(_) |
| 684 | + | StatementKind::FakeRead(_) |
| 685 | + | StatementKind::AscribeUserType(_, _) => { |
| 686 | + return None; |
| 687 | + } |
| 688 | + } |
| 689 | + } |
| 690 | + let dest_place = dest_place?; |
| 691 | + if *expected_dest_place.get_or_insert(dest_place) != dest_place { |
| 692 | + return None; |
| 693 | + } |
| 694 | + // We can ignore the paired StorageLive and StorageDead. |
| 695 | + let mut storage_live_locals: BitSet<Local> = BitSet::new_empty(body.local_decls.len()); |
| 696 | + for stmt_index in lived_stmts.iter() { |
| 697 | + let statement = &bbs[target_bb].statements[stmt_index]; |
| 698 | + match &statement.kind { |
| 699 | + StatementKind::Assign(box (place, Rvalue::Use(Operand::Copy(src_place)))) |
| 700 | + if *place == dest_place && *src_place == expected_src_place => {} |
| 701 | + StatementKind::StorageLive(local) |
| 702 | + if *local != dest_place.local && storage_live_locals.insert(*local) => {} |
| 703 | + StatementKind::StorageDead(local) |
| 704 | + if *local != dest_place.local && storage_live_locals.remove(*local) => {} |
| 705 | + StatementKind::Nop => {} |
| 706 | + _ => return None, |
| 707 | + } |
| 708 | + } |
| 709 | + if !storage_live_locals.is_empty() { |
| 710 | + return None; |
| 711 | + } |
| 712 | + } |
| 713 | + } |
| 714 | + let expected_dest_place = expected_dest_place?; |
| 715 | + let statement_index = bbs[switch_bb_idx].statements.len(); |
| 716 | + let parent_end = Location { block: switch_bb_idx, statement_index }; |
| 717 | + let mut patch = MirPatch::new(body); |
| 718 | + patch.add_assign( |
| 719 | + parent_end, |
| 720 | + expected_dest_place, |
| 721 | + Rvalue::Use(Operand::Copy(expected_src_place)), |
| 722 | + ); |
| 723 | + patch.patch_terminator(switch_bb_idx, first_terminator_kind.clone()); |
| 724 | + patch.apply(body); |
| 725 | + Some(()) |
| 726 | +} |
0 commit comments