#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void functionTestLoop(double *tabFloat, size_t size) {
  if (tabFloat == NULL || size == 0)
    return;
  int i;
  for (i = 0; i < size; ++i) {
    tabFloat[i] = 0.0;
  }
  i = 0;
  while (i < size) {
    tabFloat[i] = (double)i;
    ++i;
  }
}


x86 assembly (clang, -O0):
<functionTestLoop>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1122 <functionTestLoop+0x22>
cmpq   $0x0,-0x10(%rbp)
jne    1127 <functionTestLoop+0x27>
jmp    118f <functionTestLoop+0x8f>
movl   $0x0,-0x14(%rbp)
movslq -0x14(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    115a <functionTestLoop+0x5a>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    112e <functionTestLoop+0x2e>
movl   $0x0,-0x14(%rbp)
movslq -0x14(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    118f <functionTestLoop+0x8f>
cvtsi2sdl -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1161 <functionTestLoop+0x61>
pop    %rbp
ret

x86 assembly (clang, -O2):
<functionTestLoop>:
push   %r15
push   %r14
push   %rbx
test   %rdi,%rdi
je     1236 <functionTestLoop+0x126>
mov    %rsi,%r14
test   %rsi,%rsi
je     1236 <functionTestLoop+0x126>
mov    %rdi,%r15
lea    0x0(,%r14,8),%rdx
xor    %ebx,%ebx
xor    %esi,%esi
call   1030 <memset@plt>
cmp    $0x4,%r14
jb     1220 <functionTestLoop+0x110>
mov    %r14,%rbx
and    $0xfffffffffffffffc,%rbx
lea    -0x4(%rbx),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     123c <functionTestLoop+0x12c>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
movdqa 0xe8a(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xe90(%rip),%xmm1
movdqa 0xe98(%rip),%xmm2
movdqa 0xea0(%rip),%xmm3
movdqa 0xea8(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
cvtdq2pd %xmm0,%xmm6
paddd  %xmm1,%xmm5
cvtdq2pd %xmm5,%xmm5
movups %xmm6,(%r15,%rcx,8)
movups %xmm5,0x10(%r15,%rcx,8)
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm0,%xmm6
cvtdq2pd %xmm5,%xmm5
paddd  %xmm3,%xmm6
cvtdq2pd %xmm6,%xmm6
movups %xmm5,0x20(%r15,%rcx,8)
movups %xmm6,0x30(%r15,%rcx,8)
add    $0x8,%rcx
paddd  %xmm4,%xmm0
add    $0xfffffffffffffffe,%rdx
jne    11a0 <functionTestLoop+0x90>
test   $0x1,%al
je     120e <functionTestLoop+0xfe>
cvtdq2pd %xmm0,%xmm1
paddd  0xe13(%rip),%xmm0
cvtdq2pd %xmm0,%xmm0
movdqu %xmm1,(%r15,%rcx,8)
movdqu %xmm0,0x10(%r15,%rcx,8)
cmp    %r14,%rbx
je     1236 <functionTestLoop+0x126>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1220 <functionTestLoop+0x110>
pop    %rbx
pop    %r14
pop    %r15
ret
movdqa 0xdbc(%rip),%xmm0
xor    %ecx,%ecx
test   $0x1,%al
jne    11f1 <functionTestLoop+0xe1>
jmp    120e <functionTestLoop+0xfe>

LLVM IR (-O0):
define void @functionTestLoop(double* %0, i64 %1) {
%3 = alloca double*
%4 = alloca i64
%5 = alloca i32
store double* %0, double** %3
store i64 %1, i64* %4
%6 = load double*, double** %3
%7 = icmp eq double* %6, null
br i1 %7, label %11, label %8
8: ; preds = %2
%9 = load i64, i64* %4
%10 = icmp eq i64 %9, 0
br i1 %10, label %11, label %12
11: ; preds = %8, %2
br label %41
12: ; preds = %8
store i32 0, i32* %5
br label %13
13: ; preds = %23, %12
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = load i64, i64* %4
%17 = icmp ult i64 %15, %16
br i1 %17, label %18, label %26
18: ; preds = %13
%19 = load double*, double** %3
%20 = load i32, i32* %5
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %19, i64 %21
store double 0.000000e+00, double* %22
br label %23
23: ; preds = %18
%24 = load i32, i32* %5
%25 = add nsw i32 %24, 1
store i32 %25, i32* %5
br label %13
26: ; preds = %13
store i32 0, i32* %5
br label %27
27: ; preds = %32, %26
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = load i64, i64* %4
%31 = icmp ult i64 %29, %30
br i1 %31, label %32, label %41
32: ; preds = %27
%33 = load i32, i32* %5
%34 = sitofp i32 %33 to double
%35 = load double*, double** %3
%36 = load i32, i32* %5
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double, double* %35, i64 %37
store double %34, double* %38
%39 = load i32, i32* %5
%40 = add nsw i32 %39, 1
store i32 %40, i32* %5
br label %27
41: ; preds = %11, %27
ret void
}

LLVM IR (-O2):
define void @functionTestLoop(double* writeonly %0, i64 %1) {
%3 = icmp eq double* %0, null
%4 = icmp eq i64 %1, 0
%5 = or i1 %3, %4
br i1 %5, label %66, label %6
6: ; preds = %2
%7 = bitcast double* %0 to i8*
%8 = shl nuw i64 %1, 3
%9 = icmp ult i64 %1, 4
br i1 %9, label %57, label %10
10: ; preds = %6
%11 = and i64 %1, -4
%12 = add i64 %11, -4
%13 = lshr exact i64 %12, 2
%14 = add nuw nsw i64 %13, 1
%15 = and i64 %14, 1
%16 = icmp eq i64 %12, 0
br i1 %16, label %43, label %17
17: ; preds = %10
%18 = and i64 %14, 9223372036854775806
br label %19
19: ; preds = %19, %17
%20 = phi i64 [ 0, %17 ], [ %39, %19 ]
%21 = phi <2 x i32> [ <i32 0, i32 1>, %17 ], [ %40, %19 ]
%22 = phi i64 [ 0, %17 ], [ %41, %19 ]
%23 = add <2 x i32> %21, <i32 2, i32 2>
%24 = sitofp <2 x i32> %21 to <2 x double>
%25 = sitofp <2 x i32> %23 to <2 x double>
%26 = getelementptr inbounds double, double* %0, i64 %20
%27 = bitcast double* %26 to <2 x double>*
store <2 x double> %24, <2 x double>* %27
%28 = getelementptr inbounds double, double* %26, i64 2
%29 = bitcast double* %28 to <2 x double>*
store <2 x double> %25, <2 x double>* %29
%30 = or i64 %20, 4
%31 = add <2 x i32> %21, <i32 4, i32 4>
%32 = add <2 x i32> %21, <i32 6, i32 6>
%33 = sitofp <2 x i32> %31 to <2 x double>
%34 = sitofp <2 x i32> %32 to <2 x double>
%35 = getelementptr inbounds double, double* %0, i64 %30
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> %33, <2 x double>* %36
%37 = getelementptr inbounds double, double* %35, i64 2
%38 = bitcast double* %37 to <2 x double>*
store <2 x double> %34, <2 x double>* %38
%39 = add nuw i64 %20, 8
%40 = add <2 x i32> %21, <i32 8, i32 8>
%41 = add i64 %22, 2
%42 = icmp eq i64 %41, %18
br i1 %42, label %43, label %19
43: ; preds = %19, %10
%44 = phi i64 [ 0, %10 ], [ %39, %19 ]
%45 = phi <2 x i32> [ <i32 0, i32 1>, %10 ], [ %40, %19 ]
%46 = icmp eq i64 %15, 0
br i1 %46, label %55, label %47
47: ; preds = %43
%48 = add <2 x i32> %45, <i32 2, i32 2>
%49 = sitofp <2 x i32> %45 to <2 x double>
%50 = sitofp <2 x i32> %48 to <2 x double>
%51 = getelementptr inbounds double, double* %0, i64 %44
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> %49, <2 x double>* %52
%53 = getelementptr inbounds double, double* %51, i64 2
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> %50, <2 x double>* %54
br label %55
55: ; preds = %43, %47
%56 = icmp eq i64 %11, %1
br i1 %56, label %66, label %57
57: ; preds = %6, %55
%58 = phi i64 [ 0, %6 ], [ %11, %55 ]
br label %59
59: ; preds = %57, %59
%60 = phi i64 [ %64, %59 ], [ %58, %57 ]
%61 = trunc i64 %60 to i32
%62 = sitofp i32 %61 to double
%63 = getelementptr inbounds double, double* %0, i64 %60
store double %62, double* %63
%64 = add nuw nsw i64 %60, 1
%65 = icmp eq i64 %64, %1
br i1 %65, label %66, label %59
66: ; preds = %59, %55, %2
ret void
}