This is an archive of the discontinued LLVM Phabricator instance.

Differential D159379

[InstCombine] Baseline tests for folding ((A&B)^A)|((A&B)^B) to A^B
ClosedPublic

Authored by marcauberer on Sep 1 2023, 1:16 PM.

Details

Reviewers
GabrielRavier
RKSimon
lebedev.ri
huihuiz
fhahn
majnemer
Commits
rG4bbc9034d6c4: [InstCombine] Baseline tests for folding ((A&B)^A)|((A&B)^B) to A^B
Summary

Baseline tests for: https://reviews.llvm.org/D159380

Diff Detail

Event Timeline

marcauberer created this revision.Sep 1 2023, 1:16 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 1 2023, 1:16 PM
marcauberer requested review of this revision.Sep 1 2023, 1:16 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 1 2023, 1:16 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
marcauberer added a child revision: D159380: [InstCombine] Fold ((A&B)^A)|((A&B)^B) to A^B.Sep 1 2023, 1:19 PM
marcauberer updated this revision to Diff 555492.Sep 1 2023, 1:22 PM
marcauberer edited the summary of this revision. (Show Details)

Update commit message

Harbormaster completed remote builds in B256345: Diff 555492.Sep 1 2023, 2:05 PM
goldstein.w.n added a subscriber: goldstein.w.n.Sep 1 2023, 2:26 PM
goldstein.w.n added inline comments.
llvm/test/Transforms/InstCombine/or-xor-xor.ll
100

Can you:

  1. swap the order of the and i1 %a, %b in half the tests.
  2. make a/b binops i.e something like:
define i1 @foo(%aa, %bb, %cc) {
   %a = xor i1 %aa, %cc
   %b = xor i1 %bb, %cc
}

then swap around order of ops in the xor in some of the tests.

Also i1 is a bit of a special case. can you change tests to i8?

marcauberer updated this revision to Diff 555567.Sep 2 2023, 12:43 AM

Address review comment

marcauberer marked an inline comment as done.Sep 2 2023, 12:43 AM
Harbormaster completed remote builds in B256398: Diff 555567.Sep 2 2023, 1:19 AM
marcauberer added reviewers: lebedev.ri, huihuiz, fhahn, majnemer.Sep 7 2023, 12:32 PM
Herald added a subscriber: StephenFan. · View Herald TranscriptSep 7 2023, 12:32 PM
huihuiz accepted this revision.Sep 7 2023, 1:26 PM
This revision is now accepted and ready to land.Sep 7 2023, 1:26 PM
Closed by commit rG4bbc9034d6c4: [InstCombine] Baseline tests for folding ((A&B)^A)|((A&B)^B) to A^B (authored by marcauberer, committed by huihuiz). · Explain WhySep 7 2023, 5:04 PM
This revision was automatically updated to reflect the committed changes.
huihuiz added a commit: rG4bbc9034d6c4: [InstCombine] Baseline tests for folding ((A&B)^A)|((A&B)^B) to A^B.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
152 lines

Diff 556215

