test/CodeGen/CSKY/atomic-rmw.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=csky -verify-machineinstrs -csky-no-aliases -mattr=+2e3 < %s \
; RUN:   | FileCheck -check-prefix=CSKY %s

define i8 @atomicrmw_xchg_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI0_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI0_0:
; CSKY-NEXT:    .long __atomic_exchange_1
  %1 = atomicrmw xchg ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_xchg_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI1_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI1_0:
; CSKY-NEXT:    .long __atomic_exchange_1
  %1 = atomicrmw xchg ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_xchg_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI2_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI2_0:
; CSKY-NEXT:    .long __atomic_exchange_1
  %1 = atomicrmw xchg ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_xchg_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI3_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI3_0:
; CSKY-NEXT:    .long __atomic_exchange_1
  %1 = atomicrmw xchg ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_xchg_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI4_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI4_0:
; CSKY-NEXT:    .long __atomic_exchange_1
  %1 = atomicrmw xchg ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_add_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI5_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI5_0:
; CSKY-NEXT:    .long __atomic_fetch_add_1
  %1 = atomicrmw add ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_add_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI6_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI6_0:
; CSKY-NEXT:    .long __atomic_fetch_add_1
  %1 = atomicrmw add ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_add_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI7_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI7_0:
; CSKY-NEXT:    .long __atomic_fetch_add_1
  %1 = atomicrmw add ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_add_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI8_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI8_0:
; CSKY-NEXT:    .long __atomic_fetch_add_1
  %1 = atomicrmw add ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_add_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI9_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI9_0:
; CSKY-NEXT:    .long __atomic_fetch_add_1
  %1 = atomicrmw add ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_sub_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI10_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI10_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_1
  %1 = atomicrmw sub ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_sub_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI11_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI11_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_1
  %1 = atomicrmw sub ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_sub_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI12_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI12_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_1
  %1 = atomicrmw sub ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_sub_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI13_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI13_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_1
  %1 = atomicrmw sub ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_sub_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI14_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI14_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_1
  %1 = atomicrmw sub ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_and_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI15_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI15_0:
; CSKY-NEXT:    .long __atomic_fetch_and_1
  %1 = atomicrmw and ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_and_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI16_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI16_0:
; CSKY-NEXT:    .long __atomic_fetch_and_1
  %1 = atomicrmw and ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_and_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI17_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI17_0:
; CSKY-NEXT:    .long __atomic_fetch_and_1
  %1 = atomicrmw and ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_and_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI18_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI18_0:
; CSKY-NEXT:    .long __atomic_fetch_and_1
  %1 = atomicrmw and ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_and_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI19_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI19_0:
; CSKY-NEXT:    .long __atomic_fetch_and_1
  %1 = atomicrmw and ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_nand_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI20_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI20_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_1
  %1 = atomicrmw nand ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_nand_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI21_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI21_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_1
  %1 = atomicrmw nand ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_nand_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI22_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI22_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_1
  %1 = atomicrmw nand ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_nand_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI23_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI23_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_1
  %1 = atomicrmw nand ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_nand_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI24_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI24_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_1
  %1 = atomicrmw nand ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_or_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI25_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI25_0:
; CSKY-NEXT:    .long __atomic_fetch_or_1
  %1 = atomicrmw or ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_or_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI26_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI26_0:
; CSKY-NEXT:    .long __atomic_fetch_or_1
  %1 = atomicrmw or ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_or_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI27_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI27_0:
; CSKY-NEXT:    .long __atomic_fetch_or_1
  %1 = atomicrmw or ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_or_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI28_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI28_0:
; CSKY-NEXT:    .long __atomic_fetch_or_1
  %1 = atomicrmw or ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_or_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI29_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI29_0:
