[InstSimplify] delete shift-of-zero guard ops around funnel shifts · llvm/llvm-project@e98ec77 (original) (raw)
`@@ -500,110 +500,108 @@ define <2 x i8> @fshr_no_shift_modulo_bitwidth_splat(<2 x i8> %x, <2 x i8> %y) {
`
500
500
`ret <2 x i8> %z
`
501
501
`}
`
502
502
``
``
503
`+
; When the shift amount is 0, fshl returns its 1st parameter (x), so the guard is not needed.
`
``
504
+
503
505
`define i8 @fshl_zero_shift_guard(i8 %x, i8 %y, i8 %sh) {
`
504
506
`; CHECK-LABEL: @fshl_zero_shift_guard(
`
505
``
`-
; CHECK-NEXT: [[C:%.]] = icmp eq i8 [[SH:%.]], 0
`
506
``
`-
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.*]], i8 [[SH]])
`
507
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i8 [[X]], i8 [[F]]
`
508
``
`-
; CHECK-NEXT: ret i8 [[S]]
`
``
507
`+
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.]], i8 [[SH:%.]])
`
``
508
`+
; CHECK-NEXT: ret i8 [[F]]
`
509
509
`;
`
510
510
`%c = icmp eq i8 %sh, 0
`
511
511
`%f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
`
512
512
`%s = select i1 %c, i8 %x, i8 %f
`
513
513
`ret i8 %s
`
514
514
`}
`
515
515
``
``
516
`+
; When the shift amount is 0, fshl returns its 1st parameter (x), so the guard is not needed.
`
``
517
+
516
518
`define i8 @fshl_zero_shift_guard_swapped(i8 %x, i8 %y, i8 %sh) {
`
517
519
`; CHECK-LABEL: @fshl_zero_shift_guard_swapped(
`
518
``
`-
; CHECK-NEXT: [[C:%.]] = icmp ne i8 [[SH:%.]], 0
`
519
``
`-
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.*]], i8 [[SH]])
`
520
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i8 [[F]], i8 [[X]]
`
521
``
`-
; CHECK-NEXT: ret i8 [[S]]
`
``
520
`+
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.]], i8 [[SH:%.]])
`
``
521
`+
; CHECK-NEXT: ret i8 [[F]]
`
522
522
`;
`
523
523
`%c = icmp ne i8 %sh, 0
`
524
524
`%f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
`
525
525
`%s = select i1 %c, i8 %f, i8 %x
`
526
526
`ret i8 %s
`
527
527
`}
`
528
528
``
``
529
`+
; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
`
``
530
+
529
531
`define i8 @fshl_zero_shift_guard_inverted(i8 %x, i8 %y, i8 %sh) {
`
530
532
`; CHECK-LABEL: @fshl_zero_shift_guard_inverted(
`
531
``
`-
; CHECK-NEXT: [[C:%.]] = icmp eq i8 [[SH:%.]], 0
`
532
``
`-
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.*]], i8 [[SH]])
`
533
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i8 [[F]], i8 [[X]]
`
534
``
`-
; CHECK-NEXT: ret i8 [[S]]
`
``
533
`+
; CHECK-NEXT: ret i8 [[X:%.*]]
`
535
534
`;
`
536
535
`%c = icmp eq i8 %sh, 0
`
537
536
`%f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
`
538
537
`%s = select i1 %c, i8 %f, i8 %x
`
539
538
`ret i8 %s
`
540
539
`}
`
541
540
``
``
541
`+
; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
`
``
542
+
542
543
`define i8 @fshl_zero_shift_guard_inverted_swapped(i8 %x, i8 %y, i8 %sh) {
`
543
544
`; CHECK-LABEL: @fshl_zero_shift_guard_inverted_swapped(
`
544
``
`-
; CHECK-NEXT: [[C:%.]] = icmp ne i8 [[SH:%.]], 0
`
545
``
`-
; CHECK-NEXT: [[F:%.]] = call i8 @llvm.fshl.i8(i8 [[X:%.]], i8 [[Y:%.*]], i8 [[SH]])
`
546
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i8 [[X]], i8 [[F]]
`
547
``
`-
; CHECK-NEXT: ret i8 [[S]]
`
``
545
`+
; CHECK-NEXT: ret i8 [[X:%.*]]
`
548
546
`;
`
549
547
`%c = icmp ne i8 %sh, 0
`
550
548
`%f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
`
551
549
`%s = select i1 %c, i8 %x, i8 %f
`
552
550
`ret i8 %s
`
553
551
`}
`
554
552
``
``
553
`+
; When the shift amount is 0, fshr returns its 2nd parameter (y), so the guard is not needed.
`
``
554
+
555
555
`define i9 @fshr_zero_shift_guard(i9 %x, i9 %y, i9 %sh) {
`
556
556
`; CHECK-LABEL: @fshr_zero_shift_guard(
`
557
``
`-
; CHECK-NEXT: [[C:%.]] = icmp eq i9 [[SH:%.]], 0
`
558
``
`-
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.*]], i9 [[SH]])
`
559
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i9 [[Y]], i9 [[F]]
`
560
``
`-
; CHECK-NEXT: ret i9 [[S]]
`
``
557
`+
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.]], i9 [[SH:%.]])
`
``
558
`+
; CHECK-NEXT: ret i9 [[F]]
`
561
559
`;
`
562
560
`%c = icmp eq i9 %sh, 0
`
563
561
`%f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
`
564
562
`%s = select i1 %c, i9 %y, i9 %f
`
565
563
`ret i9 %s
`
566
564
`}
`
567
565
``
``
566
`+
; When the shift amount is 0, fshr returns its 2nd parameter (y), so the guard is not needed.
`
``
567
+
568
568
`define i9 @fshr_zero_shift_guard_swapped(i9 %x, i9 %y, i9 %sh) {
`
569
569
`; CHECK-LABEL: @fshr_zero_shift_guard_swapped(
`
570
``
`-
; CHECK-NEXT: [[C:%.]] = icmp ne i9 [[SH:%.]], 0
`
571
``
`-
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.*]], i9 [[SH]])
`
572
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i9 [[F]], i9 [[Y]]
`
573
``
`-
; CHECK-NEXT: ret i9 [[S]]
`
``
570
`+
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.]], i9 [[SH:%.]])
`
``
571
`+
; CHECK-NEXT: ret i9 [[F]]
`
574
572
`;
`
575
573
`%c = icmp ne i9 %sh, 0
`
576
574
`%f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
`
577
575
`%s = select i1 %c, i9 %f, i9 %y
`
578
576
`ret i9 %s
`
579
577
`}
`
580
578
``
``
579
`+
; When the shift amount is 0, fshr returns its 2nd parameter (y), so everything is deleted.
`
``
580
+
581
581
`define i9 @fshr_zero_shift_guard_inverted(i9 %x, i9 %y, i9 %sh) {
`
582
582
`; CHECK-LABEL: @fshr_zero_shift_guard_inverted(
`
583
``
`-
; CHECK-NEXT: [[C:%.]] = icmp eq i9 [[SH:%.]], 0
`
584
``
`-
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.*]], i9 [[SH]])
`
585
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i9 [[F]], i9 [[Y]]
`
586
``
`-
; CHECK-NEXT: ret i9 [[S]]
`
``
583
`+
; CHECK-NEXT: ret i9 [[Y:%.*]]
`
587
584
`;
`
588
585
`%c = icmp eq i9 %sh, 0
`
589
586
`%f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
`
590
587
`%s = select i1 %c, i9 %f, i9 %y
`
591
588
`ret i9 %s
`
592
589
`}
`
593
590
``
``
591
`+
; When the shift amount is 0, fshr returns its 2nd parameter (y), so everything is deleted.
`
``
592
+
594
593
`define i9 @fshr_zero_shift_guard_inverted_swapped(i9 %x, i9 %y, i9 %sh) {
`
595
594
`; CHECK-LABEL: @fshr_zero_shift_guard_inverted_swapped(
`
596
``
`-
; CHECK-NEXT: [[C:%.]] = icmp ne i9 [[SH:%.]], 0
`
597
``
`-
; CHECK-NEXT: [[F:%.]] = call i9 @llvm.fshr.i9(i9 [[X:%.]], i9 [[Y:%.*]], i9 [[SH]])
`
598
``
`-
; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i9 [[Y]], i9 [[F]]
`
599
``
`-
; CHECK-NEXT: ret i9 [[S]]
`
``
595
`+
; CHECK-NEXT: ret i9 [[Y:%.*]]
`
600
596
`;
`
601
597
`%c = icmp ne i9 %sh, 0
`
602
598
`%f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
`
603
599
`%s = select i1 %c, i9 %y, i9 %f
`
604
600
`ret i9 %s
`
605
601
`}
`
606
602
``
``
603
`+
; Negative test - make sure we're matching the correct parameter of fshl.
`
``
604
+
607
605
`define i8 @fshl_zero_shift_guard_wrong_select_op(i8 %x, i8 %y, i8 %sh) {
`
608
606
`; CHECK-LABEL: @fshl_zero_shift_guard_wrong_select_op(
`
609
607
`; CHECK-NEXT: [[C:%.]] = icmp eq i8 [[SH:%.]], 0
`
`@@ -617,12 +615,12 @@ define i8 @fshl_zero_shift_guard_wrong_select_op(i8 %x, i8 %y, i8 %sh) {
`
617
615
`ret i8 %s
`
618
616
`}
`
619
617
``
``
618
`+
; Vector types work too.
`
``
619
+
620
620
`define <2 x i8> @fshr_zero_shift_guard_splat(<2 x i8> %x, <2 x i8> %y, <2 x i8> %sh) {
`
621
621
`; CHECK-LABEL: @fshr_zero_shift_guard_splat(
`
622
``
`-
; CHECK-NEXT: [[C:%.]] = icmp eq <2 x i8> [[SH:%.]], zeroinitializer
`
623
``
`-
; CHECK-NEXT: [[F:%.]] = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> [[X:%.]], <2 x i8> [[Y:%.*]], <2 x i8> [[SH]])
`
624
``
`-
; CHECK-NEXT: [[S:%.*]] = select <2 x i1> [[C]], <2 x i8> [[Y]], <2 x i8> [[F]]
`
625
``
`-
; CHECK-NEXT: ret <2 x i8> [[S]]
`
``
622
`+
; CHECK-NEXT: [[F:%.]] = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> [[X:%.]], <2 x i8> [[Y:%.]], <2 x i8> [[SH:%.]])
`
``
623
`+
; CHECK-NEXT: ret <2 x i8> [[F]]
`
626
624
`;
`
627
625
`%c = icmp eq <2 x i8> %sh, zeroinitializer
`
628
626
`%f = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> %x, <2 x i8> %y, <2 x i8> %sh)
`