llvm/test/CodeGen/SPARC/atomics.ll

; RUN: llc < %s -mtriple=sparc -mcpu=v9 -verify-machineinstrs | FileCheck %s --check-prefixes=SPARC
; RUN: llc < %s -mtriple=sparcv9 -verify-machineinstrs | FileCheck %s --check-prefixes=SPARC64

; SPARC-LABEL: test_atomic_i8
; SPARC:       ldub [%o0]
; SPARC:       membar
; SPARC:       ldub [%o1]
; SPARC:       membar
; SPARC:       membar
; SPARC:       stb {{.+}}, [%o2]
; SPARC64-LABEL: test_atomic_i8
; SPARC64:       ldub [%o0]
; SPARC64:       membar
; SPARC64:       ldub [%o1]
; SPARC64:       membar
; SPARC64:       membar
; SPARC64:       stb {{.+}}, [%o2]
define i8 @test_atomic_i8(ptr %ptr1, ptr %ptr2, ptr %ptr3) {
entry:
  %0 = load atomic i8, ptr %ptr1 acquire, align 1
  %1 = load atomic i8, ptr %ptr2 acquire, align 1
  %2 = add i8 %0, %1
  store atomic i8 %2, ptr %ptr3 release, align 1
  ret i8 %2
}

; SPARC-LABEL: test_atomic_i16
; SPARC:       lduh [%o0]
; SPARC:       membar
; SPARC:       lduh [%o1]
; SPARC:       membar
; SPARC:       membar
; SPARC:       sth {{.+}}, [%o2]
; SPARC64-LABEL: test_atomic_i16
; SPARC64:       lduh [%o0]
; SPARC64:       membar
; SPARC64:       lduh [%o1]
; SPARC64:       membar
; SPARC64:       membar
; SPARC64:       sth {{.+}}, [%o2]
define i16 @test_atomic_i16(ptr %ptr1, ptr %ptr2, ptr %ptr3) {
entry:
  %0 = load atomic i16, ptr %ptr1 acquire, align 2
  %1 = load atomic i16, ptr %ptr2 acquire, align 2
  %2 = add i16 %0, %1
  store atomic i16 %2, ptr %ptr3 release, align 2
  ret i16 %2
}

; SPARC-LABEL: test_atomic_i32
; SPARC:       ld [%o0]
; SPARC:       membar
; SPARC:       ld [%o1]
; SPARC:       membar
; SPARC:       membar
; SPARC:       st {{.+}}, [%o2]
; SPARC64-LABEL: test_atomic_i32
; SPARC64:       ld [%o0]
; SPARC64:       membar
; SPARC64:       ld [%o1]
; SPARC64:       membar
; SPARC64:       membar
; SPARC64:       st {{.+}}, [%o2]
define i32 @test_atomic_i32(ptr %ptr1, ptr %ptr2, ptr %ptr3) {
entry:
  %0 = load atomic i32, ptr %ptr1 acquire, align 4
  %1 = load atomic i32, ptr %ptr2 acquire, align 4
  %2 = add i32 %0, %1
  store atomic i32 %2, ptr %ptr3 release, align 4
  ret i32 %2
}

;; TODO: the "move %icc" and related instructions are totally
;; redundant here. There's something weird happening in optimization
;; of the success value of cmpxchg.

; SPARC-LABEL: test_cmpxchg_i8
; SPARC:       and %o1, -4, %o2
; SPARC:       mov  3, %o3
; SPARC:       andn %o3, %o1, %o1
; SPARC:       sll %o1, 3, %o1
; SPARC:       mov  255, %o3
; SPARC:       sll %o3, %o1, %o5
; SPARC:       xor %o5, -1, %o3
; SPARC:       mov  123, %o4
; SPARC:       ld [%o2], %g2
; SPARC:       sll %o4, %o1, %o4
; SPARC:       and %o0, 255, %o0
; SPARC:       sll %o0, %o1, %o0
; SPARC:       andn %g2, %o5, %o5
; SPARC:      [[LABEL1:\.L.*]]:
; SPARC:       or %o5, %o4, %g2
; SPARC:       or %o5, %o0, %g3
; SPARC:       cas [%o2], %g3, %g2
; SPARC:       mov %g0, %g4
; SPARC:       cmp %g2, %g3
; SPARC:       move %icc, 1, %g4
; SPARC:       cmp %g4, 0
; SPARC:       bne %icc, [[LABEL2:\.L.*]]
; SPARC:       nop
; SPARC:       and %g2, %o3, %g3
; SPARC:       cmp %o5, %g3
; SPARC:       bne %icc, [[LABEL1]]
; SPARC:       mov  %g3, %o5
; SPARC:      [[LABEL2]]:
; SPARC:       retl
; SPARC:       srl %g2, %o1, %o0
; SPARC64-LABEL: test_cmpxchg_i8
; SPARC64:       and %o1, -4, %o2
; SPARC64:       mov  3, %o3
; SPARC64:       andn %o3, %o1, %o1
; SPARC64:       sll %o1, 3, %o1
; SPARC64:       mov  255, %o3
; SPARC64:       sll %o3, %o1, %o5
; SPARC64:       xor %o5, -1, %o3
; SPARC64:       mov  123, %o4
; SPARC64:       ld [%o2], %g2
; SPARC64:       sll %o4, %o1, %o4
; SPARC64:       and %o0, 255, %o0
; SPARC64:       sll %o0, %o1, %o0
; SPARC64:       andn %g2, %o5, %o5
; SPARC64:      [[LABEL1:\.L.*]]:
; SPARC64:       or %o5, %o4, %g2
; SPARC64:       or %o5, %o0, %g3
; SPARC64:       cas [%o2], %g3, %g2
; SPARC64:       mov %g0, %g4
; SPARC64:       cmp %g2, %g3
; SPARC64:       move %icc, 1, %g4
; SPARC64:       cmp %g4, 0
; SPARC64:       bne %icc, [[LABEL2:\.L.*]]
; SPARC64:       nop
; SPARC64:       and %g2, %o3, %g3
; SPARC64:       cmp %o5, %g3
; SPARC64:       bne %icc, [[LABEL1]]
; SPARC64:       mov  %g3, %o5
; SPARC64:      [[LABEL2]]:
; SPARC64:       retl
; SPARC64:       srl %g2, %o1, %o0
define i8 @test_cmpxchg_i8(i8 %a, ptr %ptr) {
entry:
  %pair = cmpxchg ptr %ptr, i8 %a, i8 123 monotonic monotonic
  %b = extractvalue { i8, i1 } %pair, 0
  ret i8 %b
}

; SPARC-LABEL: test_cmpxchg_i16
; SPARC:       and %o1, -4, %o2
; SPARC:       and %o1, 3, %o1
; SPARC:       xor %o1, 2, %o1
; SPARC:       sll %o1, 3, %o1
; SPARC:       sethi 63, %o3
; SPARC:       or %o3, 1023, %o4
; SPARC:       sll %o4, %o1, %o5
; SPARC:       xor %o5, -1, %o3
; SPARC:       and %o0, %o4, %o4
; SPARC:       ld [%o2], %g2
; SPARC:       mov  123, %o0
; SPARC:       sll %o0, %o1, %o0
; SPARC:       sll %o4, %o1, %o4
; SPARC:       andn %g2, %o5, %o5
; SPARC:      [[LABEL1:\.L.*]]:
; SPARC:       or %o5, %o0, %g2
; SPARC:       or %o5, %o4, %g3
; SPARC:       cas [%o2], %g3, %g2
; SPARC:       mov %g0, %g4
; SPARC:       cmp %g2, %g3
; SPARC:       move %icc, 1, %g4
; SPARC:       cmp %g4, 0
; SPARC:       bne %icc, [[LABEL2:\.L.*]]
; SPARC:       nop
; SPARC:       and %g2, %o3, %g3
; SPARC:       cmp %o5, %g3
; SPARC:       bne %icc, [[LABEL1]]
; SPARC:       mov  %g3, %o5
; SPARC:      [[LABEL2]]:
; SPARC:       retl
; SPARC:       srl %g2, %o1, %o0
; SPARC64-LABEL: test_cmpxchg_i16
; SPARC64:       and %o1, -4, %o2
; SPARC64:       and %o1, 3, %o1
; SPARC64:       xor %o1, 2, %o1
; SPARC64:       sll %o1, 3, %o1
; SPARC64:       sethi 63, %o3
; SPARC64:       or %o3, 1023, %o4
; SPARC64:       sll %o4, %o1, %o5
; SPARC64:       xor %o5, -1, %o3
; SPARC64:       and %o0, %o4, %o4
; SPARC64:       ld [%o2], %g2
; SPARC64:       mov  123, %o0
; SPARC64:       sll %o0, %o1, %o0
; SPARC64:       sll %o4, %o1, %o4
; SPARC64:       andn %g2, %o5, %o5
; SPARC64:      [[LABEL1:\.L.*]]:
; SPARC64:       or %o5, %o0, %g2
; SPARC64:       or %o5, %o4, %g3
; SPARC64:       cas [%o2], %g3, %g2
; SPARC64:       mov %g0, %g4
; SPARC64:       cmp %g2, %g3
; SPARC64:       move %icc, 1, %g4
; SPARC64:       cmp %g4, 0
; SPARC64:       bne %icc, [[LABEL2:\.L.*]]
; SPARC64:       nop
; SPARC64:       and %g2, %o3, %g3
; SPARC64:       cmp %o5, %g3
; SPARC64:       bne %icc, [[LABEL1]]
; SPARC64:       mov  %g3, %o5
; SPARC64:      [[LABEL2]]:
; SPARC64:       retl
; SPARC64:       srl %g2, %o1, %o0
define i16 @test_cmpxchg_i16(i16 %a, ptr %ptr) {
entry:
  %pair = cmpxchg ptr %ptr, i16 %a, i16 123 monotonic monotonic
  %b = extractvalue { i16, i1 } %pair, 0
  ret i16 %b
}

