This is an archive of the discontinued LLVM Phabricator instance.

Differential D89634

[Tests] Added tests for D88328
AbandonedPublic

Authored by xbolva00 on Oct 17 2020, 2:18 PM.

Details

Reviewers
fhahn

Diff Detail

Event Timeline

xbolva00 created this revision.Oct 17 2020, 2:18 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 17 2020, 2:18 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
xbolva00 requested review of this revision.Oct 17 2020, 2:18 PM
xbolva00 abandoned this revision.Oct 17 2020, 2:28 PM

Revision Contents

PathSize
llvm/
test/
Transforms/
DeadStoreElimination/
MSSA/
102 lines

Diff 298852

llvm/test/Transforms/DeadStoreElimination/MSSA/libcalls.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -inferattrs -basic-aa -dse < %s | FileCheck %s ; RUN: opt -S -basic-aa -dse < %s | FileCheck %s --check-prefixes=CHECK,LPM
; RUN: opt -S -aa-pipeline=basic-aa -passes=inferattrs,dse < %s | FileCheck %s --check-prefixes=CHECK,NPM
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare i8* @strcpy(i8* %dest, i8* %src) nounwind declare i8* @strcpy(i8* %dest, i8* %src) nounwind
define void @test1(i8* %src) { define void @test1(i8* %src) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
Show All 32 Lines
; ;
%B = alloca [16 x i8] %B = alloca [16 x i8]
%dest = getelementptr inbounds [16 x i8], [16 x i8]* %B, i64 0, i64 0 %dest = getelementptr inbounds [16 x i8], [16 x i8]* %B, i64 0, i64 0
%call = call i8* @strncat(i8* %dest, i8* %src, i64 12) %call = call i8* @strncat(i8* %dest, i8* %src, i64 12)
ret void ret void
} }
define void @test5(i8* nocapture %src) { define void @test5(i8* nocapture %src) {
; CHECK-LABEL: @test5( ; LPM-LABEL: @test5(
; CHECK-NEXT: ret void ; LPM-NEXT: [[DEST:%.*]] = alloca [100 x i8], align 16
; LPM-NEXT: [[ARRAYDECAY:%.*]] = getelementptr inbounds [100 x i8], [100 x i8]* [[DEST]], i64 0, i64 0
; LPM-NEXT: [[CALL:%.*]] = call i8* @strcpy(i8* [[ARRAYDECAY]], i8* [[SRC:%.*]])
; LPM-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 10
; LPM-NEXT: store i8 97, i8* [[ARRAYIDX]], align 1
; LPM-NEXT: ret void
;
; NPM-LABEL: @test5(
; NPM-NEXT: ret void
; ;
%dest = alloca [100 x i8], align 16 %dest = alloca [100 x i8], align 16
%arraydecay = getelementptr inbounds [100 x i8], [100 x i8]* %dest, i64 0, i64 0 %arraydecay = getelementptr inbounds [100 x i8], [100 x i8]* %dest, i64 0, i64 0
%call = call i8* @strcpy(i8* %arraydecay, i8* %src) %call = call i8* @strcpy(i8* %arraydecay, i8* %src)
%arrayidx = getelementptr inbounds i8, i8* %call, i64 10 %arrayidx = getelementptr inbounds i8, i8* %call, i64 10
store i8 97, i8* %arrayidx, align 1 store i8 97, i8* %arrayidx, align 1
ret void ret void
} }
Show All 19 Lines
define i32 @test_memcmp_const_size(i8* noalias %foo) { define i32 @test_memcmp_const_size(i8* noalias %foo) {
; CHECK-LABEL: @test_memcmp_const_size( ; CHECK-LABEL: @test_memcmp_const_size(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8* ; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1 ; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1 ; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1 ; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
; CHECK-NEXT: store i8 51, i8* [[GEP_2]], align 1
; CHECK-NEXT: [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
; CHECK-NEXT: store i8 52, i8* [[GEP_3]], align 1
; CHECK-NEXT: [[RES:%.*]] = call i32 @memcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2) ; CHECK-NEXT: [[RES:%.*]] = call i32 @memcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2)
; CHECK-NEXT: ret i32 [[RES]] ; CHECK-NEXT: ret i32 [[RES]]
; ;
entry: entry:
%stack = alloca [10 x i8] %stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8* %stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1 store i8 49, i8* %stack.ptr, align 1
%gep.1 = getelementptr i8, i8* %stack.ptr, i64 1 %gep.1 = getelementptr i8, i8* %stack.ptr, i64 1
Show All 40 Lines
define i1 @test_bcmp_const_size(i8* noalias %foo) { define i1 @test_bcmp_const_size(i8* noalias %foo) {
; CHECK-LABEL: @test_bcmp_const_size( ; CHECK-LABEL: @test_bcmp_const_size(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8* ; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1 ; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1 ; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1 ; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
; CHECK-NEXT: store i8 51, i8* [[GEP_2]], align 1
; CHECK-NEXT: [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
; CHECK-NEXT: store i8 52, i8* [[GEP_3]], align 1
; CHECK-NEXT: [[CALL:%.*]] = call i32 @bcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2) ; CHECK-NEXT: [[CALL:%.*]] = call i32 @bcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2)
; CHECK-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 0 ; CHECK-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 0
; CHECK-NEXT: ret i1 [[RES]] ; CHECK-NEXT: ret i1 [[RES]]
; ;
entry: entry:
%stack = alloca [10 x i8] %stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8* %stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1 store i8 49, i8* %stack.ptr, align 1
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
define i8* @test_memchr_const_size() { define i8* @test_memchr_const_size() {
; CHECK-LABEL: @test_memchr_const_size( ; CHECK-LABEL: @test_memchr_const_size(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8* ; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1 ; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1 ; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1 ; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
; CHECK-NEXT: store i8 51, i8* [[GEP_2]], align 1
; CHECK-NEXT: [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
; CHECK-NEXT: store i8 52, i8* [[GEP_3]], align 1
; CHECK-NEXT: [[CALL:%.*]] = call i8* @memchr(i8* [[STACK_PTR]], i32 42, i64 2) ; CHECK-NEXT: [[CALL:%.*]] = call i8* @memchr(i8* [[STACK_PTR]], i32 42, i64 2)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
entry: entry:
%stack = alloca [10 x i8] %stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8* %stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1 store i8 49, i8* %stack.ptr, align 1
%gep.1 = getelementptr i8, i8* %stack.ptr, i64 1 %gep.1 = getelementptr i8, i8* %stack.ptr, i64 1
Show All 40 Lines
define i8* @test_memccpy_const_size(i8* %foo) { define i8* @test_memccpy_const_size(i8* %foo) {
; CHECK-LABEL: @test_memccpy_const_size( ; CHECK-LABEL: @test_memccpy_const_size(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8* ; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1 ; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1 ; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1 ; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
; CHECK-NEXT: store i8 51, i8* [[GEP_2]], align 1
; CHECK-NEXT: [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
; CHECK-NEXT: store i8 52, i8* [[GEP_3]], align 1
; CHECK-NEXT: [[RES:%.*]] = call i8* @memccpy(i8* [[FOO:%.*]], i8* [[STACK_PTR]], i32 42, i64 2) ; CHECK-NEXT: [[RES:%.*]] = call i8* @memccpy(i8* [[FOO:%.*]], i8* [[STACK_PTR]], i32 42, i64 2)
; CHECK-NEXT: ret i8* [[RES]] ; CHECK-NEXT: ret i8* [[RES]]
; ;
entry: entry:
%stack = alloca [10 x i8] %stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8* %stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1 store i8 49, i8* %stack.ptr, align 1
%gep.1 = getelementptr i8, i8* %stack.ptr, i64 1 %gep.1 = getelementptr i8, i8* %stack.ptr, i64 1
Show All 29 Linesentry:
store i8 50, i8* %gep.1, align 1 store i8 50, i8* %gep.1, align 1
%gep.2 = getelementptr i8, i8* %stack.ptr, i64 2 %gep.2 = getelementptr i8, i8* %stack.ptr, i64 2
store i8 51, i8* %gep.2, align 1 store i8 51, i8* %gep.2, align 1
%gep.3 = getelementptr i8, i8* %stack.ptr, i64 3 %gep.3 = getelementptr i8, i8* %stack.ptr, i64 3
store i8 52, i8* %gep.3, align 1 store i8 52, i8* %gep.3, align 1
%res = call i8* @memccpy(i8* %foo, i8* %stack.ptr, i32 42, i64 %n) %res = call i8* @memccpy(i8* %foo, i8* %stack.ptr, i32 42, i64 %n)
ret i8* %res ret i8* %res
} }
define void @dse_strcpy(i8* nocapture readonly %src) {
; CHECK-LABEL: @dse_strcpy(
; CHECK-NEXT: [[A:%.*]] = alloca [256 x i8], align 16
; CHECK-NEXT: [[BUF:%.*]] = getelementptr inbounds [256 x i8], [256 x i8]* [[A]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @strcpy(i8* nonnull [[BUF]], i8* nonnull dereferenceable(1) [[SRC:%.*]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: ret void
;
%a = alloca [256 x i8], align 16
%buf = getelementptr inbounds [256 x i8], [256 x i8]* %a, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull %buf)
call i8* @strcpy(i8* nonnull %buf, i8* nonnull dereferenceable(1) %src)
call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull %buf)
ret void
}
define void @dse_strncpy(i8* nocapture readonly %src) {
; CHECK-LABEL: @dse_strncpy(
; CHECK-NEXT: [[A:%.*]] = alloca [256 x i8], align 16
; CHECK-NEXT: [[BUF:%.*]] = getelementptr inbounds [256 x i8], [256 x i8]* [[A]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @strncpy(i8* nonnull [[BUF]], i8* nonnull dereferenceable(1) [[SRC:%.*]], i64 6)
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: ret void
;
%a = alloca [256 x i8], align 16
%buf = getelementptr inbounds [256 x i8], [256 x i8]* %a, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull %buf)
call i8* @strncpy(i8* nonnull %buf, i8* nonnull dereferenceable(1) %src, i64 6)
call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull %buf)
ret void
}
define void @dse_strcat(i8* nocapture readonly %src) {
; CHECK-LABEL: @dse_strcat(
; CHECK-NEXT: [[A:%.*]] = alloca [256 x i8], align 16
; CHECK-NEXT: [[BUF:%.*]] = getelementptr inbounds [256 x i8], [256 x i8]* [[A]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @strcat(i8* nonnull [[BUF]], i8* nonnull dereferenceable(1) [[SRC:%.*]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: ret void
;
%a = alloca [256 x i8], align 16
%buf = getelementptr inbounds [256 x i8], [256 x i8]* %a, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull %buf)
call i8* @strcat(i8* nonnull %buf, i8* nonnull dereferenceable(1) %src)
call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull %buf)
ret void
}
define void @dse_strncat(i8* nocapture readonly %src) {
; CHECK-LABEL: @dse_strncat(
; CHECK-NEXT: [[A:%.*]] = alloca [256 x i8], align 16
; CHECK-NEXT: [[BUF:%.*]] = getelementptr inbounds [256 x i8], [256 x i8]* [[A]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @strncat(i8* nonnull [[BUF]], i8* nonnull dereferenceable(1) [[SRC:%.*]], i64 6)
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull [[BUF]])
; CHECK-NEXT: ret void
;
%a = alloca [256 x i8], align 16
%buf = getelementptr inbounds [256 x i8], [256 x i8]* %a, i64 0, i64 0
call void @llvm.lifetime.start.p0i8(i64 256, i8* nonnull %buf)
call i8* @strncat(i8* nonnull %buf, i8* nonnull dereferenceable(1) %src, i64 6)
call void @llvm.lifetime.end.p0i8(i64 256, i8* nonnull %buf)
ret void
}
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)