Added InstCombine transformation for combining two instructions icmp ult/ule/uge/ugt (ashr/lshr (Const2) %A), (Const1)

[ankur29.garg]

Summary

Hi,
I have added function to transform the two instructions of the type:
icmp slt/sle/ult/ule/sge/sgt/uge/ugt (ashr/lshr (Const2) %A), (Const1)

The patch for operators eq/ne has already been added in: http://reviews.llvm.org/D4068
This handles it for rest of the operators.

Please help in reviewing it.

Edit:
This patch now implements the optimization for only unsigned operators (ult/ule/ugt/uge). I've split it into two to make it easier to review. Earlier, the size of the diff was quite large.

Thanks.
Regards,
Ankur Garg

[majnemer]

You have a lot of logic in here that could easily live in InstSimplify, please move appropriate code into the InstructionSimplify analysis code in a separate differential.

[ankur29.garg]

Hi David,
Thanks for the comments. Some of the logic that i have written here is already present in InstSimplify. Those cases never reach here. I just added them for better understanding of the code flow as done for previous patch for EQ/NE. Should I remove the logic which is not being used in this function ? or Should I keep it for better understanding of the logical flow ?

Thanks.

[majnemer]

Untestable code makes this harder to understand, I'd simply assert that those states are unreachable.

[ankur29.garg]

Hi David,
All of the logic movable to InstSimplify was already present there. I have removed most of such logic from this function.
Remaining logic is quite specific to certain cases and I have left it as it is, just to avoid confusion in understanding the other cases. Though, it is already being handled in InstSimplify.

Please help in reviewing the updated revision.
Thanks.

[ankur29.garg]

Gentle Ping !

[ankur29.garg]

Gentle Ping !

[ankur29.garg]

Hi everyone,
It seems like this patch which I had submitted earlier for review was quite big and it would've taken a lot of effort for some one to review it.
So, I have split it into 2 parts.
This updated revision contains the optimization for unsigned operators (ult/ule/ugt/uge). Once this is reviewed, I will submit another patch with only signed operators so, that it becomes easier to review.

Also, Based on another patch i submitted for 'shl' instruction, I have made some changes based on the reviews I received for that patch.

This is a reduced size patch. Please help in reviewing it.

Thanks.

[silvas]

Could you verify this with a theorem prover?

[ankur29.garg]

Hi Silvas,
Can you please suggest some theorem prover which would be useful for llvm optimizations ?
The only theorem prover that I've used is http://rise4fun.com/Z3/. But, in this, we'll have to declare all the functions being used inside the logic for example, getBitWidth(), countLeadingZeros(), etc. Also, I am not sure if I can return instructions using this.

Thanks.

[ankur29.garg]

Hi silvas,
I checked the optimization using ALIVe. I found out a couple of cases, which although never reached this code, were being handled wrong. I have made the appropriate changes to exclude those cases from being handled here as they are already being handled in InstSimplify.

Since there are 4 number of operators (uge/ugt/ule/ult) and two right shifts (ashr/lshr), the total number of cases are really huge. This makes the output of alive really large. (Total 56 separate cases). Should I paste it here ?

[ankur29.garg]

Here is the ALIVe input I used to test the optimization:

Name: 1
Pre: C1 == C2 && C1 < 0 && C2 != -1
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp eq i8 %a, 0

Name: 2
Pre: C1 == C2 && C1 < 0 && C2 != -1
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ne i8 %a, 0

Name: 3
Pre: C1 == C2 && C1 < 0 && C2 != -1
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = i1 false

Name: 4
Pre: C1 == C2 && C1 < 0 && C2 != -1
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = i1 true
 
Name: 5
Pre: C1 == C2 && C2 != -1 && C2 != 0
 %shr = lshr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, 0

Name: 6
Pre: C1 == C2 && C2 != -1 && C2 != 0
 %shr = lshr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp eq i8 %a, 0

Name: 7
Pre: C1 == C2 && C2 != -1 && C2 != 0
 %shr = lshr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = i1 true

Name: 8
Pre: C1 == C2 && C2 != -1 && C2 != 0
 %shr = lshr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = i1 false

Name: 9
Pre: C1 == C2 && C1 > 0
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, 0

Name: 10
Pre: C1 == C2 && C1 > 0
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = i1 true

Name: 11
Pre: C1 == C2 && C1 > 0
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = i1 false

