[AggressiveInstCombine] Fold strcmp for short string literals with size 2

[kitaisreal]

Summary

Fold strcmp for short string literals with size 2.
Depends D155742.

[goldstein.w.n]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

909

I would just generalize this to something like: "Try to expand strcmp(P, string_literal) where strlen(string_literal) <= 2"

927

instead of == 1 || == 2 how about just <= 2? Does zero length ever occur? If so thats probably worth handling as well.

1022

This is not really easy to read. It also seems to be largerly a duplicate of the size == 1 logic.
Can you hoist it to a helper that performs the check for a given char index?

[kitaisreal]

Updated implementation.

[goldstein.w.n]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

1038

Since a precondition is the strcmp is only used for equality, why do you zext here.

1043

is NSW right?

[goldstein.w.n]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

1043

Likewise, do you need the sub at all? Can you just br on the compare of the two characters and return the compare result itself?

[kitaisreal]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

1038

Above we check that strcmp is only used in any comparison with zero, not just equality comparison.
zest is required because in strcmp we compare characters as unsigned characters.
Please check discussion in previous pull request which provides more details https://reviews.llvm.org/D154725 file AggressiveInstCombine.cpp line 949.

1043

We need sub because we want to support not only equality compare strcmp result with zero strcmp(P, 'a') == 0, but also strcmp(P, 'a') < 0 and strcmp(P, 'a') > 0.
It seems that it can be a good idea to simplify strcmp(P, 'a') == 0 to something like P[0] == 'a' && P[1] == '\0'. It seems that compiler cannot do this right now.
NSW added to follow standard strcmp implementation from glibc https://godbolt.org/z/Pd9xKcnE8.

[kitaisreal]

Re-upload the same patch with mentioning correct repository LLVM Github Monorepo.

[goldstein.w.n]

LGTM.

Not really familiar enough with AggressiveInstCombine to be only reviewer here so please wait at least a few days to a second signoff.

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

1048

nit can you rename *SubZero* variables -> *SubIsZero* or *Eq* (I first read 'SubZero' as negative).

[nikic]

Looks good to me as well.

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

939

Drop braces (and maybe combine these two conditions?)

[kitaisreal]

I will fix nit picks in separate patch, where I plan to add more efficient implementations for strcmp(P, 'x') == 0, strcmp(P, 'x') != 0.

[kitaisreal]

Fixed nit picks in follow up revision https://reviews.llvm.org/D156556.

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

if (TTI.haveFastSqrt(Ty) &&
     // trivially dead.
     Call->eraseFromParent();
     return true;
   }
 
   return false;
 }
 
