[EarlyCSE] fold commutable intrinsics

[spatel]

Summary

Handling the new min/max intrinsics is the motivation, but it turns out that we have a bunch of other intrinsics with this missing bit of analysis too.

The FP min/max tests show that we are intersecting FMF, so that should be safe.

As noted in https://llvm.org/PR46897 , there is a commutative property specifier for intrinsics, but no corresponding function attribute, and so apparently no uses of that bit. I can remove that here or independently if this is an adequate or better solution.

[lebedev.ri]

LG to me, thanks

[nikic]

As noted in https://llvm.org/PR46897 , there is a commutative property specifier for intrinsics, but no corresponding function attribute, and so apparently no uses of that bit. I can remove that here or independently if this is an adequate or better solution.

I think the basic approach here is fine. Dropping the confusing intrinsic property once this lands sounds good.

The only suggestion I would make is to make the primary Instruction::isCommutative() method actually forward to IntrinsicInst::isCommutative() for intrinsics. Having I->isCommutative() and cast<IntrinsicInst>(I)->isCommutative() report different things is confusing. I think if you do this, then we will also get commutation support in GVN for free.

[spatel]

In D86798#2244981, @nikic wrote:

As noted in https://llvm.org/PR46897 , there is a commutative property specifier for intrinsics, but no corresponding function attribute, and so apparently no uses of that bit. I can remove that here or independently if this is an adequate or better solution.

I think the basic approach here is fine. Dropping the confusing intrinsic property once this lands sounds good.

The only suggestion I would make is to make the primary Instruction::isCommutative() method actually forward to IntrinsicInst::isCommutative() for intrinsics. Having I->isCommutative() and cast<IntrinsicInst>(I)->isCommutative() report different things is confusing. I think if you do this, then we will also get commutation support in GVN for free.

Ah, good point, but I'll need to make some updates in GVN at least because it has:

assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");

...and I'm seeing regression test failures.
Or I can just leave the 'fix' intrinsics off of the list here for now. Do you have a preference?

[nikic]

In D86798#2245116, @spatel wrote:

Or I can just leave the 'fix' intrinsics off of the list here for now. Do you have a preference?

Yeah, I think it would be best to drop the fixpoint intrinsics for now, as they aren't commutative in the usual sense and we won't be able to exploit that in the current implementation anyway.

[spatel]

In D86798#2245138, @nikic wrote:

In D86798#2245116, @spatel wrote:

Or I can just leave the 'fix' intrinsics off of the list here for now. Do you have a preference?

Yeah, I think it would be best to drop the fixpoint intrinsics for now, as they aren't commutative in the usual sense and we won't be able to exploit that in the current implementation anyway.

Just dropping the fixed-point intrinsics from this patch is not enough because this assert still fires for the 2 operand intrinsics:

assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");

...because a CallInst's first operand is the called function (the 2 argument intrinsics always have 3 operands).
So at the least, I need to adjust the asserts in GVN and NewGVN. There's also a use of isCommutative() in SLP that I can't tell at a glance is safe. Still want to make those changes here, or a follow-up patch?

[nikic]

In D86798#2245372, @spatel wrote:

Just dropping the fixed-point intrinsics from this patch is not enough because this assert still fires for the 2 operand intrinsics:

assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");

...because a CallInst's first operand is the called function (the 2 argument intrinsics always have 3 operands).
So at the least, I need to adjust the asserts in GVN and NewGVN. There's also a use of isCommutative() in SLP that I can't tell at a glance is safe. Still want to make those changes here, or a follow-up patch?

Ah, that's unfortunate. Let's handle this in a followup then.

llvm/include/llvm/IR/IntrinsicInst.h

public:
   IntrinsicInst(const IntrinsicInst &) = delete;
   IntrinsicInst &operator=(const IntrinsicInst &) = delete;
 
   /// Return the intrinsic ID of this intrinsic.
   Intrinsic::ID getIntrinsicID() const {
     return getCalledFunction()->getIntrinsicID();
   }
 