; CSKY-NEXT:    .long __atomic_fetch_or_1
  %1 = atomicrmw or ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_xor_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI30_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI30_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_1
  %1 = atomicrmw xor ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_xor_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI31_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI31_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_1
  %1 = atomicrmw xor ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_xor_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI32_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI32_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_1
  %1 = atomicrmw xor ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_xor_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI33_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI33_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_1
  %1 = atomicrmw xor ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_xor_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI34_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI34_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_1
  %1 = atomicrmw xor ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_max_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB35_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI35_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB35_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI35_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw max ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_max_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB36_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI36_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB36_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI36_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw max ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_max_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB37_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI37_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB37_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI37_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw max ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_max_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB38_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI38_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB38_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI38_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw max ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_max_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB39_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI39_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB39_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI39_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw max ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_min_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB40_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI40_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB40_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI40_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw min ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_min_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB41_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI41_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB41_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI41_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw min ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_min_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB42_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI42_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB42_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI42_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw min ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_min_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB43_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI43_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB43_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI43_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw min ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_min_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    sextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB44_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sextb16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI44_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB44_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI44_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw min ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_umax_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB45_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI45_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB45_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI45_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umax ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_umax_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB46_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI46_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB46_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI46_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umax ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_umax_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB47_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI47_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB47_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI47_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umax ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_umax_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB48_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI48_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB48_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI48_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umax ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_umax_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB49_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI49_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB49_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI49_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umax ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i8 @atomicrmw_umin_i8_monotonic(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i8_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB50_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI50_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB50_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI50_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umin ptr %a, i8 %b monotonic
  ret i8 %1
}

define i8 @atomicrmw_umin_i8_acquire(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i8_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB51_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI51_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB51_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI51_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umin ptr %a, i8 %b acquire
  ret i8 %1
}

define i8 @atomicrmw_umin_i8_release(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i8_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB52_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI52_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB52_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI52_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umin ptr %a, i8 %b release
  ret i8 %1
}

define i8 @atomicrmw_umin_i8_acq_rel(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i8_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB53_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI53_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB53_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI53_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umin ptr %a, i8 %b acq_rel
  ret i8 %1
}

define i8 @atomicrmw_umin_i8_seq_cst(ptr %a, i8 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i8_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.b a0, (a0, 0)
; CSKY-NEXT:    zextb16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB54_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zextb16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.b a0, (sp, 7)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 7
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI54_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.b a0, (sp, 7)
; CSKY-NEXT:    bez32 a1, .LBB54_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI54_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_1
  %1 = atomicrmw umin ptr %a, i8 %b seq_cst
  ret i8 %1
}

define i16 @atomicrmw_xchg_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI55_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI55_0:
; CSKY-NEXT:    .long __atomic_exchange_2
  %1 = atomicrmw xchg ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_xchg_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI56_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI56_0:
; CSKY-NEXT:    .long __atomic_exchange_2
  %1 = atomicrmw xchg ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_xchg_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI57_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI57_0:
; CSKY-NEXT:    .long __atomic_exchange_2
  %1 = atomicrmw xchg ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_xchg_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI58_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI58_0:
; CSKY-NEXT:    .long __atomic_exchange_2
  %1 = atomicrmw xchg ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_xchg_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI59_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI59_0:
; CSKY-NEXT:    .long __atomic_exchange_2
  %1 = atomicrmw xchg ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_add_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI60_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI60_0:
; CSKY-NEXT:    .long __atomic_fetch_add_2
  %1 = atomicrmw add ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_add_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI61_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI61_0:
; CSKY-NEXT:    .long __atomic_fetch_add_2
  %1 = atomicrmw add ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_add_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI62_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI62_0:
; CSKY-NEXT:    .long __atomic_fetch_add_2
  %1 = atomicrmw add ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_add_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI63_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI63_0:
; CSKY-NEXT:    .long __atomic_fetch_add_2
  %1 = atomicrmw add ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_add_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI64_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI64_0:
; CSKY-NEXT:    .long __atomic_fetch_add_2
  %1 = atomicrmw add ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_sub_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI65_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI65_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_2
  %1 = atomicrmw sub ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_sub_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI66_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI66_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_2
  %1 = atomicrmw sub ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_sub_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI67_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI67_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_2
  %1 = atomicrmw sub ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_sub_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI68_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI68_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_2
  %1 = atomicrmw sub ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_sub_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI69_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI69_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_2
  %1 = atomicrmw sub ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_and_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI70_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI70_0:
; CSKY-NEXT:    .long __atomic_fetch_and_2
  %1 = atomicrmw and ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_and_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI71_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI71_0:
; CSKY-NEXT:    .long __atomic_fetch_and_2
  %1 = atomicrmw and ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_and_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI72_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI72_0:
; CSKY-NEXT:    .long __atomic_fetch_and_2
  %1 = atomicrmw and ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_and_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI73_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI73_0:
; CSKY-NEXT:    .long __atomic_fetch_and_2
  %1 = atomicrmw and ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_and_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI74_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI74_0:
; CSKY-NEXT:    .long __atomic_fetch_and_2
  %1 = atomicrmw and ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_nand_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI75_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI75_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_2
  %1 = atomicrmw nand ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_nand_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI76_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI76_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_2
  %1 = atomicrmw nand ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_nand_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI77_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI77_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_2
  %1 = atomicrmw nand ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_nand_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI78_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI78_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_2
  %1 = atomicrmw nand ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_nand_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI79_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI79_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_2
  %1 = atomicrmw nand ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_or_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI80_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI80_0:
; CSKY-NEXT:    .long __atomic_fetch_or_2
  %1 = atomicrmw or ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_or_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI81_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI81_0:
; CSKY-NEXT:    .long __atomic_fetch_or_2
  %1 = atomicrmw or ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_or_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI82_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI82_0:
; CSKY-NEXT:    .long __atomic_fetch_or_2
  %1 = atomicrmw or ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_or_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI83_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI83_0:
; CSKY-NEXT:    .long __atomic_fetch_or_2
  %1 = atomicrmw or ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_or_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI84_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI84_0:
; CSKY-NEXT:    .long __atomic_fetch_or_2
  %1 = atomicrmw or ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_xor_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI85_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI85_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_2
  %1 = atomicrmw xor ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_xor_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI86_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI86_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_2
  %1 = atomicrmw xor ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_xor_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI87_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI87_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_2
  %1 = atomicrmw xor ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_xor_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI88_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI88_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_2
  %1 = atomicrmw xor ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_xor_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_xor_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI89_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI89_0:
; CSKY-NEXT:    .long __atomic_fetch_xor_2
  %1 = atomicrmw xor ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_max_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB90_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI90_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB90_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI90_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw max ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_max_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB91_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI91_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB91_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI91_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw max ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_max_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB92_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI92_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB92_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI92_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw max ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_max_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB93_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI93_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB93_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI93_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw max ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_max_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_max_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB94_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI94_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB94_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI94_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw max ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_min_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB95_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI95_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB95_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI95_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw min ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_min_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB96_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI96_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB96_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI96_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw min ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_min_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB97_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI97_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB97_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI97_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw min ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_min_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB98_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI98_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB98_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI98_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw min ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_min_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_min_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    sexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB99_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    sexth16 a1, a0
; CSKY-NEXT:    cmplt16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI99_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB99_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI99_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw min ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_umax_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB100_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI100_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB100_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI100_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umax ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_umax_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB101_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI101_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB101_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI101_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umax ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_umax_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB102_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI102_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB102_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI102_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umax ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_umax_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB103_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI103_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB103_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI103_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umax ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_umax_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umax_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB104_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movf32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI104_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB104_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI104_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umax ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i16 @atomicrmw_umin_i16_monotonic(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i16_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB105_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 0
; CSKY-NEXT:    jsri32 [.LCPI105_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB105_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI105_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umin ptr %a, i16 %b monotonic
  ret i16 %1
}

define i16 @atomicrmw_umin_i16_acquire(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i16_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB106_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 2
; CSKY-NEXT:    jsri32 [.LCPI106_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB106_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI106_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umin ptr %a, i16 %b acquire
  ret i16 %1
}

define i16 @atomicrmw_umin_i16_release(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i16_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 0
; CSKY-NEXT:  .LBB107_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 3
; CSKY-NEXT:    jsri32 [.LCPI107_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB107_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI107_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umin ptr %a, i16 %b release
  ret i16 %1
}

define i16 @atomicrmw_umin_i16_acq_rel(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i16_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 2
; CSKY-NEXT:  .LBB108_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 4
; CSKY-NEXT:    jsri32 [.LCPI108_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB108_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI108_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umin ptr %a, i16 %b acq_rel
  ret i16 %1
}

define i16 @atomicrmw_umin_i16_seq_cst(ptr %a, i16 %b) nounwind {
; CSKY-LABEL: atomicrmw_umin_i16_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 20
; CSKY-NEXT:    st16.w l3, (sp, 16) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l2, (sp, 12) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l1, (sp, 8) # 4-byte Folded Spill
; CSKY-NEXT:    st16.w l0, (sp, 4) # 4-byte Folded Spill
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    subi16 sp, sp, 8
; CSKY-NEXT:    mov16 l0, a1
; CSKY-NEXT:    mov16 l1, a0
; CSKY-NEXT:    ld16.h a0, (a0, 0)
; CSKY-NEXT:    zexth16 l2, a1
; CSKY-NEXT:    movi16 l3, 5
; CSKY-NEXT:  .LBB109_1: # %atomicrmw.start
; CSKY-NEXT:    # =>This Inner Loop Header: Depth=1
; CSKY-NEXT:    zexth16 a1, a0
; CSKY-NEXT:    cmphs16 l2, a1
; CSKY-NEXT:    mov16 a2, l0
; CSKY-NEXT:    movt32 a2, a0
; CSKY-NEXT:    st32.h a0, (sp, 6)
; CSKY-NEXT:    st16.w l3, (sp, 0)
; CSKY-NEXT:    mov16 a0, l1
; CSKY-NEXT:    addi32 a1, sp, 6
; CSKY-NEXT:    movi16 a3, 5
; CSKY-NEXT:    jsri32 [.LCPI109_0]
; CSKY-NEXT:    mov16 a1, a0
; CSKY-NEXT:    ld32.h a0, (sp, 6)
; CSKY-NEXT:    bez32 a1, .LBB109_1
; CSKY-NEXT:  # %bb.2: # %atomicrmw.end
; CSKY-NEXT:    addi16 sp, sp, 8
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l0, (sp, 4) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l1, (sp, 8) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l2, (sp, 12) # 4-byte Folded Reload
; CSKY-NEXT:    ld16.w l3, (sp, 16) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 20
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.3:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI109_0:
; CSKY-NEXT:    .long __atomic_compare_exchange_2
  %1 = atomicrmw umin ptr %a, i16 %b seq_cst
  ret i16 %1
}

define i32 @atomicrmw_xchg_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI110_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI110_0:
; CSKY-NEXT:    .long __atomic_exchange_4
  %1 = atomicrmw xchg ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_xchg_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI111_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI111_0:
; CSKY-NEXT:    .long __atomic_exchange_4
  %1 = atomicrmw xchg ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_xchg_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI112_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI112_0:
; CSKY-NEXT:    .long __atomic_exchange_4
  %1 = atomicrmw xchg ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_xchg_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI113_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI113_0:
; CSKY-NEXT:    .long __atomic_exchange_4
  %1 = atomicrmw xchg ptr %a, i32 %b acq_rel
  ret i32 %1
}

define i32 @atomicrmw_xchg_i32_seq_cst(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_xchg_i32_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI114_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI114_0:
; CSKY-NEXT:    .long __atomic_exchange_4
  %1 = atomicrmw xchg ptr %a, i32 %b seq_cst
  ret i32 %1
}

define i32 @atomicrmw_add_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI115_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI115_0:
; CSKY-NEXT:    .long __atomic_fetch_add_4
  %1 = atomicrmw add ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_add_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI116_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI116_0:
; CSKY-NEXT:    .long __atomic_fetch_add_4
  %1 = atomicrmw add ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_add_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI117_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI117_0:
; CSKY-NEXT:    .long __atomic_fetch_add_4
  %1 = atomicrmw add ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_add_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI118_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI118_0:
; CSKY-NEXT:    .long __atomic_fetch_add_4
  %1 = atomicrmw add ptr %a, i32 %b acq_rel
  ret i32 %1
}

define i32 @atomicrmw_add_i32_seq_cst(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_add_i32_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI119_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI119_0:
; CSKY-NEXT:    .long __atomic_fetch_add_4
  %1 = atomicrmw add ptr %a, i32 %b seq_cst
  ret i32 %1
}

define i32 @atomicrmw_sub_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI120_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI120_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_4
  %1 = atomicrmw sub ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_sub_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI121_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI121_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_4
  %1 = atomicrmw sub ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_sub_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI122_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI122_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_4
  %1 = atomicrmw sub ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_sub_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI123_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI123_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_4
  %1 = atomicrmw sub ptr %a, i32 %b acq_rel
  ret i32 %1
}

define i32 @atomicrmw_sub_i32_seq_cst(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_sub_i32_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI124_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI124_0:
; CSKY-NEXT:    .long __atomic_fetch_sub_4
  %1 = atomicrmw sub ptr %a, i32 %b seq_cst
  ret i32 %1
}

define i32 @atomicrmw_and_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI125_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI125_0:
; CSKY-NEXT:    .long __atomic_fetch_and_4
  %1 = atomicrmw and ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_and_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI126_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI126_0:
; CSKY-NEXT:    .long __atomic_fetch_and_4
  %1 = atomicrmw and ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_and_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI127_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI127_0:
; CSKY-NEXT:    .long __atomic_fetch_and_4
  %1 = atomicrmw and ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_and_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI128_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI128_0:
; CSKY-NEXT:    .long __atomic_fetch_and_4
  %1 = atomicrmw and ptr %a, i32 %b acq_rel
  ret i32 %1
}

