RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-24 12:19:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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).

Differential Revision: https://reviews.llvm.org/D29336


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@294066 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2017-02-03 23:13:11 +00:00
parent 21b9ce0d3d
commit 7c4d39c349
2 changed files with 14 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -89,11 +89,13 @@ Value *InstCombiner::EmitGEPOffset(User *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 || 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 @@ bool InstCombiner::shouldChangeType(unsigned FromWidth,
/// 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());

9
test/Transforms/InstCombine/zext-phi.ll
View File

@ -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: