void ConditionalOperator(float f, double d, long double ld, int i) {
  f = i ? f : d;
  f = i ? d : f;
  f = i ? f : ld;
  f = i ? ld : f;
  d = i ? d : ld;
  d = i ? ld : d;
}


x86 assembly (clang, -O0):
<ConditionalOperator>:
push   %rbp
mov    %rsp,%rbp
fldt   0x10(%rbp)
movss  %xmm0,-0x4(%rbp)
movsd  %xmm1,-0x10(%rbp)
fstpt  -0x20(%rbp)
mov    %edi,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1134 <ConditionalOperator+0x34>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    113e <ConditionalOperator+0x3e>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1165 <ConditionalOperator+0x65>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1173 <ConditionalOperator+0x73>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1196 <ConditionalOperator+0x96>
flds   -0x4(%rbp)
fstpt  -0x5c(%rbp)
jmp    119c <ConditionalOperator+0x9c>
fldt   -0x20(%rbp)
fstpt  -0x5c(%rbp)
fldt   -0x5c(%rbp)
fstps  -0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     11c1 <ConditionalOperator+0xc1>
fldt   -0x20(%rbp)
fstpt  -0x68(%rbp)
jmp    11c7 <ConditionalOperator+0xc7>
flds   -0x4(%rbp)
fstpt  -0x68(%rbp)
fldt   -0x68(%rbp)
fstps  -0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     11ec <ConditionalOperator+0xec>
fldl   -0x10(%rbp)
fstpt  -0x74(%rbp)
jmp    11f2 <ConditionalOperator+0xf2>
fldt   -0x20(%rbp)
fstpt  -0x74(%rbp)
fldt   -0x74(%rbp)
fstpl  -0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1217 <ConditionalOperator+0x117>
fldt   -0x20(%rbp)
fstpt  -0x80(%rbp)
jmp    121d <ConditionalOperator+0x11d>
fldl   -0x10(%rbp)
fstpt  -0x80(%rbp)
fldt   -0x80(%rbp)
fstpl  -0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConditionalOperator>:
ret

LLVM IR (-O0):
define void @ConditionalOperator(float %0, double %1, x86_fp80 %2, i32 %3) {
%5 = alloca float
%6 = alloca double
%7 = alloca x86_fp80
%8 = alloca i32
store float %0, float* %5
store double %1, double* %6
store x86_fp80 %2, x86_fp80* %7
store i32 %3, i32* %8
%9 = load i32, i32* %8
%10 = icmp ne i32 %9, 0
br i1 %10, label %11, label %14
11: ; preds = %4
%12 = load float, float* %5
%13 = fpext float %12 to double
br label %16
14: ; preds = %4
%15 = load double, double* %6
br label %16
16: ; preds = %14, %11
%17 = phi double [ %13, %11 ], [ %15, %14 ]
%18 = fptrunc double %17 to float
store float %18, float* %5
%19 = load i32, i32* %8
%20 = icmp ne i32 %19, 0
br i1 %20, label %21, label %23
21: ; preds = %16
%22 = load double, double* %6
br label %26
23: ; preds = %16
%24 = load float, float* %5
%25 = fpext float %24 to double
br label %26
26: ; preds = %23, %21
%27 = phi double [ %22, %21 ], [ %25, %23 ]
%28 = fptrunc double %27 to float
store float %28, float* %5
%29 = load i32, i32* %8
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %34
31: ; preds = %26
%32 = load float, float* %5
%33 = fpext float %32 to x86_fp80
br label %36
34: ; preds = %26
%35 = load x86_fp80, x86_fp80* %7
br label %36
36: ; preds = %34, %31
%37 = phi x86_fp80 [ %33, %31 ], [ %35, %34 ]
%38 = fptrunc x86_fp80 %37 to float
store float %38, float* %5
%39 = load i32, i32* %8
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %43
41: ; preds = %36
%42 = load x86_fp80, x86_fp80* %7
br label %46
43: ; preds = %36
%44 = load float, float* %5
%45 = fpext float %44 to x86_fp80
br label %46
46: ; preds = %43, %41
%47 = phi x86_fp80 [ %42, %41 ], [ %45, %43 ]
%48 = fptrunc x86_fp80 %47 to float
store float %48, float* %5
%49 = load i32, i32* %8
%50 = icmp ne i32 %49, 0
br i1 %50, label %51, label %54
51: ; preds = %46
%52 = load double, double* %6
%53 = fpext double %52 to x86_fp80
br label %56
54: ; preds = %46
%55 = load x86_fp80, x86_fp80* %7
br label %56
56: ; preds = %54, %51
%57 = phi x86_fp80 [ %53, %51 ], [ %55, %54 ]
%58 = fptrunc x86_fp80 %57 to double
store double %58, double* %6
%59 = load i32, i32* %8
%60 = icmp ne i32 %59, 0
br i1 %60, label %61, label %63
61: ; preds = %56
%62 = load x86_fp80, x86_fp80* %7
br label %66
63: ; preds = %56
%64 = load double, double* %6
%65 = fpext double %64 to x86_fp80
br label %66
66: ; preds = %63, %61
%67 = phi x86_fp80 [ %62, %61 ], [ %65, %63 ]
%68 = fptrunc x86_fp80 %67 to double
store double %68, double* %6
ret void
}

LLVM IR (-O2):
define void @ConditionalOperator(float %0, double %1, x86_fp80 %2, i32 %3) {
ret void
}