derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
2033 lines
97 KiB
LLVM
2033 lines
97 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
|
|
; RUN: llc < %s -mtriple=nvptx64 -mcpu=sm_90 -mattr=+ptx78 | FileCheck %s
|
|
; RUN: %if ptxas-sm_90 && ptxas-isa-7.8 %{ llc < %s -mtriple=nvptx64 -mcpu=sm_90 -mattr=+ptx78 | %ptxas-verify -arch=sm_90 %}
|
|
|
|
; TODO: fix "atomic load volatile acquire": generates "ld.acquire.sys;"
|
|
; but should generate "ld.mmio.relaxed.sys; fence.acq_rel.sys;"
|
|
; TODO: fix "atomic store volatile release": generates "st.release.sys;"
|
|
; but should generate "fence.acq_rel.sys; st.mmio.relaxed.sys;"
|
|
|
|
; TODO: fix "atomic load volatile seq_cst": generates "fence.sc.sys; ld.acquire.sys;"
|
|
; but should generate "fence.sc.sys; ld.relaxed.mmio.sys; fence.acq_rel.sys;"
|
|
; TODO: fix "atomic store volatile seq_cst": generates "fence.sc.sys; st.release.sys;"
|
|
; but should generate "fence.sc.sys; st.relaxed.mmio.sys;"
|
|
|
|
; TODO: add i1, <8 x i8>, and <6 x i8> vector tests.
|
|
|
|
; TODO: add test for vectors that exceed 128-bit length
|
|
; Per https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#vectors
|
|
; vectors cannot exceed 128-bit in length, i.e., .v4.u64 is not allowed.
|
|
|
|
; TODO: generate PTX that preserves Concurrent Forward Progress
|
|
; for atomic operations to local statespace
|
|
; by generating atomic or volatile operations.
|
|
|
|
; TODO: design exposure for atomic operations on vector types.
|
|
|
|
; TODO: implement and test thread scope.
|
|
|
|
; TODO: add weak,atomic,volatile,atomic volatile tests
|
|
; for .const and .param statespaces.
|
|
|
|
; TODO: optimize .shared.sys into .shared.cta or .shared.cluster .
|
|
|
|
;; generic statespace
|
|
|
|
; CHECK-LABEL: generic_unordered_cluster
|
|
define void @generic_unordered_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_unordered_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_unordered_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_unordered_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_unordered_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_unordered_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_unordered_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic i16, ptr %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic i32, ptr %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic i64, ptr %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic float, ptr %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic double, ptr %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_unordered_volatile_cluster
|
|
define void @generic_unordered_volatile_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_unordered_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_unordered_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_unordered_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_unordered_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_unordered_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_unordered_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_monotonic_cluster
|
|
define void @generic_monotonic_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_monotonic_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_monotonic_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_monotonic_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_monotonic_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_monotonic_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_monotonic_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic i16, ptr %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic i32, ptr %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic i64, ptr %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic float, ptr %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic double, ptr %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_monotonic_volatile_cluster
|
|
define void @generic_monotonic_volatile_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_monotonic_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_monotonic_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_monotonic_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_monotonic_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_monotonic_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_monotonic_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_acq_rel_cluster
|
|
define void @generic_acq_rel_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_acq_rel_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_acq_rel_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.cluster.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_acq_rel_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_acq_rel_cluster_param_2];
|
|
; CHECK-NEXT: st.release.cluster.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_acq_rel_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.cluster.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_acq_rel_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.cluster.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.cluster.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.cluster.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.cluster.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.cluster.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.cluster.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.cluster.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.cluster.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.cluster.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic i16, ptr %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic i32, ptr %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic i64, ptr %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic float, ptr %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic double, ptr %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_acq_rel_volatile_cluster
|
|
define void @generic_acq_rel_volatile_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_acq_rel_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_acq_rel_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.sys.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_acq_rel_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_acq_rel_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.release.sys.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_acq_rel_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.sys.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_acq_rel_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.sys.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.sys.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.sys.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.sys.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.sys.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.sys.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.sys.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.sys.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.sys.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_sc_cluster
|
|
define void @generic_sc_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_sc_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_sc_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_sc_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_sc_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_sc_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_sc_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic i16, ptr %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic i32, ptr %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic i64, ptr %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic float, ptr %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic double, ptr %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: generic_sc_volatile_cluster
|
|
define void @generic_sc_volatile_cluster(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) local_unnamed_addr {
|
|
; CHECK-LABEL: generic_sc_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [generic_sc_volatile_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [generic_sc_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [generic_sc_volatile_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [generic_sc_volatile_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [generic_sc_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
;; global statespace
|
|
|
|
; CHECK-LABEL: global_unordered_cluster
|
|
define void @global_unordered_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_unordered_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_unordered_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_unordered_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_unordered_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_unordered_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_unordered_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(1) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(1) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(1) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(1) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(1) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(1) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(1) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(1) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(1) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(1) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(1) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(1) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_unordered_volatile_cluster
|
|
define void @global_unordered_volatile_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_unordered_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_unordered_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_unordered_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_unordered_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_unordered_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_unordered_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(1) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(1) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(1) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(1) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(1) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(1) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(1) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(1) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(1) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(1) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(1) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(1) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_monotonic_cluster
|
|
define void @global_monotonic_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_monotonic_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_monotonic_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_monotonic_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_monotonic_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_monotonic_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_monotonic_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(1) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(1) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(1) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(1) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(1) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(1) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(1) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(1) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(1) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(1) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(1) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(1) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_monotonic_volatile_cluster
|
|
define void @global_monotonic_volatile_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_monotonic_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_monotonic_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_monotonic_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_monotonic_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_monotonic_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_monotonic_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(1) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(1) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(1) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(1) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(1) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(1) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(1) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(1) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(1) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(1) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(1) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(1) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_acq_rel_cluster
|
|
define void @global_acq_rel_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_acq_rel_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_acq_rel_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_acq_rel_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_acq_rel_cluster_param_2];
|
|
; CHECK-NEXT: st.release.cluster.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_acq_rel_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_acq_rel_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.cluster.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.cluster.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.cluster.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.cluster.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.cluster.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(1) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(1) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(1) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(1) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(1) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(1) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(1) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(1) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(1) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(1) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(1) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(1) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_acq_rel_volatile_cluster
|
|
define void @global_acq_rel_volatile_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_acq_rel_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_acq_rel_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.sys.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_acq_rel_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_acq_rel_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.release.sys.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_acq_rel_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.sys.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_acq_rel_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.sys.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.sys.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.sys.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.sys.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.sys.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(1) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(1) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(1) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(1) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(1) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(1) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(1) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(1) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(1) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(1) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(1) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(1) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_seq_cst_cluster
|
|
define void @global_seq_cst_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_seq_cst_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_seq_cst_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_seq_cst_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_seq_cst_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_seq_cst_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_seq_cst_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(1) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(1) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(1) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(1) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(1) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(1) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(1) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(1) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: global_seq_cst_volatile_cluster
|
|
define void @global_seq_cst_volatile_cluster(ptr addrspace(1) %a, ptr addrspace(1) %b, ptr addrspace(1) %c, ptr addrspace(1) %d, ptr addrspace(1) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: global_seq_cst_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [global_seq_cst_volatile_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [global_seq_cst_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [global_seq_cst_volatile_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [global_seq_cst_volatile_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [global_seq_cst_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.global.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.global.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(1) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(1) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(1) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(1) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(1) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(1) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(1) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(1) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(1) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
;; shared
|
|
|
|
; CHECK-LABEL: shared_unordered_cluster
|
|
define void @shared_unordered_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_unordered_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_unordered_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_unordered_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_unordered_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_unordered_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_unordered_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(3) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(3) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(3) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(3) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(3) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(3) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(3) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(3) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(3) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(3) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(3) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(3) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_unordered_volatile_cluster
|
|
define void @shared_unordered_volatile_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_unordered_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_unordered_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_unordered_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_unordered_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_unordered_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_unordered_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(3) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(3) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(3) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(3) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(3) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(3) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(3) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(3) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(3) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(3) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(3) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(3) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_monotonic_cluster
|
|
define void @shared_monotonic_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_monotonic_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_monotonic_cluster_param_0];
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_monotonic_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_monotonic_cluster_param_2];
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_monotonic_cluster_param_3];
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_monotonic_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.relaxed.cluster.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.relaxed.cluster.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(3) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(3) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(3) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(3) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(3) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(3) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(3) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(3) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(3) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(3) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(3) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(3) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_monotonic_volatile_cluster
|
|
define void @shared_monotonic_volatile_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_monotonic_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_monotonic_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.volatile.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_monotonic_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_monotonic_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.volatile.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_monotonic_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.volatile.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_monotonic_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.volatile.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.volatile.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.volatile.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.volatile.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.volatile.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.volatile.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.volatile.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(3) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(3) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(3) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(3) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(3) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(3) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(3) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(3) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(3) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(3) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(3) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(3) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_acq_rel_cluster
|
|
define void @shared_acq_rel_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_acq_rel_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_acq_rel_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_acq_rel_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_acq_rel_cluster_param_2];
|
|
; CHECK-NEXT: st.release.cluster.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_acq_rel_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_acq_rel_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.cluster.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.cluster.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.cluster.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.cluster.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.cluster.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(3) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(3) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(3) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(3) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(3) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(3) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(3) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(3) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(3) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(3) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(3) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(3) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_acq_rel_volatile_cluster
|
|
define void @shared_acq_rel_volatile_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_acq_rel_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_acq_rel_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_acq_rel_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_acq_rel_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.release.sys.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_acq_rel_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_acq_rel_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.release.sys.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.release.sys.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.release.sys.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.release.sys.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.release.sys.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(3) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(3) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(3) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(3) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(3) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(3) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(3) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(3) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(3) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(3) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(3) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(3) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_seq_cst_cluster
|
|
define void @shared_seq_cst_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_seq_cst_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_seq_cst_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_seq_cst_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_seq_cst_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_seq_cst_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_seq_cst_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: ld.acquire.cluster.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.cluster;
|
|
; CHECK-NEXT: st.release.cluster.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(3) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(3) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(3) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(3) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(3) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(3) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(3) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(3) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: shared_seq_cst_volatile_cluster
|
|
define void @shared_seq_cst_volatile_cluster(ptr addrspace(3) %a, ptr addrspace(3) %b, ptr addrspace(3) %c, ptr addrspace(3) %d, ptr addrspace(3) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: shared_seq_cst_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [shared_seq_cst_volatile_cluster_param_0];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [shared_seq_cst_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [shared_seq_cst_volatile_cluster_param_2];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [shared_seq_cst_volatile_cluster_param_3];
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [shared_seq_cst_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: ld.acquire.sys.shared.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: fence.sc.sys;
|
|
; CHECK-NEXT: st.release.sys.shared.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(3) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(3) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(3) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(3) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(3) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(3) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(3) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(3) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(3) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
;; local statespace
|
|
|
|
; CHECK-LABEL: local_unordered_cluster
|
|
define void @local_unordered_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_unordered_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_unordered_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_unordered_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_unordered_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_unordered_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_unordered_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(5) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(5) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(5) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(5) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(5) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(5) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(5) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(5) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(5) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(5) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(5) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(5) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_unordered_volatile_cluster
|
|
define void @local_unordered_volatile_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_unordered_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_unordered_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_unordered_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_unordered_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_unordered_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_unordered_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(5) %a syncscope("cluster") unordered, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(5) %a syncscope("cluster") unordered, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(5) %b syncscope("cluster") unordered, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(5) %b syncscope("cluster") unordered, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(5) %c syncscope("cluster") unordered, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(5) %c syncscope("cluster") unordered, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(5) %d syncscope("cluster") unordered, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(5) %d syncscope("cluster") unordered, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(5) %e syncscope("cluster") unordered, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(5) %e syncscope("cluster") unordered, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(5) %e syncscope("cluster") unordered, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(5) %e syncscope("cluster") unordered, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_monotonic_cluster
|
|
define void @local_monotonic_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_monotonic_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_monotonic_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_monotonic_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_monotonic_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_monotonic_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_monotonic_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(5) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(5) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(5) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(5) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(5) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(5) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(5) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(5) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(5) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(5) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(5) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(5) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_monotonic_volatile_cluster
|
|
define void @local_monotonic_volatile_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_monotonic_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_monotonic_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_monotonic_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_monotonic_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_monotonic_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_monotonic_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(5) %a syncscope("cluster") monotonic, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(5) %a syncscope("cluster") monotonic, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(5) %b syncscope("cluster") monotonic, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(5) %b syncscope("cluster") monotonic, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(5) %c syncscope("cluster") monotonic, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(5) %c syncscope("cluster") monotonic, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(5) %d syncscope("cluster") monotonic, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(5) %d syncscope("cluster") monotonic, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(5) %e syncscope("cluster") monotonic, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(5) %e syncscope("cluster") monotonic, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(5) %e syncscope("cluster") monotonic, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(5) %e syncscope("cluster") monotonic, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_acq_rel_cluster
|
|
define void @local_acq_rel_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_acq_rel_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_acq_rel_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_acq_rel_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_acq_rel_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_acq_rel_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_acq_rel_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(5) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(5) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(5) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(5) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(5) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(5) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(5) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(5) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(5) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(5) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(5) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(5) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_acq_rel_volatile_cluster
|
|
define void @local_acq_rel_volatile_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_acq_rel_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_acq_rel_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_acq_rel_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_acq_rel_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_acq_rel_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_acq_rel_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(5) %a syncscope("cluster") acquire, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(5) %a syncscope("cluster") release, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(5) %b syncscope("cluster") acquire, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(5) %b syncscope("cluster") release, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(5) %c syncscope("cluster") acquire, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(5) %c syncscope("cluster") release, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(5) %d syncscope("cluster") acquire, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(5) %d syncscope("cluster") release, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(5) %e syncscope("cluster") acquire, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(5) %e syncscope("cluster") release, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(5) %e syncscope("cluster") acquire, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(5) %e syncscope("cluster") release, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_seq_cst_cluster
|
|
define void @local_seq_cst_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_seq_cst_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_seq_cst_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_seq_cst_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_seq_cst_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_seq_cst_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_seq_cst_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic i8, ptr addrspace(5) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic i8 %a.add, ptr addrspace(5) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic i16, ptr addrspace(5) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic i16 %b.add, ptr addrspace(5) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic i32, ptr addrspace(5) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic i32 %c.add, ptr addrspace(5) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic i64, ptr addrspace(5) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic i64 %d.add, ptr addrspace(5) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic float, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic float %e.add, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic double, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic double %f.add, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: local_seq_cst_volatile_cluster
|
|
define void @local_seq_cst_volatile_cluster(ptr addrspace(5) %a, ptr addrspace(5) %b, ptr addrspace(5) %c, ptr addrspace(5) %d, ptr addrspace(5) %e) local_unnamed_addr {
|
|
; CHECK-LABEL: local_seq_cst_volatile_cluster(
|
|
; CHECK: {
|
|
; CHECK-NEXT: .reg .b16 %rs<5>;
|
|
; CHECK-NEXT: .reg .b32 %r<5>;
|
|
; CHECK-NEXT: .reg .b64 %rd<10>;
|
|
; CHECK-EMPTY:
|
|
; CHECK-NEXT: // %bb.0:
|
|
; CHECK-NEXT: ld.param.b64 %rd1, [local_seq_cst_volatile_cluster_param_0];
|
|
; CHECK-NEXT: ld.local.b8 %rs1, [%rd1];
|
|
; CHECK-NEXT: ld.param.b64 %rd2, [local_seq_cst_volatile_cluster_param_1];
|
|
; CHECK-NEXT: add.s16 %rs2, %rs1, 1;
|
|
; CHECK-NEXT: ld.param.b64 %rd3, [local_seq_cst_volatile_cluster_param_2];
|
|
; CHECK-NEXT: st.local.b8 [%rd1], %rs2;
|
|
; CHECK-NEXT: ld.param.b64 %rd4, [local_seq_cst_volatile_cluster_param_3];
|
|
; CHECK-NEXT: ld.local.b16 %rs3, [%rd2];
|
|
; CHECK-NEXT: ld.param.b64 %rd5, [local_seq_cst_volatile_cluster_param_4];
|
|
; CHECK-NEXT: add.s16 %rs4, %rs3, 1;
|
|
; CHECK-NEXT: st.local.b16 [%rd2], %rs4;
|
|
; CHECK-NEXT: ld.local.b32 %r1, [%rd3];
|
|
; CHECK-NEXT: add.s32 %r2, %r1, 1;
|
|
; CHECK-NEXT: st.local.b32 [%rd3], %r2;
|
|
; CHECK-NEXT: ld.local.b64 %rd6, [%rd4];
|
|
; CHECK-NEXT: add.s64 %rd7, %rd6, 1;
|
|
; CHECK-NEXT: st.local.b64 [%rd4], %rd7;
|
|
; CHECK-NEXT: ld.local.b32 %r3, [%rd5];
|
|
; CHECK-NEXT: add.rn.f32 %r4, %r3, 0f3F800000;
|
|
; CHECK-NEXT: st.local.b32 [%rd5], %r4;
|
|
; CHECK-NEXT: ld.local.b64 %rd8, [%rd5];
|
|
; CHECK-NEXT: add.rn.f64 %rd9, %rd8, 0d3FF0000000000000;
|
|
; CHECK-NEXT: st.local.b64 [%rd5], %rd9;
|
|
; CHECK-NEXT: ret;
|
|
%a.load = load atomic volatile i8, ptr addrspace(5) %a syncscope("cluster") seq_cst, align 1
|
|
%a.add = add i8 %a.load, 1
|
|
store atomic volatile i8 %a.add, ptr addrspace(5) %a syncscope("cluster") seq_cst, align 1
|
|
|
|
%b.load = load atomic volatile i16, ptr addrspace(5) %b syncscope("cluster") seq_cst, align 2
|
|
%b.add = add i16 %b.load, 1
|
|
store atomic volatile i16 %b.add, ptr addrspace(5) %b syncscope("cluster") seq_cst, align 2
|
|
|
|
%c.load = load atomic volatile i32, ptr addrspace(5) %c syncscope("cluster") seq_cst, align 4
|
|
%c.add = add i32 %c.load, 1
|
|
store atomic volatile i32 %c.add, ptr addrspace(5) %c syncscope("cluster") seq_cst, align 4
|
|
|
|
%d.load = load atomic volatile i64, ptr addrspace(5) %d syncscope("cluster") seq_cst, align 8
|
|
%d.add = add i64 %d.load, 1
|
|
store atomic volatile i64 %d.add, ptr addrspace(5) %d syncscope("cluster") seq_cst, align 8
|
|
|
|
%e.load = load atomic volatile float, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 4
|
|
%e.add = fadd float %e.load, 1.
|
|
store atomic volatile float %e.add, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 4
|
|
|
|
%f.load = load atomic volatile double, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 8
|
|
%f.add = fadd double %f.load, 1.
|
|
store atomic volatile double %f.add, ptr addrspace(5) %e syncscope("cluster") seq_cst, align 8
|
|
|
|
ret void
|
|
}
|