mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 19:23:23 +01:00
facc0a564b
strchr("123!", C) != nullptr is a common pattern to check if C is one
of 1, 2, 3 or !. If the largest element of the string is smaller than
the target's register size we can easily create a bitfield and just
do a simple test for set membership.
int foo(char C) { return strchr("123!", C) != nullptr; } now becomes
cmpl $64, %edi ## range check
sbbb %al, %al
movabsq $0xE000200000001, %rcx
btq %rdi, %rcx ## bit test
sbbb %cl, %cl
andb %al, %cl ## and the two conditions
andb $1, %cl
movzbl %cl, %eax ## returning an int
ret
(imho the backend should expand this into a series of branches, but
that's a different story)
The code is currently limited to bit fields that fit in a register, so
usually 64 or 32 bits. Sadly, this misses anything using alpha chars
or {}. This could be fixed by just emitting a i128 bit field, but that
can generate really ugly code so we have to find a better way. To some
degree this is also recreating switch lowering logic, but we can't
simply emit a switch instruction and thus change the CFG within
instcombine.
llvm-svn: 232902
96 lines
2.9 KiB
LLVM
96 lines
2.9 KiB
LLVM
; Test that the strchr 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-n8:16:32"
|
|
|
|
@hello = constant [14 x i8] c"hello world\5Cn\00"
|
|
@null = constant [1 x i8] zeroinitializer
|
|
@newlines = constant [3 x i8] c"\0D\0A\00"
|
|
@chp = global i8* zeroinitializer
|
|
|
|
declare i8* @strchr(i8*, i32)
|
|
|
|
define void @test_simplify1() {
|
|
; CHECK: store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 6)
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: ret void
|
|
|
|
%str = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
|
|
%dst = call i8* @strchr(i8* %str, i32 119)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
define void @test_simplify2() {
|
|
; CHECK: store i8* null, i8** @chp, align 4
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: ret void
|
|
|
|
%str = getelementptr [1 x i8], [1 x i8]* @null, i32 0, i32 0
|
|
%dst = call i8* @strchr(i8* %str, i32 119)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
define void @test_simplify3() {
|
|
; CHECK: store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 13)
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: ret void
|
|
|
|
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
|
|
%dst = call i8* @strchr(i8* %src, i32 0)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
define void @test_simplify4(i32 %chr) {
|
|
; CHECK: call i8* @memchr
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: ret void
|
|
|
|
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
|
|
%dst = call i8* @strchr(i8* %src, i32 %chr)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
define void @test_simplify5() {
|
|
; CHECK: store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 13)
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: ret void
|
|
|
|
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
|
|
%dst = call i8* @strchr(i8* %src, i32 65280)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
; Check transformation strchr(p, 0) -> p + strlen(p)
|
|
define void @test_simplify6(i8* %str) {
|
|
; CHECK: %strlen = call i32 @strlen(i8* %str)
|
|
; CHECK-NOT: call i8* @strchr
|
|
; CHECK: %strchr = getelementptr i8, i8* %str, i32 %strlen
|
|
; CHECK: store i8* %strchr, i8** @chp, align 4
|
|
; CHECK: ret void
|
|
|
|
%dst = call i8* @strchr(i8* %str, i32 0)
|
|
store i8* %dst, i8** @chp
|
|
ret void
|
|
}
|
|
|
|
; Check transformation strchr("\r\n", C) != nullptr -> (C & 9217) != 0
|
|
define i1 @test_simplify7(i32 %C) {
|
|
; CHECK-LABEL: @test_simplify7
|
|
; CHECK-NEXT: [[TRUNC:%.*]] = trunc i32 %C to i16
|
|
; CHECK-NEXT: %memchr.bounds = icmp ult i16 [[TRUNC]], 16
|
|
; CHECK-NEXT: [[SHL:%.*]] = shl i16 1, [[TRUNC]]
|
|
; CHECK-NEXT: [[AND:%.*]] = and i16 [[SHL]], 9217
|
|
; CHECK-NEXT: %memchr.bits = icmp ne i16 [[AND]], 0
|
|
; CHECK-NEXT: %memchr1 = and i1 %memchr.bounds, %memchr.bits
|
|
; CHECK-NEXT: ret i1 %memchr1
|
|
|
|
%dst = call i8* @strchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @newlines, i64 0, i64 0), i32 %C)
|
|
%cmp = icmp ne i8* %dst, null
|
|
ret i1 %cmp
|
|
}
|