+  /// Return true if swapping the first two arguments to the intrinsic produces
+  /// the same result.
+  bool isCommutative() {
+    switch (getIntrinsicID()) {
+    case Intrinsic::maxnum:
+    case Intrinsic::minnum:
+    case Intrinsic::maximum:
+    case Intrinsic::minimum:
+    case Intrinsic::smax:
+    case Intrinsic::smin:
+    case Intrinsic::umax:
+    case Intrinsic::umin:
+    case Intrinsic::sadd_sat:
+    case Intrinsic::uadd_sat:
+    case Intrinsic::sadd_with_overflow:
+    case Intrinsic::uadd_with_overflow:
+    case Intrinsic::smul_with_overflow:
+    case Intrinsic::umul_with_overflow:
+    // TODO: These fixed-point math intrinsics have commutative first two
+    //       operands, but callers may not handle instructions with more than
+    //       two operands.
+    // case Intrinsic::smul_fix:
+    // case Intrinsic::umul_fix:
+    // case Intrinsic::smul_fix_sat:
+    // case Intrinsic::umul_fix_sat:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const CallInst *I) {
     if (const Function *CF = I->getCalledFunction())
       return CF->isIntrinsic();
     return false;
   }
   static bool classof(const Value *V) {
     return isa<CallInst>(V) && classof(cast<CallInst>(V));

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

return hash_combine(IVI->getOpcode(), IVI->getOperand(0),
                         hash_combine_range(IVI->idx_begin(), IVI->idx_end()));
 
   assert((isa<CallInst>(Inst) || isa<GetElementPtrInst>(Inst) ||
           isa<ExtractElementInst>(Inst) || isa<InsertElementInst>(Inst) ||
           isa<ShuffleVectorInst>(Inst) || isa<UnaryOperator>(Inst) ||
           isa<FreezeInst>(Inst)) &&
          "Invalid/unknown instruction");
 
+  // Handle intrinsics with commutative operands.
+  // TODO: Extend this to handle intrinsics with >2 operands where the 1st
+  //       2 operands are commutative.
+  auto *II = dyn_cast<IntrinsicInst>(Inst);
+  if (II && II->isCommutative() && II->getNumArgOperands() == 2) {
+    Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
+    if (LHS > RHS)
+      std::swap(LHS, RHS);
+    return hash_combine(II->getOpcode(), LHS, RHS);
+  }
+
   // Mix in the opcode.
   return hash_combine(
       Inst->getOpcode(),
       hash_combine_range(Inst->value_op_begin(), Inst->value_op_end()));
 }
 
 unsigned DenseMapInfo<SimpleValue>::getHashValue(SimpleValue Val) {
 #ifndef NDEBUG
assert(isa<CmpInst>(RHSI) &&
            "same opcode, but different instruction type?");
     CmpInst *RHSCmp = cast<CmpInst>(RHSI);
     // Commuted equality
     return LHSCmp->getOperand(0) == RHSCmp->getOperand(1) &&
            LHSCmp->getOperand(1) == RHSCmp->getOperand(0) &&
            LHSCmp->getSwappedPredicate() == RHSCmp->getPredicate();
   }
 
+  // TODO: Extend this for >2 args by matching the trailing N-2 args.
+  auto *LII = dyn_cast<IntrinsicInst>(LHSI);
+  auto *RII = dyn_cast<IntrinsicInst>(RHSI);
+  if (LII && RII && LII->getIntrinsicID() == RII->getIntrinsicID() &&
+      LII->isCommutative() && LII->getNumArgOperands() == 2) {
+    return LII->getArgOperand(0) == RII->getArgOperand(1) &&
+           LII->getArgOperand(1) == RII->getArgOperand(0);
+  }
+
   // Min/max/abs can occur with commuted operands, non-canonical predicates,
   // and/or non-canonical operands.
   // Selects can be non-trivially equivalent via inverted conditions and swaps.
   SelectPatternFlavor LSPF, RSPF;
   Value *CondL, *CondR, *LHSA, *RHSA, *LHSB, *RHSB;
   if (matchSelectWithOptionalNotCond(LHSI, CondL, LHSA, LHSB, LSPF) &&
       matchSelectWithOptionalNotCond(RHSI, CondR, RHSA, RHSB, RSPF)) {
     if (LSPF == RSPF) {

llvm/test/Transforms/EarlyCSE/commute.ll

;
   %s2 = sub i32 0, %a
   %m = mul i32 %sel, %s2
   ret i32 %m
 }
 
 define float @maxnum(float %a, float %b) {
 ; CHECK-LABEL: @maxnum(
 ; CHECK-NEXT:    [[X:%.*]] = call float @llvm.maxnum.f32(float [[A:%.*]], float [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call float @llvm.maxnum.f32(float [[B]], float [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv nnan float [[X]], [[Y]]
-; CHECK-NEXT:    ret float [[R]]
+; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %x = call float @llvm.maxnum.f32(float %a, float %b)
   %y = call float @llvm.maxnum.f32(float %b, float %a)
   %r = fdiv nnan float %x, %y
   ret float %r
 }
 
 define <2 x float> @minnum(<2 x float> %a, <2 x float> %b) {
 ; CHECK-LABEL: @minnum(
 ; CHECK-NEXT:    [[X:%.*]] = call fast <2 x float> @llvm.minnum.v2f32(<2 x float> [[A:%.*]], <2 x float> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call fast <2 x float> @llvm.minnum.v2f32(<2 x float> [[B]], <2 x float> [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv nnan <2 x float> [[X]], [[Y]]
-; CHECK-NEXT:    ret <2 x float> [[R]]
+; CHECK-NEXT:    ret <2 x float> <float 1.000000e+00, float 1.000000e+00>
 ;
   %x = call fast <2 x float> @llvm.minnum.v2f32(<2 x float> %a, <2 x float> %b)
   %y = call fast <2 x float> @llvm.minnum.v2f32(<2 x float> %b, <2 x float> %a)
   %r = fdiv nnan <2 x float> %x, %y
   ret <2 x float> %r
 }
 
 define <2 x double> @maximum(<2 x double> %a, <2 x double> %b) {
 ; CHECK-LABEL: @maximum(
-; CHECK-NEXT:    [[X:%.*]] = call fast <2 x double> @llvm.maximum.v2f64(<2 x double> [[A:%.*]], <2 x double> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call <2 x double> @llvm.maximum.v2f64(<2 x double> [[B]], <2 x double> [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv nnan <2 x double> [[X]], [[Y]]
-; CHECK-NEXT:    ret <2 x double> [[R]]
+; CHECK-NEXT:    [[X:%.*]] = call <2 x double> @llvm.maximum.v2f64(<2 x double> [[A:%.*]], <2 x double> [[B:%.*]])
+; CHECK-NEXT:    ret <2 x double> <double 1.000000e+00, double 1.000000e+00>
 ;
   %x = call fast <2 x double> @llvm.maximum.v2f64(<2 x double> %a, <2 x double> %b)
   %y = call <2 x double> @llvm.maximum.v2f64(<2 x double> %b, <2 x double> %a)
   %r = fdiv nnan <2 x double> %x, %y
   ret <2 x double> %r
 }
 
 define double @minimum(double %a, double %b) {
 ; CHECK-LABEL: @minimum(
-; CHECK-NEXT:    [[X:%.*]] = call nsz double @llvm.minimum.f64(double [[A:%.*]], double [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call ninf double @llvm.minimum.f64(double [[B]], double [[A]])
-; CHECK-NEXT:    [[R:%.*]] = fdiv nnan double [[X]], [[Y]]
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    [[X:%.*]] = call double @llvm.minimum.f64(double [[A:%.*]], double [[B:%.*]])
+; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %x = call nsz double @llvm.minimum.f64(double %a, double %b)
   %y = call ninf double @llvm.minimum.f64(double %b, double %a)
   %r = fdiv nnan double %x, %y
   ret double %r
 }
 define i16 @sadd_ov(i16 %a, i16 %b) {
 ; CHECK-LABEL: @sadd_ov(
 ; CHECK-NEXT:    [[X:%.*]] = call { i16, i1 } @llvm.sadd.with.overflow.i16(i16 [[A:%.*]], i16 [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call { i16, i1 } @llvm.sadd.with.overflow.i16(i16 [[B]], i16 [[A]])
 ; CHECK-NEXT:    [[X1:%.*]] = extractvalue { i16, i1 } [[X]], 0
-; CHECK-NEXT:    [[Y1:%.*]] = extractvalue { i16, i1 } [[Y]], 0
-; CHECK-NEXT:    [[O:%.*]] = or i16 [[X1]], [[Y1]]
-; CHECK-NEXT:    ret i16 [[O]]
+; CHECK-NEXT:    ret i16 [[X1]]
 ;
   %x = call {i16, i1} @llvm.sadd.with.overflow.i16(i16 %a, i16 %b)
   %y = call {i16, i1} @llvm.sadd.with.overflow.i16(i16 %b, i16 %a)
   %x1 = extractvalue {i16, i1} %x, 0
   %y1 = extractvalue {i16, i1} %y, 0
   %o = or i16 %x1, %y1
   ret i16 %o
 }
 
 define <5 x i65> @uadd_ov(<5 x i65> %a, <5 x i65> %b) {
 ; CHECK-LABEL: @uadd_ov(
 ; CHECK-NEXT:    [[X:%.*]] = call { <5 x i65>, <5 x i1> } @llvm.uadd.with.overflow.v5i65(<5 x i65> [[A:%.*]], <5 x i65> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call { <5 x i65>, <5 x i1> } @llvm.uadd.with.overflow.v5i65(<5 x i65> [[B]], <5 x i65> [[A]])
 ; CHECK-NEXT:    [[X1:%.*]] = extractvalue { <5 x i65>, <5 x i1> } [[X]], 0
-; CHECK-NEXT:    [[Y1:%.*]] = extractvalue { <5 x i65>, <5 x i1> } [[Y]], 0
-; CHECK-NEXT:    [[O:%.*]] = or <5 x i65> [[X1]], [[Y1]]
-; CHECK-NEXT:    ret <5 x i65> [[O]]
+; CHECK-NEXT:    ret <5 x i65> [[X1]]
 ;
   %x = call {<5 x i65>, <5 x i1>} @llvm.uadd.with.overflow.v5i65(<5 x i65> %a, <5 x i65> %b)
   %y = call {<5 x i65>, <5 x i1>} @llvm.uadd.with.overflow.v5i65(<5 x i65> %b, <5 x i65> %a)
   %x1 = extractvalue {<5 x i65>, <5 x i1>} %x, 0
   %y1 = extractvalue {<5 x i65>, <5 x i1>} %y, 0
   %o = or <5 x i65> %x1, %y1
   ret <5 x i65> %o
 }
 
 define i37 @smul_ov(i37 %a, i37 %b) {
 ; CHECK-LABEL: @smul_ov(
 ; CHECK-NEXT:    [[X:%.*]] = call { i37, i1 } @llvm.smul.with.overflow.i37(i37 [[A:%.*]], i37 [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call { i37, i1 } @llvm.smul.with.overflow.i37(i37 [[B]], i37 [[A]])
 ; CHECK-NEXT:    [[X1:%.*]] = extractvalue { i37, i1 } [[X]], 0
-; CHECK-NEXT:    [[Y1:%.*]] = extractvalue { i37, i1 } [[Y]], 0
-; CHECK-NEXT:    [[O:%.*]] = or i37 [[X1]], [[Y1]]
-; CHECK-NEXT:    ret i37 [[O]]
+; CHECK-NEXT:    ret i37 [[X1]]
 ;
   %x = call {i37, i1} @llvm.smul.with.overflow.i37(i37 %a, i37 %b)
   %y = call {i37, i1} @llvm.smul.with.overflow.i37(i37 %b, i37 %a)
   %x1 = extractvalue {i37, i1} %x, 0
   %y1 = extractvalue {i37, i1} %y, 0
   %o = or i37 %x1, %y1
   ret i37 %o
 }
 
 define <2 x i31> @umul_ov(<2 x i31> %a, <2 x i31> %b) {
 ; CHECK-LABEL: @umul_ov(
 ; CHECK-NEXT:    [[X:%.*]] = call { <2 x i31>, <2 x i1> } @llvm.umul.with.overflow.v2i31(<2 x i31> [[A:%.*]], <2 x i31> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call { <2 x i31>, <2 x i1> } @llvm.umul.with.overflow.v2i31(<2 x i31> [[B]], <2 x i31> [[A]])
 ; CHECK-NEXT:    [[X1:%.*]] = extractvalue { <2 x i31>, <2 x i1> } [[X]], 0
-; CHECK-NEXT:    [[Y1:%.*]] = extractvalue { <2 x i31>, <2 x i1> } [[Y]], 0
-; CHECK-NEXT:    [[O:%.*]] = or <2 x i31> [[X1]], [[Y1]]
-; CHECK-NEXT:    ret <2 x i31> [[O]]
+; CHECK-NEXT:    ret <2 x i31> [[X1]]
 ;
   %x = call {<2 x i31>, <2 x i1>} @llvm.umul.with.overflow.v2i31(<2 x i31> %a, <2 x i31> %b)
   %y = call {<2 x i31>, <2 x i1>} @llvm.umul.with.overflow.v2i31(<2 x i31> %b, <2 x i31> %a)
   %x1 = extractvalue {<2 x i31>, <2 x i1>} %x, 0
   %y1 = extractvalue {<2 x i31>, <2 x i1>} %y, 0
   %o = or <2 x i31> %x1, %y1
   ret <2 x i31> %o
 }
 
 define i64 @sadd_sat(i64 %a, i64 %b) {
 ; CHECK-LABEL: @sadd_sat(
 ; CHECK-NEXT:    [[X:%.*]] = call i64 @llvm.sadd.sat.i64(i64 [[A:%.*]], i64 [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call i64 @llvm.sadd.sat.i64(i64 [[B]], i64 [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or i64 [[X]], [[Y]]
-; CHECK-NEXT:    ret i64 [[O]]
+; CHECK-NEXT:    ret i64 [[X]]
 ;
   %x = call i64 @llvm.sadd.sat.i64(i64 %a, i64 %b)
   %y = call i64 @llvm.sadd.sat.i64(i64 %b, i64 %a)
   %o = or i64 %x, %y
   ret i64 %o
 }
 
 define <2 x i64> @uadd_sat(<2 x i64> %a, <2 x i64> %b) {
 ; CHECK-LABEL: @uadd_sat(
 ; CHECK-NEXT:    [[X:%.*]] = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> [[A:%.*]], <2 x i64> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> [[B]], <2 x i64> [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or <2 x i64> [[X]], [[Y]]
-; CHECK-NEXT:    ret <2 x i64> [[O]]
+; CHECK-NEXT:    ret <2 x i64> [[X]]
 ;
   %x = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %a, <2 x i64> %b)
   %y = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %b, <2 x i64> %a)
   %o = or <2 x i64> %x, %y
   ret <2 x i64> %o
 }
 
 define <2 x i64> @smax(<2 x i64> %a, <2 x i64> %b) {
 ; CHECK-LABEL: @smax(
 ; CHECK-NEXT:    [[X:%.*]] = call <2 x i64> @llvm.smax.v2i64(<2 x i64> [[A:%.*]], <2 x i64> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call <2 x i64> @llvm.smax.v2i64(<2 x i64> [[B]], <2 x i64> [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or <2 x i64> [[X]], [[Y]]
-; CHECK-NEXT:    ret <2 x i64> [[O]]
+; CHECK-NEXT:    ret <2 x i64> [[X]]
 ;
   %x = call <2 x i64> @llvm.smax.v2i64(<2 x i64> %a, <2 x i64> %b)
   %y = call <2 x i64> @llvm.smax.v2i64(<2 x i64> %b, <2 x i64> %a)
   %o = or <2 x i64> %x, %y
   ret <2 x i64> %o
 }
 
 define i4 @smin(i4 %a, i4 %b) {
 ; CHECK-LABEL: @smin(
 ; CHECK-NEXT:    [[X:%.*]] = call i4 @llvm.smin.i4(i4 [[A:%.*]], i4 [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call i4 @llvm.smin.i4(i4 [[B]], i4 [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or i4 [[X]], [[Y]]
-; CHECK-NEXT:    ret i4 [[O]]
+; CHECK-NEXT:    ret i4 [[X]]
 ;
   %x = call i4 @llvm.smin.i4(i4 %a, i4 %b)
   %y = call i4 @llvm.smin.i4(i4 %b, i4 %a)
   %o = or i4 %x, %y
   ret i4 %o
 }
 
 define i67 @umax(i67 %a, i67 %b) {
 ; CHECK-LABEL: @umax(
 ; CHECK-NEXT:    [[X:%.*]] = call i67 @llvm.umax.i67(i67 [[A:%.*]], i67 [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call i67 @llvm.umax.i67(i67 [[B]], i67 [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or i67 [[X]], [[Y]]
-; CHECK-NEXT:    ret i67 [[O]]
+; CHECK-NEXT:    ret i67 [[X]]
 ;
   %x = call i67 @llvm.umax.i67(i67 %a, i67 %b)
   %y = call i67 @llvm.umax.i67(i67 %b, i67 %a)
   %o = or i67 %x, %y
   ret i67 %o
 }
 
 define <3 x i17> @umin(<3 x i17> %a, <3 x i17> %b) {
 ; CHECK-LABEL: @umin(
 ; CHECK-NEXT:    [[X:%.*]] = call <3 x i17> @llvm.umin.v3i17(<3 x i17> [[A:%.*]], <3 x i17> [[B:%.*]])
-; CHECK-NEXT:    [[Y:%.*]] = call <3 x i17> @llvm.umin.v3i17(<3 x i17> [[B]], <3 x i17> [[A]])
-; CHECK-NEXT:    [[O:%.*]] = or <3 x i17> [[X]], [[Y]]
-; CHECK-NEXT:    ret <3 x i17> [[O]]
+; CHECK-NEXT:    ret <3 x i17> [[X]]
 ;
   %x = call <3 x i17> @llvm.umin.v3i17(<3 x i17> %a, <3 x i17> %b)
   %y = call <3 x i17> @llvm.umin.v3i17(<3 x i17> %b, <3 x i17> %a)
   %o = or <3 x i17> %x, %y
   ret <3 x i17> %o
 }
 
+; Negative test - mismatched intrinsics
+
 define i4 @smin_umin(i4 %a, i4 %b) {
 ; CHECK-LABEL: @smin_umin(
 ; CHECK-NEXT:    [[X:%.*]] = call i4 @llvm.smin.i4(i4 [[A:%.*]], i4 [[B:%.*]])
 ; CHECK-NEXT:    [[Y:%.*]] = call i4 @llvm.umin.i4(i4 [[B]], i4 [[A]])
 ; CHECK-NEXT:    [[O:%.*]] = or i4 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i4 [[O]]
 ;
   %x = call i4 @llvm.smin.i4(i4 %a, i4 %b)
   %y = call i4 @llvm.umin.i4(i4 %b, i4 %a)
   %o = or i4 %x, %y
   ret i4 %o
 }
 
+; TODO: handle >2 args
+
 define i16 @smul_fix(i16 %a, i16 %b) {
 ; CHECK-LABEL: @smul_fix(
 ; CHECK-NEXT:    [[X:%.*]] = call i16 @llvm.smul.fix.i16(i16 [[A:%.*]], i16 [[B:%.*]], i32 3)
 ; CHECK-NEXT:    [[Y:%.*]] = call i16 @llvm.smul.fix.i16(i16 [[B]], i16 [[A]], i32 3)
 ; CHECK-NEXT:    [[O:%.*]] = or i16 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i16 [[O]]
 ;
   %x = call i16 @llvm.smul.fix.i16(i16 %a, i16 %b, i32 3)
   %y = call i16 @llvm.smul.fix.i16(i16 %b, i16 %a, i32 3)
   %o = or i16 %x, %y
   ret i16 %o
 }
 
+; TODO: handle >2 args
+
 define i16 @umul_fix(i16 %a, i16 %b, i32 %s) {
 ; CHECK-LABEL: @umul_fix(
 ; CHECK-NEXT:    [[X:%.*]] = call i16 @llvm.umul.fix.i16(i16 [[A:%.*]], i16 [[B:%.*]], i32 1)
 ; CHECK-NEXT:    [[Y:%.*]] = call i16 @llvm.umul.fix.i16(i16 [[B]], i16 [[A]], i32 1)
 ; CHECK-NEXT:    [[O:%.*]] = or i16 [[X]], [[Y]]
 ; CHECK-NEXT:    ret i16 [[O]]
 ;
   %x = call i16 @llvm.umul.fix.i16(i16 %a, i16 %b, i32 1)
   %y = call i16 @llvm.umul.fix.i16(i16 %b, i16 %a, i32 1)
   %o = or i16 %x, %y
   ret i16 %o
 }
 
+; TODO: handle >2 args
+
 define <3 x i16> @smul_fix_sat(<3 x i16> %a, <3 x i16> %b) {
 ; CHECK-LABEL: @smul_fix_sat(
 ; CHECK-NEXT:    [[X:%.*]] = call <3 x i16> @llvm.smul.fix.sat.v3i16(<3 x i16> [[A:%.*]], <3 x i16> [[B:%.*]], i32 2)
 ; CHECK-NEXT:    [[Y:%.*]] = call <3 x i16> @llvm.smul.fix.sat.v3i16(<3 x i16> [[B]], <3 x i16> [[A]], i32 2)
 ; CHECK-NEXT:    [[O:%.*]] = or <3 x i16> [[X]], [[Y]]
 ; CHECK-NEXT:    ret <3 x i16> [[O]]
 ;
   %x = call <3 x i16> @llvm.smul.fix.sat.v3i16(<3 x i16> %a, <3 x i16> %b, i32 2)
   %y = call <3 x i16> @llvm.smul.fix.sat.v3i16(<3 x i16> %b, <3 x i16> %a, i32 2)
   %o = or <3 x i16> %x, %y
   ret <3 x i16> %o
 }
 
+; TODO: handle >2 args
+
 define <3 x i16> @umul_fix_sat(<3 x i16> %a, <3 x i16> %b) {
 ; CHECK-LABEL: @umul_fix_sat(
 ; CHECK-NEXT:    [[X:%.*]] = call <3 x i16> @llvm.umul.fix.sat.v3i16(<3 x i16> [[A:%.*]], <3 x i16> [[B:%.*]], i32 3)
 ; CHECK-NEXT:    [[Y:%.*]] = call <3 x i16> @llvm.umul.fix.sat.v3i16(<3 x i16> [[B]], <3 x i16> [[A]], i32 3)
 ; CHECK-NEXT:    [[O:%.*]] = or <3 x i16> [[X]], [[Y]]
 ; CHECK-NEXT:    ret <3 x i16> [[O]]
 ;
   %x = call <3 x i16> @llvm.umul.fix.sat.v3i16(<3 x i16> %a, <3 x i16> %b, i32 3)