void test_op_ignore(void) {
  signed char sc[2];
  unsigned char uc[2];
  signed short ss[2];
  unsigned short us[2];
  signed int si[2];
  unsigned int ui[2];
  signed long sl[2];
  unsigned long ul[2];
  signed long long sll[2];
  unsigned long long ull[2];
  (void)__sync_fetch_and_add(&sc[1], -1);
  (void)__sync_fetch_and_add(&uc[1], -1);
  (void)__sync_fetch_and_add(&ss[1], -1);
  (void)__sync_fetch_and_add(&us[1], -1);
  (void)__sync_fetch_and_add(&si[1], -1);
  (void)__sync_fetch_and_add(&ui[1], -1);
  (void)__sync_fetch_and_add(&sl[1], -1);
  (void)__sync_fetch_and_add(&ul[1], -1);
  (void)__sync_fetch_and_add(&sll[1], -1);
  (void)__sync_fetch_and_add(&ull[1], -1);
  (void)__sync_fetch_and_sub(&sc[1], -1);
  (void)__sync_fetch_and_sub(&uc[1], -1);
  (void)__sync_fetch_and_sub(&ss[1], -1);
  (void)__sync_fetch_and_sub(&us[1], -1);
  (void)__sync_fetch_and_sub(&si[1], -1);
  (void)__sync_fetch_and_sub(&ui[1], -1);
  (void)__sync_fetch_and_sub(&sl[1], -1);
  (void)__sync_fetch_and_sub(&ul[1], -1);
  (void)__sync_fetch_and_sub(&sll[1], -1);
  (void)__sync_fetch_and_sub(&ull[1], -1);
  (void)__sync_fetch_and_or(&sc[1], -1);
  (void)__sync_fetch_and_or(&uc[1], -1);
  (void)__sync_fetch_and_or(&ss[1], -1);
  (void)__sync_fetch_and_or(&us[1], -1);
  (void)__sync_fetch_and_or(&si[1], -1);
  (void)__sync_fetch_and_or(&ui[1], -1);
  (void)__sync_fetch_and_or(&sl[1], -1);
  (void)__sync_fetch_and_or(&ul[1], -1);
  (void)__sync_fetch_and_or(&sll[1], -1);
  (void)__sync_fetch_and_or(&ull[1], -1);
  (void)__sync_fetch_and_xor(&sc[1], -1);
  (void)__sync_fetch_and_xor(&uc[1], -1);
  (void)__sync_fetch_and_xor(&ss[1], -1);
  (void)__sync_fetch_and_xor(&us[1], -1);
  (void)__sync_fetch_and_xor(&si[1], -1);
  (void)__sync_fetch_and_xor(&ui[1], -1);
  (void)__sync_fetch_and_xor(&sl[1], -1);
  (void)__sync_fetch_and_xor(&ul[1], -1);
  (void)__sync_fetch_and_xor(&sll[1], -1);
  (void)__sync_fetch_and_xor(&ull[1], -1);
  (void)__sync_fetch_and_and(&sc[1], -1);
  (void)__sync_fetch_and_and(&uc[1], -1);
  (void)__sync_fetch_and_and(&ss[1], -1);
  (void)__sync_fetch_and_and(&us[1], -1);
  (void)__sync_fetch_and_and(&si[1], -1);
  (void)__sync_fetch_and_and(&ui[1], -1);
  (void)__sync_fetch_and_and(&sl[1], -1);
  (void)__sync_fetch_and_and(&ul[1], -1);
  (void)__sync_fetch_and_and(&sll[1], -1);
  (void)__sync_fetch_and_and(&ull[1], -1);
  (void)__sync_fetch_and_nand(&sc[1], -1);
  (void)__sync_fetch_and_nand(&uc[1], -1);
  (void)__sync_fetch_and_nand(&ss[1], -1);
  (void)__sync_fetch_and_nand(&us[1], -1);
  (void)__sync_fetch_and_nand(&si[1], -1);
  (void)__sync_fetch_and_nand(&ui[1], -1);
  (void)__sync_fetch_and_nand(&sl[1], -1);
  (void)__sync_fetch_and_nand(&ul[1], -1);
  (void)__sync_fetch_and_nand(&sll[1], -1);
  (void)__sync_fetch_and_nand(&ull[1], -1);
}


