; Commutativity.
; ============================================================================ ;
+; Used to make sure that the IR complexity sorting does not interfere.
+declare i32 @gen32()
+
+
define i32 @or_commutative0(i32 %x, i32 %y, i32 %m) {
; CHECK-LABEL: @or_commutative0(
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
ret i32 %or
}
-define i32 @or_commutative1(i32 %x, i32 %y, i32 %m) {
+define i32 @or_commutative1(i32 %x, i32 %m) {
; CHECK-LABEL: @or_commutative1(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND]], [[AND1]]
; CHECK-NEXT: ret i32 [[OR]]
;
+ %y = call i32 @gen32()
%and = and i32 %x, %m
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
}
-define i32 @or_commutative3(i32 %x, i32 %y, i32 %m) {
+define i32 @or_commutative3(i32 %x, i32 %m) {
; CHECK-LABEL: @or_commutative3(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND]], [[AND1]]
; CHECK-NEXT: ret i32 [[OR]]
;
+ %y = call i32 @gen32()
%and = and i32 %m, %x ; swapped order
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
ret i32 %or
}
-define i32 @or_commutative5(i32 %x, i32 %y, i32 %m) {
+define i32 @or_commutative5(i32 %x, i32 %m) {
; CHECK-LABEL: @or_commutative5(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND1]], [[AND]]
; CHECK-NEXT: ret i32 [[OR]]
;
+ %y = call i32 @gen32()
%and = and i32 %x, %m
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
}
-define i32 @or_commutative6(i32 %x, i32 %y, i32 %m) {
+define i32 @or_commutative6(i32 %x, i32 %m) {
; CHECK-LABEL: @or_commutative6(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[OR:%.*]] = or i32 [[AND1]], [[AND]]
; CHECK-NEXT: ret i32 [[OR]]
;
+ %y = call i32 @gen32()
%and = and i32 %m, %x ; swapped order
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
ret i32 %xor
}
-define i32 @xor_commutative1(i32 %x, i32 %y, i32 %m) {
+define i32 @xor_commutative1(i32 %x, i32 %m) {
; CHECK-LABEL: @xor_commutative1(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND]], [[AND1]]
; CHECK-NEXT: ret i32 [[XOR]]
;
+ %y = call i32 @gen32()
%and = and i32 %x, %m
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
}
-define i32 @xor_commutative3(i32 %x, i32 %y, i32 %m) {
+define i32 @xor_commutative3(i32 %x, i32 %m) {
; CHECK-LABEL: @xor_commutative3(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND]], [[AND1]]
; CHECK-NEXT: ret i32 [[XOR]]
;
+ %y = call i32 @gen32()
%and = and i32 %m, %x ; swapped order
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
ret i32 %xor
}
-define i32 @xor_commutative5(i32 %x, i32 %y, i32 %m) {
+define i32 @xor_commutative5(i32 %x, i32 %m) {
; CHECK-LABEL: @xor_commutative5(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], [[M:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND1]], [[AND]]
; CHECK-NEXT: ret i32 [[XOR]]
;
+ %y = call i32 @gen32()
%and = and i32 %x, %m
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
}
-define i32 @xor_commutative6(i32 %x, i32 %y, i32 %m) {
+define i32 @xor_commutative6(i32 %x, i32 %m) {
; CHECK-LABEL: @xor_commutative6(
+; CHECK-NEXT: [[Y:%.*]] = call i32 @gen32()
; CHECK-NEXT: [[AND:%.*]] = and i32 [[M:%.*]], [[X:%.*]]
; CHECK-NEXT: [[NEG:%.*]] = xor i32 [[M]], -1
-; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NEG]], [[Y:%.*]]
+; CHECK-NEXT: [[AND1:%.*]] = and i32 [[Y]], [[NEG]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[AND1]], [[AND]]
; CHECK-NEXT: ret i32 [[XOR]]
;
+ %y = call i32 @gen32()
%and = and i32 %m, %x ; swapped order
%neg = xor i32 %m, -1
%and1 = and i32 %y, %neg; swapped order
}
+
define i32 @or_constmask_commutative(i32 %x, i32 %y) {
; CHECK-LABEL: @or_constmask_commutative(
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 65280