1 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s 2 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s 3 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s 4 5 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" 6 target triple = "x86_64-unknown-linux-gnu" 7 8 ; atomicrmw xchg: store clean shadow, return clean shadow 9 10 define i32 @AtomicRmwXchg(i32* %p, i32 %x) sanitize_memory { 11 entry: 12 %0 = atomicrmw xchg i32* %p, i32 %x seq_cst 13 ret i32 %0 14 } 15 16 ; CHECK-LABEL: @AtomicRmwXchg 17 ; CHECK: store i32 0, 18 ; CHECK: atomicrmw xchg {{.*}} seq_cst 19 ; CHECK: store i32 0, {{.*}} @__msan_retval_tls 20 ; CHECK: ret i32 21 22 23 ; atomicrmw max: exactly the same as above 24 25 define i32 @AtomicRmwMax(i32* %p, i32 %x) sanitize_memory { 26 entry: 27 %0 = atomicrmw max i32* %p, i32 %x seq_cst 28 ret i32 %0 29 } 30 31 ; CHECK-LABEL: @AtomicRmwMax 32 ; CHECK: store i32 0, 33 ; CHECK: atomicrmw max {{.*}} seq_cst 34 ; CHECK: store i32 0, {{.*}} @__msan_retval_tls 35 ; CHECK: ret i32 36 37 38 ; cmpxchg: the same as above, but also check %a shadow 39 40 define i32 @Cmpxchg(i32* %p, i32 %a, i32 %b) sanitize_memory { 41 entry: 42 %pair = cmpxchg i32* %p, i32 %a, i32 %b seq_cst seq_cst 43 %0 = extractvalue { i32, i1 } %pair, 0 44 ret i32 %0 45 } 46 47 ; CHECK-LABEL: @Cmpxchg 48 ; CHECK: store { i32, i1 } zeroinitializer, 49 ; CHECK: icmp 50 ; CHECK: br 51 ; CHECK: @__msan_warning 52 ; CHECK: cmpxchg {{.*}} seq_cst seq_cst 53 ; CHECK: store i32 0, {{.*}} @__msan_retval_tls 54 ; CHECK: ret i32 55 56 57 ; relaxed cmpxchg: bump up to "release monotonic" 58 59 define i32 @CmpxchgMonotonic(i32* %p, i32 %a, i32 %b) sanitize_memory { 60 entry: 61 %pair = cmpxchg i32* %p, i32 %a, i32 %b monotonic monotonic 62 %0 = extractvalue { i32, i1 } %pair, 0 63 ret i32 %0 64 } 65 66 ; CHECK-LABEL: @CmpxchgMonotonic 67 ; CHECK: store { i32, i1 } zeroinitializer, 68 ; CHECK: icmp 69 ; CHECK: br 70 ; CHECK: @__msan_warning 71 ; CHECK: cmpxchg {{.*}} release monotonic 72 ; CHECK: store i32 0, {{.*}} @__msan_retval_tls 73 ; CHECK: ret i32 74 75 76 ; atomic load: preserve alignment, load shadow value after app value 77 78 define i32 @AtomicLoad(i32* %p) sanitize_memory { 79 entry: 80 %0 = load atomic i32, i32* %p seq_cst, align 16 81 ret i32 %0 82 } 83 84 ; CHECK-LABEL: @AtomicLoad 85 ; CHECK: load atomic i32, i32* {{.*}} seq_cst, align 16 86 ; CHECK: [[SHADOW:%[01-9a-z_]+]] = load i32, i32* {{.*}}, align 16 87 ; CHECK: store i32 {{.*}}[[SHADOW]], {{.*}} @__msan_retval_tls 88 ; CHECK: ret i32 89 90 91 ; atomic load: preserve alignment, load shadow value after app value 92 93 define i32 @AtomicLoadAcquire(i32* %p) sanitize_memory { 94 entry: 95 %0 = load atomic i32, i32* %p acquire, align 16 96 ret i32 %0 97 } 98 99 ; CHECK-LABEL: @AtomicLoadAcquire 100 ; CHECK: load atomic i32, i32* {{.*}} acquire, align 16 101 ; CHECK: [[SHADOW:%[01-9a-z_]+]] = load i32, i32* {{.*}}, align 16 102 ; CHECK: store i32 {{.*}}[[SHADOW]], {{.*}} @__msan_retval_tls 103 ; CHECK: ret i32 104 105 106 ; atomic load monotonic: bump up to load acquire 107 108 define i32 @AtomicLoadMonotonic(i32* %p) sanitize_memory { 109 entry: 110 %0 = load atomic i32, i32* %p monotonic, align 16 111 ret i32 %0 112 } 113 114 ; CHECK-LABEL: @AtomicLoadMonotonic 115 ; CHECK: load atomic i32, i32* {{.*}} acquire, align 16 116 ; CHECK: [[SHADOW:%[01-9a-z_]+]] = load i32, i32* {{.*}}, align 16 117 ; CHECK: store i32 {{.*}}[[SHADOW]], {{.*}} @__msan_retval_tls 118 ; CHECK: ret i32 119 120 121 ; atomic load unordered: bump up to load acquire 122 123 define i32 @AtomicLoadUnordered(i32* %p) sanitize_memory { 124 entry: 125 %0 = load atomic i32, i32* %p unordered, align 16 126 ret i32 %0 127 } 128 129 ; CHECK-LABEL: @AtomicLoadUnordered 130 ; CHECK: load atomic i32, i32* {{.*}} acquire, align 16 131 ; CHECK: [[SHADOW:%[01-9a-z_]+]] = load i32, i32* {{.*}}, align 16 132 ; CHECK: store i32 {{.*}}[[SHADOW]], {{.*}} @__msan_retval_tls 133 ; CHECK: ret i32 134 135 136 ; atomic store: preserve alignment, store clean shadow value before app value 137 138 define void @AtomicStore(i32* %p, i32 %x) sanitize_memory { 139 entry: 140 store atomic i32 %x, i32* %p seq_cst, align 16 141 ret void 142 } 143 144 ; CHECK-LABEL: @AtomicStore 145 ; CHECK-NOT: @__msan_param_tls 146 ; CHECK: store i32 0, i32* {{.*}}, align 16 147 ; CHECK: store atomic i32 %x, i32* %p seq_cst, align 16 148 ; CHECK: ret void 149 150 151 ; atomic store: preserve alignment, store clean shadow value before app value 152 153 define void @AtomicStoreRelease(i32* %p, i32 %x) sanitize_memory { 154 entry: 155 store atomic i32 %x, i32* %p release, align 16 156 ret void 157 } 158 159 ; CHECK-LABEL: @AtomicStoreRelease 160 ; CHECK-NOT: @__msan_param_tls 161 ; CHECK: store i32 0, i32* {{.*}}, align 16 162 ; CHECK: store atomic i32 %x, i32* %p release, align 16 163 ; CHECK: ret void 164 165 166 ; atomic store monotonic: bumped up to store release 167 168 define void @AtomicStoreMonotonic(i32* %p, i32 %x) sanitize_memory { 169 entry: 170 store atomic i32 %x, i32* %p monotonic, align 16 171 ret void 172 } 173 174 ; CHECK-LABEL: @AtomicStoreMonotonic 175 ; CHECK-NOT: @__msan_param_tls 176 ; CHECK: store i32 0, i32* {{.*}}, align 16 177 ; CHECK: store atomic i32 %x, i32* %p release, align 16 178 ; CHECK: ret void 179 180 181 ; atomic store unordered: bumped up to store release 182 183 define void @AtomicStoreUnordered(i32* %p, i32 %x) sanitize_memory { 184 entry: 185 store atomic i32 %x, i32* %p unordered, align 16 186 ret void 187 } 188 189 ; CHECK-LABEL: @AtomicStoreUnordered 190 ; CHECK-NOT: @__msan_param_tls 191 ; CHECK: store i32 0, i32* {{.*}}, align 16 192 ; CHECK: store atomic i32 %x, i32* %p release, align 16 193 ; CHECK: ret void 194