llvm/test/Transforms/InstCombine/or-xor-xor.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use.i3(i1)
declare void @use.i5(i5)
declare void @use.i32(i5)
define i1 @or_xor_xor_normal_variant1(i1 %a, i1 %b) {
; CHECK-LABEL: @or_xor_xor_normal_variant1(
; CHECK-NEXT: [[AND:%.*]] = and i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i1 [[AND]], [[A]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i1 [[AND]], [[B]]
; CHECK-NEXT: [[OR:%.*]] = or i1 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i1 [[OR]]
;
%and = and i1 %a, %b
%xor1 = xor i1 %and, %a
%xor2 = xor i1 %and, %b
%or = or i1 %xor1, %xor2
ret i1 %or
}
define i8 @or_xor_xor_normal_variant2(i8 %a, i8 %b) {
; CHECK-LABEL: @or_xor_xor_normal_variant2(
; CHECK-NEXT: [[AND:%.*]] = and i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i8 [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i8 [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or i8 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i8 [[OR]]
;
%and = and i8 %a, %b
%xor1 = xor i8 %and, %b
%xor2 = xor i8 %a, %and
%or = or i8 %xor1, %xor2
ret i8 %or
}
define i16 @or_xor_xor_normal_variant3(i16 %a, i16 %b) {
; CHECK-LABEL: @or_xor_xor_normal_variant3(
; CHECK-NEXT: [[AND:%.*]] = and i16 [[B:%.*]], [[A:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i16 [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i16 [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or i16 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i16 [[OR]]
;
%and = and i16 %b, %a
%xor1 = xor i16 %b, %and
%xor2 = xor i16 %a, %and
%or = or i16 %xor1, %xor2
ret i16 %or
}
define i64 @or_xor_xor_normal_variant4(i64 %a, i64 %b) {
; CHECK-LABEL: @or_xor_xor_normal_variant4(
; CHECK-NEXT: [[AND:%.*]] = and i64 [[B:%.*]], [[A:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i64 [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i64 [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or i64 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i64 [[OR]]
;
%and = and i64 %b, %a
%xor1 = xor i64 %and, %b
%xor2 = xor i64 %and, %a
%or = or i64 %xor1, %xor2
ret i64 %or
}
define i32 @or_xor_xor_normal_binops(i32 %aa, i32 %bb, i32 %cc) {
; CHECK-LABEL: @or_xor_xor_normal_binops(
; CHECK-NEXT: [[A:%.*]] = xor i32 [[AA:%.*]], [[CC:%.*]]
; CHECK-NEXT: [[B:%.*]] = xor i32 [[BB:%.*]], [[CC]]
; CHECK-NEXT: [[AND:%.*]] = and i32 [[B]], [[A]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[AND]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[A]], [[AND]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[OR]]
;
%a = xor i32 %aa, %cc
%b = xor i32 %bb, %cc
%and = and i32 %b, %a
%xor1 = xor i32 %b, %and
%xor2 = xor i32 %a, %and
%or = or i32 %xor1, %xor2
ret i32 %or
}
define <3 x i1> @or_xor_xor_normal_vector(<3 x i1> %a, <3 x i1> %b) {
; CHECK-LABEL: @or_xor_xor_normal_vector(
; CHECK-NEXT: [[AND:%.*]] = and <3 x i1> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor <3 x i1> [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor <3 x i1> [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or <3 x i1> [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret <3 x i1> [[OR]]
;
%and = and <3 x i1> %a, %b
%xor1 = xor <3 x i1> %and, %b
%xor2 = xor <3 x i1> %and, %a
%or = or <3 x i1> %xor1, %xor2
ret <3 x i1> %or
goldstein.w.nUnsubmitted
Done
ReplyInline Actions

Can you:

  1. swap the order of the and i1 %a, %b in half the tests.
  2. make a/b binops i.e something like:
define i1 @foo(%aa, %bb, %cc) {
   %a = xor i1 %aa, %cc
   %b = xor i1 %bb, %cc
}

then swap around order of ops in the xor in some of the tests.

Also i1 is a bit of a special case. can you change tests to i8?

goldstein.w.n: Can you: 1) swap the order of the `and i1 %a, %b` in half the tests. 2) make a/b binops i.e…
}
define i3 @or_xor_xor_normal_multiple_uses_and(i3 %a, i3 %b) {
; CHECK-LABEL: @or_xor_xor_normal_multiple_uses_and(
; CHECK-NEXT: [[AND:%.*]] = and i3 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: call void @use.i3(i3 [[AND]])
; CHECK-NEXT: [[XOR1:%.*]] = xor i3 [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i3 [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or i3 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i3 [[OR]]
;
%and = and i3 %a, %b
call void @use.i3(i3 %and)
%xor1 = xor i3 %b, %and
%xor2 = xor i3 %a, %and
%or = or i3 %xor1, %xor2
ret i3 %or
}
define i32 @or_xor_xor_negative_multiple_uses_xor1(i32 %a, i32 %b) {
; CHECK-LABEL: @or_xor_xor_negative_multiple_uses_xor1(
; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[AND]], [[B]]
; CHECK-NEXT: call void @use.i32(i32 [[XOR1]])
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[AND]], [[A]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[OR]]
;
%and = and i32 %a, %b
%xor1 = xor i32 %and, %b
call void @use.i32(i32 %xor1)
%xor2 = xor i32 %and, %a
%or = or i32 %xor1, %xor2
ret i32 %or
}
define i5 @or_xor_xor_negative_multiple_uses_xor2(i5 %a, i5 %b) {
; CHECK-LABEL: @or_xor_xor_negative_multiple_uses_xor2(
; CHECK-NEXT: [[AND:%.*]] = and i5 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[XOR1:%.*]] = xor i5 [[AND]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i5 [[AND]], [[A]]
; CHECK-NEXT: call void @use.i5(i5 [[XOR2]])
; CHECK-NEXT: [[OR:%.*]] = or i5 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i5 [[OR]]
;
%and = and i5 %a, %b
%xor1 = xor i5 %and, %b
%xor2 = xor i5 %and, %a
call void @use.i5(i5 %xor2)
%or = or i5 %xor1, %xor2
ret i5 %or
}