[InstCombine] Expand strcmp(s, "x") to memcmp

[xbolva00]

Summary

strcmp(s, y) -> memcmp(s,y,2) where y is string with single char, e.g. "x")

[efriedma]

This is not correct: consider, for example, strcmp("xx", "x").

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

Ah yes, sure. I updated patch to compare two chars

[efriedma]

Oh, okay, that makes more sense.

Unfortunately, this transform is still illegal: if the unknown operand is the empty string, memcmp can read past the end of the string, which is undefined behavior (and may crash in practice).

[xbolva00]

In D50019#1181301, @efriedma wrote:

Oh, okay, that makes more sense.

Unfortunately, this transform is still illegal: if the unknown operand is the empty string, memcmp can read past the end of the string, which is undefined behavior (and may crash in practice).

Ah yes :/ I wanted to do similar transformation as GCC does. But with memcmp this is not possible.

[efriedma]

If you want to expand strcmp inline, probably the best way to do that is to extend the existing ExpandMemCmpPass pass.

[xbolva00]

What about

char buf[10];
if (strcmp(buf, "key") eq / ne 0)

?

We can promote it to memcmp now, no?

[efriedma]

Not sure how often that shows up, but yes, if you can prove the the pointer is dereferenceable, it's okay to transform to memcmp.

[xbolva00]

In D50019#1183062, @efriedma wrote:

Not sure how often that shows up, but yes, if you can prove the the pointer is dereferenceable, it's okay to transform to memcmp.

It is not so rare, I see it in many code bases.

Motivating example;
https://searchcode.com/file/71153892/src/resmom/linux/mom_mach.c

lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilder<> &B) {
   uint64_t Len2 = GetStringLength(Str2P);
   if (Len1 && Len2) {
     return emitMemCmp(Str1P, Str2P,
                       ConstantInt::get(DL.getIntPtrType(CI->getContext()),
                                        std::min(Len1, Len2)),
                       B, DL, TLI);
   }
 
+  // strcmp("x", x) -> *x == 'x'
+  if ((HasStr1 && Str1.size() == 1) || (HasStr2 && Str2.size() == 1))
+    return emitMemCmp(Str1P, Str2P,
+                      ConstantInt::get(DL.getIntPtrType(CI->getContext()), 2),
+                      B, DL, TLI);
+
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
   Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
   if (Str1P == Str2P) // strncmp(x,x,n)  -> 0
     return ConstantInt::get(CI->getType(), 0);
 

test/Transforms/InstCombine/strcmp-1.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the strcmp library call simplifier works correctly.
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
 @hello = constant [6 x i8] c"hello\00"
 @hell = constant [5 x i8] c"hell\00"
 @bell = constant [5 x i8] c"bell\00"
+@str_single_char = constant [2 x i8] c".\00"
 @null = constant [1 x i8] zeroinitializer
 
 declare i32 @strcmp(i8*, i8*)
 
 ; strcmp("", x) -> -*x
 define i32 @test1(i8* %str2) {
 ; CHECK-LABEL: @test1(
-; CHECK: %strcmpload = load i8, i8* %str
-; CHECK: %1 = zext i8 %strcmpload to i32
-; CHECK: %2 = sub nsw i32 0, %1
-; CHECK: ret i32 %2
+; CHECK-NEXT:    [[STRCMPLOAD:%.*]] = load i8, i8* [[STR2:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i8 [[STRCMPLOAD]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = sub nsw i32 0, [[TMP1]]
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
 
   %str1 = getelementptr inbounds [1 x i8], [1 x i8]* @null, i32 0, i32 0
   %temp1 = call i32 @strcmp(i8* %str1, i8* %str2)
   ret i32 %temp1
 
 }
 
 ; strcmp(x, "") -> *x
 define i32 @test2(i8* %str1) {
 ; CHECK-LABEL: @test2(
-; CHECK: %strcmpload = load i8, i8* %str
-; CHECK: %1 = zext i8 %strcmpload to i32
-; CHECK: ret i32 %1
+; CHECK-NEXT:    [[STRCMPLOAD:%.*]] = load i8, i8* [[STR1:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i8 [[STRCMPLOAD]] to i32
+; CHECK-NEXT:    ret i32 [[TMP1]]
+;
 
   %str2 = getelementptr inbounds [1 x i8], [1 x i8]* @null, i32 0, i32 0
   %temp1 = call i32 @strcmp(i8* %str1, i8* %str2)
   ret i32 %temp1
 }
 
 ; strcmp(x, y)  -> cnst
 define i32 @test3() {
 ; CHECK-LABEL: @test3(
-; CHECK: ret i32 -1
+; CHECK-NEXT:    ret i32 -1
+;
 
   %str1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %str2 = getelementptr inbounds [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   %temp1 = call i32 @strcmp(i8* %str1, i8* %str2)
   ret i32 %temp1
 }
 
 define i32 @test4() {
 ; CHECK-LABEL: @test4(
-; CHECK: ret i32 1
+; CHECK-NEXT:    ret i32 1
+;
 
   %str1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %str2 = getelementptr inbounds [1 x i8], [1 x i8]* @null, i32 0, i32 0
   %temp1 = call i32 @strcmp(i8* %str1, i8* %str2)
   ret i32 %temp1
 }
 
 ; strcmp(x, y)   -> memcmp(x, y, <known length>)
 ; (This transform is rather difficult to trigger in a useful manner)
 define i32 @test5(i1 %b) {
 ; CHECK-LABEL: @test5(
-; CHECK: %memcmp = call i32 @memcmp(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* %str2, i32 5)
-; CHECK: ret i32 %memcmp
+; CHECK-NEXT:    [[STR2:%.*]] = select i1 [[B:%.*]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @hell, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @bell, i32 0, i32 0)
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* [[STR2]], i32 5)
+; CHECK-NEXT:    ret i32 [[MEMCMP]]
+;
 
   %str1 = getelementptr inbounds [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   %temp1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %temp2 = getelementptr inbounds [5 x i8], [5 x i8]* @bell, i32 0, i32 0
   %str2 = select i1 %b, i8* %temp1, i8* %temp2
   %temp3 = call i32 @strcmp(i8* %str1, i8* %str2)
   ret i32 %temp3
 }
 
 ; strcmp(x,x)  -> 0
 define i32 @test6(i8* %str) {
 ; CHECK-LABEL: @test6(
-; CHECK: ret i32 0
+; CHECK-NEXT:    ret i32 0
+;
 
   %temp1 = call i32 @strcmp(i8* %str, i8* %str)
   ret i32 %temp1
 }
+
+; strcmp(x,"x")  -> *x == 'x'
+define i32 @compare_single_char(i8* %s) {
+; CHECK-LABEL: @compare_single_char(
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[S:%.*]], i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str_single_char, i32 0, i32 0), i32 2)
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
+; CHECK-NEXT:    ret i32 [[CONV]]
+;
+  %call = tail call i32 @strcmp(i8* %s, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str_single_char, i64 0, i64 0)) #2
+  %cmp = icmp eq i32 %call, 0
+  %conv = zext i1 %cmp to i32
+  ret i32 %conv
+}
+
+; strcmp("x", x)  -> *x == 'x'
+define i32 @compare_single_char_rev(i8* %s) {
+; CHECK-LABEL: @compare_single_char_rev(
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str_single_char, i32 0, i32 0), i8* [[S:%.*]], i32 2)
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
+; CHECK-NEXT:    ret i32 [[CONV]]
+;
+  %call = tail call i32 @strcmp(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str_single_char, i64 0, i64 0), i8* %s) #2
+  %cmp = icmp eq i32 %call, 0
+  %conv = zext i1 %cmp to i32
+  ret i32 %conv
+}