define i32 @atomicrmw_and_i32_seq_cst(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_and_i32_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI129_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI129_0:
; CSKY-NEXT:    .long __atomic_fetch_and_4
  %1 = atomicrmw and ptr %a, i32 %b seq_cst
  ret i32 %1
}

define i32 @atomicrmw_nand_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI130_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI130_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_4
  %1 = atomicrmw nand ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_nand_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI131_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI131_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_4
  %1 = atomicrmw nand ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_nand_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI132_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI132_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_4
  %1 = atomicrmw nand ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_nand_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI133_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI133_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_4
  %1 = atomicrmw nand ptr %a, i32 %b acq_rel
  ret i32 %1
}

define i32 @atomicrmw_nand_i32_seq_cst(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_nand_i32_seq_cst:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 5
; CSKY-NEXT:    jsri32 [.LCPI134_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI134_0:
; CSKY-NEXT:    .long __atomic_fetch_nand_4
  %1 = atomicrmw nand ptr %a, i32 %b seq_cst
  ret i32 %1
}

define i32 @atomicrmw_or_i32_monotonic(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i32_monotonic:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 0
; CSKY-NEXT:    jsri32 [.LCPI135_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI135_0:
; CSKY-NEXT:    .long __atomic_fetch_or_4
  %1 = atomicrmw or ptr %a, i32 %b monotonic
  ret i32 %1
}

define i32 @atomicrmw_or_i32_acquire(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i32_acquire:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 2
; CSKY-NEXT:    jsri32 [.LCPI136_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI136_0:
; CSKY-NEXT:    .long __atomic_fetch_or_4
  %1 = atomicrmw or ptr %a, i32 %b acquire
  ret i32 %1
}

define i32 @atomicrmw_or_i32_release(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i32_release:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 3
; CSKY-NEXT:    jsri32 [.LCPI137_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI137_0:
; CSKY-NEXT:    .long __atomic_fetch_or_4
  %1 = atomicrmw or ptr %a, i32 %b release
  ret i32 %1
}

define i32 @atomicrmw_or_i32_acq_rel(ptr %a, i32 %b) nounwind {
; CSKY-LABEL: atomicrmw_or_i32_acq_rel:
; CSKY:       # %bb.0:
; CSKY-NEXT:    subi16 sp, sp, 4
; CSKY-NEXT:    st32.w lr, (sp, 0) # 4-byte Folded Spill
; CSKY-NEXT:    movi16 a2, 4
; CSKY-NEXT:    jsri32 [.LCPI138_0]
; CSKY-NEXT:    ld32.w lr, (sp, 0) # 4-byte Folded Reload
; CSKY-NEXT:    addi16 sp, sp, 4
; CSKY-NEXT:    rts16
; CSKY-NEXT:    .p2align 1
; CSKY-NEXT:  # %bb.1:
; CSKY-NEXT:    .p2align 2
; CSKY-NEXT:  .LCPI138_0:
; CSKY-NEXT:    .long __atomic_fetch_or_4
  %1 = atomicrmw or ptr %a, i32 %b acq_rel