x86 assembly (clang, -O0):
<test_op_ignore>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
lock addb $0xff,-0x1(%rbp)
lock addb $0xff,-0x3(%rbp)
lock addw $0xffff,-0x6(%rbp)
lock addw $0xffff,-0xa(%rbp)
lock addl $0xffffffff,-0x10(%rbp)
lock addl $0xffffffff,-0x18(%rbp)
lock addq $0xffffffffffffffff,-0x28(%rbp)
lock addq $0xffffffffffffffff,-0x38(%rbp)
lock addq $0xffffffffffffffff,-0x48(%rbp)
lock addq $0xffffffffffffffff,-0x58(%rbp)
lock subb $0xff,-0x1(%rbp)
lock subb $0xff,-0x3(%rbp)
lock subw $0xffff,-0x6(%rbp)
lock subw $0xffff,-0xa(%rbp)
lock subl $0xffffffff,-0x10(%rbp)
lock subl $0xffffffff,-0x18(%rbp)
lock subq $0xffffffffffffffff,-0x28(%rbp)
lock subq $0xffffffffffffffff,-0x38(%rbp)
lock subq $0xffffffffffffffff,-0x48(%rbp)
lock subq $0xffffffffffffffff,-0x58(%rbp)
lock orb $0xff,-0x1(%rbp)
lock orb $0xff,-0x3(%rbp)
lock orw $0xffff,-0x6(%rbp)
lock orw $0xffff,-0xa(%rbp)
lock orl $0xffffffff,-0x10(%rbp)
lock orl $0xffffffff,-0x18(%rbp)
lock orq $0xffffffffffffffff,-0x28(%rbp)
lock orq $0xffffffffffffffff,-0x38(%rbp)
lock orq $0xffffffffffffffff,-0x48(%rbp)
lock orq $0xffffffffffffffff,-0x58(%rbp)
lock xorb $0xff,-0x1(%rbp)
lock xorb $0xff,-0x3(%rbp)
lock xorw $0xffff,-0x6(%rbp)
lock xorw $0xffff,-0xa(%rbp)
lock xorl $0xffffffff,-0x10(%rbp)
lock xorl $0xffffffff,-0x18(%rbp)
lock xorq $0xffffffffffffffff,-0x28(%rbp)
lock xorq $0xffffffffffffffff,-0x38(%rbp)
lock xorq $0xffffffffffffffff,-0x48(%rbp)
lock xorq $0xffffffffffffffff,-0x58(%rbp)
mfence
mov    -0x1(%rbp),%al
mfence
mov    -0x3(%rbp),%al
mfence
mov    -0x6(%rbp),%ax
mfence
mov    -0xa(%rbp),%ax
mfence
mov    -0x10(%rbp),%eax
mfence
mov    -0x18(%rbp),%eax
mfence
mov    -0x28(%rbp),%rax
mfence
mov    -0x38(%rbp),%rax
mfence
mov    -0x48(%rbp),%rax
mfence
mov    -0x58(%rbp),%rax
lea    -0x2(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x1(%rbp),%al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
mov    -0x70(%rbp),%rcx
mov    %al,%dl
not    %dl
lock cmpxchg %dl,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %al,-0x61(%rbp)
jne    1262 <test_op_ignore+0x162>
jmp    123f <test_op_ignore+0x13f>
lea    -0x4(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x3(%rbp),%al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
mov    -0x80(%rbp),%rcx
mov    %al,%dl
not    %dl
lock cmpxchg %dl,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %al,-0x71(%rbp)
jne    1297 <test_op_ignore+0x197>
jmp    1274 <test_op_ignore+0x174>
lea    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x6(%rbp),%ax
mov    %ax,-0x82(%rbp)
mov    -0x82(%rbp),%ax
mov    -0x90(%rbp),%rcx
mov    %ax,%dx
mov    %edx,-0x98(%rbp)
not    %edx
mov    %edx,-0x94(%rbp)
lock cmpxchg %dx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %ax,-0x82(%rbp)
jne    12ed <test_op_ignore+0x1ed>
jmp    12b1 <test_op_ignore+0x1b1>
lea    -0xc(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa(%rbp),%ax
mov    %ax,-0x9a(%rbp)
mov    -0x9a(%rbp),%ax
mov    -0xa8(%rbp),%rcx
mov    %ax,%dx
mov    %edx,-0xb0(%rbp)
not    %edx
mov    %edx,-0xac(%rbp)
lock cmpxchg %dx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %ax,-0x9a(%rbp)
jne    1343 <test_op_ignore+0x243>
jmp    1307 <test_op_ignore+0x207>
lea    -0x14(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0xc0(%rbp),%rcx
mov    %eax,%edx
not    %edx
lock cmpxchg %edx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %eax,-0xb4(%rbp)
jne    1387 <test_op_ignore+0x287>
jmp    135b <test_op_ignore+0x25b>
lea    -0x1c(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0xd0(%rbp),%rcx
mov    %eax,%edx
not    %edx
lock cmpxchg %edx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %eax,-0xc4(%rbp)
jne    13cb <test_op_ignore+0x2cb>
jmp    139f <test_op_ignore+0x29f>
lea    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    %rax,%rdx
not    %rdx
lock cmpxchg %rdx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %rax,-0xd8(%rbp)
jne    1416 <test_op_ignore+0x316>
jmp    13e5 <test_op_ignore+0x2e5>
lea    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
mov    -0xf0(%rbp),%rcx
mov    %rax,%rdx
not    %rdx
lock cmpxchg %rdx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %rax,-0xe8(%rbp)
jne    1461 <test_op_ignore+0x361>
jmp    1430 <test_op_ignore+0x330>
lea    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x100(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
mov    -0x100(%rbp),%rcx
mov    %rax,%rdx
not    %rdx
lock cmpxchg %rdx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %rax,-0xf8(%rbp)
jne    14ac <test_op_ignore+0x3ac>
jmp    147b <test_op_ignore+0x37b>
lea    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x110(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rcx
mov    %rax,%rdx
not    %rdx
lock cmpxchg %rdx,(%rcx)
sete   %cl
test   $0x1,%cl
mov    %rax,-0x108(%rbp)
jne    14f7 <test_op_ignore+0x3f7>
jmp    14c6 <test_op_ignore+0x3c6>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_op_ignore>:
lock addb $0xff,-0x61(%rsp)
lock addb $0xff,-0x63(%rsp)
lock addw $0xffff,-0x5a(%rsp)
lock addw $0xffff,-0x5e(%rsp)
lock addl $0xffffffff,-0x4c(%rsp)
lock addl $0xffffffff,-0x54(%rsp)
lock addq $0xffffffffffffffff,-0x10(%rsp)
lock addq $0xffffffffffffffff,-0x20(%rsp)
lock addq $0xffffffffffffffff,-0x30(%rsp)
lock addq $0xffffffffffffffff,-0x40(%rsp)
lock subb $0xff,-0x61(%rsp)
lock subb $0xff,-0x63(%rsp)
lock subw $0xffff,-0x5a(%rsp)
lock subw $0xffff,-0x5e(%rsp)
lock subl $0xffffffff,-0x4c(%rsp)
lock subl $0xffffffff,-0x54(%rsp)
lock subq $0xffffffffffffffff,-0x10(%rsp)
lock subq $0xffffffffffffffff,-0x20(%rsp)
lock subq $0xffffffffffffffff,-0x30(%rsp)
lock subq $0xffffffffffffffff,-0x40(%rsp)
mov    $0xff,%al
xchg   %al,-0x61(%rsp)
mov    $0xff,%al
xchg   %al,-0x63(%rsp)
mov    $0xffff,%ax
xchg   %ax,-0x5a(%rsp)
mov    $0xffff,%ax
xchg   %ax,-0x5e(%rsp)
mov    $0xffffffff,%eax
xchg   %eax,-0x4c(%rsp)
mov    $0xffffffff,%eax
xchg   %eax,-0x54(%rsp)
mov    $0xffffffffffffffff,%rax
xchg   %rax,-0x10(%rsp)
mov    $0xffffffffffffffff,%rax
xchg   %rax,-0x20(%rsp)
mov    $0xffffffffffffffff,%rax
xchg   %rax,-0x30(%rsp)
mov    $0xffffffffffffffff,%rax
xchg   %rax,-0x40(%rsp)
lock xorb $0xff,-0x61(%rsp)
lock xorb $0xff,-0x63(%rsp)
lock xorw $0xffff,-0x5a(%rsp)
lock xorw $0xffff,-0x5e(%rsp)
lock xorl $0xffffffff,-0x4c(%rsp)
lock xorl $0xffffffff,-0x54(%rsp)
lock xorq $0xffffffffffffffff,-0x10(%rsp)
lock xorq $0xffffffffffffffff,-0x20(%rsp)
lock xorq $0xffffffffffffffff,-0x30(%rsp)
lock xorq $0xffffffffffffffff,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
lock orl $0x0,-0x40(%rsp)
mov    -0x61(%rsp),%al
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%ecx
not    %cl
lock cmpxchg %cl,-0x61(%rsp)
jne    1270 <test_op_ignore+0x170>
mov    -0x63(%rsp),%al
mov    %eax,%ecx
not    %cl
lock cmpxchg %cl,-0x63(%rsp)
jne    1280 <test_op_ignore+0x180>
movzwl -0x5a(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
not    %ecx
lock cmpxchg %cx,-0x5a(%rsp)
jne    12a0 <test_op_ignore+0x1a0>
movzwl -0x5e(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,%ecx
not    %ecx
lock cmpxchg %cx,-0x5e(%rsp)
jne    12c0 <test_op_ignore+0x1c0>
mov    -0x4c(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
not    %ecx
lock cmpxchg %ecx,-0x4c(%rsp)
jne    12e0 <test_op_ignore+0x1e0>
mov    -0x54(%rsp),%eax
mov    %eax,%ecx
not    %ecx
lock cmpxchg %ecx,-0x54(%rsp)
jne    12f0 <test_op_ignore+0x1f0>
mov    -0x10(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rcx
not    %rcx
lock cmpxchg %rcx,-0x10(%rsp)
jne    1310 <test_op_ignore+0x210>
mov    -0x20(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rcx
not    %rcx
lock cmpxchg %rcx,-0x20(%rsp)
jne    1330 <test_op_ignore+0x230>
mov    -0x30(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rcx
not    %rcx
lock cmpxchg %rcx,-0x30(%rsp)
jne    1350 <test_op_ignore+0x250>
mov    -0x40(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rcx
not    %rcx
lock cmpxchg %rcx,-0x40(%rsp)
jne    1370 <test_op_ignore+0x270>
ret

LLVM IR (-O0):
define void @test_op_ignore() {
%1 = alloca [2 x i8]
%2 = alloca [2 x i8]
%3 = alloca [2 x i16]
%4 = alloca [2 x i16]
%5 = alloca [2 x i32]
%6 = alloca [2 x i32]
%7 = alloca [2 x i64]
%8 = alloca [2 x i64]
%9 = alloca [2 x i64]
%10 = alloca [2 x i64]
%11 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%12 = atomicrmw add i8* %11, i8 -1 seq_cst
%13 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%14 = atomicrmw add i8* %13, i8 -1 seq_cst
%15 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%16 = atomicrmw add i16* %15, i16 -1 seq_cst
%17 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%18 = atomicrmw add i16* %17, i16 -1 seq_cst
%19 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%20 = atomicrmw add i32* %19, i32 -1 seq_cst
%21 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%22 = atomicrmw add i32* %21, i32 -1 seq_cst
%23 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%24 = atomicrmw add i64* %23, i64 -1 seq_cst
%25 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%26 = atomicrmw add i64* %25, i64 -1 seq_cst
%27 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%28 = atomicrmw add i64* %27, i64 -1 seq_cst
%29 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%30 = atomicrmw add i64* %29, i64 -1 seq_cst
%31 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%32 = atomicrmw sub i8* %31, i8 -1 seq_cst
%33 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%34 = atomicrmw sub i8* %33, i8 -1 seq_cst
%35 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%36 = atomicrmw sub i16* %35, i16 -1 seq_cst
%37 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%38 = atomicrmw sub i16* %37, i16 -1 seq_cst
%39 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%40 = atomicrmw sub i32* %39, i32 -1 seq_cst
%41 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%42 = atomicrmw sub i32* %41, i32 -1 seq_cst
%43 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%44 = atomicrmw sub i64* %43, i64 -1 seq_cst
%45 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%46 = atomicrmw sub i64* %45, i64 -1 seq_cst
%47 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%48 = atomicrmw sub i64* %47, i64 -1 seq_cst
%49 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%50 = atomicrmw sub i64* %49, i64 -1 seq_cst
%51 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%52 = atomicrmw or i8* %51, i8 -1 seq_cst
%53 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%54 = atomicrmw or i8* %53, i8 -1 seq_cst
%55 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%56 = atomicrmw or i16* %55, i16 -1 seq_cst
%57 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%58 = atomicrmw or i16* %57, i16 -1 seq_cst
%59 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%60 = atomicrmw or i32* %59, i32 -1 seq_cst
%61 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%62 = atomicrmw or i32* %61, i32 -1 seq_cst
%63 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%64 = atomicrmw or i64* %63, i64 -1 seq_cst
%65 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%66 = atomicrmw or i64* %65, i64 -1 seq_cst
%67 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%68 = atomicrmw or i64* %67, i64 -1 seq_cst
%69 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%70 = atomicrmw or i64* %69, i64 -1 seq_cst
%71 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%72 = atomicrmw xor i8* %71, i8 -1 seq_cst
%73 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%74 = atomicrmw xor i8* %73, i8 -1 seq_cst
%75 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%76 = atomicrmw xor i16* %75, i16 -1 seq_cst
%77 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%78 = atomicrmw xor i16* %77, i16 -1 seq_cst
%79 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%80 = atomicrmw xor i32* %79, i32 -1 seq_cst
%81 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%82 = atomicrmw xor i32* %81, i32 -1 seq_cst
%83 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%84 = atomicrmw xor i64* %83, i64 -1 seq_cst
%85 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%86 = atomicrmw xor i64* %85, i64 -1 seq_cst
%87 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%88 = atomicrmw xor i64* %87, i64 -1 seq_cst
%89 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%90 = atomicrmw xor i64* %89, i64 -1 seq_cst
%91 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%92 = atomicrmw and i8* %91, i8 -1 seq_cst
%93 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%94 = atomicrmw and i8* %93, i8 -1 seq_cst
%95 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%96 = atomicrmw and i16* %95, i16 -1 seq_cst
%97 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%98 = atomicrmw and i16* %97, i16 -1 seq_cst
%99 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%100 = atomicrmw and i32* %99, i32 -1 seq_cst
%101 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%102 = atomicrmw and i32* %101, i32 -1 seq_cst
%103 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%104 = atomicrmw and i64* %103, i64 -1 seq_cst
%105 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%106 = atomicrmw and i64* %105, i64 -1 seq_cst
%107 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%108 = atomicrmw and i64* %107, i64 -1 seq_cst
%109 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%110 = atomicrmw and i64* %109, i64 -1 seq_cst
%111 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%112 = atomicrmw nand i8* %111, i8 -1 seq_cst
%113 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%114 = atomicrmw nand i8* %113, i8 -1 seq_cst
%115 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%116 = atomicrmw nand i16* %115, i16 -1 seq_cst
%117 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%118 = atomicrmw nand i16* %117, i16 -1 seq_cst
%119 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%120 = atomicrmw nand i32* %119, i32 -1 seq_cst
%121 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%122 = atomicrmw nand i32* %121, i32 -1 seq_cst
%123 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%124 = atomicrmw nand i64* %123, i64 -1 seq_cst
%125 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%126 = atomicrmw nand i64* %125, i64 -1 seq_cst
%127 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%128 = atomicrmw nand i64* %127, i64 -1 seq_cst
%129 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%130 = atomicrmw nand i64* %129, i64 -1 seq_cst
ret void
}

LLVM IR (-O2):
define void @test_op_ignore() {
%1 = alloca [2 x i8]
%2 = alloca [2 x i8]
%3 = alloca [2 x i16]
%4 = alloca [2 x i16]
%5 = alloca [2 x i32]
%6 = alloca [2 x i32]
%7 = alloca [2 x i64]
%8 = alloca [2 x i64]
%9 = alloca [2 x i64]
%10 = alloca [2 x i64]
%11 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 0
%12 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 0
%13 = bitcast [2 x i16]* %3 to i8*
%14 = bitcast [2 x i16]* %4 to i8*
%15 = bitcast [2 x i32]* %5 to i8*
%16 = bitcast [2 x i32]* %6 to i8*
%17 = bitcast [2 x i64]* %7 to i8*
%18 = bitcast [2 x i64]* %8 to i8*
%19 = bitcast [2 x i64]* %9 to i8*
%20 = bitcast [2 x i64]* %10 to i8*
%21 = getelementptr inbounds [2 x i8], [2 x i8]* %1, i64 0, i64 1
%22 = atomicrmw add i8* %21, i8 -1 seq_cst
%23 = getelementptr inbounds [2 x i8], [2 x i8]* %2, i64 0, i64 1
%24 = atomicrmw add i8* %23, i8 -1 seq_cst
%25 = getelementptr inbounds [2 x i16], [2 x i16]* %3, i64 0, i64 1
%26 = atomicrmw add i16* %25, i16 -1 seq_cst
%27 = getelementptr inbounds [2 x i16], [2 x i16]* %4, i64 0, i64 1
%28 = atomicrmw add i16* %27, i16 -1 seq_cst
%29 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%30 = atomicrmw add i32* %29, i32 -1 seq_cst
%31 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%32 = atomicrmw add i32* %31, i32 -1 seq_cst
%33 = getelementptr inbounds [2 x i64], [2 x i64]* %7, i64 0, i64 1
%34 = atomicrmw add i64* %33, i64 -1 seq_cst
%35 = getelementptr inbounds [2 x i64], [2 x i64]* %8, i64 0, i64 1
%36 = atomicrmw add i64* %35, i64 -1 seq_cst
%37 = getelementptr inbounds [2 x i64], [2 x i64]* %9, i64 0, i64 1
%38 = atomicrmw add i64* %37, i64 -1 seq_cst
%39 = getelementptr inbounds [2 x i64], [2 x i64]* %10, i64 0, i64 1
%40 = atomicrmw add i64* %39, i64 -1 seq_cst
%41 = atomicrmw sub i8* %21, i8 -1 seq_cst
%42 = atomicrmw sub i8* %23, i8 -1 seq_cst
%43 = atomicrmw sub i16* %25, i16 -1 seq_cst
%44 = atomicrmw sub i16* %27, i16 -1 seq_cst
%45 = atomicrmw sub i32* %29, i32 -1 seq_cst
%46 = atomicrmw sub i32* %31, i32 -1 seq_cst
%47 = atomicrmw sub i64* %33, i64 -1 seq_cst
%48 = atomicrmw sub i64* %35, i64 -1 seq_cst
%49 = atomicrmw sub i64* %37, i64 -1 seq_cst
%50 = atomicrmw sub i64* %39, i64 -1 seq_cst
%51 = atomicrmw xchg i8* %21, i8 -1 seq_cst
%52 = atomicrmw xchg i8* %23, i8 -1 seq_cst
%53 = atomicrmw xchg i16* %25, i16 -1 seq_cst
%54 = atomicrmw xchg i16* %27, i16 -1 seq_cst
%55 = atomicrmw xchg i32* %29, i32 -1 seq_cst
%56 = atomicrmw xchg i32* %31, i32 -1 seq_cst
%57 = atomicrmw xchg i64* %33, i64 -1 seq_cst
%58 = atomicrmw xchg i64* %35, i64 -1 seq_cst
%59 = atomicrmw xchg i64* %37, i64 -1 seq_cst
%60 = atomicrmw xchg i64* %39, i64 -1 seq_cst
%61 = atomicrmw xor i8* %21, i8 -1 seq_cst
%62 = atomicrmw xor i8* %23, i8 -1 seq_cst
%63 = atomicrmw xor i16* %25, i16 -1 seq_cst
%64 = atomicrmw xor i16* %27, i16 -1 seq_cst
%65 = atomicrmw xor i32* %29, i32 -1 seq_cst
%66 = atomicrmw xor i32* %31, i32 -1 seq_cst
%67 = atomicrmw xor i64* %33, i64 -1 seq_cst
%68 = atomicrmw xor i64* %35, i64 -1 seq_cst
%69 = atomicrmw xor i64* %37, i64 -1 seq_cst
%70 = atomicrmw xor i64* %39, i64 -1 seq_cst
%71 = atomicrmw or i8* %21, i8 0 seq_cst
%72 = atomicrmw or i8* %23, i8 0 seq_cst
%73 = atomicrmw or i16* %25, i16 0 seq_cst
%74 = atomicrmw or i16* %27, i16 0 seq_cst
%75 = atomicrmw or i32* %29, i32 0 seq_cst
%76 = atomicrmw or i32* %31, i32 0 seq_cst
%77 = atomicrmw or i64* %33, i64 0 seq_cst
%78 = atomicrmw or i64* %35, i64 0 seq_cst
%79 = atomicrmw or i64* %37, i64 0 seq_cst
%80 = atomicrmw or i64* %39, i64 0 seq_cst
%81 = atomicrmw nand i8* %21, i8 -1 seq_cst
%82 = atomicrmw nand i8* %23, i8 -1 seq_cst
%83 = atomicrmw nand i16* %25, i16 -1 seq_cst
%84 = atomicrmw nand i16* %27, i16 -1 seq_cst
%85 = atomicrmw nand i32* %29, i32 -1 seq_cst
%86 = atomicrmw nand i32* %31, i32 -1 seq_cst
%87 = atomicrmw nand i64* %33, i64 -1 seq_cst
%88 = atomicrmw nand i64* %35, i64 -1 seq_cst
%89 = atomicrmw nand i64* %37, i64 -1 seq_cst
%90 = atomicrmw nand i64* %39, i64 -1 seq_cst
ret void
}