Name: 12
Pre: C1 == C2 && C1 > 0
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp eq i8 %a, 0

Name: 13
Pre: C1 != C2 && C1 < 0 && C2 < C1 && C2 >> (log2(~C2) - log2(~C1)) == C1
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp uge i8 %a, log2(~C2) - log2(~C1)

Name: 14
Pre: C1 != C2 && C1 < 0 && C2 < C1 && C2 >> (log2(~C2) - log2(~C1)) == C1
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, log2(~C2) - log2(~C1)
 
Name: 15
Pre: C1 != C2 && C1 < 0 && C2 < C1 && C2 >> (log2(~C2) - log2(~C1)) == C1
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, log2(~C2) - log2(~C1)

Name: 16
Pre: C1 != C2 && C1 < 0 && C2 < C1 && C2 >> (log2(~C2) - log2(~C1)) == C1
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, log2(~C2) - log2(~C1)


Name: 17
Pre: C1 != C2 && C1 < 0 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u> (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, log2(~C2) - log2(~C1) - 1

Name: 18
Pre: C1 != C2 && C1 < 0 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u> (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, log2(~C2) - log2(~C1) - 1

Name: 19
Pre: C1 != C2 && C1 < 0 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u> (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, log2(~C2) - log2(~C1)

Name: 20
Pre: C1 != C2 && C1 < 0 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u> (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, log2(~C2) - log2(~C1)

Name: 21
Pre: C1 != C2 && C1 < -1 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u< (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, log2(~C2) - log2(~C1)

Name: 22
Pre: C1 != C2 && C1 < -1 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u< (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, log2(~C2) - log2(~C1)

Name: 23
Pre: C1 != C2 && C1 < -1 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u< (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, log2(~C2) - log2(~C1) + 1

Name: 24
Pre: C1 != C2 && C1 < -1 && C2 < C1 && (C2 >> (log2(~C2) - log2(~C1))) u< (C1)
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, log2(~C2) - log2(~C1) + 1
 
Name: 25
Pre: C1 != C2 && C1 > 0 && C1 u> C2
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = i1 false

Name: 26
Pre: C1 != C2 && C1 > 0 && C1 u> C2
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = i1 false

Name: 27
Pre: C1 != C2 && C1 > 0 && C1 u> C2
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = i1 true

Name: 28
Pre: C1 != C2 && C1 > 0 && C1 u> C2
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = i1 true

Name: 29
Pre: C1 != C2 && C1 > 0 && C2 > 0 && (C1 u< C2) && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 30
Pre: C1 != C2 && C1 > 0 && C2 > 0 && (C1 u< C2) && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp uge i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 31
Pre: C1 != C2 && C1 > 0 && C2 > 0 && (C1 u< C2) && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 32
Pre: C1 != C2 && C1 > 0 && C2 > 0 && (C1 u< C2) && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)
 
Name: 33
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 34
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 35
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 36
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1


Name: 37
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 38
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 39
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 40
Pre: C1 != C2 && C1 > 0 && C2 > 0 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = ashr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)
 
Name: 41
Pre: C1 != C2 && C1 u> C2
 %shr = lshr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = i1 false

Name: 42
Pre: C1 != C2 && C1 u> C2
 %shr = lshr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = i1 false

Name: 43
Pre: C1 != C2 && C1 u> C2
 %shr = lshr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = i1 true

Name: 44
Pre: C1 != C2 && C1 u> C2
 %shr = lshr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = i1 true

Name: 45
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 46
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp uge i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 47
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ult i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 48
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 == lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)
 
Name: 49
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 50
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 51
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 52
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u> lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2) - 1

Name: 53
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ult i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 54
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ule i8 %shr, C1
=>
 %cmp = icmp ugt i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 55
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp ugt i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

Name: 56
Pre: C1 != 0 && C2 != 0 && C1 != C2 && C1 u< C2 && C1 u< lshr(C2, countLeadingZeros(C1) - countLeadingZeros(C2))
 %shr = lshr i8 C2, %a
 %cmp = icmp uge i8 %shr, C1
=>
 %cmp = icmp ule i8 %a, countLeadingZeros(C1) - countLeadingZeros(C2)

[ankur29.garg]

Gentle Ping !

[ankur29.garg]

Gentle Ping !

[ankur29.garg]

Gentle Ping!

[ankur29.garg]

Hi David,
Can you please help in reviewing this patch. I have added the ALIVe output for proving the correctness of the transformation.

Thanks.

[majnemer]

lib/Transforms/InstCombine/InstCombineCompares.cpp

1146

This should be handled by InstSimplify.

1157

As should this.

1180

And this.

2874–2883

Why is this else if now? It should be fine as if.

2874–2885

This code would be more general if you use m_APInt instead of m_ConstantInt.

2875

Can you just make this if, I think it makes the control flow a little simpler.

[ankur29.garg]

Hi David,
Thanks for reviewing the patch. I have made the changes as per your comments.

About the change from ConstantInt to APInt:
There are two ConstantInt variables 'CI' and 'CI2'. The variable 'CI' is being used elsewhere too. Should I make this change ? And CI2 is being used in 2 other functions. Both these functions right now, expect ConstantInt. Should I change it for all the functions ?

Thanks.

[ankur29.garg]

Gentle Ping !

[ankur29.garg]

Gentle Ping ! Please help in reviewing the changes.

[ankur29.garg]

Gentle Ping

lib/Transforms/InstCombine/InstCombine.h

public:
   Instruction *visitICmpInstWithInstAndIntCst(ICmpInst &ICI, Instruction *LHS,
                                               ConstantInt *RHS);
   Instruction *FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI,
                               ConstantInt *DivRHS);
   Instruction *FoldICmpShrCst(ICmpInst &ICI, BinaryOperator *DivI,
                               ConstantInt *DivRHS);
   Instruction *FoldICmpCstShrCst(ICmpInst &I, Value *Op, Value *A,
                                  ConstantInt *CI1, ConstantInt *CI2);
+  Instruction *FoldICmpLgGtCstShrCst(ICmpInst &I, Value *Op, Value *A,
+                                     ConstantInt *CI1, ConstantInt *CI2);
   Instruction *FoldICmpAddOpCst(Instruction &ICI, Value *X, ConstantInt *CI,
                                 ICmpInst::Predicate Pred);
   Instruction *FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
                            ICmpInst::Predicate Cond, Instruction &I);
   Instruction *FoldShiftByConstant(Value *Op0, Constant *Op1,
                                    BinaryOperator &I);
   Instruction *commonCastTransforms(CastInst &CI);
   Instruction *commonPointerCastTransforms(CastInst &CI);

lib/Transforms/InstCombine/InstCombineCompares.cpp

Instruction *InstCombiner::FoldICmpCstShrCst(ICmpInst &I, Value *Op, Value *A,
 
   if (IsAShr ? AP1 == AP2.ashr(Shift) : AP1 == AP2.lshr(Shift))
     return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
 
   // Shifting const2 will never be equal to const1.
   return getConstant(false);
 }
 
+Instruction *InstCombiner::FoldICmpLgGtCstShrCst(ICmpInst &I, Value *Op,
+                                                 Value *A, ConstantInt *CI1,
+                                                 ConstantInt *CI2) {
+
+  auto getConstantIfGreater = [&I, this](bool IsTrue) {
+    if (I.getPredicate() == I.ICMP_SLT || I.getPredicate() == I.ICMP_ULT ||
+        I.getPredicate() == I.ICMP_SLE || I.getPredicate() == I.ICMP_ULE)
+      IsTrue = !IsTrue;
+    return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), IsTrue));
+  };
+
+  APInt AP1 = CI1->getValue();
+  APInt AP2 = CI2->getValue();
+
+  bool IsAShr = isa<AShrOperator>(Op);
+
+  if (!AP1) {
+    if (AP2.isNegative()) {
+      // AP1 is zero and MSB of AP2 is set
+      assert(!IsAShr);
+      if (I.getPredicate() == I.ICMP_SGT ||
+          I.getPredicate() == I.ICMP_SGE) {
+        return new ICmpInst(I.ICMP_UGT, A,
+                            ConstantInt::get(A->getType(), 0));
+      } else if (I.getPredicate() == I.ICMP_SLT) {
+        return new ICmpInst(I.ICMP_EQ, A,
+                            ConstantInt::get(A->getType(), 0));
+      } else if (I.getPredicate() == I.ICMP_SLE){
+        // A == 0 || A >= 32
+        return NULL;
+      }
+      else {
+        //Shouldn't reach here
+        return NULL;
+      }
+    } else {
+      // AP1 is zero and MSB of AP2 is unset
+      // Doesn't matter if signed or unsigned comparison
+      int logAP2 = AP2.logBase2();
+
+      if (I.getPredicate() == I.ICMP_ULT || I.getPredicate() == I.ICMP_SLT) {
+        return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+      } else if (I.getPredicate() == I.ICMP_ULE ||
+                 I.getPredicate() == I.ICMP_SLE) {
+        return new ICmpInst(I.ICMP_UGT, A,
+                            ConstantInt::get(A->getType(), AP2.logBase2()));
+      } else if (I.getPredicate() == I.ICMP_SGE ||
+                 I.getPredicate() == I.ICMP_UGE) {
+        return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+      } else {
+        if (AP2 == AP2.ashr(logAP2))
+          return new ICmpInst(I.ICMP_ULT, A,
+                              ConstantInt::get(A->getType(), AP2.logBase2()));
+        else
+          return new ICmpInst(I.ICMP_ULE, A,
+                              ConstantInt::get(A->getType(), AP2.logBase2()));
+      }
+    }
+  }
+  // Cases where AP2 = 0 and AP1 is nonzero, handled in InstSimplify
+  // Both AP1, AP2 are non-zero
+  if (AP1 == AP2) {
+    if (I.isUnsigned()) {
+      if (I.getPredicate() == I.ICMP_ULT) {
+        return new ICmpInst(I.ICMP_UGT, A,
+                            ConstantInt::getNullValue(A->getType()));
+      } else if (I.getPredicate() == I.ICMP_ULE) {
+        return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+      } else if (I.getPredicate() == I.ICMP_UGT) {
+        return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+      } else {
+        return new ICmpInst(I.ICMP_EQ, A,
+                            ConstantInt::getNullValue(A->getType()));
+      }
+    } else {
+      if (AP1.isNegative()) {
+        if (I.getPredicate() == I.ICMP_SGE) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+        } else if (I.getPredicate() == I.ICMP_SGT) {
+          return new ICmpInst(I.ICMP_UGT, A,
+                              ConstantInt::getNullValue(A->getType()));
+        } else if (I.getPredicate() == I.ICMP_SLT) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+        } else {
+          return new ICmpInst(I.ICMP_EQ, A,
+                              ConstantInt::getNullValue(A->getType()));
+        }
+      } else {
+        if (I.getPredicate() == I.ICMP_SLT) {
+          return new ICmpInst(I.ICMP_UGT, A,
+                              ConstantInt::getNullValue(A->getType()));
+        } else if (I.getPredicate() == I.ICMP_SLE) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+        } else if (I.getPredicate() == I.ICMP_SGT) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+        } else {
+          return new ICmpInst(I.ICMP_EQ, A,
+                              ConstantInt::getNullValue(A->getType()));
+        }
+      }
+    }
+  }
+
+  if (IsAShr) {
+    if (AP1.isNegative()) {
+      AP1 = -AP1;
+      AP2 = -AP2;
+
+      if (AP1.ugt(AP2)) {
+        return getConstantIfGreater(true);
+      } else {
+        int Shift = AP2.logBase2() - AP1.logBase2();
+        if (AP1 == AP2.lshr(Shift)) {
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT) {
+            return new ICmpInst(I.ICMP_ULT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_ULE ||
+                     I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_ULE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_UGT ||
+                     I.getPredicate() == I.ICMP_SGT) {
+            return new ICmpInst(I.ICMP_UGT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else {
+            return new ICmpInst(I.ICMP_UGE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        } else {
+          if (AP1.ugt(AP2.lshr(Shift))) {
+            Shift--;
+          }
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT ||
+              I.getPredicate() == I.ICMP_ULE ||
+              I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_ULT, A,
+                                ConstantInt::get(A->getType(), Shift + 1));
+          } else {
+            return new ICmpInst(I.ICMP_UGT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        }
+      }
+      return NULL;
+    } else {
+      if (AP1.ugt(AP2)) {
+        return getConstantIfGreater(false);
+      } else {
+        int Shift = AP2.logBase2() - AP1.logBase2();
+        if (AP1 == AP2.lshr(Shift)) {
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT) {
+            return new ICmpInst(I.ICMP_UGT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_ULE ||
+                     I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_UGE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_UGT ||
+                     I.getPredicate() == I.ICMP_SGT) {
+            return new ICmpInst(I.ICMP_ULT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else {
+            return new ICmpInst(I.ICMP_ULE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        } else {
+          if (AP1.ugt(AP2.lshr(Shift))) {
+            Shift--;
+          }
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT ||
+              I.getPredicate() == I.ICMP_ULE ||
+              I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_UGE, A,
+                                ConstantInt::get(A->getType(), Shift + 1));
+          } else {
+            return new ICmpInst(I.ICMP_ULE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        }
+      }
+    }
+  } else {
+    if (AP1.isNegative() != AP2.isNegative()) {
+      if (AP1.isNegative()) {
+        if (I.isUnsigned()) {
+          return getConstantIfGreater(false);
+        } else {
+          return getConstantIfGreater(true);
+        }
+      } else {
+        if (I.isUnsigned()) {
+          int x = 32 - AP1.logBase2() - 1;
+          if (AP1 == AP2.lshr(x)) {
+            if (I.getPredicate() == I.ICMP_UGT) {
+              return new ICmpInst(I.ICMP_ULT, A,
+                                  ConstantInt::get(A->getType(), x));
+            } else if (I.getPredicate() == I.ICMP_UGE) {
+              return new ICmpInst(I.ICMP_ULE, A,
+                                  ConstantInt::get(A->getType(), x));
+            } else if (I.getPredicate() == I.ICMP_ULT) {
+              return new ICmpInst(I.ICMP_UGT, A,
+                                  ConstantInt::get(A->getType(), x));
+            } else {
+              return new ICmpInst(I.ICMP_UGE, A,
+                                  ConstantInt::get(A->getType(), x));
+            }
+          } else {
+            if (AP2.lshr(x).ult(AP1)) {
+              x--;
+            }
+            if (I.getPredicate() == I.ICMP_UGT ||
+                I.getPredicate() == I.ICMP_UGE) {
+              return new ICmpInst(I.ICMP_ULE, A,
+                                  ConstantInt::get(A->getType(), x));
+            } else {
+              return new ICmpInst(I.ICMP_UGE, A,
+                                  ConstantInt::get(A->getType(), x + 1));
+            }
+          }
+        } else {
+          return NULL;
+        }
+      }
+    } else if (AP1.isNegative()) {
+      if (I.getPredicate() == I.ICMP_ULT || I.getPredicate() == I.ICMP_ULE) {
+        if (AP1.ugt(AP2)) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+        } else {
+          return new ICmpInst(I.ICMP_UGT, A, ConstantInt::get(A->getType(), 0));
+        }
+      } else if (I.getPredicate() == I.ICMP_UGT ||
+                 I.getPredicate() == I.ICMP_UGE) {
+        if (AP2.ugt(AP1)) {
+          return new ICmpInst(I.ICMP_EQ, A, ConstantInt::get(A->getType(), 0));
+        } else {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+        }
+      } else if (I.getPredicate() == I.ICMP_SLT ||
+                 I.getPredicate() == I.ICMP_SLE) {
+        if (AP2.slt(AP1)) {
+          return new ICmpInst(I.ICMP_EQ, A, ConstantInt::get(A->getType(), 0));
+        } else {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), false));
+        }
+      } else {
+        if (AP2.sgt(AP1)) {
+          return ReplaceInstUsesWith(I, ConstantInt::get(I.getType(), true));
+        } else {
+          return new ICmpInst(I.ICMP_UGT, A, ConstantInt::get(A->getType(), 0));
+        }
+      }
+    } else {
+      if (AP1.ugt(AP2)) {
+        return getConstantIfGreater(false);
+      } else {
+        int Shift = AP2.logBase2() - AP1.logBase2();
+        if (AP1 == AP2.lshr(Shift)) {
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT) {
+            return new ICmpInst(I.ICMP_UGT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_ULE ||
+                     I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_UGE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else if (I.getPredicate() == I.ICMP_UGT ||
+                     I.getPredicate() == I.ICMP_SGT) {
+            return new ICmpInst(I.ICMP_ULT, A,
+                                ConstantInt::get(A->getType(), Shift));
+          } else {
+            return new ICmpInst(I.ICMP_ULE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        } else {
+          if (AP1.ugt(AP2.lshr(Shift))) {
+            Shift--;
+          }
+          if (I.getPredicate() == I.ICMP_ULT ||
+              I.getPredicate() == I.ICMP_SLT ||
+              I.getPredicate() == I.ICMP_ULE ||
+              I.getPredicate() == I.ICMP_SLE) {
+            return new ICmpInst(I.ICMP_UGE, A,
+                                ConstantInt::get(A->getType(), Shift + 1));
+          } else {
+            return new ICmpInst(I.ICMP_ULE, A,
+                                ConstantInt::get(A->getType(), Shift));
+          }
+        }
+      }
+    }
+  }
+}
+
 /// visitICmpInstWithInstAndIntCst - Handle "icmp (instr, intcst)".
 ///
 Instruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI,
                                                           Instruction *LHSI,
                                                           ConstantInt *RHS) {
   const APInt &RHSV = RHS->getValue();
 
   switch (LHSI->getOpcode()) {
case ICmpInst::ICMP_UGE:
       return new ICmpInst(ICmpInst::ICMP_UGT, Op0,
                           Builder->getInt(CI->getValue()-1));
     case ICmpInst::ICMP_SGE:
       assert(!CI->isMinValue(true));                  // A >=s MIN -> TRUE
       return new ICmpInst(ICmpInst::ICMP_SGT, Op0,
                           Builder->getInt(CI->getValue()-1));
     }
 
-    // (icmp eq/ne (ashr/lshr const2, A), const1)
-    if (I.isEquality()) {
-      ConstantInt *CI2;
-      if (match(Op0, m_AShr(m_ConstantInt(CI2), m_Value(A))) ||
-          match(Op0, m_LShr(m_ConstantInt(CI2), m_Value(A)))) {
+      // (icmp eq/ne (ashr/lshr const2, A), const1)
+      if (I.isEquality()) {
         return FoldICmpCstShrCst(I, Op0, A, CI, CI2);
+      } else {
+        Instruction *I2 = FoldICmpLgGtCstShrCst(I, Op0, A, CI, CI2);
+        if (I2 != NULL)
+          return I2;
       }
     }
 
     // If this comparison is a normal comparison, it demands all
     // bits, if it is a sign bit comparison, it only demands the sign bit.
     bool UnusedBit;
     isSignBit = isSignBitCheck(I.getPredicate(), CI, UnusedBit);
   }
 
   // See if we can fold the comparison based on range information we can get

test/Transforms/InstCombine/icmp-shr.ll

 
 ; CHECK-LABEL: @PR20945(
 ; CHECK: icmp ne i32 %B, 1
 define i1 @PR20945(i32 %B) {
   %shr = ashr i32 -9, %B
   %cmp = icmp ne i32 %shr, -5
   ret i1 %cmp
 }
+
+; Test cases for icmp shr ugt/sgt/uge/sge/ult/slt/ule/sle
+define i1 @lshr_sgt_both_zero(i8 %a) {
+; CHECK-LABEL: @lshr_sgt_both_zero(
+; CHECK-NEXT: ret i1 false
+  %shr = lshr i8 0, %a
+  %cmp = icmp sgt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sge_both_zero(i8 %a) {
+; CHECK-LABEL: @lshr_sge_both_zero(
+; CHECK-NEXT: ret i1 true
+  %shr = lshr i8 0, %a
+  %cmp = icmp sge i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sge_ap1_zero_ap2_negative(i8 %a) {
+; CHECK-LABEL: @lshr_sge_ap1_zero_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 -4, %a
+  %cmp = icmp sge i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sgt_ap1_zero_ap2_negative(i8 %a) {
+; CHECK-LABEL: @lshr_sgt_ap1_zero_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 -5, %a
+  %cmp = icmp sgt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_slt_ap1_zero_ap2_negative(i8 %a) {
+; CHECK-LABEL: @lshr_slt_ap1_zero_ap2_negative(
+; CHECK-NEXT: %cmp = icmp eq i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 -6, %a
+  %cmp = icmp slt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sle_ap1_zero_ap2_negative(i8 %a) {
+; CHECK-LABEL: @lshr_sle_ap1_zero_ap2_negative(
+; CHECK-NEXT: %shr = lshr i8 -5, %a
+; CHECK-NEXT: %cmp = icmp slt i8 %shr, 1
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 -5, %a
+  %cmp = icmp sle i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @ashr_sgt_ap1_zero_ap2_positive(i8 %a) {
+; CHECK-LABEL: @ashr_sgt_ap1_zero_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ult i8 %a, 3
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 5, %a
+  %cmp = icmp sgt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @ashr_sle_ap1_zero_ap2_positive(i8 %a) {
+; CHECK-LABEL: @ashr_sle_ap1_zero_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ugt i8 %a, 2
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 7, %a
+  %cmp = icmp sle i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @ashr_ugt_ap1_zero_ap2_positive(i8 %a) {
+; CHECK-LABEL: @ashr_ugt_ap1_zero_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ult i8 %a, 3
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 5, %a
+  %cmp = icmp ugt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sgt_ap1_zero_ap2_positive(i8 %a) {
+; CHECK-LABEL: @lshr_sgt_ap1_zero_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ult i8 %a, 3
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 5, %a
+  %cmp = icmp sgt i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_sle_ap1_zero_ap2_positive(i8 %a) {
+; CHECK-LABEL: @lshr_sle_ap1_zero_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ugt i8 %a, 2
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i8 7, %a
+  %cmp = icmp sle i8 %shr, 0
+  ret i1 %cmp
+}
+
+define i1 @lshr_ugt_ap1_negative_ap2_zero(i8 %a) {
+; CHECK-LABEL: @lshr_ugt_ap1_negative_ap2_zero(
+; CHECK-NEXT: ret i1 false
+  %shr = lshr i8 0, %a
+  %cmp = icmp ugt i8 %shr, -7
+  ret i1 %cmp
+}
+
+define i1 @lshr_sge_ap1_negative_ap2_zero(i8 %a) {
+; CHECK-LABEL: @lshr_sge_ap1_negative_ap2_zero(
+; CHECK-NEXT: ret i1 true
+  %shr = lshr i8 0, %a
+  %cmp = icmp sge i8 %shr, -6
+  ret i1 %cmp
+}
+
+define i1 @ashr_sgt_ap1_positive_ap2_zero(i8 %a) {
+; CHECK-LABEL: @ashr_sgt_ap1_positive_ap2_zero(
+; CHECK-NEXT: ret i1 false
+  %shr = ashr i8 0, %a
+  %cmp = icmp sgt i8 %shr, 7
+  ret i1 %cmp
+}
+
+define i1 @ashr_slt_ap1_positive_ap2_zero(i8 %a) {
+; CHECK-LABEL: @ashr_slt_ap1_positive_ap2_zero(
+; CHECK-NEXT: ret i1 true
+  %shr = ashr i8 0, %a
+  %cmp = icmp slt i8 %shr, 5
+  ret i1 %cmp
+}
+
+define i1 @ashr_ult_ap1_equal_ap2(i8 %a) {
+; CHECK-LABEL: @ashr_ult_ap1_equal_ap2(
+; CHECK-NEXT: %cmp = icmp ne i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 13, %a
+  %cmp = icmp ult i8 %shr, 13
+  ret i1 %cmp
+}
+
+define i1 @ashr_uge_ap1_equal_ap2(i8 %a) {
+; CHECK-LABEL: @ashr_uge_ap1_equal_ap2(
+; CHECK-NEXT: %cmp = icmp eq i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 13, %a
+  %cmp = icmp uge i8 %shr, 13
+  ret i1 %cmp
+}
+
+define i1 @ashr_sgt_ap1_equal_ap2_negative(i8 %a) {
+; CHECK-LABEL: @ashr_sgt_ap1_equal_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 -13, %a
+  %cmp = icmp sgt i8 %shr, -13
+  ret i1 %cmp
+}
+
+define i1 @ashr_sle_ap1_equal_ap2_negative(i8 %a) {
+; CHECK-LABEL: @ashr_sle_ap1_equal_ap2_negative(
+; CHECK-NEXT: %cmp = icmp eq i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 -13, %a
+  %cmp = icmp sle i8 %shr, -13
+  ret i1 %cmp
+}
+
+define i1 @ashr_sge_ap1_equal_ap2_positive(i8 %a) {
+; CHECK-LABEL: @ashr_sge_ap1_equal_ap2_positive(
+; CHECK-NEXT: %cmp = icmp eq i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 13, %a
+  %cmp = icmp sge i8 %shr, 13
+  ret i1 %cmp
+}
+
+define i1 @ashr_slt_ap1_equal_ap2_positive(i8 %a) {
+; CHECK-LABEL: @ashr_slt_ap1_equal_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ne i8 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i8 13, %a
+  %cmp = icmp slt i8 %shr, 13
+  ret i1 %cmp
+}
+
+define i1 @ashr_sgt_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @ashr_sgt_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i32 -22, %a
+  %cmp = icmp sgt i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @ashr_slt_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @ashr_slt_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i32 -22, %a
+  %cmp = icmp slt i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @ashr_sge_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @ashr_sge_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i32 -22, %a
+  %cmp = icmp sge i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @ashr_sle_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @ashr_sle_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = ashr i32 -22, %a
+  %cmp = icmp sle i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ule_ap1_positive_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_ule_ap1_positive_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ugt i32 %a, 28
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp ule i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ult_ap1_positive_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_ult_ap1_positive_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ugt i32 %a, 28
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp ult i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ugt_ap1_positive_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_ugt_ap1_positive_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ult i32 %a, 29
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp ugt i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_uge_ap1_positive_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_uge_ap1_positive_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ult i32 %a, 29
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp uge i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ult_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_ult_ap1_negative_ap2_negative(
+; CHECK-NEXT: ret i1 true
+  %shr = lshr i32 -22, %a
+  %cmp = icmp ult i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ugt_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_ugt_ap1_negative_ap2_negative(
+; CHECK-NEXT: ret i1 false
+  %shr = lshr i32 -22, %a
+  %cmp = icmp ugt i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @lshr_slt_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_slt_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp slt i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @lshr_sgt_ap1_negative_ap2_negative(i32 %a) {
+; CHECK-LABEL: @lshr_sgt_ap1_negative_ap2_negative(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -22, %a
+  %cmp = icmp sgt i32 %shr, -14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ult_ap1_negative_ap2_negative_ap1_greater(i32 %a) {
+; CHECK-LABEL: @lshr_ult_ap1_negative_ap2_negative_ap1_greater(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -14, %a
+  %cmp = icmp ult i32 %shr, -22
+  ret i1 %cmp
+}
+
+define i1 @lshr_ugt_ap1_negative_ap2_negative_ap1_greater(i32 %a) {
+; CHECK-LABEL: @lshr_ugt_ap1_negative_ap2_negative_ap1_greater(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 -14, %a
+  %cmp = icmp ugt i32 %shr, -22
+  ret i1 %cmp
+}
+
+define i1 @lshr_slt_ap1_negative_ap2_negative_ap1_greater(i32 %a) {
+; CHECK-LABEL: @lshr_slt_ap1_negative_ap2_negative_ap1_greater(
+; CHECK-NEXT: ret i1 false
+  %shr = lshr i32 -14, %a
+  %cmp = icmp slt i32 %shr, -22
+  ret i1 %cmp
+}
+
+define i1 @lshr_sgt_ap1_negative_ap2_negative_ap1_greater(i32 %a) {
+; CHECK-LABEL: @lshr_sgt_ap1_negative_ap2_negative_ap1_greater(
+; CHECK-NEXT: ret i1 true
+  %shr = lshr i32 -14, %a
+  %cmp = icmp sgt i32 %shr, -22
+  ret i1 %cmp
+}
+
+define i1 @lshr_ult_ap1_positive_ap2_positive(i32 %a) {
+; CHECK-LABEL: @lshr_ult_ap1_positive_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 22, %a
+  %cmp = icmp ult i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_ugt_ap1_positive_ap2_positive(i32 %a) {
+; CHECK-LABEL: @lshr_ugt_ap1_positive_ap2_positive(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 22, %a
+  %cmp = icmp ugt i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_slt_ap1_positive_ap2_positive(i32 %a) {
+; CHECK-LABEL: @lshr_slt_ap1_positive_ap2_positive(
+; CHECK-NEXT: %cmp = icmp ne i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 22, %a
+  %cmp = icmp slt i32 %shr, 14
+  ret i1 %cmp
+}
+
+define i1 @lshr_sgt_ap1_positive_ap2_positive(i32 %a) {
+; CHECK-LABEL: @lshr_sgt_ap1_positive_ap2_positive(
+; CHECK-NEXT: %cmp = icmp eq i32 %a, 0
+; CHECK-NEXT: ret i1 %cmp
+  %shr = lshr i32 22, %a
+  %cmp = icmp sgt i32 %shr, 14
+  ret i1 %cmp
+}