-/// Try to expand strcmp(P, "x") calls.
+/// Try to expand strcmp(P, "x"), strcmp(P, "xy") calls.
 static bool expandStrcmp(CallInst *CI, DominatorTree &DT, bool &MadeCFGChange) {
   Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
 
   // Trivial cases are optimized during inst combine
   if (Str1P == Str2P)
     return false;
 
   StringRef Str1, Str2;
   bool HasStr1 = getConstantStringInfo(Str1P, Str1);
   bool HasStr2 = getConstantStringInfo(Str2P, Str2);
 
   Value *NonConstantP = nullptr;
   StringRef ConstantStr;
 
-  if (!HasStr1 && HasStr2 && Str2.size() == 1) {
+  if (!HasStr1 && HasStr2 && (Str2.size() == 1 || Str2.size() == 2)) {
     NonConstantP = Str1P;
     ConstantStr = Str2;
-  } else if (!HasStr2 && HasStr1 && Str1.size() == 1) {
+  } else if (!HasStr2 && HasStr1 && (Str1.size() == 1 || Str1.size() == 2)) {
     NonConstantP = Str2P;
     ConstantStr = Str1;
   } else {
     return false;
   }
 
   // Check if strcmp result is only used in a comparison with zero
   if (!isOnlyUsedInZeroComparison(CI))
     return false;
 
   // For strcmp(P, "x") do the following transformation:
   //
   // (before)
   // dst = strcmp(P, "x")
   //
   // (after)
   // v0 = P[0] - 'x'
   // [if v0 == 0]
   //   v1 = P[1]
   // dst = phi(v0, v1)
   //
+  // For strcmp(P, "xy") do the following transformation:
+  //
+  // (before)
+  // dst = strcmp(P, "x")
+  //
+  // (after)
+  // v0 = P[0] - 'x'
+  // [if v0 == 0]
+  //   v1 = P[1] - 'y'
+  //   [if v1 == 0]
+  //     v2 = P[2]
+  // dst = phi(v0, v1, v2)
+  //
 
   IRBuilder<> B(CI->getParent());
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
 
   Type *RetType = CI->getType();
 
   B.SetInsertPoint(CI);
   BasicBlock *InitialBB = B.GetInsertBlock();
   Value *Str1FirstCharacterValue =
       B.CreateZExt(B.CreateLoad(B.getInt8Ty(), NonConstantP), RetType);
   Value *Str2FirstCharacterValue =
       ConstantInt::get(RetType, static_cast<unsigned char>(ConstantStr[0]));
   Value *FirstCharacterSub =
       B.CreateNSWSub(Str1FirstCharacterValue, Str2FirstCharacterValue);
   Value *IsFirstCharacterSubZero =
       B.CreateICmpEQ(FirstCharacterSub, ConstantInt::get(RetType, 0));
   Instruction *IsFirstCharacterSubZeroBBTerminator = SplitBlockAndInsertIfThen(
       IsFirstCharacterSubZero, CI, /*Unreachable*/ false,
       /*BranchWeights*/ nullptr, &DTU);
 
+  BasicBlock *StrcmpExpandSubJoinBB = CI->getParent();
+
   B.SetInsertPoint(IsFirstCharacterSubZeroBBTerminator);
   B.GetInsertBlock()->setName("strcmp_expand_sub_is_zero");
   BasicBlock *IsFirstCharacterSubZeroBB = B.GetInsertBlock();
   Value *Str1SecondCharacterValue = B.CreateZExt(
       B.CreateLoad(B.getInt8Ty(), B.CreateConstInBoundsGEP1_64(
                                       B.getInt8Ty(), NonConstantP, 1)),
       RetType);
+  Value *IsFirstCharacterSubZeroResult = Str1SecondCharacterValue;
+
+  bool TwoCharacterConstantStr = ConstantStr.size() == 2;
+  BasicBlock *IsSecondCharacterSubZeroBB = nullptr;
+  Value *Str1ThirdCharacterValue = nullptr;
+
+  if (TwoCharacterConstantStr) {
+    Value *Str2SecondCharacterValue =
+        ConstantInt::get(RetType, static_cast<unsigned char>(ConstantStr[1]));
+    Value *SecondCharacterSub =
+        B.CreateNSWSub(Str1SecondCharacterValue, Str2SecondCharacterValue);
+    IsFirstCharacterSubZeroResult = SecondCharacterSub;
+    Value *IsSecondCharacterSubZero =
+        B.CreateICmpEQ(SecondCharacterSub, ConstantInt::get(RetType, 0));
+    IsSecondCharacterSubZeroBB =
+        BasicBlock::Create(B.getContext(), "strcmp_expand_sub_is_zero",
+                           InitialBB->getParent(), StrcmpExpandSubJoinBB);
+
+    B.CreateCondBr(IsSecondCharacterSubZero, IsSecondCharacterSubZeroBB,
+                   StrcmpExpandSubJoinBB);
+    IsFirstCharacterSubZeroBBTerminator->eraseFromParent();
+
+    B.SetInsertPoint(IsSecondCharacterSubZeroBB);
+    Str1ThirdCharacterValue = B.CreateZExt(
+        B.CreateLoad(B.getInt8Ty(), B.CreateConstInBoundsGEP1_64(
+                                        B.getInt8Ty(), NonConstantP, 2)),
+        RetType);
+    B.CreateBr(StrcmpExpandSubJoinBB);
+
+    DTU.applyUpdates({{DominatorTree::Insert, IsSecondCharacterSubZeroBB,
+                       StrcmpExpandSubJoinBB}});
+  }
 
   B.SetInsertPoint(CI);
-  B.GetInsertBlock()->setName("strcmp_expand_sub_join");
+  StrcmpExpandSubJoinBB->setName("strcmp_expand_sub_join");
 
-  PHINode *Result = B.CreatePHI(RetType, 2);
+  PHINode *Result = B.CreatePHI(RetType, 2 + TwoCharacterConstantStr);
   Result->addIncoming(FirstCharacterSub, InitialBB);
-  Result->addIncoming(Str1SecondCharacterValue, IsFirstCharacterSubZeroBB);
+  Result->addIncoming(IsFirstCharacterSubZeroResult, IsFirstCharacterSubZeroBB);
+
+  if (TwoCharacterConstantStr)
+    Result->addIncoming(Str1ThirdCharacterValue, IsSecondCharacterSubZeroBB);
 
   CI->replaceAllUsesWith(Result);
   CI->eraseFromParent();
 
   MadeCFGChange = true;
 
   return true;
 }
 
 static bool foldLibraryCalls(Instruction &I, TargetTransformInfo &TTI,
                              TargetLibraryInfo &TLI, DominatorTree &DT,
                              AssumptionCache &AC, bool &MadeCFGChange) {
   CallInst *CI = dyn_cast<CallInst>(&I);
   if (!CI)
     return false;
 
   LibFunc Func;
   Module *M = I.getModule();
   if (!TLI.getLibFunc(*CI, Func) || !isLibFuncEmittable(M, &TLI, Func))
     return false;
 
   switch (Func) {
   case LibFunc_sqrt:
   case LibFunc_sqrtf:

llvm/test/Transforms/AggressiveInstCombine/strcmp.ll

 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s1)
   ret i32 %call
 }
 
 define i1 @expand_strcmp_eq_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_eq_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_ne_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_ne_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp ne i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_sgt_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_sgt_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp sgt i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_sge_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_sge_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp sge i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_slt_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_slt_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp slt i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_sle_s2(ptr %C) {
 ; CHECK-LABEL: @expand_strcmp_sle_s2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr [[C:%.*]], ptr @s2)
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[CALL]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[C:%.*]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = zext i8 [[TMP1]] to i32
+; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i32 [[TMP2]], 48
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[TMP3]], 0
+; CHECK-NEXT:    br i1 [[TMP4]], label [[STRCMP_EXPAND_SUB_IS_ZERO:%.*]], label [[STRCMP_EXPAND_SUB_JOIN:%.*]]
+; CHECK:       strcmp_expand_sub_is_zero:
+; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, ptr [[TMP5]], align 1
+; CHECK-NEXT:    [[TMP7:%.*]] = zext i8 [[TMP6]] to i32
+; CHECK-NEXT:    [[TMP8:%.*]] = sub nsw i32 [[TMP7]], 49
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
+; CHECK-NEXT:    br i1 [[TMP9]], label [[STRCMP_EXPAND_SUB_IS_ZERO1:%.*]], label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_is_zero1:
+; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[C]], i64 2
+; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[TMP10]], align 1
+; CHECK-NEXT:    [[TMP12:%.*]] = zext i8 [[TMP11]] to i32
+; CHECK-NEXT:    br label [[STRCMP_EXPAND_SUB_JOIN]]
+; CHECK:       strcmp_expand_sub_join:
+; CHECK-NEXT:    [[TMP13:%.*]] = phi i32 [ [[TMP3]], [[TMP0:%.*]] ], [ [[TMP8]], [[STRCMP_EXPAND_SUB_IS_ZERO]] ], [ [[TMP12]], [[STRCMP_EXPAND_SUB_IS_ZERO1]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[TMP13]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @strcmp(ptr %C, ptr @s2)
   %cmp = icmp sle i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @expand_strcmp_s3(ptr %C) {