xref: /llvm-project/llvm/test/CodeGen/AArch64/memsize-remarks.ll (revision 5ddce70ef0e5a641d7fea95e31fc5e2439cb98cb) 
1; RUN: llc %s -pass-remarks-analysis=gisel-irtranslator-memsize -pass-remarks-output=%t.opt.yaml -pass-remarks-filter=gisel-irtranslator-memsize -global-isel -o /dev/null 2>&1 | FileCheck %s --check-prefix=GISEL --implicit-check-not=GISEL
2; RUN: cat %t.opt.yaml | FileCheck -check-prefix=YAML %s
3
4source_filename = "memsize.c"
5target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
6target triple = "arm64-apple-ios7.0.0"
7
8declare ptr @__memmove_chk(ptr, ptr, i64, i64) #1
9declare ptr @__memcpy_chk(ptr, ptr, i64, i64) #1
10declare ptr @__memset_chk(ptr, i32, i64, i64) #1
11declare i64 @llvm.objectsize.i64.p0(ptr, i1 immarg, i1 immarg, i1 immarg) #2
12declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) argmemonly nounwind willreturn writeonly
13declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn
14declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn
15declare void @bzero(ptr nocapture, i64) nofree nounwind
16declare void @bcopy(ptr nocapture, ptr nocapture, i64) nofree nounwind
17declare ptr @memset(ptr, i32, i64)
18
19define void @memcpy_dynamic(ptr %d, ptr %s, i64 %l) #0 !dbg !14 {
20entry:
21  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !16
22; GISEL: remark: memsize.c:4:3: Call to memcpy.{{$}}
23  %call = call ptr @__memcpy_chk(ptr %d, ptr %s, i64 %l, i64 %0) #4, !dbg !17
24  ret void, !dbg !18
25}
26
27define void @memcpy_single(ptr %d, ptr %s, i64 %l) #0 !dbg !23 {
28entry:
29  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !24
30; GISEL: remark: memsize.c:10:3: Call to memcpy. Memory operation size: 1 bytes.
31  %call = call ptr @__memcpy_chk(ptr %d, ptr %s, i64 1, i64 %0) #4, !dbg !25
32  ret void, !dbg !26
33}
34
35define void @memcpy_intrinsic(ptr %d, ptr %s, i64 %l) #0 {
36entry:
37  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false)
38; GISEL: remark: <unknown>:0:0: Call to memcpy. Memory operation size: 1 bytes.
39  call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 1, i1 false)
40  ret void
41}
42
43define void @memcpy_static(ptr %d, ptr %s, i64 %l) #0 !dbg !27 {
44entry:
45  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !28
46; GISEL: remark: memsize.c:13:3: Call to memcpy. Memory operation size: 100 bytes.
47  %call = call ptr @__memcpy_chk(ptr %d, ptr %s, i64 100, i64 %0) #4, !dbg !29
48  ret void, !dbg !30
49}
50
51define void @memcpy_huge(ptr %d, ptr %s, i64 %l) #0 !dbg !31 {
52entry:
53  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !32
54; GISEL: remark: memsize.c:16:3: Call to memcpy. Memory operation size: 100000 bytes.
55  %call = call ptr @__memcpy_chk(ptr %d, ptr %s, i64 100000, i64 %0) #4, !dbg !33
56  ret void, !dbg !34
57}
58
59define void @memmove_dynamic(ptr %d, ptr %s, i64 %l) #0 {
60entry:
61  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false)
62; GISEL: remark: <unknown>:0:0: Call to memmove.{{$}}
63  %call = call ptr @__memmove_chk(ptr %d, ptr %s, i64 %l, i64 %0) #4
64  ret void
65}
66
67define void @memmove_single(ptr %d, ptr %s, i64 %l) #0 {
68entry:
69  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false)
70; GISEL: remark: <unknown>:0:0: Call to memmove. Memory operation size: 1 bytes.
71  %call = call ptr @__memmove_chk(ptr %d, ptr %s, i64 1, i64 %0) #4
72  ret void
73}
74
75define void @memmove_static(ptr %d, ptr %s, i64 %l) #0 {
76entry:
77  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false)
78; GISEL: remark: <unknown>:0:0: Call to memmove. Memory operation size: 100 bytes.
79  %call = call ptr @__memmove_chk(ptr %d, ptr %s, i64 100, i64 %0) #4
80  ret void
81}
82
83define void @memmove_huge(ptr %d, ptr %s, i64 %l) #0 {
84entry:
85  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false)
86; GISEL: remark: <unknown>:0:0: Call to memmove. Memory operation size: 100000 bytes.
87  %call = call ptr @__memmove_chk(ptr %d, ptr %s, i64 100000, i64 %0) #4
88  ret void
89}
90
91define void @memset_dynamic(ptr %d, i64 %l) #0 !dbg !38 {
92entry:
93  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !39
94; GISEL: remark: memsize.c:22:3: Call to memset.{{$}}
95  %call = call ptr @__memset_chk(ptr %d, i32 0, i64 %l, i64 %0) #4, !dbg !40
96  ret void, !dbg !41
97}
98
99define void @memset_single(ptr %d, i64 %l) #0 !dbg !46 {
100entry:
101  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !47
102; GISEL: remark: memsize.c:28:3: Call to memset. Memory operation size: 1 bytes.
103  %call = call ptr @__memset_chk(ptr %d, i32 0, i64 1, i64 %0) #4, !dbg !48
104  ret void, !dbg !49
105}
106
107define void @memset_static(ptr %d, i64 %l) #0 !dbg !50 {
108entry:
109  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !51
110; GISEL: remark: memsize.c:31:3: Call to memset. Memory operation size: 100 bytes.
111  %call = call ptr @__memset_chk(ptr %d, i32 0, i64 100, i64 %0) #4, !dbg !52
112  ret void, !dbg !53
113}
114
115define void @memset_huge(ptr %d, i64 %l) #0 !dbg !54 {
116entry:
117  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !55
118; GISEL: remark: memsize.c:34:3: Call to memset. Memory operation size: 100000 bytes.
119  %call = call ptr @__memset_chk(ptr %d, i32 0, i64 100000, i64 %0) #4, !dbg !56
120  ret void, !dbg !57
121}
122
123define void @memset_empty(ptr %d, i64 %l) #0 !dbg !42 {
124entry:
125  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !43
126; GISEL: remark: memsize.c:25:3: Call to memset. Memory operation size: 0 bytes.
127  %call = call ptr @__memset_chk(ptr %d, i32 0, i64 0, i64 %0) #4, !dbg !44
128  ret void, !dbg !45
129}
130
131; YAML-LABEL: Function:        memcpy_empty
132define void @memcpy_empty(ptr %d, ptr %s, i64 %l) #0 !dbg !19 {
133entry:
134  %0 = call i64 @llvm.objectsize.i64.p0(ptr %d, i1 false, i1 true, i1 false), !dbg !20
135; GISEL: remark: memsize.c:7:3: Call to memcpy. Memory operation size: 0 bytes.
136  %call = call ptr @__memcpy_chk(ptr %d, ptr %s, i64 0, i64 %0) #4, !dbg !21
137  ret void, !dbg !22
138}
139
140; Emit remarks for memcpy, memmove, memset, bzero, bcopy with known constant
141; sizes to an object of known size.
142define void @known_call_with_dereferenceable_bytes(ptr dereferenceable(42) %dst, ptr dereferenceable(314) %src) {
143; GISEL: Call to memset. Memory operation size: 1 bytes.
144; GISEL-NOT:  Read Variables:
145; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
146; YAML:       --- !Analysis
147; YAML:       gisel-irtranslator-memsize
148; YAML:       Name:            MemoryOpIntrinsicCall
149; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
150; YAML-NEXT:  Args:
151; YAML-NEXT:    - String:          'Call to '
152; YAML-NEXT:    - Callee:          memset
153; YAML-NEXT:    - String:          .
154; YAML-NEXT:    - String:          ' Memory operation size: '
155; YAML-NEXT:    - StoreSize:       '1'
156; YAML-NEXT:    - String:          ' bytes.'
157; YAML-NEXT:    - String:          "\n Written Variables: "
158; YAML-NEXT:    - WVarName:        '<unknown>'
159; YAML-NEXT:    - String:          ' ('
160; YAML-NEXT:    - WVarSize:        '42'
161; YAML-NEXT:    - String:          ' bytes)'
162; YAML-NEXT:    - String:          .
163; YAML-NEXT:    - String:          ' Inlined: '
164; YAML-NEXT:    - StoreInlined:    'false'
165; YAML-NEXT:    - String:          .
166; YAML-NEXT:    - String:          ' Volatile: '
167; YAML-NEXT:    - StoreVolatile:   'false'
168; YAML-NEXT:    - String:          .
169; YAML-NEXT:    - String:          ' Atomic: '
170; YAML-NEXT:    - StoreAtomic:     'false'
171; YAML-NEXT:    - String:          .
172; YAML-NEXT:  ...
173  call void @llvm.memset.p0.i64(ptr %dst, i8 0, i64 1, i1 false)
174
175; GISEL: Call to memcpy. Memory operation size: 1 bytes.
176; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
177; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
178; YAML:       --- !Analysis
179; YAML:       gisel-irtranslator-memsize
180; YAML:       Name:            MemoryOpIntrinsicCall
181; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
182; YAML-NEXT:  Args:
183; YAML-NEXT:    - String:          'Call to '
184; YAML-NEXT:    - Callee:          memcpy
185; YAML-NEXT:    - String:          .
186; YAML-NEXT:    - String:          ' Memory operation size: '
187; YAML-NEXT:    - StoreSize:       '1'
188; YAML-NEXT:    - String:          ' bytes.'
189; YAML-NEXT:    - String:          "\n Read Variables: "
190; YAML-NEXT:    - RVarName:        '<unknown>'
191; YAML-NEXT:    - String:          ' ('
192; YAML-NEXT:    - RVarSize:        '314'
193; YAML-NEXT:    - String:          ' bytes)'
194; YAML-NEXT:    - String:          .
195; YAML-NEXT:    - String:          "\n Written Variables: "
196; YAML-NEXT:    - WVarName:        '<unknown>'
197; YAML-NEXT:    - String:          ' ('
198; YAML-NEXT:    - WVarSize:        '42'
199; YAML-NEXT:    - String:          ' bytes)'
200; YAML-NEXT:    - String:          .
201; YAML-NEXT:    - String:          ' Inlined: '
202; YAML-NEXT:    - StoreInlined:    'false'
203; YAML-NEXT:    - String:          .
204; YAML-NEXT:    - String:          ' Volatile: '
205; YAML-NEXT:    - StoreVolatile:   'false'
206; YAML-NEXT:    - String:          .
207; YAML-NEXT:    - String:          ' Atomic: '
208; YAML-NEXT:    - StoreAtomic:     'false'
209; YAML-NEXT:    - String:          .
210; YAML-NEXT:  ...
211  call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 1, i1 false)
212
213; GISEL: Call to memmove. Memory operation size: 1 bytes.
214; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
215; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
216; YAML:       --- !Analysis
217; YAML:       gisel-irtranslator-memsize
218; YAML:       Name:            MemoryOpIntrinsicCall
219; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
220; YAML-NEXT:  Args:
221; YAML-NEXT:    - String:          'Call to '
222; YAML-NEXT:    - Callee:          memmove
223; YAML-NEXT:    - String:          .
224; YAML-NEXT:    - String:          ' Memory operation size: '
225; YAML-NEXT:    - StoreSize:       '1'
226; YAML-NEXT:    - String:          ' bytes.'
227; YAML-NEXT:    - String:          "\n Read Variables: "
228; YAML-NEXT:    - RVarName:        '<unknown>'
229; YAML-NEXT:    - String:          ' ('
230; YAML-NEXT:    - RVarSize:        '314'
231; YAML-NEXT:    - String:          ' bytes)'
232; YAML-NEXT:    - String:          .
233; YAML-NEXT:    - String:          "\n Written Variables: "
234; YAML-NEXT:    - WVarName:        '<unknown>'
235; YAML-NEXT:    - String:          ' ('
236; YAML-NEXT:    - WVarSize:        '42'
237; YAML-NEXT:    - String:          ' bytes)'
238; YAML-NEXT:    - String:          .
239; YAML-NEXT:    - String:          ' Inlined: '
240; YAML-NEXT:    - StoreInlined:    'false'
241; YAML-NEXT:    - String:          .
242; YAML-NEXT:    - String:          ' Volatile: '
243; YAML-NEXT:    - StoreVolatile:   'false'
244; YAML-NEXT:    - String:          .
245; YAML-NEXT:    - String:          ' Atomic: '
246; YAML-NEXT:    - StoreAtomic:     'false'
247; YAML-NEXT:    - String:          .
248; YAML-NEXT:  ...
249  call void @llvm.memmove.p0.p0.i64(ptr %dst, ptr %src, i64 1, i1 false)
250
251; GISEL: Call to bzero. Memory operation size: 1 bytes.
252; GISEL-NOT:  Read Variables:
253; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
254; YAML:       --- !Analysis
255; YAML:       gisel-irtranslator-memsize
256; YAML:       Name:            MemoryOpCall
257; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
258; YAML-NEXT:  Args:
259; YAML-NEXT:    - String:          'Call to '
260; YAML-NEXT:    - Callee:          bzero
261; YAML-NEXT:    - String:          .
262; YAML-NEXT:    - String:          ' Memory operation size: '
263; YAML-NEXT:    - StoreSize:       '1'
264; YAML-NEXT:    - String:          ' bytes.'
265; YAML-NEXT:    - String:          "\n Written Variables: "
266; YAML-NEXT:    - WVarName:        '<unknown>'
267; YAML-NEXT:    - String:          ' ('
268; YAML-NEXT:    - WVarSize:        '42'
269; YAML-NEXT:    - String:          ' bytes)'
270; YAML-NEXT:    - String:          .
271; YAML-NEXT:  ...
272  call void @bzero(ptr %dst, i64 1)
273
274; GISEL: Call to bcopy. Memory operation size: 1 bytes.
275; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
276; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
277; YAML:       --- !Analysis
278; YAML:       gisel-irtranslator-memsize
279; YAML:       Name:            MemoryOpCall
280; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
281; YAML-NEXT:  Args:
282; YAML-NEXT:    - String:          'Call to '
283; YAML-NEXT:    - Callee:          bcopy
284; YAML-NEXT:    - String:          .
285; YAML-NEXT:    - String:          ' Memory operation size: '
286; YAML-NEXT:    - StoreSize:       '1'
287; YAML-NEXT:    - String:          ' bytes.'
288; YAML-NEXT:    - String:          "\n Read Variables: "
289; YAML-NEXT:    - RVarName:        '<unknown>'
290; YAML-NEXT:    - String:          ' ('
291; YAML-NEXT:    - RVarSize:        '314'
292; YAML-NEXT:    - String:          ' bytes)'
293; YAML-NEXT:    - String:          .
294; YAML-NEXT:    - String:          "\n Written Variables: "
295; YAML-NEXT:    - WVarName:        '<unknown>'
296; YAML-NEXT:    - String:          ' ('
297; YAML-NEXT:    - WVarSize:        '42'
298; YAML-NEXT:    - String:          ' bytes)'
299; YAML-NEXT:    - String:          .
300; YAML-NEXT:  ...
301  call void @bcopy(ptr %dst, ptr %src, i64 1)
302  ret void
303}
304
305@dropbear = external unnamed_addr constant [3 x i8], align 1
306@koala = external unnamed_addr constant [7 x i8], align 1
307
308define void @slicePun() {
309bb:
310; GISEL: remark: <unknown>:0:0: Call to memcpy. Memory operation size: 24 bytes.{{$}}
311; GISEL-NEXT: Read Variables: koala (56 bytes).
312; GISEL-NEXT: Written Variables: dropbear (24 bytes).
313  tail call void @llvm.memcpy.p0.p0.i64(ptr align 1 @dropbear,
314                                            ptr @koala, i64 24, i1 false)
315  ret void
316}
317
318attributes #0 = { noinline nounwind ssp uwtable "frame-pointer"="non-leaf" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="apple-a7" "target-features"="+aes,+crypto,+fp-armv8,+neon,+sha2,+zcm,+zcz" }
319attributes #1 = { nounwind "frame-pointer"="non-leaf" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="apple-a7" "target-features"="+aes,+crypto,+fp-armv8,+neon,+sha2,+zcm,+zcz" }
320attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }
321attributes #3 = { argmemonly nofree nosync nounwind willreturn }
322attributes #4 = { nounwind }
323
324!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9}
325!llvm.dbg.cu = !{!10}
326!llvm.ident = !{!13}
327
328!0 = !{i32 2, !"SDK Version", [2 x i32] [i32 12, i32 0]}
329!1 = !{i32 2, !"Debug Info Version", i32 3}
330!2 = !{i32 1, !"wchar_size", i32 4}
331!3 = !{i32 8, !"branch-target-enforcement", i32 0}
332!4 = !{i32 8, !"sign-return-address", i32 0}
333!5 = !{i32 8, !"sign-return-address-all", i32 0}
334!6 = !{i32 8, !"sign-return-address-with-bkey", i32 0}
335!7 = !{i32 7, !"PIC Level", i32 2}
336!8 = !{i32 7, !"uwtable", i32 1}
337!9 = !{i32 7, !"frame-pointer", i32 1}
338!10 = distinct !DICompileUnit(language: DW_LANG_C99, file: !11, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug, enums: !12, splitDebugInlining: false, nameTableKind: None, sysroot: "/")
339!11 = !DIFile(filename: "memsize.c", directory: "")
340!12 = !{}
341!13 = !{!"clang"}
342!14 = distinct !DISubprogram(name: "memcpy_dynamic", scope: !11, file: !11, line: 3, type: !15, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
343!15 = !DISubroutineType(types: !12)
344!16 = !DILocation(line: 4, column: 36, scope: !14)
345!17 = !DILocation(line: 4, column: 3, scope: !14)
346!18 = !DILocation(line: 5, column: 1, scope: !14)
347!19 = distinct !DISubprogram(name: "memcpy_empty", scope: !11, file: !11, line: 6, type: !15, scopeLine: 6, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
348!20 = !DILocation(line: 7, column: 36, scope: !19)
349!21 = !DILocation(line: 7, column: 3, scope: !19)
350!22 = !DILocation(line: 8, column: 1, scope: !19)
351!23 = distinct !DISubprogram(name: "memcpy_single", scope: !11, file: !11, line: 9, type: !15, scopeLine: 9, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
352!24 = !DILocation(line: 10, column: 36, scope: !23)
353!25 = !DILocation(line: 10, column: 3, scope: !23)
354!26 = !DILocation(line: 11, column: 1, scope: !23)
355!27 = distinct !DISubprogram(name: "memcpy_static", scope: !11, file: !11, line: 12, type: !15, scopeLine: 12, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
356!28 = !DILocation(line: 13, column: 38, scope: !27)
357!29 = !DILocation(line: 13, column: 3, scope: !27)
358!30 = !DILocation(line: 14, column: 1, scope: !27)
359!31 = distinct !DISubprogram(name: "memcpy_huge", scope: !11, file: !11, line: 15, type: !15, scopeLine: 15, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
360!32 = !DILocation(line: 16, column: 41, scope: !31)
361!33 = !DILocation(line: 16, column: 3, scope: !31)
362!34 = !DILocation(line: 17, column: 1, scope: !31)
363!35 = distinct !DISubprogram(name: "memcpy_inline", scope: !11, file: !11, line: 18, type: !15, scopeLine: 18, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
364!36 = !DILocation(line: 19, column: 3, scope: !35)
365!37 = !DILocation(line: 20, column: 1, scope: !35)
366!38 = distinct !DISubprogram(name: "memset_dynamic", scope: !11, file: !11, line: 21, type: !15, scopeLine: 21, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
367!39 = !DILocation(line: 22, column: 36, scope: !38)
368!40 = !DILocation(line: 22, column: 3, scope: !38)
369!41 = !DILocation(line: 23, column: 1, scope: !38)
370!42 = distinct !DISubprogram(name: "memset_empty", scope: !11, file: !11, line: 24, type: !15, scopeLine: 24, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
371!43 = !DILocation(line: 25, column: 36, scope: !42)
372!44 = !DILocation(line: 25, column: 3, scope: !42)
373!45 = !DILocation(line: 26, column: 1, scope: !42)
374!46 = distinct !DISubprogram(name: "memset_single", scope: !11, file: !11, line: 27, type: !15, scopeLine: 27, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
375!47 = !DILocation(line: 28, column: 36, scope: !46)
376!48 = !DILocation(line: 28, column: 3, scope: !46)
377!49 = !DILocation(line: 29, column: 1, scope: !46)
378!50 = distinct !DISubprogram(name: "memset_static", scope: !11, file: !11, line: 30, type: !15, scopeLine: 30, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
379!51 = !DILocation(line: 31, column: 38, scope: !50)
380!52 = !DILocation(line: 31, column: 3, scope: !50)
381!53 = !DILocation(line: 32, column: 1, scope: !50)
382!54 = distinct !DISubprogram(name: "memset_huge", scope: !11, file: !11, line: 33, type: !15, scopeLine: 33, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
383!55 = !DILocation(line: 34, column: 41, scope: !54)
384!56 = !DILocation(line: 34, column: 3, scope: !54)
385!57 = !DILocation(line: 35, column: 1, scope: !54)
386!58 = distinct !DISubprogram(name: "auto_init", scope: !11, file: !11, line: 37, type: !15, scopeLine: 37, spFlags: DISPFlagDefinition, unit: !10, retainedNodes: !12)
387