; SPARC-LABEL: test_cmpxchg_i32
; SPARC:       mov 123, [[R:%[gilo][0-7]]]
; SPARC:       cas [%o1], %o0, [[R]]
; SPARC64-LABEL: test_cmpxchg_i32
; SPARC64:       mov 123, [[R:%[gilo][0-7]]]
; SPARC64:       cas [%o1], %o0, [[R]]
define i32 @test_cmpxchg_i32(i32 %a, ptr %ptr) {
entry:
  %pair = cmpxchg ptr %ptr, i32 %a, i32 123 monotonic monotonic
  %b = extractvalue { i32, i1 } %pair, 0
  ret i32 %b
}

; SPARC-LABEL: test_swap_i8
; SPARC:       mov 42, [[R:%[gilo][0-7]]]
; SPARC:       cas
; SPARC64-LABEL: test_swap_i8
; SPARC64:       mov 42, [[R:%[gilo][0-7]]]
; SPARC64:       cas
define i8 @test_swap_i8(i8 %a, ptr %ptr) {
entry:
  %b = atomicrmw xchg ptr %ptr, i8 42 monotonic
  ret i8 %b
}

; SPARC-LABEL: test_swap_i16
; SPARC:       mov 42, [[R:%[gilo][0-7]]]
; SPARC:       cas
; SPARC64-LABEL: test_swap_i16
; SPARC64:       mov 42, [[R:%[gilo][0-7]]]
; SPARC64:       cas
define i16 @test_swap_i16(i16 %a, ptr %ptr) {
entry:
  %b = atomicrmw xchg ptr %ptr, i16 42 monotonic
  ret i16 %b
}

; SPARC-LABEL: test_swap_i32
; SPARC:       mov 42, [[R:%[gilo][0-7]]]
; SPARC:       swap [%o1], [[R]]
; SPARC64-LABEL: test_swap_i32
; SPARC64:       mov 42, [[R:%[gilo][0-7]]]
; SPARC64:       swap [%o1], [[R]]
define i32 @test_swap_i32(i32 %a, ptr %ptr) {
entry:
  %b = atomicrmw xchg ptr %ptr, i32 42 monotonic
  ret i32 %b
}

; SPARC-LABEL: test_load_sub_i8
; SPARC: membar
; SPARC: .L{{.*}}:
; SPARC: sub
; SPARC: cas [{{%[gilo][0-7]}}]
; SPARC: membar
; SPARC64-LABEL: test_load_sub_i8
; SPARC64: membar
; SPARC64: .L{{.*}}:
; SPARC64: sub
; SPARC64: cas [{{%[gilo][0-7]}}]
; SPARC64: membar
define zeroext i8 @test_load_sub_i8(ptr %p, i8 zeroext %v) {
entry:
  %0 = atomicrmw sub ptr %p, i8 %v seq_cst
  ret i8 %0
}

