void test_1(void) {
  dcl_acc(({
    _Complex char x;
    __real__(x) = (1), __imag__(x) == (2);
    x;
  }));
  dcl_acs(({
    _Complex short x;
    __real__(x) = (3), __imag__(x) == (4);
    x;
  }));
  dcl_aci(({
    _Complex int x;
    __real__(x) = (5), __imag__(x) == (6);
    x;
  }));
  dcl_acll(({
    _Complex long long x;
    __real__(x) = (7), __imag__(x) == (8);
    x;
  }));
  dcl_acf(({
    _Complex float x;
    __real__(x) = (9), __imag__(x) == (10);
    x;
  }));
  dcl_acd(({
    _Complex double x;
    __real__(x) = (11), __imag__(x) == (12);
    x;
  }));
}


x86 assembly (clang, -O0):
<test_1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movb   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%cl
mov    -0x7(%rbp),%al
mov    %cl,-0x10(%rbp)
mov    %al,-0xf(%rbp)
mov    -0x10(%rbp),%cl
mov    -0xf(%rbp),%al
mov    %cl,-0x18(%rbp)
mov    %al,-0x17(%rbp)
movzwl -0x18(%rbp),%edi
xor    %eax,%eax
mov    %al,-0xc1(%rbp)
call   1030 <dcl_acc@plt>
mov    -0xc1(%rbp),%al
movw   $0x3,-0x20(%rbp)
mov    -0x20(%rbp),%dx
mov    -0x1e(%rbp),%cx
mov    %dx,-0x28(%rbp)
mov    %cx,-0x26(%rbp)
mov    -0x28(%rbp),%dx
mov    -0x26(%rbp),%cx
mov    %dx,-0x30(%rbp)
mov    %cx,-0x2e(%rbp)
mov    -0x30(%rbp),%edi
call   1050 <dcl_acs@plt>
mov    -0xc1(%rbp),%al
movl   $0x5,-0x38(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    %edx,-0x40(%rbp)
mov    %ecx,-0x3c(%rbp)
mov    -0x40(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    %edx,-0x48(%rbp)
mov    %ecx,-0x44(%rbp)
mov    -0x48(%rbp),%rdi
call   1060 <dcl_aci@plt>
mov    -0xc1(%rbp),%al
movq   $0x7,-0x58(%rbp)
mov    -0x58(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    %rdx,-0x68(%rbp)
mov    %rcx,-0x60(%rbp)
mov    -0x68(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    %rdx,-0x78(%rbp)
mov    %rcx,-0x70(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   1040 <dcl_acll@plt>
movl   $0x41100000,-0x80(%rbp)
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
movss  %xmm1,-0x88(%rbp)
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm1,-0x90(%rbp)
ff
movss  %xmm0,-0x8c(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <dcl_acf@plt>
movsd  0xd73(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm1,-0xb0(%rbp)
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm1,-0xc0(%rbp)
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
mov    $0x2,%al
call   1070 <dcl_acd@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_1>:
push   %rax
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <dcl_acc@plt>
mov    $0x3,%edi
xor    %eax,%eax
call   1050 <dcl_acs@plt>
mov    $0x5,%edi
xor    %eax,%eax
call   1060 <dcl_aci@plt>
mov    $0x7,%edi
xor    %eax,%eax
call   1040 <dcl_acll@plt>
movss  0xe67(%rip),%xmm0
mov    $0x1,%al
call   1080 <dcl_acf@plt>
movsd  0xe60(%rip),%xmm0
mov    $0x2,%al
pop    %rcx
jmp    1070 <dcl_acd@plt>

LLVM IR (-O0):
define void @test_1() {
%1 = alloca { i8, i8 }
%2 = alloca { i8, i8 }
%3 = alloca { i8, i8 }
%4 = alloca { i16, i16 }
%5 = alloca { i16, i16 }
%6 = alloca { i16, i16 }
%7 = alloca { i32, i32 }
%8 = alloca { i32, i32 }
%9 = alloca { i32, i32 }
%10 = alloca { i64, i64 }
%11 = alloca { i64, i64 }
%12 = alloca { i64, i64 }
%13 = alloca { float, float }
%14 = alloca { float, float }
%15 = alloca { float, float }
%16 = alloca { double, double }
%17 = alloca { double, double }
%18 = alloca { double, double }
%19 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %1, i32 0, i32 0
store i8 1, i8* %19
%20 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %1, i32 0, i32 1
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 2
%24 = zext i1 %23 to i32
%25 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %1, i32 0, i32 0
%26 = load i8, i8* %25
%27 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %1, i32 0, i32 1
%28 = load i8, i8* %27
%29 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %2, i32 0, i32 0
%30 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %2, i32 0, i32 1
store i8 %26, i8* %29
store i8 %28, i8* %30
%31 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %2, i32 0, i32 0
%32 = load i8, i8* %31
%33 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %2, i32 0, i32 1
%34 = load i8, i8* %33
%35 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %3, i32 0, i32 0
%36 = getelementptr inbounds { i8, i8 }, { i8, i8 }* %3, i32 0, i32 1
store i8 %32, i8* %35
store i8 %34, i8* %36
%37 = bitcast { i8, i8 }* %3 to i16*
%38 = load i16, i16* %37
%39 = call i32 (i16, ...) bitcast (i32 (...)* @dcl_acc to i32 (i16, ...)*)(i16 %38)
%40 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %4, i32 0, i32 0
store i16 3, i16* %40
%41 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %4, i32 0, i32 1
%42 = load i16, i16* %41
%43 = sext i16 %42 to i32
%44 = icmp eq i32 %43, 4
%45 = zext i1 %44 to i32
%46 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %4, i32 0, i32 0
%47 = load i16, i16* %46
%48 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %4, i32 0, i32 1
%49 = load i16, i16* %48
%50 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %5, i32 0, i32 0
%51 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %5, i32 0, i32 1
store i16 %47, i16* %50
store i16 %49, i16* %51
%52 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %5, i32 0, i32 0
%53 = load i16, i16* %52
%54 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %5, i32 0, i32 1
%55 = load i16, i16* %54
%56 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %6, i32 0, i32 0
%57 = getelementptr inbounds { i16, i16 }, { i16, i16 }* %6, i32 0, i32 1
store i16 %53, i16* %56
store i16 %55, i16* %57
%58 = bitcast { i16, i16 }* %6 to i32*
%59 = load i32, i32* %58
%60 = call i32 (i32, ...) bitcast (i32 (...)* @dcl_acs to i32 (i32, ...)*)(i32 %59)
%61 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %7, i32 0, i32 0
store i32 5, i32* %61
%62 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %7, i32 0, i32 1
%63 = load i32, i32* %62
%64 = icmp eq i32 %63, 6
%65 = zext i1 %64 to i32
%66 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %7, i32 0, i32 0
%67 = load i32, i32* %66
%68 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %7, i32 0, i32 1
%69 = load i32, i32* %68
%70 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %8, i32 0, i32 0
%71 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %8, i32 0, i32 1
store i32 %67, i32* %70
store i32 %69, i32* %71
%72 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %8, i32 0, i32 0
%73 = load i32, i32* %72
%74 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %8, i32 0, i32 1
%75 = load i32, i32* %74
%76 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %9, i32 0, i32 0
%77 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %9, i32 0, i32 1
store i32 %73, i32* %76
store i32 %75, i32* %77
%78 = bitcast { i32, i32 }* %9 to i64*
%79 = load i64, i64* %78
%80 = call i32 (i64, ...) bitcast (i32 (...)* @dcl_aci to i32 (i64, ...)*)(i64 %79)
%81 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %10, i32 0, i32 0
store i64 7, i64* %81
%82 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %10, i32 0, i32 1
%83 = load i64, i64* %82
%84 = icmp eq i64 %83, 8
%85 = zext i1 %84 to i32
%86 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %10, i32 0, i32 0
%87 = load i64, i64* %86
%88 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %10, i32 0, i32 1
%89 = load i64, i64* %88
%90 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %11, i32 0, i32 0
%91 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %11, i32 0, i32 1
store i64 %87, i64* %90
store i64 %89, i64* %91
%92 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %11, i32 0, i32 0
%93 = load i64, i64* %92
%94 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %11, i32 0, i32 1
%95 = load i64, i64* %94
%96 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %12, i32 0, i32 0
%97 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %12, i32 0, i32 1
store i64 %93, i64* %96
store i64 %95, i64* %97
%98 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %12, i32 0, i32 0
%99 = load i64, i64* %98
%100 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %12, i32 0, i32 1
%101 = load i64, i64* %100
%102 = call i32 (i64, i64, ...) bitcast (i32 (...)* @dcl_acll to i32 (i64, i64, ...)*)(i64 %99, i64 %101)
%103 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 0
store float 9.000000e+00, float* %103
%104 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 1
%105 = load float, float* %104
%106 = fcmp oeq float %105, 1.000000e+01
%107 = zext i1 %106 to i32
%108 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 0
%109 = load float, float* %108
%110 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 1
%111 = load float, float* %110
%112 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%113 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
store float %109, float* %112
store float %111, float* %113
%114 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%115 = load float, float* %114
%116 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
%117 = load float, float* %116
%118 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%119 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
store float %115, float* %118
store float %117, float* %119
%120 = bitcast { float, float }* %15 to <2 x float>*
%121 = load <2 x float>, <2 x float>* %120
%122 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @dcl_acf to i32 (<2 x float>, ...)*)(<2 x float> %121)
%123 = getelementptr inbounds { double, double }, { double, double }* %16, i32 0, i32 0
store double 1.100000e+01, double* %123
%124 = getelementptr inbounds { double, double }, { double, double }* %16, i32 0, i32 1
%125 = load double, double* %124
%126 = fcmp oeq double %125, 1.200000e+01
%127 = zext i1 %126 to i32
%128 = getelementptr inbounds { double, double }, { double, double }* %16, i32 0, i32 0
%129 = load double, double* %128
%130 = getelementptr inbounds { double, double }, { double, double }* %16, i32 0, i32 1
%131 = load double, double* %130
%132 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 0
%133 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 1
store double %129, double* %132
store double %131, double* %133
%134 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 0
%135 = load double, double* %134
%136 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 1
%137 = load double, double* %136
%138 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 0
%139 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 1
store double %135, double* %138
store double %137, double* %139
%140 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 0
%141 = load double, double* %140
%142 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 1
%143 = load double, double* %142
%144 = call i32 (double, double, ...) bitcast (i32 (...)* @dcl_acd to i32 (double, double, ...)*)(double %141, double %143)
ret void
}

LLVM IR (-O2):
define void @test_1() {
%1 = tail call i32 (i16, ...) bitcast (i32 (...)* @dcl_acc to i32 (i16, ...)*)(i16 1)
%2 = tail call i32 (i32, ...) bitcast (i32 (...)* @dcl_acs to i32 (i32, ...)*)(i32 3)
%3 = tail call i32 (i64, ...) bitcast (i32 (...)* @dcl_aci to i32 (i64, ...)*)(i64 5)
%4 = tail call i32 (i64, i64, ...) bitcast (i32 (...)* @dcl_acll to i32 (i64, i64, ...)*)(i64 7, i64 undef)
%5 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @dcl_acf to i32 (<2 x float>, ...)*)(<2 x float> <float 9.000000e+00, float undef>)
%6 = tail call i32 (double, double, ...) bitcast (i32 (...)* @dcl_acd to i32 (double, double, ...)*)(double 1.100000e+01, double undef)
ret void
}