[InstCombine] treat i1 as a special type in shouldChangeType()

[spatel]

Summary

This patch is based on the llvm-dev discussion here:
http://lists.llvm.org/pipermail/llvm-dev/2017-January/109631.html

Folding to i1 should always be desirable because that's better for value tracking and we have special folds for i1 types.

I checked for other users of shouldChangeType() where this might have an effect, but we already handle the i1 case differently than other types in all of those cases.

Side note: the default datalayout includes i1, so it seems we only find this gap in shouldChangeType + phi folding for the case when there is (1) an explicit datalayout without i1, (2) casting to i1 from a legal type, and (3) a phi with exactly 2 incoming casted operands (as Björn mentioned).

[efriedma]

I think this makes sense; we have getBooleanContents in CodeGen, so we should generate reasonable results for i1 phi nodes even if i1 isn't considered a legal integer type.

[dotdash]

LGTM except for the style nitpick which is just personal preference. I don't think I'm allowed to actually accept patches though.

lib/Transforms/InstCombine/InstructionCombining.cpp

98

I think those would be a bit more legible when written as:

bool ToLegal = ToWidth == 1 || DL.isLegalInteger(ToWidth)

[spatel]

Patch updated:
Simplify code from cond ? true : x to cond || x.

Does one approval of the direction plus one possibly unqualified LGTM mean I can commit? :)

[efriedma]

LGTM.

lib/Transforms/InstCombine/InstructionCombining.cpp

 
 Value *InstCombiner::EmitGEPOffset(User *GEP) {
   return llvm::EmitGEPOffset(Builder, DL, GEP);
 }
 
 /// Return true if it is desirable to convert an integer computation from a
 /// given bit width to a new bit width.
 /// We don't want to convert from a legal to an illegal type or from a smaller
-/// to a larger illegal type.
+/// to a larger illegal type. A width of '1' is always treated as a legal type
+/// because i1 is a fundamental type in IR, and there are many specialized
+/// optimizations for i1 types.
 bool InstCombiner::shouldChangeType(unsigned FromWidth,
                                     unsigned ToWidth) const {
-  bool FromLegal = DL.isLegalInteger(FromWidth);
-  bool ToLegal = DL.isLegalInteger(ToWidth);
+  bool FromLegal = FromWidth == 1 ? true : DL.isLegalInteger(FromWidth);
+  bool ToLegal = ToWidth == 1 ? true : DL.isLegalInteger(ToWidth);
 
   // If this is a legal integer from type, and the result would be an illegal
   // type, don't do the transformation.
   if (FromLegal && !ToLegal)
     return false;
 
   // Otherwise, if both are illegal, do not increase the size of the result. We
   // do allow things like i160 -> i64, but not i64 -> i160.
   if (!FromLegal && !ToLegal && ToWidth > FromWidth)
     return false;
 
   return true;
 }
 
 /// Return true if it is desirable to convert a computation from 'From' to 'To'.
 /// We don't want to convert from a legal to an illegal type or from a smaller
-/// to a larger illegal type.
+/// to a larger illegal type. i1 is always treated as a legal type because it is
+/// a fundamental type in IR, and there are many specialized optimizations for
+/// i1 types.
 bool InstCombiner::shouldChangeType(Type *From, Type *To) const {
   assert(From->isIntegerTy() && To->isIntegerTy());
 
   unsigned FromWidth = From->getPrimitiveSizeInBits();
   unsigned ToWidth = To->getPrimitiveSizeInBits();
   return shouldChangeType(FromWidth, ToWidth);
 }
 

test/Transforms/InstCombine/zext-phi.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-n8:16:32:64"
 
+; Although i1 is not in the datalayout, we should treat it
+; as a legal type because it is a fundamental type in IR.
+; This means we should shrink the phi (sink the zexts).
+
 define i64 @sink_i1_casts(i1 %cond1, i1 %cond2) {
 ; CHECK-LABEL: @sink_i1_casts(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[Z1:%.*]] = zext i1 %cond1 to i64
 ; CHECK-NEXT:    br i1 %cond1, label %if, label %end
 ; CHECK:       if:
-; CHECK-NEXT:    [[Z2:%.*]] = zext i1 %cond2 to i64
 ; CHECK-NEXT:    br label %end
 ; CHECK:       end:
-; CHECK-NEXT:    [[PHI:%.*]] = phi i64 [ [[Z1]], %entry ], [ [[Z2]], %if ]
+; CHECK-NEXT:    [[PHI_IN:%.*]] = phi i1 [ %cond1, %entry ], [ %cond2, %if ]
+; CHECK-NEXT:    [[PHI:%.*]] = zext i1 [[PHI:%.*]].in to i64
 ; CHECK-NEXT:    ret i64 [[PHI]]
 ;
 entry:
   %z1 = zext i1 %cond1 to i64
   br i1 %cond1, label %if, label %end
 
 if:
   %z2 = zext i1 %cond2 to i64
   br label %end
 
 end:
   %phi = phi i64 [ %z1, %entry ], [ %z2, %if ]
   ret i64 %phi
 }