; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
;
; Test that strncpy(D, S, N) calls with the empty string S as a source
; are simplified for all values of N.
;
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare ptr @strncpy(ptr, ptr, i64)
; A string of length 4 but size 9 to also verify that characters after
; the nul don't affect the transformation.
@s4 = constant [9 x i8] c"1234\00567\00"
declare void @sink(ptr, ptr)
; Verify that exactly overlapping strncpy(D, D, N) calls are simplified
; only when N < 2.
define void @fold_strncpy_overlap(ptr %dst, i64 %n) {
; CHECK-LABEL: @fold_strncpy_overlap(
; CHECK-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[DST]])
; CHECK-NEXT: ret void
;
; Fold strncpy(D, D, 0) to D.
%ed_0 = call ptr @strncpy(ptr %dst, ptr %dst, i64 0)
call void @sink(ptr %dst, ptr %ed_0)
; Fold strncpy(D, D, 1) to D.
%ed_1 = call ptr @strncpy(ptr %dst, ptr %dst, i64 1)
call void @sink(ptr %dst, ptr %ed_1)
ret void
}
; Verify that exactly overlapping strncpy(D, D, N) calls are left alone
; when N >= 2.
; Such calls are undefined and although they're benign and could be
; simplified to
; memset(D + strnlen(D, N), D, N - strnlen(D, N))
; there is little to gain from it.
define void @call_strncpy_overlap(ptr %dst, i64 %n) {
; CHECK-LABEL: @call_strncpy_overlap(
; CHECK-NEXT: [[ED_2:%.*]] = call ptr @strncpy(ptr noundef nonnull dereferenceable(1) [[DST:%.*]], ptr noundef nonnull dereferenceable(1) [[DST]], i64 2)
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_2]])
; CHECK-NEXT: [[ED_3:%.*]] = call ptr @strncpy(ptr noundef nonnull dereferenceable(1) [[DST]], ptr noundef nonnull dereferenceable(1) [[DST]], i64 3)
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_3]])
; CHECK-NEXT: [[ED_N:%.*]] = call ptr @strncpy(ptr [[DST]], ptr [[DST]], i64 [[N:%.*]])
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_N]])
; CHECK-NEXT: ret void
;
; Do not transform strncpy(D, D, 2).
%ed_2 = call ptr @strncpy(ptr %dst, ptr %dst, i64 2)
call void @sink(ptr %dst, ptr %ed_2)
; Do not transform strncpy(D, D, 3).
%ed_3 = call ptr @strncpy(ptr %dst, ptr %dst, i64 3)
call void @sink(ptr %dst, ptr %ed_3)
; Do not transform strncpy(D, D, N).
%ed_n = call ptr @strncpy(ptr %dst, ptr %dst, i64 %n)
call void @sink(ptr %dst, ptr %ed_n)
ret void
}
; Verify that strncpy(D, "", N) calls are transformed to memset(D, 0, N).
define void @fold_strncpy_s0(ptr %dst, i64 %n) {
; CHECK-LABEL: @fold_strncpy_s0(
; CHECK-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; CHECK-NEXT: store i8 0, ptr [[DST]], align 1
; CHECK-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[DST]])
; CHECK-NEXT: store i16 0, ptr [[DST]], align 1
; CHECK-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[DST]])
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], i8 0, i64 9, i1 false)
; CHECK-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[DST]])
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr nonnull align 1 [[DST]], i8 0, i64 [[N:%.*]], i1 false)
; CHECK-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[DST]])
; CHECK-NEXT: ret void
;
%ps0 = getelementptr [9 x i8], ptr @s4, i32 0, i32 4
; Fold strncpy(D, "", 0) to just D.
%es0_0 = call ptr @strncpy(ptr %dst, ptr %ps0, i64 0)
call void @sink(ptr %dst, ptr %es0_0)
; Transform strncpy(D, "", 1) to *D = '\0, D.
%es0_1 = call ptr @strncpy(ptr %dst, ptr %ps0, i64 1)
call void @sink(ptr %dst, ptr %es0_1)
; Transform strncpy(D, "", 2) to memset(D, 0, 2), D.
%es0_2 = call ptr @strncpy(ptr %dst, ptr %ps0, i64 2)
call void @sink(ptr %dst, ptr %es0_2)
; Transform strncpy(D, "", 9) to memset(D, 0, 9), D.
%es0_9 = call ptr @strncpy(ptr %dst, ptr %ps0, i64 9)
call void @sink(ptr %dst, ptr %es0_9)
; Transform strncpy(D, "", n) to memset(D, 0, n), D.
%es0_n = call ptr @strncpy(ptr %dst, ptr %ps0, i64 %n)
call void @sink(ptr %dst, ptr %es0_n)
ret void
}
; Verify that strncpy(D, S, N) calls with nonconstant source S and constant
; size are simplified when N < 2.
define void @fold_strncpy_s(ptr %dst, ptr %src, i64 %n) {
; CHECK-LABEL: @fold_strncpy_s(
; CHECK-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; CHECK-NEXT: [[STXNCPY_CHAR0:%.*]] = load i8, ptr [[SRC:%.*]], align 1
; CHECK-NEXT: store i8 [[STXNCPY_CHAR0]], ptr [[DST]], align 1
; CHECK-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[DST]])
; CHECK-NEXT: ret void
;
; Fold strncpy(D, S, 0) to just D.
%ed_0 = call ptr @strncpy(ptr %dst, ptr %src, i64 0)
call void @sink(ptr %dst, ptr %ed_0)
; Transform strncpy(D, S, 1) to *D = '\0, D.
%ed_1 = call ptr @strncpy(ptr %dst, ptr %src, i64 1)
call void @sink(ptr %dst, ptr %ed_1)
ret void
}
; Verify that strncpy(D, S, N) calls with nonconstant source S and constant
; size are not transformed when N is either unknown or greater than one.
; Also verify that the arguments of the call are annotated with the right
; attributes.
define void @call_strncpy_s(ptr %dst, ptr %src, i64 %n) {
; CHECK-LABEL: @call_strncpy_s(
; CHECK-NEXT: [[ED_2:%.*]] = call ptr @strncpy(ptr noundef nonnull dereferenceable(1) [[DST:%.*]], ptr noundef nonnull dereferenceable(1) [[SRC:%.*]], i64 2)
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_2]])
; CHECK-NEXT: [[ED_9:%.*]] = call ptr @strncpy(ptr noundef nonnull dereferenceable(1) [[DST]], ptr noundef nonnull dereferenceable(1) [[SRC]], i64 9)
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_9]])
; CHECK-NEXT: [[ED_N:%.*]] = call ptr @strncpy(ptr [[DST]], ptr [[SRC]], i64 [[N:%.*]])
; CHECK-NEXT: call void @sink(ptr [[DST]], ptr [[ED_N]])
; CHECK-NEXT: ret void
;
; Do not transform strncpy(D, S, 2) when S is unknown. Both *D and *S must
; be derefernceable but neither D[1] nor S[1] need be.
%ed_2 = call ptr @strncpy(ptr %dst, ptr %src, i64 2)
call void @sink(ptr %dst, ptr %ed_2)
; Do not transform strncpy(D, S, 9) when S is unknown..
%ed_9 = call ptr @strncpy(ptr %dst, ptr %src, i64 9)
call void @sink(ptr %dst, ptr %ed_9)
; Do not transform strncpy(D, S, N) when all arguments are unknown. Both
; D and S must be nonnull but neither *D nor *S need be dereferenceable.
; TODO: Both D and S should be annotated nonnull and noundef regardless
; of the value of N. See https://reviews.llvm.org/D124633.
%ed_n = call ptr @strncpy(ptr %dst, ptr %src, i64 %n)
call void @sink(ptr %dst, ptr %ed_n)
ret void
}
Codebase Browser
llvm