diff options
Diffstat (limited to 'test/Instrumentation')
27 files changed, 545 insertions, 140 deletions
diff --git a/test/Instrumentation/AddressSanitizer/X86/asm_attr.ll b/test/Instrumentation/AddressSanitizer/X86/asm_attr.ll index b83a7e9..0667a14 100644 --- a/test/Instrumentation/AddressSanitizer/X86/asm_attr.ll +++ b/test/Instrumentation/AddressSanitizer/X86/asm_attr.ll @@ -4,16 +4,16 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" ; CHECK-LABEL: mov_no_attr -; CHECK-NOT: callq __sanitizer_sanitize_load8@PLT -; CHECK-NOT: callq __sanitizer_sanitize_store8@PLT +; CHECK-NOT: callq __asan_report_load@PLT +; CHECK-NOT: callq __asan_report_store@PLT define void @mov_no_attr(i64* %dst, i64* %src) { tail call void asm sideeffect "movq ($1), %rax \0A\09movq %rax, ($0) \0A\09", "r,r,~{memory},~{rax},~{dirflag},~{fpsr},~{flags}"(i64* %dst, i64* %src) ret void } ; CHECK-LABEL: mov_sanitize -; CHECK: callq __sanitizer_sanitize_load8@PLT -; CHECK: callq __sanitizer_sanitize_store8@PLT +; CHECK: callq __asan_report_load8@PLT +; CHECK: callq __asan_report_store8@PLT define void @mov_sanitize(i64* %dst, i64* %src) sanitize_address { tail call void asm sideeffect "movq ($1), %rax \0A\09movq %rax, ($0) \0A\09", "r,r,~{memory},~{rax},~{dirflag},~{fpsr},~{flags}"(i64* %dst, i64* %src) ret void diff --git a/test/Instrumentation/AddressSanitizer/X86/asm_mov.ll b/test/Instrumentation/AddressSanitizer/X86/asm_mov.ll index 030af7e..ad5e02e 100644 --- a/test/Instrumentation/AddressSanitizer/X86/asm_mov.ll +++ b/test/Instrumentation/AddressSanitizer/X86/asm_mov.ll @@ -5,18 +5,35 @@ target triple = "x86_64-unknown-linux-gnu" ; CHECK-LABEL: mov1b ; CHECK: leaq -128(%rsp), %rsp +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: pushq %rcx ; CHECK-NEXT: pushq %rdi +; CHECK-NEXT: pushfq ; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_load1@PLT +; CHECK-NEXT: movq %rdi, %rax +; CHECK-NEXT: shrq $3, %rax +; CHECK-NEXT: movb 2147450880(%rax), %al +; CHECK-NEXT: testb %al, %al +; CHECK-NEXT: je [[A:.*]] +; CHECK-NEXT: movl %edi, %ecx +; CHECK-NEXT: andl $7, %ecx +; CHECK-NEXT: movsbl %al, %eax +; CHECK-NEXT: cmpl %eax, %ecx +; CHECK-NEXT: jl {{.*}} +; CHECK-NEXT: cld +; CHECK-NEXT: emms +; CHECK-NEXT: andq $-16, %rsp +; CHECK-NEXT: callq __asan_report_load1@PLT +; CHECK-NEXT: [[A]]: +; CHECK-NEXT: popfq ; CHECK-NEXT: popq %rdi +; CHECK-NEXT: popq %rcx +; CHECK-NEXT: popq %rax ; CHECK-NEXT: leaq 128(%rsp), %rsp ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_store1@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: callq __asan_report_store1@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: movb {{.*}}, {{.*}} define void @mov1b(i8* %dst, i8* %src) #0 { @@ -27,18 +44,14 @@ entry: ; CHECK-LABEL: mov2b ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_load2@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: leal 1(%ecx), %ecx +; CHECK: callq __asan_report_load2@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_store2@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: leal 1(%ecx), %ecx +; CHECK: callq __asan_report_store2@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: movw {{.*}}, {{.*}} define void @mov2b(i16* %dst, i16* %src) #0 { @@ -49,18 +62,14 @@ entry: ; CHECK-LABEL: mov4b ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_load4@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: addl $3, %ecx +; CHECK: callq __asan_report_load4@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_store4@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: addl $3, %ecx +; CHECK: callq __asan_report_store4@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: movl {{.*}}, {{.*}} define void @mov4b(i32* %dst, i32* %src) #0 { @@ -71,17 +80,35 @@ entry: ; CHECK-LABEL: mov8b ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_load8@PLT -; CHECK-NEXT: popq %rdi +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: pushfq +; CHECK-NEXT: leaq {{.*}}, %rax +; CHECK-NEXT: shrq $3, %rax +; CHECK-NEXT: cmpb $0, 2147450880(%rax) +; CHECK-NEXT: je [[A:.*]] +; CHECK-NEXT: cld +; CHECK-NEXT: emms +; CHECK-NEXT: andq $-16, %rsp +; CHECK-NEXT: callq __asan_report_load8@PLT +; CHECK-NEXT: [[A]]: +; CHECK-NEXT: popfq +; CHECK-NEXT: popq %rax ; CHECK-NEXT: leaq 128(%rsp), %rsp ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_store8@PLT -; CHECK-NEXT: popq %rdi +; CHECK-NEXT: pushq %rax +; CHECK-NEXT: pushfq +; CHECK-NEXT: leaq {{.*}}, %rax +; CHECK-NEXT: shrq $3, %rax +; CHECK-NEXT: cmpb $0, 2147450880(%rax) +; CHECK-NEXT: je [[A:.*]] +; CHECK-NEXT: cld +; CHECK-NEXT: emms +; CHECK-NEXT: andq $-16, %rsp +; CHECK-NEXT: callq __asan_report_store8@PLT +; CHECK-NEXT: [[A]]: +; CHECK-NEXT: popfq +; CHECK-NEXT: popq %rax ; CHECK-NEXT: leaq 128(%rsp), %rsp ; CHECK: movq {{.*}}, {{.*}} @@ -93,18 +120,14 @@ entry: ; CHECK-LABEL: mov16b ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_load16@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: cmpw $0, 2147450880(%rax) +; CHECK: callq __asan_report_load16@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: leaq -128(%rsp), %rsp -; CHECK-NEXT: pushq %rdi -; CHECK-NEXT: leaq {{.*}}, %rdi -; CHECK-NEXT: callq __sanitizer_sanitize_store16@PLT -; CHECK-NEXT: popq %rdi -; CHECK-NEXT: leaq 128(%rsp), %rsp +; CHECK: cmpw $0, 2147450880(%rax) +; CHECK: callq __asan_report_store16@PLT +; CHECK: leaq 128(%rsp), %rsp ; CHECK: movaps {{.*}}, {{.*}} define void @mov16b(<2 x i64>* %dst, <2 x i64>* %src) #0 { diff --git a/test/Instrumentation/AddressSanitizer/X86/asm_mov.s b/test/Instrumentation/AddressSanitizer/X86/asm_mov.s index df217c0..74a788c 100644 --- a/test/Instrumentation/AddressSanitizer/X86/asm_mov.s +++ b/test/Instrumentation/AddressSanitizer/X86/asm_mov.s @@ -7,20 +7,14 @@ # CHECK-LABEL: mov1b: # # CHECK: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rsi), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_load1@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_load1@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movb (%rsi), %al # # CHECK-NEXT: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rdi), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_store1@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_store1@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movb %al, (%rdi) mov1b: # @mov1b @@ -42,20 +36,14 @@ mov1b: # @mov1b # CHECK-LABEL: mov16b: # # CHECK: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rsi), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_load16@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_load16@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movaps (%rsi), %xmm0 # # CHECK-NEXT: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rdi), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_store16@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_store16@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movaps %xmm0, (%rdi) mov16b: # @mov16b diff --git a/test/Instrumentation/AddressSanitizer/X86/asm_mov_no_instrumentation.s b/test/Instrumentation/AddressSanitizer/X86/asm_mov_no_instrumentation.s index cc05527..e3a1541 100644 --- a/test/Instrumentation/AddressSanitizer/X86/asm_mov_no_instrumentation.s +++ b/test/Instrumentation/AddressSanitizer/X86/asm_mov_no_instrumentation.s @@ -5,8 +5,8 @@ .align 16, 0x90 .type mov1b,@function # CHECK-LABEL: mov1b -# CHECK-NOT: callq __sanitizer_sanitize_load1@PLT -# CHECK-NOT: callq __sanitizer_sanitize_store1@PLT +# CHECK-NOT: callq __asan_report_load1@PLT +# CHECK-NOT: callq __asan_report_store1@PLT mov1b: # @mov1b .cfi_startproc # BB#0: diff --git a/test/Instrumentation/AddressSanitizer/X86/asm_swap_intel.s b/test/Instrumentation/AddressSanitizer/X86/asm_swap_intel.s index 8a6a8d5..ca3c54c 100644 --- a/test/Instrumentation/AddressSanitizer/X86/asm_swap_intel.s +++ b/test/Instrumentation/AddressSanitizer/X86/asm_swap_intel.s @@ -7,38 +7,26 @@ # CHECK-LABEL: swap: # # CHECK: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rcx), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_load8@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_load8@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movq (%rcx), %rax # # CHECK-NEXT: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rdx), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_load8@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_load8@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movq (%rdx), %rbx # -# CHECK: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rcx), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_store8@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK-NEXT: leaq -128(%rsp), %rsp +# CHECK: callq __asan_report_store8@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movq %rbx, (%rcx) # # CHECK-NEXT: leaq -128(%rsp), %rsp -# CHECK-NEXT: pushq %rdi -# CHECK-NEXT: leaq (%rdx), %rdi -# CHECK-NEXT: callq __sanitizer_sanitize_store8@PLT -# CHECK-NEXT: popq %rdi -# CHECK-NEXT: leaq 128(%rsp), %rsp +# CHECK: callq __asan_report_store8@PLT +# CHECK: leaq 128(%rsp), %rsp # # CHECK-NEXT: movq %rax, (%rdx) swap: # @swap diff --git a/test/Instrumentation/AddressSanitizer/X86/lit.local.cfg b/test/Instrumentation/AddressSanitizer/X86/lit.local.cfg index ba763cf..e71f3cc 100644 --- a/test/Instrumentation/AddressSanitizer/X86/lit.local.cfg +++ b/test/Instrumentation/AddressSanitizer/X86/lit.local.cfg @@ -1,4 +1,3 @@ -targets = set(config.root.targets_to_build.split()) -if not 'X86' in targets: +if not 'X86' in config.root.targets: config.unsupported = True diff --git a/test/Instrumentation/AddressSanitizer/coverage-dbg.ll b/test/Instrumentation/AddressSanitizer/coverage-dbg.ll index 77d7286..3f7998d 100644 --- a/test/Instrumentation/AddressSanitizer/coverage-dbg.ll +++ b/test/Instrumentation/AddressSanitizer/coverage-dbg.ll @@ -2,32 +2,66 @@ ; RUN: opt < %s -asan -asan-module -asan-coverage=1 -S | FileCheck %s +; C++ source: +; 1: struct A { +; 2: int f(); +; 3: int x; +; 4: }; +; 5: +; 6: int A::f() { +; 7: return x; +; 8: } +; clang++ ../1.cc -O3 -g -S -emit-llvm -fno-strict-aliasing +; and add sanitize_address to @_ZN1A1fEv + +; Test that __sanitizer_cov call has !dbg pointing to the opening { of A::f(). +; CHECK: call void @__sanitizer_cov(), !dbg [[A:!.*]] +; CHECK: [[A]] = metadata !{i32 6, i32 0, metadata !{{.*}}, null} + + target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" -; Function Attrs: nounwind readnone uwtable -define void @_Z1fv() #0 { +%struct.A = type { i32 } + +; Function Attrs: nounwind readonly uwtable +define i32 @_ZN1A1fEv(%struct.A* nocapture readonly %this) #0 align 2 { entry: - ret void, !dbg !11 + tail call void @llvm.dbg.value(metadata !{%struct.A* %this}, i64 0, metadata !15), !dbg !20 + %x = getelementptr inbounds %struct.A* %this, i64 0, i32 0, !dbg !21 + %0 = load i32* %x, align 4, !dbg !21 + ret i32 %0, !dbg !21 } -; CHECK: call void @__sanitizer_cov(), !dbg ! +; Function Attrs: nounwind readnone +declare void @llvm.dbg.value(metadata, i64, metadata) #1 -attributes #0 = { sanitize_address nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { sanitize_address nounwind readonly uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #1 = { nounwind readnone } !llvm.dbg.cu = !{!0} -!llvm.module.flags = !{!8, !9} -!llvm.ident = !{!10} +!llvm.module.flags = !{!17, !18} +!llvm.ident = !{!19} -!0 = metadata !{i32 786449, metadata !1, i32 4, metadata !"clang version 3.5.0 (208682)", i1 true, metadata !"", i32 0, metadata !2, metadata !2, metadata !3, metadata !2, metadata !2, metadata !"", i32 1} ; [ DW_TAG_compile_unit ] [/tmp//tmp/1.cc] [DW_LANG_C_plus_plus] -!1 = metadata !{metadata !"/tmp/1.cc", metadata !"/tmp"} +!0 = metadata !{i32 786449, metadata !1, i32 4, metadata !"clang version 3.5.0 (210251)", i1 true, metadata !"", i32 0, metadata !2, metadata !3, metadata !12, metadata !2, metadata !2, metadata !"", i32 1} ; [ DW_TAG_compile_unit ] [/code/llvm/build0/../1.cc] [DW_LANG_C_plus_plus] +!1 = metadata !{metadata !"../1.cc", metadata !"/code/llvm/build0"} !2 = metadata !{} !3 = metadata !{metadata !4} -!4 = metadata !{i32 786478, metadata !1, metadata !5, metadata !"f", metadata !"f", metadata !"_Z1fv", i32 1, metadata !6, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 true, void ()* @_Z1fv, null, null, metadata !2, i32 1} ; [ DW_TAG_subprogram ] [line 1] [def] [f] -!5 = metadata !{i32 786473, metadata !1} ; [ DW_TAG_file_type ] [/tmp//tmp/1.cc] -!6 = metadata !{i32 786453, i32 0, null, metadata !"", i32 0, i64 0, i64 0, i64 0, i32 0, null, metadata !7, i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] [line 0, size 0, align 0, offset 0] [from ] -!7 = metadata !{null} -!8 = metadata !{i32 2, metadata !"Dwarf Version", i32 4} -!9 = metadata !{i32 1, metadata !"Debug Info Version", i32 1} -!10 = metadata !{metadata !"clang version 3.5.0 (208682)"} -!11 = metadata !{i32 2, i32 0, metadata !4, null} +!4 = metadata !{i32 786451, metadata !1, null, metadata !"A", i32 1, i64 32, i64 32, i32 0, i32 0, null, metadata !5, i32 0, null, null, metadata !"_ZTS1A"} ; [ DW_TAG_structure_type ] [A] [line 1, size 32, align 32, offset 0] [def] [from ] +!5 = metadata !{metadata !6, metadata !8} +!6 = metadata !{i32 786445, metadata !1, metadata !"_ZTS1A", metadata !"x", i32 3, i64 32, i64 32, i64 0, i32 0, metadata !7} ; [ DW_TAG_member ] [x] [line 3, size 32, align 32, offset 0] [from int] +!7 = metadata !{i32 786468, null, null, metadata !"int", i32 0, i64 32, i64 32, i64 0, i32 0, i32 5} ; [ DW_TAG_base_type ] [int] [line 0, size 32, align 32, offset 0, enc DW_ATE_signed] +!8 = metadata !{i32 786478, metadata !1, metadata !"_ZTS1A", metadata !"f", metadata !"f", metadata !"_ZN1A1fEv", i32 2, metadata !9, i1 false, i1 false, i32 0, i32 0, null, i32 256, i1 true, null, null, i32 0, null, i32 2} ; [ DW_TAG_subprogram ] [line 2] [f] +!9 = metadata !{i32 786453, i32 0, null, metadata !"", i32 0, i64 0, i64 0, i64 0, i32 0, null, metadata !10, i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] [line 0, size 0, align 0, offset 0] [from ] +!10 = metadata !{metadata !7, metadata !11} +!11 = metadata !{i32 786447, null, null, metadata !"", i32 0, i64 64, i64 64, i64 0, i32 1088, metadata !"_ZTS1A"} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [artificial] [from _ZTS1A] +!12 = metadata !{metadata !13} +!13 = metadata !{i32 786478, metadata !1, metadata !"_ZTS1A", metadata !"f", metadata !"f", metadata !"_ZN1A1fEv", i32 6, metadata !9, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 true, i32 (%struct.A*)* @_ZN1A1fEv, null, metadata !8, metadata !14, i32 6} ; [ DW_TAG_subprogram ] [line 6] [def] [f] +!14 = metadata !{metadata !15} +!15 = metadata !{i32 786689, metadata !13, metadata !"this", null, i32 16777216, metadata !16, i32 1088, i32 0} ; [ DW_TAG_arg_variable ] [this] [line 0] +!16 = metadata !{i32 786447, null, null, metadata !"", i32 0, i64 64, i64 64, i64 0, i32 0, metadata !"_ZTS1A"} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from _ZTS1A] +!17 = metadata !{i32 2, metadata !"Dwarf Version", i32 4} +!18 = metadata !{i32 2, metadata !"Debug Info Version", i32 1} +!19 = metadata !{metadata !"clang version 3.5.0 (210251)"} +!20 = metadata !{i32 0, i32 0, metadata !13, null} +!21 = metadata !{i32 7, i32 0, metadata !13, null} diff --git a/test/Instrumentation/AddressSanitizer/coverage.ll b/test/Instrumentation/AddressSanitizer/coverage.ll index 5bc5103..79bb5c1 100644 --- a/test/Instrumentation/AddressSanitizer/coverage.ll +++ b/test/Instrumentation/AddressSanitizer/coverage.ll @@ -1,7 +1,20 @@ +; RUN: opt < %s -asan -asan-module -asan-coverage=0 -S | FileCheck %s --check-prefix=CHECK0 ; RUN: opt < %s -asan -asan-module -asan-coverage=1 -S | FileCheck %s --check-prefix=CHECK1 ; RUN: opt < %s -asan -asan-module -asan-coverage=2 -S | FileCheck %s --check-prefix=CHECK2 ; RUN: opt < %s -asan -asan-module -asan-coverage=2 -asan-coverage-block-threshold=10 -S | FileCheck %s --check-prefix=CHECK2 ; RUN: opt < %s -asan -asan-module -asan-coverage=2 -asan-coverage-block-threshold=1 -S | FileCheck %s --check-prefix=CHECK1 + +; RUN: opt < %s -asan -asan-module -asan-coverage=0 -asan-globals=0 -S | \ +; RUN: FileCheck %s --check-prefix=CHECK0 +; RUN: opt < %s -asan -asan-module -asan-coverage=1 -asan-globals=0 -S | \ +; RUN: FileCheck %s --check-prefix=CHECK1 +; RUN: opt < %s -asan -asan-module -asan-coverage=2 -asan-globals=0 -S | \ +; RUN: FileCheck %s --check-prefix=CHECK2 +; RUN: opt < %s -asan -asan-module -asan-coverage=2 -asan-coverage-block-threshold=10 \ +; RUN: -asan-globals=0 -S | FileCheck %s --check-prefix=CHECK2 +; RUN: opt < %s -asan -asan-module -asan-coverage=2 -asan-coverage-block-threshold=1 \ +; RUN: -asan-globals=0 -S | FileCheck %s --check-prefix=CHECK1 + target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target triple = "x86_64-unknown-linux-gnu" define void @foo(i32* %a) sanitize_address { @@ -17,6 +30,9 @@ entry: ret void } +; CHECK0-NOT: call void @__sanitizer_cov( +; CHECK0-NOT: call void @__sanitizer_cov_module_init( + ; CHECK1-LABEL: define void @foo ; CHECK1: %0 = load atomic i8* @__asan_gen_cov_foo monotonic, align 1 ; CHECK1: %1 = icmp eq i8 0, %0 diff --git a/test/Instrumentation/AddressSanitizer/debug_info.ll b/test/Instrumentation/AddressSanitizer/debug_info.ll index daf2957..336b98b 100644 --- a/test/Instrumentation/AddressSanitizer/debug_info.ll +++ b/test/Instrumentation/AddressSanitizer/debug_info.ll @@ -1,4 +1,4 @@ -; RUN: opt < %s -asan -asan-module -S | FileCheck %s +; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck %s ; Checks that llvm.dbg.declare instructions are updated ; accordingly as we merge allocas. @@ -47,8 +47,9 @@ declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone ; Verify that debug descriptors for argument and local variable will be replaced ; with descriptors that end with OpDeref (encoded as 2). -; CHECK: ![[ARG_ID]] = metadata {{.*}} i64 2} ; [ DW_TAG_arg_variable ] [p] [line 1] -; CHECK: ![[VAR_ID]] = metadata {{.*}} i64 2} ; [ DW_TAG_auto_variable ] [r] [line 2] +; CHECK: ![[ARG_ID]] = {{.*}}metadata ![[OPDEREF:[0-9]+]]} ; [ DW_TAG_arg_variable ] [p] [line 1] +; CHECK: ![[OPDEREF]] = metadata !{i64 2} +; CHECK: ![[VAR_ID]] = {{.*}}metadata ![[OPDEREF]]} ; [ DW_TAG_auto_variable ] [r] [line 2] ; Verify that there are no more variable descriptors. ; CHECK-NOT: DW_TAG_arg_variable ; CHECK-NOT: DW_TAG_auto_variable diff --git a/test/Instrumentation/AddressSanitizer/do-not-instrument-llvm-metadata.ll b/test/Instrumentation/AddressSanitizer/do-not-instrument-llvm-metadata.ll index fbfc096..d02f12a 100644 --- a/test/Instrumentation/AddressSanitizer/do-not-instrument-llvm-metadata.ll +++ b/test/Instrumentation/AddressSanitizer/do-not-instrument-llvm-metadata.ll @@ -5,7 +5,7 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" @.str_noinst = private unnamed_addr constant [4 x i8] c"aaa\00", section "llvm.metadata" -@.str_inst = private unnamed_addr constant [4 x i8] c"aaa\00", +@.str_inst = private unnamed_addr constant [4 x i8] c"aaa\00" ; CHECK-NOT: {{asan_gen.*str_noinst}} ; CHECK: {{asan_gen.*str_inst}} diff --git a/test/Instrumentation/AddressSanitizer/global_metadata.ll b/test/Instrumentation/AddressSanitizer/global_metadata.ll new file mode 100644 index 0000000..9641c3e --- /dev/null +++ b/test/Instrumentation/AddressSanitizer/global_metadata.ll @@ -0,0 +1,63 @@ +; RUN: opt < %s -asan -asan-module -S | FileCheck %s + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +; Globals: +@global = global i32 0, align 4 +@dyn_init_global = global i32 0, align 4 +@blacklisted_global = global i32 0, align 4 +@_ZZ4funcvE10static_var = internal global i32 0, align 4 +@.str = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1 +@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_asan_globals.cpp, i8* null }] + +; Sanitizer location descriptors: +@.str1 = private unnamed_addr constant [22 x i8] c"/tmp/asan-globals.cpp\00", align 1 +@.asan_loc_descr = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* @.str1, i32 5, i32 5 } +@.asan_loc_descr1 = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* @.str1, i32 7, i32 5 } +@.asan_loc_descr2 = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* @.str1, i32 12, i32 14 } +@.asan_loc_descr4 = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* @.str1, i32 14, i32 25 } + +; Check that globals were instrumented, but sanitizer location descriptors weren't: +; CHECK: @global = global { i32, [60 x i8] } zeroinitializer, align 32 +; CHECK: @.str = internal unnamed_addr constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, align 32 +; CHECK: @.asan_loc_descr = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* @.str1, i32 5, i32 5 } + +; Check that location decriptors were passed into __asan_register_globals: +; CHECK: i64 ptrtoint ({ [22 x i8]*, i32, i32 }* @.asan_loc_descr to i64) + +; Function Attrs: nounwind sanitize_address +define internal void @__cxx_global_var_init() #0 section ".text.startup" { +entry: + %0 = load i32* @global, align 4 + store i32 %0, i32* @dyn_init_global, align 4 + ret void +} + +; Function Attrs: nounwind sanitize_address +define void @_Z4funcv() #1 { +entry: + %literal = alloca i8*, align 8 + store i8* getelementptr inbounds ([14 x i8]* @.str, i32 0, i32 0), i8** %literal, align 8 + ret void +} + +; Function Attrs: nounwind sanitize_address +define internal void @_GLOBAL__sub_I_asan_globals.cpp() #0 section ".text.startup" { +entry: + call void @__cxx_global_var_init() + ret void +} + +attributes #0 = { nounwind sanitize_address } +attributes #1 = { nounwind sanitize_address "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } + +!llvm.asan.globals = !{!0, !1, !2, !3, !4} +!llvm.ident = !{!5} + +!0 = metadata !{i32* @global, { [22 x i8]*, i32, i32 }* @.asan_loc_descr, i1 false, i1 false} +!1 = metadata !{i32* @dyn_init_global, { [22 x i8]*, i32, i32 }* @.asan_loc_descr1, i1 true, i1 false} +!2 = metadata !{i32* @blacklisted_global, null, i1 false, i1 true} +!3 = metadata !{i32* @_ZZ4funcvE10static_var, { [22 x i8]*, i32, i32 }* @.asan_loc_descr2, i1 false, i1 false} +!4 = metadata !{[14 x i8]* @.str, { [22 x i8]*, i32, i32 }* @.asan_loc_descr4, i1 false, i1 false} +!5 = metadata !{metadata !"clang version 3.5.0 (211282)"} diff --git a/test/Instrumentation/AddressSanitizer/instrument_global.ll b/test/Instrumentation/AddressSanitizer/instrument_global.ll index 7945e81..816ab29 100644 --- a/test/Instrumentation/AddressSanitizer/instrument_global.ll +++ b/test/Instrumentation/AddressSanitizer/instrument_global.ll @@ -68,8 +68,8 @@ entry: } -!llvm.asan.dynamically_initialized_globals = !{!0} -!0 = metadata !{[10 x i32]* @GlobDy} +!llvm.asan.globals = !{!0} +!0 = metadata !{[10 x i32]* @GlobDy, null, i1 true, i1 false} ; CHECK-LABEL: define internal void @asan.module_ctor ; CHECK-NOT: ret diff --git a/test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll b/test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll index 1d00cfa..83ff53f 100644 --- a/test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll +++ b/test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll @@ -7,9 +7,11 @@ target triple = "x86_64-unknown-linux-gnu" @YYY = global i32 0, align 4 ; W/o dynamic initializer. ; Clang will emit the following metadata identifying @xxx as dynamically ; initialized. -!0 = metadata !{i32* @xxx} -!1 = metadata !{i32* @XXX} -!llvm.asan.dynamically_initialized_globals = !{!0, !1} +!0 = metadata !{i32* @xxx, null, i1 true, i1 false} +!1 = metadata !{i32* @XXX, null, i1 true, i1 false} +!2 = metadata !{i32* @yyy, null, i1 false, i1 false} +!3 = metadata !{i32* @YYY, null, i1 false, i1 false} +!llvm.asan.globals = !{!0, !1, !2, !3} define i32 @initializer() uwtable { entry: @@ -23,6 +25,8 @@ entry: ret void } +@llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }] + define internal void @_GLOBAL__I_a() sanitize_address section ".text.startup" { entry: call void @__cxx_global_var_init() diff --git a/test/Instrumentation/AddressSanitizer/lifetime.ll b/test/Instrumentation/AddressSanitizer/lifetime.ll index 1961997..175a07d 100644 --- a/test/Instrumentation/AddressSanitizer/lifetime.ll +++ b/test/Instrumentation/AddressSanitizer/lifetime.ll @@ -1,5 +1,5 @@ ; Test hanlding of llvm.lifetime intrinsics. -; RUN: opt < %s -asan -asan-module -asan-check-lifetime -S | FileCheck %s +; RUN: opt < %s -asan -asan-module -asan-check-lifetime -asan-use-after-return=0 -S | FileCheck %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" diff --git a/test/Instrumentation/AddressSanitizer/stack-poisoning.ll b/test/Instrumentation/AddressSanitizer/stack-poisoning.ll index 6919e53..ace12d0 100644 --- a/test/Instrumentation/AddressSanitizer/stack-poisoning.ll +++ b/test/Instrumentation/AddressSanitizer/stack-poisoning.ll @@ -1,5 +1,5 @@ ; RUN: opt < %s -asan -asan-module -asan-use-after-return -S | FileCheck --check-prefix=CHECK-UAR %s -; RUN: opt < %s -asan -asan-module -S | FileCheck --check-prefix=CHECK-PLAIN %s +; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck --check-prefix=CHECK-PLAIN %s target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" diff --git a/test/Instrumentation/BoundsChecking/phi.ll b/test/Instrumentation/BoundsChecking/phi.ll index 0f9d1b0..25a5ed1 100644 --- a/test/Instrumentation/BoundsChecking/phi.ll +++ b/test/Instrumentation/BoundsChecking/phi.ll @@ -52,7 +52,7 @@ fn.exit: } -@global_as1 = private addrspace(1) unnamed_addr constant [10 x i8] c"ola\00mundo\00", align 1 +@global_as1 = private unnamed_addr addrspace(1) constant [10 x i8] c"ola\00mundo\00", align 1 define void @f1_as1(i8 addrspace(1)* nocapture %c) { ; CHECK: @f1_as1 diff --git a/test/Instrumentation/DataFlowSanitizer/prefix-rename.ll b/test/Instrumentation/DataFlowSanitizer/prefix-rename.ll index 1a56460..f3c36b1 100644 --- a/test/Instrumentation/DataFlowSanitizer/prefix-rename.ll +++ b/test/Instrumentation/DataFlowSanitizer/prefix-rename.ll @@ -8,7 +8,15 @@ module asm ".symver f1,f@@version1" ; CHECK: @"dfs$f2" = alias {{.*}} @"dfs$f1" @f2 = alias void ()* @f1 +; CHECK: @"dfs$g2" = alias {{.*}} @"dfs$g1" +@g2 = alias bitcast (void (i8*)* @g1 to void (i16*)*) + ; CHECK: define void @"dfs$f1" define void @f1() { ret void } + +; CHECK: define void @"dfs$g1" +define void @g1(i8*) { + ret void +} diff --git a/test/Instrumentation/MemorySanitizer/atomics.ll b/test/Instrumentation/MemorySanitizer/atomics.ll index 98697d7..c8f3b88 100644 --- a/test/Instrumentation/MemorySanitizer/atomics.ll +++ b/test/Instrumentation/MemorySanitizer/atomics.ll @@ -37,12 +37,13 @@ entry: define i32 @Cmpxchg(i32* %p, i32 %a, i32 %b) sanitize_memory { entry: - %0 = cmpxchg i32* %p, i32 %a, i32 %b seq_cst seq_cst + %pair = cmpxchg i32* %p, i32 %a, i32 %b seq_cst seq_cst + %0 = extractvalue { i32, i1 } %pair, 0 ret i32 %0 } ; CHECK: @Cmpxchg -; CHECK: store i32 0, +; CHECK: store { i32, i1 } zeroinitializer, ; CHECK: icmp ; CHECK: br ; CHECK: @__msan_warning @@ -55,12 +56,13 @@ entry: define i32 @CmpxchgMonotonic(i32* %p, i32 %a, i32 %b) sanitize_memory { entry: - %0 = cmpxchg i32* %p, i32 %a, i32 %b monotonic monotonic + %pair = cmpxchg i32* %p, i32 %a, i32 %b monotonic monotonic + %0 = extractvalue { i32, i1 } %pair, 0 ret i32 %0 } ; CHECK: @CmpxchgMonotonic -; CHECK: store i32 0, +; CHECK: store { i32, i1 } zeroinitializer, ; CHECK: icmp ; CHECK: br ; CHECK: @__msan_warning diff --git a/test/Instrumentation/MemorySanitizer/instrumentation-with-call-threshold.ll b/test/Instrumentation/MemorySanitizer/instrumentation-with-call-threshold.ll index 34988ef..beb3c5f 100644 --- a/test/Instrumentation/MemorySanitizer/instrumentation-with-call-threshold.ll +++ b/test/Instrumentation/MemorySanitizer/instrumentation-with-call-threshold.ll @@ -1,7 +1,10 @@ ; Test -msan-instrumentation-with-call-threshold +; Test that in with-calls mode there are no calls to __msan_chain_origin - they +; are done from __msan_maybe_store_origin_*. ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -S | FileCheck %s ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s +; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -msan-track-origins=2 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" @@ -41,7 +44,10 @@ entry: ; CHECK: load {{.*}} @__msan_param_tls ; CHECK-ORIGINS: load {{.*}} @__msan_param_origin_tls ; CHECK: store +; CHECK-ORIGINS-NOT: __msan_chain_origin ; CHECK-ORIGINS: bitcast i64* {{.*}} to i8* +; CHECK-ORIGINS-NOT: __msan_chain_origin ; CHECK-ORIGINS: call void @__msan_maybe_store_origin_8( +; CHECK-ORIGINS-NOT: __msan_chain_origin ; CHECK: store i64 ; CHECK: ret void diff --git a/test/Instrumentation/MemorySanitizer/missing_origin.ll b/test/Instrumentation/MemorySanitizer/missing_origin.ll new file mode 100644 index 0000000..673e853 --- /dev/null +++ b/test/Instrumentation/MemorySanitizer/missing_origin.ll @@ -0,0 +1,19 @@ +; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +; Test that result origin is directy propagated from the argument, +; and is not affected by all the literal undef operands. +; https://code.google.com/p/memory-sanitizer/issues/detail?id=56 + +define <4 x i32> @Shuffle(<4 x i32> %x) nounwind uwtable sanitize_memory { +entry: + %y = shufflevector <4 x i32> %x, <4 x i32> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef> + ret <4 x i32> %y +} + +; CHECK-LABEL: @Shuffle( +; CHECK: [[A:%.*]] = load i32* {{.*}}@__msan_param_origin_tls, +; CHECK: store i32 [[A]], i32* @__msan_retval_origin_tls +; CHECK: ret <4 x i32> diff --git a/test/Instrumentation/MemorySanitizer/msan_basic.ll b/test/Instrumentation/MemorySanitizer/msan_basic.ll index 6b71310..51693cd 100644 --- a/test/Instrumentation/MemorySanitizer/msan_basic.ll +++ b/test/Instrumentation/MemorySanitizer/msan_basic.ll @@ -651,7 +651,7 @@ define void @VACopy(i8* %p1, i8* %p2) nounwind uwtable sanitize_memory { declare void @llvm.va_start(i8*) nounwind ; Function Attrs: nounwind uwtable -define void @VAStart(i32 %x, ...) { +define void @VAStart(i32 %x, ...) sanitize_memory { entry: %x.addr = alloca i32, align 4 %va = alloca [1 x %struct.__va_list_tag], align 16 @@ -683,7 +683,7 @@ entry: ; CHECK: ret void -; Test that checks are omitted but shadow propagation is kept if +; Test that checks are omitted and returned value is always initialized if ; sanitize_memory attribute is missing. define i32 @NoSanitizeMemory(i32 %x) uwtable { @@ -703,9 +703,7 @@ declare void @bar() ; CHECK: @NoSanitizeMemory ; CHECK-NOT: @__msan_warning -; CHECK: load i32* {{.*}} @__msan_param_tls -; CHECK-NOT: @__msan_warning -; CHECK: store {{.*}} @__msan_retval_tls +; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK-NOT: @__msan_warning ; CHECK: ret i32 @@ -745,6 +743,29 @@ declare i32 @NoSanitizeMemoryUndefHelper(i32 %x) ; CHECK: ret i32 +; Test PHINode instrumentation in blacklisted functions + +define i32 @NoSanitizeMemoryPHI(i32 %x) { +entry: + %tobool = icmp ne i32 %x, 0 + br i1 %tobool, label %cond.true, label %cond.false + +cond.true: ; preds = %entry + br label %cond.end + +cond.false: ; preds = %entry + br label %cond.end + +cond.end: ; preds = %cond.false, %cond.true + %cond = phi i32 [ undef, %cond.true ], [ undef, %cond.false ] + ret i32 %cond +} + +; CHECK: [[A:%.*]] = phi i32 [ undef, %cond.true ], [ undef, %cond.false ] +; CHECK: store i32 0, i32* bitcast {{.*}} @__msan_retval_tls +; CHECK: ret i32 [[A]] + + ; Test argument shadow alignment define <2 x i64> @ArgumentShadowAlignment(i64 %a, <2 x i64> %b) sanitize_memory { @@ -825,3 +846,17 @@ entry: ; CHECK: store i64 16, i64* @__msan_va_arg_overflow_size_tls ; CHECK: call void (i32, ...)* @VAArgStructFn ; CHECK: ret void + +declare i32 @InnerTailCall(i32 %a) + +define void @MismatchedReturnTypeTailCall(i32 %a) sanitize_memory { + %b = tail call i32 @InnerTailCall(i32 %a) + ret void +} + +; We used to strip off the 'tail' modifier, but now that we unpoison return slot +; shadow before the call, we don't need to anymore. + +; CHECK-LABEL: define void @MismatchedReturnTypeTailCall +; CHECK: tail call i32 @InnerTailCall +; CHECK: ret void diff --git a/test/Instrumentation/MemorySanitizer/mul_by_constant.ll b/test/Instrumentation/MemorySanitizer/mul_by_constant.ll new file mode 100644 index 0000000..e068f69 --- /dev/null +++ b/test/Instrumentation/MemorySanitizer/mul_by_constant.ll @@ -0,0 +1,94 @@ +; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +; Check instrumentation mul when one of the operands is a constant. + +define i64 @MulConst(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, 42949672960000 + ret i64 %y +} + +; 42949672960000 = 2**32 * 10000 +; 36 trailing zero bits +; 68719476736 = 2**36 + +; CHECK-LABEL: @MulConst( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], 68719476736 +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + + +define i64 @MulZero(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, 0 + ret i64 %y +} + +; CHECK-LABEL: @MulZero( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], 0{{$}} +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + + +define i64 @MulNeg(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, -16 + ret i64 %y +} + +; CHECK-LABEL: @MulNeg( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], 16 +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + + +define i64 @MulNeg2(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, -48 + ret i64 %y +} + +; CHECK-LABEL: @MulNeg2( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], 16 +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + + +define i64 @MulOdd(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, 12345 + ret i64 %y +} + +; CHECK-LABEL: @MulOdd( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], 1 +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + + +define i64 @MulLarge(i64 %x) sanitize_memory { +entry: + %y = mul i64 %x, -9223372036854775808 + ret i64 %y +} + +; -9223372036854775808 = 0x7000000000000000 + +; CHECK-LABEL: @MulLarge( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul i64 [[A]], -9223372036854775808 +; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls + +define <4 x i32> @MulVectorConst(<4 x i32> %x) sanitize_memory { +entry: + %y = mul <4 x i32> %x, <i32 3072, i32 0, i32 -16, i32 -48> + ret <4 x i32> %y +} + +; CHECK-LABEL: @MulVectorConst( +; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls +; CHECK: [[B:%.*]] = mul <4 x i32> [[A]], <i32 1024, i32 0, i32 16, i32 16> +; CHECK: store <4 x i32> [[B]], <4 x i32>* {{.*}} @__msan_retval_tls diff --git a/test/Instrumentation/MemorySanitizer/store-origin.ll b/test/Instrumentation/MemorySanitizer/store-origin.ll index 024a10a..0bd9777 100644 --- a/test/Instrumentation/MemorySanitizer/store-origin.ll +++ b/test/Instrumentation/MemorySanitizer/store-origin.ll @@ -20,7 +20,7 @@ entry: ; Function Attrs: nounwind readnone declare void @llvm.dbg.value(metadata, i64, metadata) #1 -attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { nounwind sanitize_memory "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #1 = { nounwind readnone } !llvm.dbg.cu = !{!0} diff --git a/test/Instrumentation/MemorySanitizer/vector_arith.ll b/test/Instrumentation/MemorySanitizer/vector_arith.ll new file mode 100644 index 0000000..6541a1c --- /dev/null +++ b/test/Instrumentation/MemorySanitizer/vector_arith.ll @@ -0,0 +1,65 @@ +; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +declare <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16>, <8 x i16>) nounwind readnone +declare x86_mmx @llvm.x86.ssse3.pmadd.ub.sw(x86_mmx, x86_mmx) nounwind readnone +declare <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8>, <16 x i8>) nounwind readnone +declare x86_mmx @llvm.x86.mmx.psad.bw(x86_mmx, x86_mmx) nounwind readnone + +define <4 x i32> @Test_sse2_pmadd_wd(<8 x i16> %a, <8 x i16> %b) sanitize_memory { +entry: + %c = tail call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %a, <8 x i16> %b) nounwind + ret <4 x i32> %c +} + +; CHECK-LABEL: @Test_sse2_pmadd_wd( +; CHECK: or <8 x i16> +; CHECK: bitcast <8 x i16> {{.*}} to <4 x i32> +; CHECK: icmp ne <4 x i32> {{.*}}, zeroinitializer +; CHECK: sext <4 x i1> {{.*}} to <4 x i32> +; CHECK: ret <4 x i32> + + +define x86_mmx @Test_ssse3_pmadd_ub_sw(x86_mmx %a, x86_mmx %b) sanitize_memory { +entry: + %c = tail call x86_mmx @llvm.x86.ssse3.pmadd.ub.sw(x86_mmx %a, x86_mmx %b) nounwind + ret x86_mmx %c +} + +; CHECK-LABEL: @Test_ssse3_pmadd_ub_sw( +; CHECK: or i64 +; CHECK: bitcast i64 {{.*}} to <4 x i16> +; CHECK: icmp ne <4 x i16> {{.*}}, zeroinitializer +; CHECK: sext <4 x i1> {{.*}} to <4 x i16> +; CHECK: bitcast <4 x i16> {{.*}} to i64 +; CHECK: ret x86_mmx + + +define <2 x i64> @Test_x86_sse2_psad_bw(<16 x i8> %a, <16 x i8> %b) sanitize_memory { + %c = tail call <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8> %a, <16 x i8> %b) + ret <2 x i64> %c +} + +; CHECK-LABEL: @Test_x86_sse2_psad_bw( +; CHECK: or <16 x i8> {{.*}}, {{.*}} +; CHECK: bitcast <16 x i8> {{.*}} to <2 x i64> +; CHECK: icmp ne <2 x i64> {{.*}}, zeroinitializer +; CHECK: sext <2 x i1> {{.*}} to <2 x i64> +; CHECK: lshr <2 x i64> {{.*}}, <i64 48, i64 48> +; CHECK: ret <2 x i64> + + +define x86_mmx @Test_x86_mmx_psad_bw(x86_mmx %a, x86_mmx %b) sanitize_memory { +entry: + %c = tail call x86_mmx @llvm.x86.mmx.psad.bw(x86_mmx %a, x86_mmx %b) nounwind + ret x86_mmx %c +} + +; CHECK-LABEL: @Test_x86_mmx_psad_bw( +; CHECK: or i64 +; CHECK: icmp ne i64 +; CHECK: sext i1 {{.*}} to i64 +; CHECK: lshr i64 {{.*}}, 48 +; CHECK: ret x86_mmx diff --git a/test/Instrumentation/MemorySanitizer/vector_pack.ll b/test/Instrumentation/MemorySanitizer/vector_pack.ll new file mode 100644 index 0000000..31c0c62 --- /dev/null +++ b/test/Instrumentation/MemorySanitizer/vector_pack.ll @@ -0,0 +1,60 @@ +; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +declare <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32>, <4 x i32>) nounwind readnone +declare <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %a, <16 x i16> %b) nounwind readnone +declare x86_mmx @llvm.x86.mmx.packuswb(x86_mmx, x86_mmx) nounwind readnone + +define <8 x i16> @Test_packssdw_128(<4 x i32> %a, <4 x i32> %b) sanitize_memory { +entry: + %c = tail call <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32> %a, <4 x i32> %b) nounwind + ret <8 x i16> %c +} + +; CHECK-LABEL: @Test_packssdw_128( +; CHECK-DAG: icmp ne <4 x i32> {{.*}}, zeroinitializer +; CHECK-DAG: sext <4 x i1> {{.*}} to <4 x i32> +; CHECK-DAG: icmp ne <4 x i32> {{.*}}, zeroinitializer +; CHECK-DAG: sext <4 x i1> {{.*}} to <4 x i32> +; CHECK-DAG: call <8 x i16> @llvm.x86.sse2.packssdw.128( +; CHECK-DAG: call <8 x i16> @llvm.x86.sse2.packssdw.128( +; CHECK: ret <8 x i16> + + +define <32 x i8> @Test_avx_packuswb(<16 x i16> %a, <16 x i16> %b) sanitize_memory { +entry: + %c = tail call <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %a, <16 x i16> %b) nounwind + ret <32 x i8> %c +} + +; CHECK-LABEL: @Test_avx_packuswb( +; CHECK-DAG: icmp ne <16 x i16> {{.*}}, zeroinitializer +; CHECK-DAG: sext <16 x i1> {{.*}} to <16 x i16> +; CHECK-DAG: icmp ne <16 x i16> {{.*}}, zeroinitializer +; CHECK-DAG: sext <16 x i1> {{.*}} to <16 x i16> +; CHECK-DAG: call <32 x i8> @llvm.x86.avx2.packsswb( +; CHECK-DAG: call <32 x i8> @llvm.x86.avx2.packuswb( +; CHECK: ret <32 x i8> + + +define x86_mmx @Test_mmx_packuswb(x86_mmx %a, x86_mmx %b) sanitize_memory { +entry: + %c = tail call x86_mmx @llvm.x86.mmx.packuswb(x86_mmx %a, x86_mmx %b) nounwind + ret x86_mmx %c +} + +; CHECK-LABEL: @Test_mmx_packuswb( +; CHECK-DAG: bitcast i64 {{.*}} to <4 x i16> +; CHECK-DAG: bitcast i64 {{.*}} to <4 x i16> +; CHECK-DAG: icmp ne <4 x i16> {{.*}}, zeroinitializer +; CHECK-DAG: sext <4 x i1> {{.*}} to <4 x i16> +; CHECK-DAG: icmp ne <4 x i16> {{.*}}, zeroinitializer +; CHECK-DAG: sext <4 x i1> {{.*}} to <4 x i16> +; CHECK-DAG: bitcast <4 x i16> {{.*}} to x86_mmx +; CHECK-DAG: bitcast <4 x i16> {{.*}} to x86_mmx +; CHECK-DAG: call x86_mmx @llvm.x86.mmx.packsswb({{.*}} +; CHECK-DAG: bitcast x86_mmx {{.*}} to i64 +; CHECK-DAG: call x86_mmx @llvm.x86.mmx.packuswb({{.*}} +; CHECK: ret x86_mmx diff --git a/test/Instrumentation/MemorySanitizer/vector_shift.ll b/test/Instrumentation/MemorySanitizer/vector_shift.ll index d32f51b..91e4bd5 100644 --- a/test/Instrumentation/MemorySanitizer/vector_shift.ll +++ b/test/Instrumentation/MemorySanitizer/vector_shift.ll @@ -13,7 +13,7 @@ declare <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16>, i32) declare <2 x i64> @llvm.x86.sse2.psll.dq(<2 x i64>, i32) declare <2 x i64> @llvm.x86.sse2.psll.dq.bs(<2 x i64>, i32) -define i64 @test_mmx(i64 %x.coerce, i64 %y.coerce) { +define i64 @test_mmx(i64 %x.coerce, i64 %y.coerce) sanitize_memory { entry: %0 = bitcast i64 %x.coerce to <2 x i32> %1 = bitcast <2 x i32> %0 to x86_mmx @@ -35,7 +35,7 @@ entry: ; CHECK: ret i64 -define <8 x i16> @test_sse2_scalar(<8 x i16> %x, i32 %y) { +define <8 x i16> @test_sse2_scalar(<8 x i16> %x, i32 %y) sanitize_memory { entry: %0 = tail call <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16> %x, i32 %y) ret <8 x i16> %0 @@ -51,7 +51,7 @@ entry: ; CHECK: ret <8 x i16> -define <8 x i16> @test_sse2(<8 x i16> %x, <8 x i16> %y) { +define <8 x i16> @test_sse2(<8 x i16> %x, <8 x i16> %y) sanitize_memory { entry: %0 = tail call <8 x i16> @llvm.x86.sse2.psrl.w(<8 x i16> %x, <8 x i16> %y) ret <8 x i16> %0 @@ -71,7 +71,7 @@ entry: ; Test variable shift (i.e. vector by vector). -define <4 x i32> @test_avx2(<4 x i32> %x, <4 x i32> %y) { +define <4 x i32> @test_avx2(<4 x i32> %x, <4 x i32> %y) sanitize_memory { entry: %0 = tail call <4 x i32> @llvm.x86.avx2.psllv.d(<4 x i32> %x, <4 x i32> %y) ret <4 x i32> %0 @@ -85,7 +85,7 @@ entry: ; CHECK: = tail call <4 x i32> @llvm.x86.avx2.psllv.d( ; CHECK: ret <4 x i32> -define <8 x i32> @test_avx2_256(<8 x i32> %x, <8 x i32> %y) { +define <8 x i32> @test_avx2_256(<8 x i32> %x, <8 x i32> %y) sanitize_memory { entry: %0 = tail call <8 x i32> @llvm.x86.avx2.psllv.d.256(<8 x i32> %x, <8 x i32> %y) ret <8 x i32> %0 diff --git a/test/Instrumentation/ThreadSanitizer/tsan_basic.ll b/test/Instrumentation/ThreadSanitizer/tsan_basic.ll index d449a97..dc6e43e 100644 --- a/test/Instrumentation/ThreadSanitizer/tsan_basic.ll +++ b/test/Instrumentation/ThreadSanitizer/tsan_basic.ll @@ -27,7 +27,7 @@ declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) ; Check that tsan converts mem intrinsics back to function calls. -define void @MemCpyTest(i8* nocapture %x, i8* nocapture %y) { +define void @MemCpyTest(i8* nocapture %x, i8* nocapture %y) sanitize_thread { entry: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %x, i8* %y, i64 16, i32 4, i1 false) ret void @@ -36,7 +36,7 @@ entry: ; CHECK: ret void } -define void @MemMoveTest(i8* nocapture %x, i8* nocapture %y) { +define void @MemMoveTest(i8* nocapture %x, i8* nocapture %y) sanitize_thread { entry: tail call void @llvm.memmove.p0i8.p0i8.i64(i8* %x, i8* %y, i64 16, i32 4, i1 false) ret void @@ -45,7 +45,7 @@ entry: ; CHECK: ret void } -define void @MemSetTest(i8* nocapture %x) { +define void @MemSetTest(i8* nocapture %x) sanitize_thread { entry: tail call void @llvm.memset.p0i8.i64(i8* %x, i8 77, i64 16, i32 4, i1 false) ret void |