llvm/test/CodeGen/AArch64/memsize-remarks.ll

   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
   4 source_filename = "memsize.c"
   5 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   6 target triple = "arm64-apple-ios7.0.0"
   7
   8 declare ptr @__memmove_chk(ptr, ptr, i64, i64) #1
   9 declare ptr @__memcpy_chk(ptr, ptr, i64, i64) #1
  10 declare ptr @__memset_chk(ptr, i32, i64, i64) #1
  11 declare i64 @llvm.objectsize.i64.p0(ptr, i1 immarg, i1 immarg, i1 immarg) #2
  12 declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) argmemonly nounwind willreturn writeonly
  13 declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn
  14 declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn
  15 declare void @bzero(ptr nocapture, i64) nofree nounwind
  16 declare void @bcopy(ptr nocapture, ptr nocapture, i64) nofree nounwind
  17 declare ptr @memset(ptr, i32, i64)
  18
  19 define void @memcpy_dynamic(ptr %d, ptr %s, i64 %l) #0 !dbg !14 {
  20 entry:
  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
  27 define void @memcpy_single(ptr %d, ptr %s, i64 %l) #0 !dbg !23 {
  28 entry:
  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
  35 define void @memcpy_intrinsic(ptr %d, ptr %s, i64 %l) #0 {
  36 entry:
  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
  43 define void @memcpy_static(ptr %d, ptr %s, i64 %l) #0 !dbg !27 {
  44 entry:
  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
  51 define void @memcpy_huge(ptr %d, ptr %s, i64 %l) #0 !dbg !31 {
  52 entry:
  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
  59 define void @memmove_dynamic(ptr %d, ptr %s, i64 %l) #0 {
  60 entry:
  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
  67 define void @memmove_single(ptr %d, ptr %s, i64 %l) #0 {
  68 entry:
  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
  75 define void @memmove_static(ptr %d, ptr %s, i64 %l) #0 {
  76 entry:
  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
  83 define void @memmove_huge(ptr %d, ptr %s, i64 %l) #0 {
  84 entry:
  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
  91 define void @memset_dynamic(ptr %d, i64 %l) #0 !dbg !38 {
  92 entry:
  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
  99 define void @memset_single(ptr %d, i64 %l) #0 !dbg !46 {
 100 entry:
 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
 107 define void @memset_static(ptr %d, i64 %l) #0 !dbg !50 {
 108 entry:
 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
 115 define void @memset_huge(ptr %d, i64 %l) #0 !dbg !54 {
 116 entry:
 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
 123 define void @memset_empty(ptr %d, i64 %l) #0 !dbg !42 {
 124 entry:
 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
 132 define void @memcpy_empty(ptr %d, ptr %s, i64 %l) #0 !dbg !19 {
 133 entry:
 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.
 142 define 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
 308 define void @slicePun() {
 309 bb:
 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
 318 attributes #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" }
 319 attributes #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" }
 320 attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }
 321 attributes #3 = { argmemonly nofree nosync nounwind willreturn }
 322 attributes #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)