xref: /llvm-project/llvm/test/Transforms/InstCombine/memset-1.ll (revision 635f93dff7f07a58af4e8a7c915dfdb1852bb76b)
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2; Test that the memset library call simplifier works correctly.
3;
4; RUN: opt < %s -passes=instcombine -S | FileCheck %s
5
6target 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"
7
8declare ptr @memset(ptr, i32, i32)
9declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i32, i1)
10declare noalias ptr @malloc(i32) #1
11
12; Check memset(mem1, val, size) -> llvm.memset(mem1, val, size, 1).
13
14define ptr @test_simplify1(ptr %mem, i32 %val, i32 %size) {
15; CHECK-LABEL: @test_simplify1(
16; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
17; CHECK-NEXT:    call void @llvm.memset.p0.i32(ptr align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
18; CHECK-NEXT:    ret ptr [[MEM]]
19;
20  %ret = call ptr @memset(ptr %mem, i32 %val, i32 %size)
21  ret ptr %ret
22}
23
24define ptr @test_simplify1_tail(ptr %mem, i32 %val, i32 %size) {
25; CHECK-LABEL: @test_simplify1_tail(
26; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
27; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
28; CHECK-NEXT:    ret ptr [[MEM]]
29;
30  %ret = tail call ptr @memset(ptr %mem, i32 %val, i32 %size)
31  ret ptr %ret
32}
33
34define ptr @test_simplify1_musttail(ptr %mem, i32 %val, i32 %size) {
35; CHECK-LABEL: @test_simplify1_musttail(
36; CHECK-NEXT:    [[RET:%.*]] = musttail call ptr @memset(ptr [[MEM:%.*]], i32 [[VAL:%.*]], i32 [[SIZE:%.*]])
37; CHECK-NEXT:    ret ptr [[RET]]
38;
39  %ret = musttail call ptr @memset(ptr %mem, i32 %val, i32 %size)
40  ret ptr %ret
41}
42
43; Malloc + memset pattern is now handled by DSE in a more general way.
44
45define ptr @pr25892_lite(i32 %size) #0 {
46; CHECK-LABEL: @pr25892_lite(
47; CHECK-NEXT:    [[CALL1:%.*]] = call ptr @malloc(i32 [[SIZE:%.*]]) #[[ATTR0:[0-9]+]]
48; CHECK-NEXT:    call void @llvm.memset.p0.i32(ptr align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
49; CHECK-NEXT:    ret ptr [[CALL1]]
50;
51  %call1 = call ptr @malloc(i32 %size) #1
52  %call2 = call ptr @memset(ptr %call1, i32 0, i32 %size) #1
53  ret ptr %call2
54}
55
56; A memset intrinsic should be handled similarly to a memset() libcall.
57; Notice that malloc + memset pattern is now handled by DSE in a more general way.
58
59define ptr @malloc_and_memset_intrinsic(i32 %n) #0 {
60; CHECK-LABEL: @malloc_and_memset_intrinsic(
61; CHECK-NEXT:    [[CALL:%.*]] = call ptr @malloc(i32 [[N:%.*]])
62; CHECK-NEXT:    call void @llvm.memset.p0.i32(ptr align 1 [[CALL]], i8 0, i32 [[N]], i1 false)
63; CHECK-NEXT:    ret ptr [[CALL]]
64;
65  %call = call ptr @malloc(i32 %n)
66  call void @llvm.memset.p0.i32(ptr %call, i8 0, i32 %n, i32 1, i1 false)
67  ret ptr %call
68}
69
70; This should not create a calloc and should not crash the compiler.
71; Notice that malloc + memset pattern is now handled by DSE in a more general way.
72
73define ptr @notmalloc_memset(i32 %size, ptr %notmalloc) {
74; CHECK-LABEL: @notmalloc_memset(
75; CHECK-NEXT:    [[CALL1:%.*]] = call ptr [[NOTMALLOC:%.*]](i32 [[SIZE:%.*]]) #[[ATTR0]]
76; CHECK-NEXT:    call void @llvm.memset.p0.i32(ptr align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
77; CHECK-NEXT:    ret ptr [[CALL1]]
78;
79  %call1 = call ptr %notmalloc(i32 %size) #1
80  %call2 = call ptr @memset(ptr %call1, i32 0, i32 %size) #1
81  ret ptr %call2
82}
83
84; This doesn't fire currently because the malloc has more than one use.
85; Notice that malloc + memset pattern is now handled by DSE in a more general way.
86
87define ptr @pr25892(i32 %size) #0 {
88; CHECK-LABEL: @pr25892(
89; CHECK-NEXT:  entry:
90; CHECK-NEXT:    [[CALL:%.*]] = tail call ptr @malloc(i32 [[SIZE:%.*]]) #[[ATTR0]]
91; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[CALL]], null
92; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
93; CHECK:       if.end:
94; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr nonnull align 1 [[CALL]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
95; CHECK-NEXT:    br label [[CLEANUP]]
96; CHECK:       cleanup:
97; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL]], [[IF_END]] ], [ null, [[ENTRY:%.*]] ]
98; CHECK-NEXT:    ret ptr [[RETVAL_0]]
99;
100entry:
101  %call = tail call ptr @malloc(i32 %size) #1
102  %cmp = icmp eq ptr %call, null
103  br i1 %cmp, label %cleanup, label %if.end
104if.end:
105  %call2 = tail call ptr @memset(ptr nonnull %call, i32 0, i32 %size) #1
106  br label %cleanup
107cleanup:
108  %retval.0 = phi ptr [ %call, %if.end ], [ null, %entry ]
109  ret ptr %retval.0
110}
111
112; If there's a calloc transform, the store must also be eliminated.
113
114define ptr @buffer_is_modified_then_memset(i32 %size) {
115; CHECK-LABEL: @buffer_is_modified_then_memset(
116; CHECK-NEXT:    [[PTR:%.*]] = tail call ptr @malloc(i32 [[SIZE:%.*]]) #[[ATTR0]]
117; CHECK-NEXT:    store i8 1, ptr [[PTR]], align 1
118; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr nonnull align 1 [[PTR]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
119; CHECK-NEXT:    ret ptr [[PTR]]
120;
121  %ptr = tail call ptr @malloc(i32 %size) #1
122  store i8 1, ptr %ptr           ;; fdata[0] = 1;
123  %memset = tail call ptr @memset(ptr nonnull %ptr, i32 0, i32 %size) #1
124  ret ptr %memset
125}
126
127define ptr @memset_size_select(i1 %b, ptr %ptr) {
128; CHECK-LABEL: @memset_size_select(
129; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
130; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr noundef nonnull align 1 dereferenceable(10) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
131; CHECK-NEXT:    ret ptr [[PTR]]
132;
133  %size = select i1 %b, i32 10, i32 50
134  %memset = tail call ptr @memset(ptr nonnull %ptr, i32 0, i32 %size) #1
135  ret ptr %memset
136}
137
138
139define ptr @memset_size_select2(i1 %b, ptr %ptr) {
140; CHECK-LABEL: @memset_size_select2(
141; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
142; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr noundef nonnull align 1 dereferenceable(80) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
143; CHECK-NEXT:    ret ptr [[PTR]]
144;
145  %size = select i1 %b, i32 10, i32 50
146  %memset = tail call ptr @memset(ptr nonnull dereferenceable(80) %ptr, i32 0, i32 %size) #1
147  ret ptr %memset
148}
149
150define ptr @memset_size_select3(i1 %b, ptr %ptr) {
151; CHECK-LABEL: @memset_size_select3(
152; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
153; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false)
154; CHECK-NEXT:    ret ptr [[PTR]]
155;
156  %size = select i1 %b, i32 10, i32 50
157  %memset = tail call ptr @memset(ptr dereferenceable_or_null(40) %ptr, i32 0, i32 %size)
158  ret ptr %memset
159}
160
161define ptr @memset_size_select4(i1 %b, ptr %ptr) {
162; CHECK-LABEL: @memset_size_select4(
163; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
164; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
165; CHECK-NEXT:    ret ptr [[PTR]]
166;
167  %size = select i1 %b, i32 10, i32 50
168  %memset = tail call ptr @memset(ptr nonnull dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
169  ret ptr %memset
170}
171
172define ptr @memset_size_ashr(i1 %b, ptr %ptr, i32 %v) {
173; CHECK-LABEL: @memset_size_ashr(
174; CHECK-NEXT:    [[SIZE:%.*]] = ashr i32 -2, [[V:%.*]]
175; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr noundef nonnull align 1 dereferenceable(1) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
176; CHECK-NEXT:    ret ptr [[PTR]]
177;
178  %size = ashr i32 -2, %v
179  %memset = tail call ptr @memset(ptr nonnull %ptr, i32 0, i32 %size) #1
180  ret ptr %memset
181}
182
183define ptr @memset_attrs1(i1 %b, ptr %ptr, i32 %size) {
184; CHECK-LABEL: @memset_attrs1(
185; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
186; CHECK-NEXT:    ret ptr [[PTR]]
187;
188  %memset = tail call ptr @memset(ptr dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
189  ret ptr %memset
190}
191
192; be sure to drop nonnull since size is unknown and can be 0
193; do not change dereferenceable attribute
194define ptr @memset_attrs2(i1 %b, ptr %ptr, i32 %size) {
195; CHECK-LABEL: @memset_attrs2(
196; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
197; CHECK-NEXT:    ret ptr [[PTR]]
198;
199  %memset = tail call ptr @memset(ptr nonnull dereferenceable(40) %ptr, i32 0, i32 %size) #1
200  ret ptr %memset
201}
202
203; size is unknown, just copy attrs, no changes in attrs
204define ptr @memset_attrs3(i1 %b, ptr %ptr, i32 %size) {
205; CHECK-LABEL: @memset_attrs3(
206; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr nonnull align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
207; CHECK-NEXT:    ret ptr [[PTR]]
208;
209  %memset = tail call ptr @memset(ptr nonnull dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
210  ret ptr %memset
211}
212
213; be sure to drop nonnull since size is unknown and can be 0
214define ptr @memset_attrs4(i1 %b, ptr %ptr, i32 %size) {
215; CHECK-LABEL: @memset_attrs4(
216; CHECK-NEXT:    tail call void @llvm.memset.p0.i32(ptr nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
217; CHECK-NEXT:    ret ptr [[PTR]]
218;
219  %memset = tail call ptr @memset(ptr nonnull %ptr, i32 0, i32 %size) #1
220  ret ptr %memset
221}
222
223define ptr @test_no_incompatible_attr(ptr %mem, i32 %val, i32 %size) {
224; CHECK-LABEL: @test_no_incompatible_attr(
225; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
226; CHECK-NEXT:    call void @llvm.memset.p0.i32(ptr align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
227; CHECK-NEXT:    ret ptr [[MEM]]
228;
229  %ret = call dereferenceable(1) ptr @memset(ptr %mem, i32 %val, i32 %size)
230  ret ptr %ret
231}
232
233attributes #0 = { nounwind ssp uwtable }
234attributes #1 = { nounwind }
235attributes #2 = { nounwind readnone }
236
237