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

[Sanjay Patel via Phabricator via llvm-commits]

spatel updated this revision to Diff 86673.
spatel marked an inline comment as done.
spatel added a comment.

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? :)


https://reviews.llvm.org/D29336

Files:
  lib/Transforms/InstCombine/InstructionCombining.cpp
  test/Transforms/InstCombine/zext-phi.ll


Index: test/Transforms/InstCombine/zext-phi.ll
===================================================================
--- test/Transforms/InstCombine/zext-phi.ll
+++ test/Transforms/InstCombine/zext-phi.ll
@@ -2,16 +2,19 @@
 
 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:
Index: lib/Transforms/InstCombine/InstructionCombining.cpp
===================================================================
--- lib/Transforms/InstCombine/InstructionCombining.cpp
+++ lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -89,11 +89,13 @@
 /// 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 || DL.isLegalInteger(FromWidth);
+  bool ToLegal = ToWidth == 1 || DL.isLegalInteger(ToWidth);
 
   // If this is a legal integer from type, and the result would be an illegal
   // type, don't do the transformation.
@@ -110,7 +112,9 @@
 
 /// 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());
 


-------------- next part --------------
A non-text attachment was scrubbed...
Name: D29336.86673.patch
Type: text/x-patch
Size: 2710 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170201/1621a467/attachment.bin>