; SPARC-LABEL: test_load_sub_i16
; SPARC: membar
; SPARC: .L{{.*}}:
; SPARC: sub
; SPARC: cas [{{%[gilo][0-7]}}]
; SPARC: membar
; SPARC64-LABEL: test_load_sub_i16
; SPARC64: membar
; SPARC64: .L{{.*}}:
; SPARC64: sub
; SPARC64: cas [{{%[gilo][0-7]}}]
; SPARC64: membar
define zeroext i16 @test_load_sub_i16(ptr %p, i16 zeroext %v) {
entry:
  %0 = atomicrmw sub ptr %p, i16 %v seq_cst
  ret i16 %0
}

; SPARC-LABEL: test_load_add_i32
; SPARC: membar
; SPARC: mov [[U:%[gilo][0-7]]], [[V:%[gilo][0-7]]]
; SPARC: add [[U:%[gilo][0-7]]], %o1, [[V2:%[gilo][0-7]]]
; SPARC: cas [%o0], [[V]], [[V2]]
; SPARC: membar
; SPARC64-LABEL: test_load_add_i32
; SPARC64: membar
; SPARC64: mov [[U:%[gilo][0-7]]], [[V:%[gilo][0-7]]]
; SPARC64: add [[U:%[gilo][0-7]]], %o1, [[V2:%[gilo][0-7]]]
; SPARC64: cas [%o0], [[V]], [[V2]]
; SPARC64: membar
define zeroext i32 @test_load_add_i32(ptr %p, i32 zeroext %v) {
entry:
  %0 = atomicrmw add ptr %p, i32 %v seq_cst
  ret i32 %0
}

; SPARC-LABEL: test_load_xor_32
; SPARC: membar
; SPARC: xor
; SPARC: cas [%o0]
; SPARC: membar
; SPARC64-LABEL: test_load_xor_32
; SPARC64: membar
; SPARC64: xor
; SPARC64: cas [%o0]
; SPARC64: membar
define zeroext i32 @test_load_xor_32(ptr %p, i32 zeroext %v) {
entry:
  %0 = atomicrmw xor ptr %p, i32 %v seq_cst
  ret i32 %0
}

; SPARC-LABEL: test_load_and_32
; SPARC: membar
; SPARC: and
; SPARC-NOT: xor
; SPARC: cas [%o0]
; SPARC: membar
; SPARC64-LABEL: test_load_and_32
; SPARC64: membar
; SPARC64: and
; SPARC64-NOT: xor
; SPARC64: cas [%o0]
; SPARC64: membar
define zeroext i32 @test_load_and_32(ptr %p, i32 zeroext %v) {
entry:
  %0 = atomicrmw and ptr %p, i32 %v seq_cst
  ret i32 %0
}

; SPARC-LABEL: test_load_nand_32
; SPARC: membar
; SPARC: and
; SPARC: xor
; SPARC: cas [%o0]
; SPARC: membar
; SPARC64-LABEL: test_load_nand_32
; SPARC64: membar
; SPARC64: and
; SPARC64: xor
; SPARC64: cas [%o0]
; SPARC64: membar
define zeroext i32 @test_load_nand_32(ptr %p, i32 zeroext %v) {
entry:
  %0 = atomicrmw nand ptr %p, i32 %v seq_cst
  ret i32 %0
}

; SPARC-LABEL: test_load_umin_32
; SPARC: membar
; SPARC: cmp
; SPARC: movleu %icc
; SPARC: cas [%o0]
; SPARC: membar
; SPARC64-LABEL: test_load_umin_32
; SPARC64: membar
; SPARC64: cmp
; SPARC64: movleu %icc
; SPARC64: cas [%o0]
; SPARC64: membar
define zeroext i32 @test_load_umin_32(ptr %p, i32 zeroext %v) {
entry:
  %0 = atomicrmw umin ptr %p, i32 %v seq_cst
  ret i32 %0
}