1 ; RUN: llc -mtriple=armv8-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-LE --check-prefix=CHECK-ARM --check-prefix=CHECK-ARM-LE 2 ; RUN: llc -mtriple=armebv8-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-BE --check-prefix=CHECK-ARM --check-prefix=CHECK-ARM-BE 3 ; RUN: llc -mtriple=thumbv8-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-LE --check-prefix=CHECK-THUMB --check-prefix=CHECK-THUMB-LE 4 ; RUN: llc -mtriple=thumbebv8-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-BE --check-prefix=CHECK-THUMB --check-prefix=CHECK-THUMB-BE 5 6 @var8 = global i8 0 7 @var16 = global i16 0 8 @var32 = global i32 0 9 @var64 = global i64 0 10 11 define i8 @test_atomic_load_add_i8(i8 %offset) nounwind { 12 ; CHECK-LABEL: test_atomic_load_add_i8: 13 %old = atomicrmw add i8* @var8, i8 %offset seq_cst 14 ; CHECK-NOT: dmb 15 ; CHECK-NOT: mcr 16 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 17 ; CHECK: movt r[[ADDR]], :upper16:var8 18 19 ; CHECK: .LBB{{[0-9]+}}_1: 20 ; CHECK: ldaexb r[[OLD:[0-9]+]], [r[[ADDR]]] 21 ; r0 below is a reasonable guess but could change: it certainly comes into the 22 ; function there. 23 ; CHECK-NEXT: add{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 24 ; CHECK-NEXT: stlexb [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 25 ; CHECK-NEXT: cmp [[STATUS]], #0 26 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 27 ; CHECK-NOT: dmb 28 ; CHECK-NOT: mcr 29 30 ; CHECK: mov r0, r[[OLD]] 31 ret i8 %old 32 } 33 34 define i16 @test_atomic_load_add_i16(i16 %offset) nounwind { 35 ; CHECK-LABEL: test_atomic_load_add_i16: 36 %old = atomicrmw add i16* @var16, i16 %offset acquire 37 ; CHECK-NOT: dmb 38 ; CHECK-NOT: mcr 39 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 40 ; CHECK: movt r[[ADDR]], :upper16:var16 41 42 ; CHECK: .LBB{{[0-9]+}}_1: 43 ; CHECK: ldaexh r[[OLD:[0-9]+]], [r[[ADDR]]] 44 ; r0 below is a reasonable guess but could change: it certainly comes into the 45 ; function there. 46 ; CHECK-NEXT: add{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 47 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 48 ; CHECK-NEXT: cmp [[STATUS]], #0 49 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 50 ; CHECK-NOT: dmb 51 ; CHECK-NOT: mcr 52 53 ; CHECK: mov r0, r[[OLD]] 54 ret i16 %old 55 } 56 57 define i32 @test_atomic_load_add_i32(i32 %offset) nounwind { 58 ; CHECK-LABEL: test_atomic_load_add_i32: 59 %old = atomicrmw add i32* @var32, i32 %offset release 60 ; CHECK-NOT: dmb 61 ; CHECK-NOT: mcr 62 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 63 ; CHECK: movt r[[ADDR]], :upper16:var32 64 65 ; CHECK: .LBB{{[0-9]+}}_1: 66 ; CHECK: ldrex r[[OLD:[0-9]+]], [r[[ADDR]]] 67 ; r0 below is a reasonable guess but could change: it certainly comes into the 68 ; function there. 69 ; CHECK-NEXT: add{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 70 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 71 ; CHECK-NEXT: cmp [[STATUS]], #0 72 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 73 ; CHECK-NOT: dmb 74 ; CHECK-NOT: mcr 75 76 ; CHECK: mov r0, r[[OLD]] 77 ret i32 %old 78 } 79 80 define void @test_atomic_load_add_i64(i64 %offset) nounwind { 81 ; CHECK-LABEL: test_atomic_load_add_i64: 82 %old = atomicrmw add i64* @var64, i64 %offset monotonic 83 ; CHECK-NOT: dmb 84 ; CHECK-NOT: mcr 85 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 86 ; CHECK: movt r[[ADDR]], :upper16:var64 87 88 ; CHECK: .LBB{{[0-9]+}}_1: 89 ; CHECK: ldrexd r[[OLD1:[0-9]+]], r[[OLD2:[0-9]+]], [r[[ADDR]]] 90 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 91 ; function there. 92 ; CHECK-LE-NEXT: adds{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 93 ; CHECK-LE-NEXT: adc{{(\.w)?}} [[NEW2:r[0-9]+]], r[[OLD2]], r1 94 ; CHECK-BE-NEXT: adds{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 95 ; CHECK-BE-NEXT: adc{{(\.w)?}} [[NEW1:r[0-9]+]], r[[OLD1]], r0 96 ; CHECK-NEXT: strexd [[STATUS:r[0-9]+]], [[NEW1]], [[NEW2]], [r[[ADDR]]] 97 ; CHECK-NEXT: cmp [[STATUS]], #0 98 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 99 ; CHECK-NOT: dmb 100 ; CHECK-NOT: mcr 101 102 ; CHECK: strd r[[OLD1]], r[[OLD2]], [r[[ADDR]]] 103 store i64 %old, i64* @var64 104 ret void 105 } 106 107 define i8 @test_atomic_load_sub_i8(i8 %offset) nounwind { 108 ; CHECK-LABEL: test_atomic_load_sub_i8: 109 %old = atomicrmw sub i8* @var8, i8 %offset monotonic 110 ; CHECK-NOT: dmb 111 ; CHECK-NOT: mcr 112 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 113 ; CHECK: movt r[[ADDR]], :upper16:var8 114 115 ; CHECK: .LBB{{[0-9]+}}_1: 116 ; CHECK: ldrexb r[[OLD:[0-9]+]], [r[[ADDR]]] 117 ; r0 below is a reasonable guess but could change: it certainly comes into the 118 ; function there. 119 ; CHECK-NEXT: sub{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 120 ; CHECK-NEXT: strexb [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 121 ; CHECK-NEXT: cmp [[STATUS]], #0 122 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 123 ; CHECK-NOT: dmb 124 ; CHECK-NOT: mcr 125 126 ; CHECK: mov r0, r[[OLD]] 127 ret i8 %old 128 } 129 130 define i16 @test_atomic_load_sub_i16(i16 %offset) nounwind { 131 ; CHECK-LABEL: test_atomic_load_sub_i16: 132 %old = atomicrmw sub i16* @var16, i16 %offset release 133 ; CHECK-NOT: dmb 134 ; CHECK-NOT: mcr 135 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 136 ; CHECK: movt r[[ADDR]], :upper16:var16 137 138 ; CHECK: .LBB{{[0-9]+}}_1: 139 ; CHECK: ldrexh r[[OLD:[0-9]+]], [r[[ADDR]]] 140 ; r0 below is a reasonable guess but could change: it certainly comes into the 141 ; function there. 142 ; CHECK-NEXT: sub{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 143 ; CHECK-NEXT: stlexh [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 144 ; CHECK-NEXT: cmp [[STATUS]], #0 145 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 146 ; CHECK-NOT: dmb 147 ; CHECK-NOT: mcr 148 149 ; CHECK: mov r0, r[[OLD]] 150 ret i16 %old 151 } 152 153 define i32 @test_atomic_load_sub_i32(i32 %offset) nounwind { 154 ; CHECK-LABEL: test_atomic_load_sub_i32: 155 %old = atomicrmw sub i32* @var32, i32 %offset acquire 156 ; CHECK-NOT: dmb 157 ; CHECK-NOT: mcr 158 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 159 ; CHECK: movt r[[ADDR]], :upper16:var32 160 161 ; CHECK: .LBB{{[0-9]+}}_1: 162 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 163 ; r0 below is a reasonable guess but could change: it certainly comes into the 164 ; function there. 165 ; CHECK-NEXT: sub{{s?}} [[NEW:r[0-9]+]], r[[OLD]], r0 166 ; CHECK-NEXT: strex [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 167 ; CHECK-NEXT: cmp [[STATUS]], #0 168 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 169 ; CHECK-NOT: dmb 170 ; CHECK-NOT: mcr 171 172 ; CHECK: mov r0, r[[OLD]] 173 ret i32 %old 174 } 175 176 define void @test_atomic_load_sub_i64(i64 %offset) nounwind { 177 ; CHECK-LABEL: test_atomic_load_sub_i64: 178 %old = atomicrmw sub i64* @var64, i64 %offset seq_cst 179 ; CHECK-NOT: dmb 180 ; CHECK-NOT: mcr 181 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 182 ; CHECK: movt r[[ADDR]], :upper16:var64 183 184 ; CHECK: .LBB{{[0-9]+}}_1: 185 ; CHECK: ldaexd r[[OLD1:[0-9]+]], r[[OLD2:[0-9]+]], [r[[ADDR]]] 186 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 187 ; function there. 188 ; CHECK-LE-NEXT: subs{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 189 ; CHECK-LE-NEXT: sbc{{(\.w)?}} [[NEW2:r[0-9]+]], r[[OLD2]], r1 190 ; CHECK-BE-NEXT: subs{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 191 ; CHECK-BE-NEXT: sbc{{(\.w)?}} [[NEW1:r[0-9]+]], r[[OLD1]], r0 192 ; CHECK-NEXT: stlexd [[STATUS:r[0-9]+]], [[NEW1]], [[NEW2]], [r[[ADDR]]] 193 ; CHECK-NEXT: cmp [[STATUS]], #0 194 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 195 ; CHECK-NOT: dmb 196 ; CHECK-NOT: mcr 197 198 ; CHECK: strd r[[OLD1]], r[[OLD2]], [r[[ADDR]]] 199 store i64 %old, i64* @var64 200 ret void 201 } 202 203 define i8 @test_atomic_load_and_i8(i8 %offset) nounwind { 204 ; CHECK-LABEL: test_atomic_load_and_i8: 205 %old = atomicrmw and i8* @var8, i8 %offset release 206 ; CHECK-NOT: dmb 207 ; CHECK-NOT: mcr 208 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 209 ; CHECK: movt r[[ADDR]], :upper16:var8 210 211 ; CHECK: .LBB{{[0-9]+}}_1: 212 ; CHECK: ldrexb r[[OLD:[0-9]+]], [r[[ADDR]]] 213 ; r0 below is a reasonable guess but could change: it certainly comes into the 214 ; function there. 215 ; CHECK-NEXT: and{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 216 ; CHECK-NEXT: stlexb [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 217 ; CHECK-NEXT: cmp [[STATUS]], #0 218 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 219 ; CHECK-NOT: dmb 220 ; CHECK-NOT: mcr 221 222 ; CHECK: mov r0, r[[OLD]] 223 ret i8 %old 224 } 225 226 define i16 @test_atomic_load_and_i16(i16 %offset) nounwind { 227 ; CHECK-LABEL: test_atomic_load_and_i16: 228 %old = atomicrmw and i16* @var16, i16 %offset monotonic 229 ; CHECK-NOT: dmb 230 ; CHECK-NOT: mcr 231 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 232 ; CHECK: movt r[[ADDR]], :upper16:var16 233 234 ; CHECK: .LBB{{[0-9]+}}_1: 235 ; CHECK: ldrexh r[[OLD:[0-9]+]], [r[[ADDR]]] 236 ; r0 below is a reasonable guess but could change: it certainly comes into the 237 ; function there. 238 ; CHECK-NEXT: and{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 239 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 240 ; CHECK-NEXT: cmp [[STATUS]], #0 241 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 242 ; CHECK-NOT: dmb 243 ; CHECK-NOT: mcr 244 245 ; CHECK: mov r0, r[[OLD]] 246 ret i16 %old 247 } 248 249 define i32 @test_atomic_load_and_i32(i32 %offset) nounwind { 250 ; CHECK-LABEL: test_atomic_load_and_i32: 251 %old = atomicrmw and i32* @var32, i32 %offset seq_cst 252 ; CHECK-NOT: dmb 253 ; CHECK-NOT: mcr 254 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 255 ; CHECK: movt r[[ADDR]], :upper16:var32 256 257 ; CHECK: .LBB{{[0-9]+}}_1: 258 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 259 ; r0 below is a reasonable guess but could change: it certainly comes into the 260 ; function there. 261 ; CHECK-NEXT: and{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 262 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 263 ; CHECK-NEXT: cmp [[STATUS]], #0 264 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 265 ; CHECK-NOT: dmb 266 ; CHECK-NOT: mcr 267 268 ; CHECK: mov r0, r[[OLD]] 269 ret i32 %old 270 } 271 272 define void @test_atomic_load_and_i64(i64 %offset) nounwind { 273 ; CHECK-LABEL: test_atomic_load_and_i64: 274 %old = atomicrmw and i64* @var64, i64 %offset acquire 275 ; CHECK-NOT: dmb 276 ; CHECK-NOT: mcr 277 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 278 ; CHECK: movt r[[ADDR]], :upper16:var64 279 280 ; CHECK: .LBB{{[0-9]+}}_1: 281 ; CHECK: ldaexd r[[OLD1:[0-9]+]], r[[OLD2:[0-9]+]], [r[[ADDR]]] 282 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 283 ; function there. 284 ; CHECK-LE-DAG: and{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 285 ; CHECK-LE-DAG: and{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 286 ; CHECK-BE-DAG: and{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 287 ; CHECK-BE-DAG: and{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 288 ; CHECK: strexd [[STATUS:r[0-9]+]], [[NEW1]], [[NEW2]], [r[[ADDR]]] 289 ; CHECK-NEXT: cmp [[STATUS]], #0 290 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 291 ; CHECK-NOT: dmb 292 ; CHECK-NOT: mcr 293 294 ; CHECK: strd r[[OLD1]], r[[OLD2]], [r[[ADDR]]] 295 store i64 %old, i64* @var64 296 ret void 297 } 298 299 define i8 @test_atomic_load_or_i8(i8 %offset) nounwind { 300 ; CHECK-LABEL: test_atomic_load_or_i8: 301 %old = atomicrmw or i8* @var8, i8 %offset seq_cst 302 ; CHECK-NOT: dmb 303 ; CHECK-NOT: mcr 304 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 305 ; CHECK: movt r[[ADDR]], :upper16:var8 306 307 ; CHECK: .LBB{{[0-9]+}}_1: 308 ; CHECK: ldaexb r[[OLD:[0-9]+]], [r[[ADDR]]] 309 ; r0 below is a reasonable guess but could change: it certainly comes into the 310 ; function there. 311 ; CHECK-NEXT: orr{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 312 ; CHECK-NEXT: stlexb [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 313 ; CHECK-NEXT: cmp [[STATUS]], #0 314 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 315 ; CHECK-NOT: dmb 316 ; CHECK-NOT: mcr 317 318 ; CHECK: mov r0, r[[OLD]] 319 ret i8 %old 320 } 321 322 define i16 @test_atomic_load_or_i16(i16 %offset) nounwind { 323 ; CHECK-LABEL: test_atomic_load_or_i16: 324 %old = atomicrmw or i16* @var16, i16 %offset monotonic 325 ; CHECK-NOT: dmb 326 ; CHECK-NOT: mcr 327 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 328 ; CHECK: movt r[[ADDR]], :upper16:var16 329 330 ; CHECK: .LBB{{[0-9]+}}_1: 331 ; CHECK: ldrexh r[[OLD:[0-9]+]], [r[[ADDR]]] 332 ; r0 below is a reasonable guess but could change: it certainly comes into the 333 ; function there. 334 ; CHECK-NEXT: orr{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 335 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 336 ; CHECK-NEXT: cmp [[STATUS]], #0 337 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 338 ; CHECK-NOT: dmb 339 ; CHECK-NOT: mcr 340 341 ; CHECK: mov r0, r[[OLD]] 342 ret i16 %old 343 } 344 345 define i32 @test_atomic_load_or_i32(i32 %offset) nounwind { 346 ; CHECK-LABEL: test_atomic_load_or_i32: 347 %old = atomicrmw or i32* @var32, i32 %offset acquire 348 ; CHECK-NOT: dmb 349 ; CHECK-NOT: mcr 350 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 351 ; CHECK: movt r[[ADDR]], :upper16:var32 352 353 ; CHECK: .LBB{{[0-9]+}}_1: 354 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 355 ; r0 below is a reasonable guess but could change: it certainly comes into the 356 ; function there. 357 ; CHECK-NEXT: orr{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 358 ; CHECK-NEXT: strex [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 359 ; CHECK-NEXT: cmp [[STATUS]], #0 360 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 361 ; CHECK-NOT: dmb 362 ; CHECK-NOT: mcr 363 364 ; CHECK: mov r0, r[[OLD]] 365 ret i32 %old 366 } 367 368 define void @test_atomic_load_or_i64(i64 %offset) nounwind { 369 ; CHECK-LABEL: test_atomic_load_or_i64: 370 %old = atomicrmw or i64* @var64, i64 %offset release 371 ; CHECK-NOT: dmb 372 ; CHECK-NOT: mcr 373 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 374 ; CHECK: movt r[[ADDR]], :upper16:var64 375 376 ; CHECK: .LBB{{[0-9]+}}_1: 377 ; CHECK: ldrexd r[[OLD1:[0-9]+]], r[[OLD2:[0-9]+]], [r[[ADDR]]] 378 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 379 ; function there. 380 ; CHECK-LE-DAG: orr{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 381 ; CHECK-LE-DAG: orr{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 382 ; CHECK-BE-DAG: orr{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 383 ; CHECK-BE-DAG: orr{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 384 ; CHECK: stlexd [[STATUS:r[0-9]+]], [[NEW1]], [[NEW2]], [r[[ADDR]]] 385 ; CHECK-NEXT: cmp [[STATUS]], #0 386 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 387 ; CHECK-NOT: dmb 388 ; CHECK-NOT: mcr 389 390 ; CHECK: strd r[[OLD1]], r[[OLD2]], [r[[ADDR]]] 391 store i64 %old, i64* @var64 392 ret void 393 } 394 395 define i8 @test_atomic_load_xor_i8(i8 %offset) nounwind { 396 ; CHECK-LABEL: test_atomic_load_xor_i8: 397 %old = atomicrmw xor i8* @var8, i8 %offset acquire 398 ; CHECK-NOT: dmb 399 ; CHECK-NOT: mcr 400 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 401 ; CHECK: movt r[[ADDR]], :upper16:var8 402 403 ; CHECK: .LBB{{[0-9]+}}_1: 404 ; CHECK: ldaexb r[[OLD:[0-9]+]], [r[[ADDR]]] 405 ; r0 below is a reasonable guess but could change: it certainly comes into the 406 ; function there. 407 ; CHECK-NEXT: eor{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 408 ; CHECK-NEXT: strexb [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 409 ; CHECK-NEXT: cmp [[STATUS]], #0 410 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 411 ; CHECK-NOT: dmb 412 ; CHECK-NOT: mcr 413 414 ; CHECK: mov r0, r[[OLD]] 415 ret i8 %old 416 } 417 418 define i16 @test_atomic_load_xor_i16(i16 %offset) nounwind { 419 ; CHECK-LABEL: test_atomic_load_xor_i16: 420 %old = atomicrmw xor i16* @var16, i16 %offset release 421 ; CHECK-NOT: dmb 422 ; CHECK-NOT: mcr 423 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 424 ; CHECK: movt r[[ADDR]], :upper16:var16 425 426 ; CHECK: .LBB{{[0-9]+}}_1: 427 ; CHECK: ldrexh r[[OLD:[0-9]+]], [r[[ADDR]]] 428 ; r0 below is a reasonable guess but could change: it certainly comes into the 429 ; function there. 430 ; CHECK-NEXT: eor{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 431 ; CHECK-NEXT: stlexh [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 432 ; CHECK-NEXT: cmp [[STATUS]], #0 433 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 434 ; CHECK-NOT: dmb 435 ; CHECK-NOT: mcr 436 437 ; CHECK: mov r0, r[[OLD]] 438 ret i16 %old 439 } 440 441 define i32 @test_atomic_load_xor_i32(i32 %offset) nounwind { 442 ; CHECK-LABEL: test_atomic_load_xor_i32: 443 %old = atomicrmw xor i32* @var32, i32 %offset seq_cst 444 ; CHECK-NOT: dmb 445 ; CHECK-NOT: mcr 446 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 447 ; CHECK: movt r[[ADDR]], :upper16:var32 448 449 ; CHECK: .LBB{{[0-9]+}}_1: 450 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 451 ; r0 below is a reasonable guess but could change: it certainly comes into the 452 ; function there. 453 ; CHECK-NEXT: eor{{(\.w)?}} [[NEW:r[0-9]+]], r[[OLD]], r0 454 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], [[NEW]], [r[[ADDR]]] 455 ; CHECK-NEXT: cmp [[STATUS]], #0 456 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 457 ; CHECK-NOT: dmb 458 ; CHECK-NOT: mcr 459 460 ; CHECK: mov r0, r[[OLD]] 461 ret i32 %old 462 } 463 464 define void @test_atomic_load_xor_i64(i64 %offset) nounwind { 465 ; CHECK-LABEL: test_atomic_load_xor_i64: 466 %old = atomicrmw xor i64* @var64, i64 %offset monotonic 467 ; CHECK-NOT: dmb 468 ; CHECK-NOT: mcr 469 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 470 ; CHECK: movt r[[ADDR]], :upper16:var64 471 472 ; CHECK: .LBB{{[0-9]+}}_1: 473 ; CHECK: ldrexd r[[OLD1:[0-9]+]], r[[OLD2:[0-9]+]], [r[[ADDR]]] 474 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 475 ; function there. 476 ; CHECK-LE-DAG: eor{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 477 ; CHECK-LE-DAG: eor{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 478 ; CHECK-BE-DAG: eor{{(\.w)?}} [[NEW2:r[0-9]+|lr]], r[[OLD2]], r1 479 ; CHECK-BE-DAG: eor{{(\.w)?}} [[NEW1:r[0-9]+|lr]], r[[OLD1]], r0 480 ; CHECK: strexd [[STATUS:r[0-9]+]], [[NEW1]], [[NEW2]], [r[[ADDR]]] 481 ; CHECK-NEXT: cmp [[STATUS]], #0 482 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 483 ; CHECK-NOT: dmb 484 ; CHECK-NOT: mcr 485 486 ; CHECK: strd r[[OLD1]], r[[OLD2]], [r[[ADDR]]] 487 store i64 %old, i64* @var64 488 ret void 489 } 490 491 define i8 @test_atomic_load_xchg_i8(i8 %offset) nounwind { 492 ; CHECK-LABEL: test_atomic_load_xchg_i8: 493 %old = atomicrmw xchg i8* @var8, i8 %offset monotonic 494 ; CHECK-NOT: dmb 495 ; CHECK-NOT: mcr 496 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 497 ; CHECK: movt r[[ADDR]], :upper16:var8 498 499 ; CHECK: .LBB{{[0-9]+}}_1: 500 ; CHECK: ldrexb r[[OLD:[0-9]+]], [r[[ADDR]]] 501 ; r0 below is a reasonable guess but could change: it certainly comes into the 502 ; function there. 503 ; CHECK-NEXT: strexb [[STATUS:r[0-9]+]], r0, [r[[ADDR]]] 504 ; CHECK-NEXT: cmp [[STATUS]], #0 505 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 506 ; CHECK-NOT: dmb 507 ; CHECK-NOT: mcr 508 509 ; CHECK: mov r0, r[[OLD]] 510 ret i8 %old 511 } 512 513 define i16 @test_atomic_load_xchg_i16(i16 %offset) nounwind { 514 ; CHECK-LABEL: test_atomic_load_xchg_i16: 515 %old = atomicrmw xchg i16* @var16, i16 %offset seq_cst 516 ; CHECK-NOT: dmb 517 ; CHECK-NOT: mcr 518 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 519 ; CHECK: movt r[[ADDR]], :upper16:var16 520 521 ; CHECK: .LBB{{[0-9]+}}_1: 522 ; CHECK: ldaexh r[[OLD:[0-9]+]], [r[[ADDR]]] 523 ; r0 below is a reasonable guess but could change: it certainly comes into the 524 ; function there. 525 ; CHECK-NEXT: stlexh [[STATUS:r[0-9]+]], r0, [r[[ADDR]]] 526 ; CHECK-NEXT: cmp [[STATUS]], #0 527 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 528 ; CHECK-NOT: dmb 529 ; CHECK-NOT: mcr 530 531 ; CHECK: mov r0, r[[OLD]] 532 ret i16 %old 533 } 534 535 define i32 @test_atomic_load_xchg_i32(i32 %offset) nounwind { 536 ; CHECK-LABEL: test_atomic_load_xchg_i32: 537 %old = atomicrmw xchg i32* @var32, i32 %offset release 538 ; CHECK-NOT: dmb 539 ; CHECK-NOT: mcr 540 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 541 ; CHECK: movt r[[ADDR]], :upper16:var32 542 543 ; CHECK: .LBB{{[0-9]+}}_1: 544 ; CHECK: ldrex r[[OLD:[0-9]+]], [r[[ADDR]]] 545 ; r0 below is a reasonable guess but could change: it certainly comes into the 546 ; function there. 547 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], r0, [r[[ADDR]]] 548 ; CHECK-NEXT: cmp [[STATUS]], #0 549 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 550 ; CHECK-NOT: dmb 551 ; CHECK-NOT: mcr 552 553 ; CHECK: mov r0, r[[OLD]] 554 ret i32 %old 555 } 556 557 define void @test_atomic_load_xchg_i64(i64 %offset) nounwind { 558 ; CHECK-LABEL: test_atomic_load_xchg_i64: 559 %old = atomicrmw xchg i64* @var64, i64 %offset acquire 560 ; CHECK-NOT: dmb 561 ; CHECK-NOT: mcr 562 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 563 ; CHECK: movt r[[ADDR]], :upper16:var64 564 565 ; CHECK: .LBB{{[0-9]+}}_1: 566 ; CHECK: ldaexd [[OLD1:r[0-9]+]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 567 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 568 ; function there. 569 ; CHECK-NEXT: strexd [[STATUS:r[0-9]+]], r0, r1, [r[[ADDR]]] 570 ; CHECK-NEXT: cmp [[STATUS]], #0 571 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 572 ; CHECK-NOT: dmb 573 ; CHECK-NOT: mcr 574 575 ; CHECK: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 576 store i64 %old, i64* @var64 577 ret void 578 } 579 580 define i8 @test_atomic_load_min_i8(i8 signext %offset) nounwind { 581 ; CHECK-LABEL: test_atomic_load_min_i8: 582 %old = atomicrmw min i8* @var8, i8 %offset acquire 583 ; CHECK-NOT: dmb 584 ; CHECK-NOT: mcr 585 ; CHECK-DAG: movw [[ADDR:r[0-9]+|lr]], :lower16:var8 586 ; CHECK-DAG: movt [[ADDR]], :upper16:var8 587 588 ; CHECK: .LBB{{[0-9]+}}_1: 589 ; CHECK: ldaexb r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 590 ; CHECK-NEXT: sxtb r[[OLDX:[0-9]+]], r[[OLD]] 591 ; r0 below is a reasonable guess but could change: it certainly comes into the 592 ; function there. 593 ; CHECK-NEXT: cmp r[[OLDX]], r0 594 ; Thumb mode: it le 595 ; CHECK: movle r[[OLDX]], r[[OLD]] 596 ; CHECK-NEXT: strexb [[STATUS:r[0-9]+]], r[[OLDX]], {{.*}}[[ADDR]]] 597 ; CHECK-NEXT: cmp [[STATUS]], #0 598 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 599 ; CHECK-NOT: dmb 600 ; CHECK-NOT: mcr 601 602 ; CHECK: mov r0, r[[OLD]] 603 ret i8 %old 604 } 605 606 define i16 @test_atomic_load_min_i16(i16 signext %offset) nounwind { 607 ; CHECK-LABEL: test_atomic_load_min_i16: 608 %old = atomicrmw min i16* @var16, i16 %offset release 609 ; CHECK-NOT: dmb 610 ; CHECK-NOT: mcr 611 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var16 612 ; CHECK: movt [[ADDR]], :upper16:var16 613 614 ; CHECK: .LBB{{[0-9]+}}_1: 615 ; CHECK: ldrexh r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 616 ; CHECK-NEXT: sxth r[[OLDX:[0-9]+]], r[[OLD]] 617 ; r0 below is a reasonable guess but could change: it certainly comes into the 618 ; function there. 619 ; CHECK-NEXT: cmp r[[OLDX]], r0 620 ; Thumb mode: it le 621 ; CHECK: movle r[[OLDX]], r[[OLD]] 622 ; CHECK-NEXT: stlexh [[STATUS:r[0-9]+]], r[[OLDX]], {{.*}}[[ADDR]] 623 ; CHECK-NEXT: cmp [[STATUS]], #0 624 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 625 ; CHECK-NOT: dmb 626 ; CHECK-NOT: mcr 627 628 ; CHECK: mov r0, r[[OLD]] 629 ret i16 %old 630 } 631 632 define i32 @test_atomic_load_min_i32(i32 %offset) nounwind { 633 ; CHECK-LABEL: test_atomic_load_min_i32: 634 %old = atomicrmw min i32* @var32, i32 %offset monotonic 635 ; CHECK-NOT: dmb 636 ; CHECK-NOT: mcr 637 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 638 ; CHECK: movt r[[ADDR]], :upper16:var32 639 640 ; CHECK: .LBB{{[0-9]+}}_1: 641 ; CHECK: ldrex r[[OLD:[0-9]+]], [r[[ADDR]]] 642 ; r0 below is a reasonable guess but could change: it certainly comes into the 643 ; function there. 644 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 645 ; CHECK-NEXT: cmp r[[OLD]], r0 646 ; Thumb mode: it le 647 ; CHECK: movle r[[NEW]], r[[OLD]] 648 ; CHECK-NEXT: strex [[STATUS:r[0-9]+]], r[[NEW]], [r[[ADDR]]] 649 ; CHECK-NEXT: cmp [[STATUS]], #0 650 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 651 ; CHECK-NOT: dmb 652 ; CHECK-NOT: mcr 653 654 ; CHECK: mov r0, r[[OLD]] 655 ret i32 %old 656 } 657 658 define void @test_atomic_load_min_i64(i64 %offset) nounwind { 659 ; CHECK-LABEL: test_atomic_load_min_i64: 660 %old = atomicrmw min i64* @var64, i64 %offset seq_cst 661 ; CHECK-NOT: dmb 662 ; CHECK-NOT: mcr 663 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 664 ; CHECK: movt r[[ADDR]], :upper16:var64 665 666 ; CHECK: .LBB{{[0-9]+}}_1: 667 ; CHECK: ldaexd [[OLD1:r[0-9]+|lr]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 668 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 669 ; function there. 670 ; CHECK-ARM: mov [[LOCARRY:r[0-9]+|lr]], #0 671 ; CHECK-ARM: mov [[HICARRY:r[0-9]+|lr]], #0 672 ; CHECK-ARM-LE: cmp [[OLD1]], r0 673 ; CHECK-ARM-LE: movwls [[LOCARRY]], #1 674 ; CHECK-ARM-LE: cmp [[OLD2]], r1 675 ; CHECK-ARM-LE: movwle [[HICARRY]], #1 676 ; CHECK-ARM-BE: cmp [[OLD2]], r1 677 ; CHECK-ARM-BE: movwls [[LOCARRY]], #1 678 ; CHECK-ARM-BE: cmp [[OLD1]], r0 679 ; CHECK-ARM-BE: movwle [[HICARRY]], #1 680 ; CHECK-ARM: moveq [[HICARRY]], [[LOCARRY]] 681 ; CHECK-ARM: cmp [[HICARRY]], #0 682 ; CHECK-ARM: mov [[MINHI:r[0-9]+]], r1 683 ; CHECK-ARM: movne [[MINHI]], [[OLD2]] 684 ; CHECK-ARM: mov [[MINLO:r[0-9]+]], r0 685 ; CHECK-ARM: movne [[MINLO]], [[OLD1]] 686 ; CHECK-ARM: stlexd [[STATUS:r[0-9]+]], [[MINLO]], [[MINHI]], [r[[ADDR]]] 687 ; CHECK-THUMB: stlexd [[STATUS:r[0-9]+]], {{r[0-9]+}}, {{r[0-9]+}}, [r[[ADDR]]] 688 ; CHECK-NEXT: cmp [[STATUS]], #0 689 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 690 ; CHECK-NOT: dmb 691 ; CHECK-NOT: mcr 692 693 ; CHECK-ARM: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 694 store i64 %old, i64* @var64 695 ret void 696 } 697 698 define i8 @test_atomic_load_max_i8(i8 signext %offset) nounwind { 699 ; CHECK-LABEL: test_atomic_load_max_i8: 700 %old = atomicrmw max i8* @var8, i8 %offset seq_cst 701 ; CHECK-NOT: dmb 702 ; CHECK-NOT: mcr 703 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var8 704 ; CHECK: movt [[ADDR]], :upper16:var8 705 706 ; CHECK: .LBB{{[0-9]+}}_1: 707 ; CHECK: ldaexb r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 708 ; CHECK-NEXT: sxtb r[[OLDX:[0-9]+]], r[[OLD]] 709 ; r0 below is a reasonable guess but could change: it certainly comes into the 710 ; function there. 711 ; CHECK-NEXT: cmp r[[OLDX]], r0 712 ; Thumb mode: it gt 713 ; CHECK: movgt r[[OLDX]], r[[OLD]] 714 ; CHECK-NEXT: stlexb [[STATUS:r[0-9]+]], r[[OLDX]], {{.*}}[[ADDR]] 715 ; CHECK-NEXT: cmp [[STATUS]], #0 716 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 717 ; CHECK-NOT: dmb 718 ; CHECK-NOT: mcr 719 720 ; CHECK: mov r0, r[[OLD]] 721 ret i8 %old 722 } 723 724 define i16 @test_atomic_load_max_i16(i16 signext %offset) nounwind { 725 ; CHECK-LABEL: test_atomic_load_max_i16: 726 %old = atomicrmw max i16* @var16, i16 %offset acquire 727 ; CHECK-NOT: dmb 728 ; CHECK-NOT: mcr 729 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 730 ; CHECK: movt r[[ADDR]], :upper16:var16 731 732 ; CHECK: .LBB{{[0-9]+}}_1: 733 ; CHECK: ldaexh r[[OLD:[0-9]+]], [r[[ADDR]]] 734 ; CHECK-NEXT: sxth r[[OLDX:[0-9]+]], r[[OLD]] 735 ; r0 below is a reasonable guess but could change: it certainly comes into the 736 ; function there. 737 ; CHECK-NEXT: cmp r[[OLDX]], r0 738 ; Thumb mode: it gt 739 ; CHECK: movgt r[[OLDX]], r[[OLD]] 740 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], r[[OLDX]], [r[[ADDR]]] 741 ; CHECK-NEXT: cmp [[STATUS]], #0 742 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 743 ; CHECK-NOT: dmb 744 ; CHECK-NOT: mcr 745 746 ; CHECK: mov r0, r[[OLD]] 747 ret i16 %old 748 } 749 750 define i32 @test_atomic_load_max_i32(i32 %offset) nounwind { 751 ; CHECK-LABEL: test_atomic_load_max_i32: 752 %old = atomicrmw max i32* @var32, i32 %offset release 753 ; CHECK-NOT: dmb 754 ; CHECK-NOT: mcr 755 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 756 ; CHECK: movt r[[ADDR]], :upper16:var32 757 758 ; CHECK: .LBB{{[0-9]+}}_1: 759 ; CHECK: ldrex r[[OLD:[0-9]+]], [r[[ADDR]]] 760 ; r0 below is a reasonable guess but could change: it certainly comes into the 761 ; function there. 762 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 763 ; CHECK-NEXT: cmp r[[OLD]], r0 764 ; Thumb mode: it gt 765 ; CHECK: movgt r[[NEW]], r[[OLD]] 766 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], r[[NEW]], [r[[ADDR]]] 767 ; CHECK-NEXT: cmp [[STATUS]], #0 768 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 769 ; CHECK-NOT: dmb 770 ; CHECK-NOT: mcr 771 772 ; CHECK: mov r0, r[[OLD]] 773 ret i32 %old 774 } 775 776 define void @test_atomic_load_max_i64(i64 %offset) nounwind { 777 ; CHECK-LABEL: test_atomic_load_max_i64: 778 %old = atomicrmw max i64* @var64, i64 %offset monotonic 779 ; CHECK-NOT: dmb 780 ; CHECK-NOT: mcr 781 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 782 ; CHECK: movt r[[ADDR]], :upper16:var64 783 784 ; CHECK: .LBB{{[0-9]+}}_1: 785 ; CHECK: ldrexd [[OLD1:r[0-9]+]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 786 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 787 ; function there. 788 ; CHECK-ARM: mov [[LOCARRY:r[0-9]+|lr]], #0 789 ; CHECK-ARM: mov [[HICARRY:r[0-9]+|lr]], #0 790 ; CHECK-ARM-LE: cmp [[OLD1]], r0 791 ; CHECK-ARM-LE: movwhi [[LOCARRY]], #1 792 ; CHECK-ARM-LE: cmp [[OLD2]], r1 793 ; CHECK-ARM-LE: movwgt [[HICARRY]], #1 794 ; CHECK-ARM-BE: cmp [[OLD2]], r1 795 ; CHECK-ARM-BE: movwhi [[LOCARRY]], #1 796 ; CHECK-ARM-BE: cmp [[OLD1]], r0 797 ; CHECK-ARM-BE: movwgt [[HICARRY]], #1 798 ; CHECK-ARM: moveq [[HICARRY]], [[LOCARRY]] 799 ; CHECK-ARM: cmp [[HICARRY]], #0 800 ; CHECK-ARM: mov [[MINHI:r[0-9]+]], r1 801 ; CHECK-ARM: movne [[MINHI]], [[OLD2]] 802 ; CHECK-ARM: mov [[MINLO:r[0-9]+]], r0 803 ; CHECK-ARM: movne [[MINLO]], [[OLD1]] 804 ; CHECK-ARM: strexd [[STATUS:r[0-9]+]], [[MINLO]], [[MINHI]], [r[[ADDR]]] 805 ; CHECK-THUMB: strexd [[STATUS:r[0-9]+]], {{r[0-9]+}}, {{r[0-9]+}}, [r[[ADDR]]] 806 ; CHECK-NEXT: cmp [[STATUS]], #0 807 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 808 ; CHECK-NOT: dmb 809 ; CHECK-NOT: mcr 810 811 ; CHECK-ARM: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 812 store i64 %old, i64* @var64 813 ret void 814 } 815 816 define i8 @test_atomic_load_umin_i8(i8 zeroext %offset) nounwind { 817 ; CHECK-LABEL: test_atomic_load_umin_i8: 818 %old = atomicrmw umin i8* @var8, i8 %offset monotonic 819 ; CHECK-NOT: dmb 820 ; CHECK-NOT: mcr 821 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var8 822 ; CHECK: movt [[ADDR]], :upper16:var8 823 824 ; CHECK: .LBB{{[0-9]+}}_1: 825 ; CHECK: ldrexb r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 826 ; r0 below is a reasonable guess but could change: it certainly comes into the 827 ; function there. 828 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 829 ; CHECK-NEXT: cmp r[[OLD]], r0 830 ; Thumb mode: it ls 831 ; CHECK: movls r[[NEW]], r[[OLD]] 832 ; CHECK-NEXT: strexb [[STATUS:r[0-9]+]], r[[NEW]], {{.*}}[[ADDR]] 833 ; CHECK-NEXT: cmp [[STATUS]], #0 834 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 835 ; CHECK-NOT: dmb 836 ; CHECK-NOT: mcr 837 838 ; CHECK: mov r0, r[[OLD]] 839 ret i8 %old 840 } 841 842 define i16 @test_atomic_load_umin_i16(i16 zeroext %offset) nounwind { 843 ; CHECK-LABEL: test_atomic_load_umin_i16: 844 %old = atomicrmw umin i16* @var16, i16 %offset acquire 845 ; CHECK-NOT: dmb 846 ; CHECK-NOT: mcr 847 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var16 848 ; CHECK: movt [[ADDR]], :upper16:var16 849 850 ; CHECK: .LBB{{[0-9]+}}_1: 851 ; CHECK: ldaexh r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 852 ; r0 below is a reasonable guess but could change: it certainly comes into the 853 ; function there. 854 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 855 ; CHECK-NEXT: cmp r[[OLD]], r0 856 ; Thumb mode: it ls 857 ; CHECK: movls r[[NEW]], r[[OLD]] 858 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], r[[NEW]], {{.*}}[[ADDR]] 859 ; CHECK-NEXT: cmp [[STATUS]], #0 860 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 861 ; CHECK-NOT: dmb 862 ; CHECK-NOT: mcr 863 864 ; CHECK: mov r0, r[[OLD]] 865 ret i16 %old 866 } 867 868 define i32 @test_atomic_load_umin_i32(i32 %offset) nounwind { 869 ; CHECK-LABEL: test_atomic_load_umin_i32: 870 %old = atomicrmw umin i32* @var32, i32 %offset seq_cst 871 ; CHECK-NOT: dmb 872 ; CHECK-NOT: mcr 873 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 874 ; CHECK: movt r[[ADDR]], :upper16:var32 875 876 ; CHECK: .LBB{{[0-9]+}}_1: 877 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 878 ; r0 below is a reasonable guess but could change: it certainly comes into the 879 ; function there. 880 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 881 ; CHECK-NEXT: cmp r[[OLD]], r0 882 ; Thumb mode: it ls 883 ; CHECK: movls r[[NEW]], r[[OLD]] 884 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], r[[NEW]], [r[[ADDR]]] 885 ; CHECK-NEXT: cmp [[STATUS]], #0 886 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 887 ; CHECK-NOT: dmb 888 ; CHECK-NOT: mcr 889 890 ; CHECK: mov r0, r[[OLD]] 891 ret i32 %old 892 } 893 894 define void @test_atomic_load_umin_i64(i64 %offset) nounwind { 895 ; CHECK-LABEL: test_atomic_load_umin_i64: 896 %old = atomicrmw umin i64* @var64, i64 %offset seq_cst 897 ; CHECK-NOT: dmb 898 ; CHECK-NOT: mcr 899 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 900 ; CHECK: movt r[[ADDR]], :upper16:var64 901 902 ; CHECK: .LBB{{[0-9]+}}_1: 903 ; CHECK: ldaexd [[OLD1:r[0-9]+|lr]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 904 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 905 ; function there. 906 ; CHECK-ARM: mov [[LOCARRY:r[0-9]+|lr]], #0 907 ; CHECK-ARM: mov [[HICARRY:r[0-9]+|lr]], #0 908 ; CHECK-ARM-LE: cmp [[OLD1]], r0 909 ; CHECK-ARM-LE: movwls [[LOCARRY]], #1 910 ; CHECK-ARM-LE: cmp [[OLD2]], r1 911 ; CHECK-ARM-LE: movwls [[HICARRY]], #1 912 ; CHECK-ARM-BE: cmp [[OLD2]], r1 913 ; CHECK-ARM-BE: movwls [[LOCARRY]], #1 914 ; CHECK-ARM-BE: cmp [[OLD1]], r0 915 ; CHECK-ARM-BE: movwls [[HICARRY]], #1 916 ; CHECK-ARM: moveq [[HICARRY]], [[LOCARRY]] 917 ; CHECK-ARM: cmp [[HICARRY]], #0 918 ; CHECK-ARM: mov [[MINHI:r[0-9]+]], r1 919 ; CHECK-ARM: movne [[MINHI]], [[OLD2]] 920 ; CHECK-ARM: mov [[MINLO:r[0-9]+]], r0 921 ; CHECK-ARM: movne [[MINLO]], [[OLD1]] 922 ; CHECK-ARM: stlexd [[STATUS:r[0-9]+]], [[MINLO]], [[MINHI]], [r[[ADDR]]] 923 ; CHECK-THUMB: stlexd [[STATUS:r[0-9]+]], {{r[0-9]+}}, {{r[0-9]+}}, [r[[ADDR]]] 924 ; CHECK-NEXT: cmp [[STATUS]], #0 925 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 926 ; CHECK-NOT: dmb 927 ; CHECK-NOT: mcr 928 929 ; CHECK-ARM: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 930 store i64 %old, i64* @var64 931 ret void 932 } 933 934 define i8 @test_atomic_load_umax_i8(i8 zeroext %offset) nounwind { 935 ; CHECK-LABEL: test_atomic_load_umax_i8: 936 %old = atomicrmw umax i8* @var8, i8 %offset acq_rel 937 ; CHECK-NOT: dmb 938 ; CHECK-NOT: mcr 939 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var8 940 ; CHECK: movt [[ADDR]], :upper16:var8 941 942 ; CHECK: .LBB{{[0-9]+}}_1: 943 ; CHECK: ldaexb r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 944 ; r0 below is a reasonable guess but could change: it certainly comes into the 945 ; function there. 946 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 947 ; CHECK-NEXT: cmp r[[OLD]], r0 948 ; Thumb mode: it hi 949 ; CHECK: movhi r[[NEW]], r[[OLD]] 950 ; CHECK-NEXT: stlexb [[STATUS:r[0-9]+]], r[[NEW]], {{.*}}[[ADDR]] 951 ; CHECK-NEXT: cmp [[STATUS]], #0 952 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 953 ; CHECK-NOT: dmb 954 ; CHECK-NOT: mcr 955 956 ; CHECK: mov r0, r[[OLD]] 957 ret i8 %old 958 } 959 960 define i16 @test_atomic_load_umax_i16(i16 zeroext %offset) nounwind { 961 ; CHECK-LABEL: test_atomic_load_umax_i16: 962 %old = atomicrmw umax i16* @var16, i16 %offset monotonic 963 ; CHECK-NOT: dmb 964 ; CHECK-NOT: mcr 965 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var16 966 ; CHECK: movt [[ADDR]], :upper16:var16 967 968 ; CHECK: .LBB{{[0-9]+}}_1: 969 ; CHECK: ldrexh r[[OLD:[0-9]+]], {{.*}}[[ADDR]] 970 ; r0 below is a reasonable guess but could change: it certainly comes into the 971 ; function there. 972 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 973 ; CHECK-NEXT: cmp r[[OLD]], r0 974 ; Thumb mode: it hi 975 ; CHECK: movhi r[[NEW]], r[[OLD]] 976 ; CHECK-NEXT: strexh [[STATUS:r[0-9]+]], r[[NEW]], {{.*}}[[ADDR]] 977 ; CHECK-NEXT: cmp [[STATUS]], #0 978 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 979 ; CHECK-NOT: dmb 980 ; CHECK-NOT: mcr 981 982 ; CHECK: mov r0, r[[OLD]] 983 ret i16 %old 984 } 985 986 define i32 @test_atomic_load_umax_i32(i32 %offset) nounwind { 987 ; CHECK-LABEL: test_atomic_load_umax_i32: 988 %old = atomicrmw umax i32* @var32, i32 %offset seq_cst 989 ; CHECK-NOT: dmb 990 ; CHECK-NOT: mcr 991 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 992 ; CHECK: movt r[[ADDR]], :upper16:var32 993 994 ; CHECK: .LBB{{[0-9]+}}_1: 995 ; CHECK: ldaex r[[OLD:[0-9]+]], [r[[ADDR]]] 996 ; r0 below is a reasonable guess but could change: it certainly comes into the 997 ; function there. 998 ; CHECK-NEXT: mov r[[NEW:[0-9]+]], r0 999 ; CHECK-NEXT: cmp r[[OLD]], r0 1000 ; Thumb mode: it hi 1001 ; CHECK: movhi r[[NEW]], r[[OLD]] 1002 ; CHECK-NEXT: stlex [[STATUS:r[0-9]+]], r[[NEW]], [r[[ADDR]]] 1003 ; CHECK-NEXT: cmp [[STATUS]], #0 1004 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1005 ; CHECK-NOT: dmb 1006 ; CHECK-NOT: mcr 1007 1008 ; CHECK: mov r0, r[[OLD]] 1009 ret i32 %old 1010 } 1011 1012 define void @test_atomic_load_umax_i64(i64 %offset) nounwind { 1013 ; CHECK-LABEL: test_atomic_load_umax_i64: 1014 %old = atomicrmw umax i64* @var64, i64 %offset seq_cst 1015 ; CHECK-NOT: dmb 1016 ; CHECK-NOT: mcr 1017 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 1018 ; CHECK: movt r[[ADDR]], :upper16:var64 1019 1020 ; CHECK: .LBB{{[0-9]+}}_1: 1021 ; CHECK: ldaexd [[OLD1:r[0-9]+|lr]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 1022 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 1023 ; function there. 1024 ; CHECK-ARM: mov [[LOCARRY:r[0-9]+|lr]], #0 1025 ; CHECK-ARM: mov [[HICARRY:r[0-9]+|lr]], #0 1026 ; CHECK-ARM-LE: cmp [[OLD1]], r0 1027 ; CHECK-ARM-LE: movwhi [[LOCARRY]], #1 1028 ; CHECK-ARM-LE: cmp [[OLD2]], r1 1029 ; CHECK-ARM-LE: movwhi [[HICARRY]], #1 1030 ; CHECK-ARM-BE: cmp [[OLD2]], r1 1031 ; CHECK-ARM-BE: movwhi [[LOCARRY]], #1 1032 ; CHECK-ARM-BE: cmp [[OLD1]], r0 1033 ; CHECK-ARM-BE: movwhi [[HICARRY]], #1 1034 ; CHECK-ARM: moveq [[HICARRY]], [[LOCARRY]] 1035 ; CHECK-ARM: cmp [[HICARRY]], #0 1036 ; CHECK-ARM: mov [[MINHI:r[0-9]+]], r1 1037 ; CHECK-ARM: movne [[MINHI]], [[OLD2]] 1038 ; CHECK-ARM: mov [[MINLO:r[0-9]+]], r0 1039 ; CHECK-ARM: movne [[MINLO]], [[OLD1]] 1040 ; CHECK-ARM: stlexd [[STATUS:r[0-9]+]], [[MINLO]], [[MINHI]], [r[[ADDR]]] 1041 ; CHECK-THUMB: stlexd [[STATUS:r[0-9]+]], {{r[0-9]+}}, {{r[0-9]+}}, [r[[ADDR]]] 1042 ; CHECK-NEXT: cmp [[STATUS]], #0 1043 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1044 ; CHECK-NOT: dmb 1045 ; CHECK-NOT: mcr 1046 1047 ; CHECK-ARM: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 1048 store i64 %old, i64* @var64 1049 ret void 1050 } 1051 1052 define i8 @test_atomic_cmpxchg_i8(i8 zeroext %wanted, i8 zeroext %new) nounwind { 1053 ; CHECK-LABEL: test_atomic_cmpxchg_i8: 1054 %pair = cmpxchg i8* @var8, i8 %wanted, i8 %new acquire acquire 1055 %old = extractvalue { i8, i1 } %pair, 0 1056 ; CHECK-NOT: dmb 1057 ; CHECK-NOT: mcr 1058 ; CHECK-DAG: movw r[[ADDR:[0-9]+]], :lower16:var8 1059 ; CHECK-DAG: movt r[[ADDR]], :upper16:var8 1060 ; CHECK-THUMB-DAG: mov r[[WANTED:[0-9]+]], r0 1061 1062 ; CHECK: .LBB{{[0-9]+}}_1: 1063 ; CHECK: ldaexb r[[OLD:[0-9]+]], [r[[ADDR]]] 1064 ; r0 below is a reasonable guess but could change: it certainly comes into the 1065 ; function there. 1066 ; CHECK-ARM-NEXT: cmp r[[OLD]], r0 1067 ; CHECK-THUMB-NEXT: cmp r[[OLD]], r[[WANTED]] 1068 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_3 1069 ; CHECK-NEXT: BB#2: 1070 ; As above, r1 is a reasonable guess. 1071 ; CHECK: strexb [[STATUS:r[0-9]+]], r1, [r[[ADDR]]] 1072 ; CHECK-NEXT: cmp [[STATUS]], #0 1073 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1074 ; CHECK-NEXT: b .LBB{{[0-9]+}}_4 1075 ; CHECK-NEXT: .LBB{{[0-9]+}}_3: 1076 ; CHECK-NEXT: clrex 1077 ; CHECK-NEXT: .LBB{{[0-9]+}}_4: 1078 ; CHECK-NOT: dmb 1079 ; CHECK-NOT: mcr 1080 1081 ; CHECK-ARM: mov r0, r[[OLD]] 1082 ret i8 %old 1083 } 1084 1085 define i16 @test_atomic_cmpxchg_i16(i16 zeroext %wanted, i16 zeroext %new) nounwind { 1086 ; CHECK-LABEL: test_atomic_cmpxchg_i16: 1087 %pair = cmpxchg i16* @var16, i16 %wanted, i16 %new seq_cst seq_cst 1088 %old = extractvalue { i16, i1 } %pair, 0 1089 ; CHECK-NOT: dmb 1090 ; CHECK-NOT: mcr 1091 ; CHECK-DAG: movw r[[ADDR:[0-9]+]], :lower16:var16 1092 ; CHECK-DAG: movt r[[ADDR]], :upper16:var16 1093 ; CHECK-THUMB-DAG: mov r[[WANTED:[0-9]+]], r0 1094 1095 ; CHECK: .LBB{{[0-9]+}}_1: 1096 ; CHECK: ldaexh r[[OLD:[0-9]+]], [r[[ADDR]]] 1097 ; r0 below is a reasonable guess but could change: it certainly comes into the 1098 ; function there. 1099 ; CHECK-ARM-NEXT: cmp r[[OLD]], r0 1100 ; CHECK-THUMB-NEXT: cmp r[[OLD]], r[[WANTED]] 1101 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_3 1102 ; CHECK-NEXT: BB#2: 1103 ; As above, r1 is a reasonable guess. 1104 ; CHECK: stlexh [[STATUS:r[0-9]+]], r1, [r[[ADDR]]] 1105 ; CHECK-NEXT: cmp [[STATUS]], #0 1106 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1107 ; CHECK-NEXT: b .LBB{{[0-9]+}}_4 1108 ; CHECK-NEXT: .LBB{{[0-9]+}}_3: 1109 ; CHECK-NEXT: clrex 1110 ; CHECK-NEXT: .LBB{{[0-9]+}}_4: 1111 ; CHECK-NOT: dmb 1112 ; CHECK-NOT: mcr 1113 1114 ; CHECK-ARM: mov r0, r[[OLD]] 1115 ret i16 %old 1116 } 1117 1118 define void @test_atomic_cmpxchg_i32(i32 %wanted, i32 %new) nounwind { 1119 ; CHECK-LABEL: test_atomic_cmpxchg_i32: 1120 %pair = cmpxchg i32* @var32, i32 %wanted, i32 %new release monotonic 1121 %old = extractvalue { i32, i1 } %pair, 0 1122 store i32 %old, i32* @var32 1123 ; CHECK-NOT: dmb 1124 ; CHECK-NOT: mcr 1125 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var32 1126 ; CHECK: movt r[[ADDR]], :upper16:var32 1127 1128 ; CHECK: .LBB{{[0-9]+}}_1: 1129 ; CHECK: ldrex r[[OLD:[0-9]+]], [r[[ADDR]]] 1130 ; r0 below is a reasonable guess but could change: it certainly comes into the 1131 ; function there. 1132 ; CHECK-NEXT: cmp r[[OLD]], r0 1133 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_3 1134 ; CHECK-NEXT: BB#2: 1135 ; As above, r1 is a reasonable guess. 1136 ; CHECK: stlex [[STATUS:r[0-9]+]], r1, [r[[ADDR]]] 1137 ; CHECK-NEXT: cmp [[STATUS]], #0 1138 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1139 ; CHECK-NEXT: b .LBB{{[0-9]+}}_4 1140 ; CHECK-NEXT: .LBB{{[0-9]+}}_3: 1141 ; CHECK-NEXT: clrex 1142 ; CHECK-NEXT: .LBB{{[0-9]+}}_4: 1143 ; CHECK-NOT: dmb 1144 ; CHECK-NOT: mcr 1145 1146 ; CHECK: str{{(.w)?}} r[[OLD]], 1147 ret void 1148 } 1149 1150 define void @test_atomic_cmpxchg_i64(i64 %wanted, i64 %new) nounwind { 1151 ; CHECK-LABEL: test_atomic_cmpxchg_i64: 1152 %pair = cmpxchg i64* @var64, i64 %wanted, i64 %new monotonic monotonic 1153 %old = extractvalue { i64, i1 } %pair, 0 1154 ; CHECK-NOT: dmb 1155 ; CHECK-NOT: mcr 1156 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 1157 ; CHECK: movt r[[ADDR]], :upper16:var64 1158 1159 ; CHECK: .LBB{{[0-9]+}}_1: 1160 ; CHECK: ldrexd [[OLD1:r[0-9]+|lr]], [[OLD2:r[0-9]+|lr]], [r[[ADDR]]] 1161 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 1162 ; function there. 1163 ; CHECK-LE-DAG: eor{{(\.w)?}} [[MISMATCH_LO:r[0-9]+|lr]], [[OLD1]], r0 1164 ; CHECK-LE-DAG: eor{{(\.w)?}} [[MISMATCH_HI:r[0-9]+|lr]], [[OLD2]], r1 1165 ; CHECK-ARM-LE: orrs{{(\.w)?}} {{r[0-9]+}}, [[MISMATCH_LO]], [[MISMATCH_HI]] 1166 ; CHECK-THUMB-LE: orrs{{(\.w)?}} {{(r[0-9]+, )?}}[[MISMATCH_HI]], [[MISMATCH_LO]] 1167 ; CHECK-BE-DAG: eor{{(\.w)?}} [[MISMATCH_HI:r[0-9]+|lr]], [[OLD2]], r1 1168 ; CHECK-BE-DAG: eor{{(\.w)?}} [[MISMATCH_LO:r[0-9]+|lr]], [[OLD1]], r0 1169 ; CHECK-ARM-BE: orrs{{(\.w)?}} {{r[0-9]+}}, [[MISMATCH_HI]], [[MISMATCH_LO]] 1170 ; CHECK-THUMB-BE: orrs{{(\.w)?}} {{(r[0-9]+, )?}}[[MISMATCH_LO]], [[MISMATCH_HI]] 1171 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_3 1172 ; CHECK-NEXT: BB#2: 1173 ; As above, r2, r3 is a reasonable guess. 1174 ; CHECK: strexd [[STATUS:r[0-9]+]], r2, r3, [r[[ADDR]]] 1175 ; CHECK-NEXT: cmp [[STATUS]], #0 1176 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1177 ; CHECK-NEXT: b .LBB{{[0-9]+}}_4 1178 ; CHECK-NEXT: .LBB{{[0-9]+}}_3: 1179 ; CHECK-NEXT: clrex 1180 ; CHECK-NEXT: .LBB{{[0-9]+}}_4: 1181 ; CHECK-NOT: dmb 1182 ; CHECK-NOT: mcr 1183 1184 ; CHECK-ARM: strd [[OLD1]], [[OLD2]], [r[[ADDR]]] 1185 store i64 %old, i64* @var64 1186 ret void 1187 } 1188 1189 define i8 @test_atomic_load_monotonic_i8() nounwind { 1190 ; CHECK-LABEL: test_atomic_load_monotonic_i8: 1191 %val = load atomic i8, i8* @var8 monotonic, align 1 1192 ; CHECK-NOT: dmb 1193 ; CHECK-NOT: mcr 1194 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1195 ; CHECK: movt r[[ADDR]], :upper16:var8 1196 ; CHECK: ldrb r0, [r[[ADDR]]] 1197 ; CHECK-NOT: dmb 1198 ; CHECK-NOT: mcr 1199 1200 ret i8 %val 1201 } 1202 1203 define i8 @test_atomic_load_monotonic_regoff_i8(i64 %base, i64 %off) nounwind { 1204 ; CHECK-LABEL: test_atomic_load_monotonic_regoff_i8: 1205 %addr_int = add i64 %base, %off 1206 %addr = inttoptr i64 %addr_int to i8* 1207 1208 %val = load atomic i8, i8* %addr monotonic, align 1 1209 ; CHECK-NOT: dmb 1210 ; CHECK-NOT: mcr 1211 ; CHECK-LE: ldrb r0, [r0, r2] 1212 ; CHECK-BE: ldrb r0, [r1, r3] 1213 ; CHECK-NOT: dmb 1214 ; CHECK-NOT: mcr 1215 1216 ret i8 %val 1217 } 1218 1219 define i8 @test_atomic_load_acquire_i8() nounwind { 1220 ; CHECK-LABEL: test_atomic_load_acquire_i8: 1221 %val = load atomic i8, i8* @var8 acquire, align 1 1222 ; CHECK-NOT: dmb 1223 ; CHECK-NOT: mcr 1224 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1225 ; CHECK-NOT: dmb 1226 ; CHECK-NOT: mcr 1227 ; CHECK: movt r[[ADDR]], :upper16:var8 1228 ; CHECK-NOT: dmb 1229 ; CHECK-NOT: mcr 1230 ; CHECK: ldab r0, [r[[ADDR]]] 1231 ; CHECK-NOT: dmb 1232 ; CHECK-NOT: mcr 1233 ret i8 %val 1234 } 1235 1236 define i8 @test_atomic_load_seq_cst_i8() nounwind { 1237 ; CHECK-LABEL: test_atomic_load_seq_cst_i8: 1238 %val = load atomic i8, i8* @var8 seq_cst, align 1 1239 ; CHECK-NOT: dmb 1240 ; CHECK-NOT: mcr 1241 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1242 ; CHECK-NOT: dmb 1243 ; CHECK-NOT: mcr 1244 ; CHECK: movt r[[ADDR]], :upper16:var8 1245 ; CHECK-NOT: dmb 1246 ; CHECK-NOT: mcr 1247 ; CHECK: ldab r0, [r[[ADDR]]] 1248 ; CHECK-NOT: dmb 1249 ; CHECK-NOT: mcr 1250 ret i8 %val 1251 } 1252 1253 define i16 @test_atomic_load_monotonic_i16() nounwind { 1254 ; CHECK-LABEL: test_atomic_load_monotonic_i16: 1255 %val = load atomic i16, i16* @var16 monotonic, align 2 1256 ; CHECK-NOT: dmb 1257 ; CHECK-NOT: mcr 1258 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 1259 ; CHECK-NOT: dmb 1260 ; CHECK-NOT: mcr 1261 ; CHECK: movt r[[ADDR]], :upper16:var16 1262 ; CHECK-NOT: dmb 1263 ; CHECK-NOT: mcr 1264 ; CHECK: ldrh r0, [r[[ADDR]]] 1265 ; CHECK-NOT: dmb 1266 ; CHECK-NOT: mcr 1267 1268 ret i16 %val 1269 } 1270 1271 define i32 @test_atomic_load_monotonic_regoff_i32(i64 %base, i64 %off) nounwind { 1272 ; CHECK-LABEL: test_atomic_load_monotonic_regoff_i32: 1273 %addr_int = add i64 %base, %off 1274 %addr = inttoptr i64 %addr_int to i32* 1275 1276 %val = load atomic i32, i32* %addr monotonic, align 4 1277 ; CHECK-NOT: dmb 1278 ; CHECK-NOT: mcr 1279 ; CHECK-LE: ldr r0, [r0, r2] 1280 ; CHECK-BE: ldr r0, [r1, r3] 1281 ; CHECK-NOT: dmb 1282 ; CHECK-NOT: mcr 1283 1284 ret i32 %val 1285 } 1286 1287 define i64 @test_atomic_load_seq_cst_i64() nounwind { 1288 ; CHECK-LABEL: test_atomic_load_seq_cst_i64: 1289 %val = load atomic i64, i64* @var64 seq_cst, align 8 1290 ; CHECK-NOT: dmb 1291 ; CHECK-NOT: mcr 1292 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var64 1293 ; CHECK-NOT: dmb 1294 ; CHECK-NOT: mcr 1295 ; CHECK: movt r[[ADDR]], :upper16:var64 1296 ; CHECK-NOT: dmb 1297 ; CHECK-NOT: mcr 1298 ; CHECK: ldaexd r0, r1, [r[[ADDR]]] 1299 ; CHECK-NOT: dmb 1300 ; CHECK-NOT: mcr 1301 ret i64 %val 1302 } 1303 1304 define void @test_atomic_store_monotonic_i8(i8 %val) nounwind { 1305 ; CHECK-LABEL: test_atomic_store_monotonic_i8: 1306 store atomic i8 %val, i8* @var8 monotonic, align 1 1307 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1308 ; CHECK: movt r[[ADDR]], :upper16:var8 1309 ; CHECK: strb r0, [r[[ADDR]]] 1310 1311 ret void 1312 } 1313 1314 define void @test_atomic_store_monotonic_regoff_i8(i64 %base, i64 %off, i8 %val) nounwind { 1315 ; CHECK-LABEL: test_atomic_store_monotonic_regoff_i8: 1316 1317 %addr_int = add i64 %base, %off 1318 %addr = inttoptr i64 %addr_int to i8* 1319 1320 store atomic i8 %val, i8* %addr monotonic, align 1 1321 ; CHECK-LE: ldr{{b?(\.w)?}} [[VAL:r[0-9]+]], [sp] 1322 ; CHECK-LE: strb [[VAL]], [r0, r2] 1323 ; CHECK-BE: ldrb{{(\.w)?}} [[VAL:r[0-9]+]], [sp, #3] 1324 ; CHECK-BE: strb [[VAL]], [r1, r3] 1325 1326 ret void 1327 } 1328 1329 define void @test_atomic_store_release_i8(i8 %val) nounwind { 1330 ; CHECK-LABEL: test_atomic_store_release_i8: 1331 store atomic i8 %val, i8* @var8 release, align 1 1332 ; CHECK-NOT: dmb 1333 ; CHECK-NOT: mcr 1334 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1335 ; CHECK-NOT: dmb 1336 ; CHECK-NOT: mcr 1337 ; CHECK: movt r[[ADDR]], :upper16:var8 1338 ; CHECK-NOT: dmb 1339 ; CHECK-NOT: mcr 1340 ; CHECK: stlb r0, [r[[ADDR]]] 1341 ; CHECK-NOT: dmb 1342 ; CHECK-NOT: mcr 1343 ret void 1344 } 1345 1346 define void @test_atomic_store_seq_cst_i8(i8 %val) nounwind { 1347 ; CHECK-LABEL: test_atomic_store_seq_cst_i8: 1348 store atomic i8 %val, i8* @var8 seq_cst, align 1 1349 ; CHECK-NOT: dmb 1350 ; CHECK-NOT: mcr 1351 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var8 1352 ; CHECK-NOT: dmb 1353 ; CHECK-NOT: mcr 1354 ; CHECK: movt r[[ADDR]], :upper16:var8 1355 ; CHECK-NOT: dmb 1356 ; CHECK-NOT: mcr 1357 ; CHECK: stlb r0, [r[[ADDR]]] 1358 ; CHECK-NOT: dmb 1359 ; CHECK-NOT: mcr 1360 ret void 1361 } 1362 1363 define void @test_atomic_store_monotonic_i16(i16 %val) nounwind { 1364 ; CHECK-LABEL: test_atomic_store_monotonic_i16: 1365 store atomic i16 %val, i16* @var16 monotonic, align 2 1366 ; CHECK-NOT: dmb 1367 ; CHECK-NOT: mcr 1368 ; CHECK: movw r[[ADDR:[0-9]+]], :lower16:var16 1369 ; CHECK-NOT: dmb 1370 ; CHECK-NOT: mcr 1371 ; CHECK: movt r[[ADDR]], :upper16:var16 1372 ; CHECK-NOT: dmb 1373 ; CHECK-NOT: mcr 1374 ; CHECK: strh r0, [r[[ADDR]]] 1375 ; CHECK-NOT: dmb 1376 ; CHECK-NOT: mcr 1377 ret void 1378 } 1379 1380 define void @test_atomic_store_monotonic_regoff_i32(i64 %base, i64 %off, i32 %val) nounwind { 1381 ; CHECK-LABEL: test_atomic_store_monotonic_regoff_i32: 1382 1383 %addr_int = add i64 %base, %off 1384 %addr = inttoptr i64 %addr_int to i32* 1385 1386 store atomic i32 %val, i32* %addr monotonic, align 4 1387 ; CHECK-NOT: dmb 1388 ; CHECK-NOT: mcr 1389 ; CHECK: ldr [[VAL:r[0-9]+]], [sp] 1390 ; CHECK-NOT: dmb 1391 ; CHECK-NOT: mcr 1392 ; CHECK-LE: str [[VAL]], [r0, r2] 1393 ; CHECK-BE: str [[VAL]], [r1, r3] 1394 ; CHECK-NOT: dmb 1395 ; CHECK-NOT: mcr 1396 1397 ret void 1398 } 1399 1400 define void @test_atomic_store_release_i64(i64 %val) nounwind { 1401 ; CHECK-LABEL: test_atomic_store_release_i64: 1402 store atomic i64 %val, i64* @var64 release, align 8 1403 ; CHECK-NOT: dmb 1404 ; CHECK-NOT: mcr 1405 ; CHECK: movw [[ADDR:r[0-9]+|lr]], :lower16:var64 1406 ; CHECK: movt [[ADDR]], :upper16:var64 1407 1408 ; CHECK: .LBB{{[0-9]+}}_1: 1409 ; r0, r1 below is a reasonable guess but could change: it certainly comes into the 1410 ; function there. 1411 ; CHECK: stlexd [[STATUS:r[0-9]+]], r0, r1, {{.*}}[[ADDR]] 1412 ; CHECK-NEXT: cmp [[STATUS]], #0 1413 ; CHECK-NEXT: bne .LBB{{[0-9]+}}_1 1414 ; CHECK-NOT: dmb 1415 ; CHECK-NOT: mcr 1416 1417 ret void 1418 } 1419 1420 define i32 @not.barriers(i32* %var, i1 %cond) { 1421 ; CHECK-LABEL: not.barriers: 1422 br i1 %cond, label %atomic_ver, label %simple_ver 1423 simple_ver: 1424 %oldval = load i32, i32* %var 1425 %newval = add nsw i32 %oldval, -1 1426 store i32 %newval, i32* %var 1427 br label %somewhere 1428 atomic_ver: 1429 fence seq_cst 1430 %val = atomicrmw add i32* %var, i32 -1 monotonic 1431 fence seq_cst 1432 br label %somewhere 1433 ; CHECK: dmb 1434 ; CHECK: ldrex 1435 ; CHECK: dmb 1436 ; The key point here is that the second dmb isn't immediately followed by the 1437 ; simple_ver basic block, which LLVM attempted to do when DMB had been marked 1438 ; with isBarrier. For now, look for something that looks like "somewhere". 1439 ; CHECK-NEXT: {{mov|bx}} 1440 somewhere: 1441 %combined = phi i32 [ %val, %atomic_ver ], [ %newval, %simple_ver] 1442 ret i32 %combined 1443 } 1444
