void THFloatVector_fill(float *x, float c, long n) {
  long i = 0;
  for (; i < n - 4; i += 4) {
    x[i] = c;
    x[i + 1] = c;
    x[i + 2] = c;
    x[i + 3] = c;
  }
  for (; i < n; i++)
    x[i] = c;
}


x86 assembly (clang, -O0):
<THFloatVector_fill>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x4,%rcx
cmp    %rcx,%rax
jge    118a <THFloatVector_fill+0x8a>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x8(%rax,%rcx,4)
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0xc(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    1119 <THFloatVector_fill+0x19>
jmp    118f <THFloatVector_fill+0x8f>
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    11c0 <THFloatVector_fill+0xc0>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    118f <THFloatVector_fill+0x8f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<THFloatVector_fill>:
cmp    $0x5,%rsi
jl     1117 <THFloatVector_fill+0x17>
lea    -0x5(%rsi),%r9
cmp    $0xc,%r9
jae    111e <THFloatVector_fill+0x1e>
xor    %eax,%eax
jmp    1209 <THFloatVector_fill+0x109>
xor    %eax,%eax
jmp    1230 <THFloatVector_fill+0x130>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmp    $0xc,%rcx
jae    1154 <THFloatVector_fill+0x54>
xor    %edx,%edx
jmp    11cc <THFloatVector_fill+0xcc>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rax
lea    0xc0(%rdi),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups %xmm1,-0xc0(%rcx)
movups %xmm1,-0xb0(%rcx)
movups %xmm1,-0xa0(%rcx)
movups %xmm1,-0x90(%rcx)
movups %xmm1,-0x80(%rcx)
movups %xmm1,-0x70(%rcx)
movups %xmm1,-0x60(%rcx)
movups %xmm1,-0x50(%rcx)
movups %xmm1,-0x40(%rcx)
movups %xmm1,-0x30(%rcx)
movups %xmm1,-0x20(%rcx)
movups %xmm1,-0x10(%rcx)
movups %xmm1,(%rcx)
movups %xmm1,0x10(%rcx)
movups %xmm1,0x20(%rcx)
movups %xmm1,0x30(%rcx)
add    $0x10,%rdx
add    $0x100,%rcx
add    $0xfffffffffffffffc,%rax
jne    1170 <THFloatVector_fill+0x70>
test   %r10,%r10
je     11fc <THFloatVector_fill+0xfc>
shl    $0x4,%rdx
add    %rdi,%rdx
shl    $0x6,%r10
xor    %eax,%eax
xchg   %ax,%ax
movups %xmm1,(%rdx,%rax,1)
movups %xmm1,0x10(%rdx,%rax,1)
movups %xmm1,0x20(%rdx,%rax,1)
movups %xmm1,0x30(%rdx,%rax,1)
add    $0x40,%rax
cmp    %rax,%r10
jne    11e0 <THFloatVector_fill+0xe0>
lea    0x0(,%r8,4),%rax
cmp    %r8,%r9
je     1230 <THFloatVector_fill+0x130>
lea    -0x4(%rsi),%rcx
nopl   (%rax)
movss  %xmm0,(%rdi,%rax,4)
movss  %xmm0,0x4(%rdi,%rax,4)
movss  %xmm0,0x8(%rdi,%rax,4)
movss  %xmm0,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rcx,%rax
jl     1210 <THFloatVector_fill+0x110>
cmp    %rsi,%rax
jge    130e <THFloatVector_fill+0x20e>
mov    %rsi,%r9
sub    %rax,%r9
cmp    $0x8,%r9
jb     1300 <THFloatVector_fill+0x200>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r8),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    1277 <THFloatVector_fill+0x177>
xor    %ecx,%ecx
jmp    12c1 <THFloatVector_fill+0x1c1>
and    $0xfffffffffffffffc,%r11
lea    (%rdi,%rax,4),%rdx
add    $0x70,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm1,-0x70(%rdx,%rcx,4)
movups %xmm1,-0x60(%rdx,%rcx,4)
movups %xmm1,-0x50(%rdx,%rcx,4)
movups %xmm1,-0x40(%rdx,%rcx,4)
movups %xmm1,-0x30(%rdx,%rcx,4)
movups %xmm1,-0x20(%rdx,%rcx,4)
movups %xmm1,-0x10(%rdx,%rcx,4)
movups %xmm1,(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%r11
jne    1290 <THFloatVector_fill+0x190>
test   %r10,%r10
je     12f2 <THFloatVector_fill+0x1f2>
add    %rax,%rcx
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups %xmm1,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    12e0 <THFloatVector_fill+0x1e0>
cmp    %r8,%r9
je     130e <THFloatVector_fill+0x20e>
add    %r8,%rax
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1300 <THFloatVector_fill+0x200>
ret

LLVM IR (-O0):
define void @THFloatVector_fill(float* %0, float %1, i64 %2) {
%4 = alloca float*
%5 = alloca float
%6 = alloca i64
%7 = alloca i64
store float* %0, float** %4
store float %1, float* %5
store i64 %2, i64* %6
store i64 0, i64* %7
br label %8
8: ; preds = %33, %3
%9 = load i64, i64* %7
%10 = load i64, i64* %6
%11 = sub nsw i64 %10, 4
%12 = icmp slt i64 %9, %11
br i1 %12, label %13, label %36
13: ; preds = %8
%14 = load float, float* %5
%15 = load float*, float** %4
%16 = load i64, i64* %7
%17 = getelementptr inbounds float, float* %15, i64 %16
store float %14, float* %17
%18 = load float, float* %5
%19 = load float*, float** %4
%20 = load i64, i64* %7
%21 = add nsw i64 %20, 1
%22 = getelementptr inbounds float, float* %19, i64 %21
store float %18, float* %22
%23 = load float, float* %5
%24 = load float*, float** %4
%25 = load i64, i64* %7
%26 = add nsw i64 %25, 2
%27 = getelementptr inbounds float, float* %24, i64 %26
store float %23, float* %27
%28 = load float, float* %5
%29 = load float*, float** %4
%30 = load i64, i64* %7
%31 = add nsw i64 %30, 3
%32 = getelementptr inbounds float, float* %29, i64 %31
store float %28, float* %32
br label %33
33: ; preds = %13
%34 = load i64, i64* %7
%35 = add nsw i64 %34, 4
store i64 %35, i64* %7
br label %8
36: ; preds = %8
br label %37
37: ; preds = %46, %36
%38 = load i64, i64* %7
%39 = load i64, i64* %6
%40 = icmp slt i64 %38, %39
br i1 %40, label %41, label %49
41: ; preds = %37
%42 = load float, float* %5
%43 = load float*, float** %4
%44 = load i64, i64* %7
%45 = getelementptr inbounds float, float* %43, i64 %44
store float %42, float* %45
br label %46
46: ; preds = %41
%47 = load i64, i64* %7
%48 = add nsw i64 %47, 1
store i64 %48, i64* %7
br label %37
49: ; preds = %37
ret void
}

LLVM IR (-O2):
define void @THFloatVector_fill(float* nocapture writeonly %0, float %1, i64 %2) {
%4 = add nsw i64 %2, -4
%5 = icmp sgt i64 %2, 4
br i1 %5, label %6, label %72
6: ; preds = %3
%7 = add i64 %2, -5
%8 = lshr i64 %7, 2
%9 = add nuw nsw i64 %8, 1
%10 = icmp ult i64 %7, 12
br i1 %10, label %70, label %11
11: ; preds = %6
%12 = and i64 %9, 9223372036854775804
%13 = shl i64 %12, 2
%14 = insertelement <4 x float> poison, float %1, i64 0
%15 = add nsw i64 %12, -4
%16 = lshr exact i64 %15, 2
%17 = add nuw nsw i64 %16, 1
%18 = and i64 %17, 3
%19 = icmp ult i64 %15, 12
br i1 %19, label %52, label %20
20: ; preds = %11
%21 = and i64 %17, 9223372036854775804
%22 = getelementptr inbounds float, float* %0, i64 -3
%23 = shufflevector <4 x float> %14, <4 x float> poison, <16 x i32> zeroinitializer
%24 = getelementptr inbounds float, float* %0, i64 -3
%25 = shufflevector <4 x float> %14, <4 x float> poison, <16 x i32> zeroinitializer
%26 = getelementptr inbounds float, float* %0, i64 -3
%27 = shufflevector <4 x float> %14, <4 x float> poison, <16 x i32> zeroinitializer
%28 = getelementptr inbounds float, float* %0, i64 -3
%29 = shufflevector <4 x float> %14, <4 x float> poison, <16 x i32> zeroinitializer
br label %30
30: ; preds = %30, %20
%31 = phi i64 [ 0, %20 ], [ %49, %30 ]
%32 = phi i64 [ 0, %20 ], [ %50, %30 ]
%33 = shl i64 %31, 2
%34 = or i64 %33, 3
%35 = getelementptr inbounds float, float* %22, i64 %34
%36 = bitcast float* %35 to <16 x float>*
store <16 x float> %23, <16 x float>* %36
%37 = shl i64 %31, 2
%38 = or i64 %37, 19
%39 = getelementptr inbounds float, float* %24, i64 %38
%40 = bitcast float* %39 to <16 x float>*
store <16 x float> %25, <16 x float>* %40
%41 = shl i64 %31, 2
%42 = or i64 %41, 35
%43 = getelementptr inbounds float, float* %26, i64 %42
%44 = bitcast float* %43 to <16 x float>*
store <16 x float> %27, <16 x float>* %44
%45 = shl i64 %31, 2
%46 = or i64 %45, 51
%47 = getelementptr inbounds float, float* %28, i64 %46
%48 = bitcast float* %47 to <16 x float>*
store <16 x float> %29, <16 x float>* %48
%49 = add nuw i64 %31, 16
%50 = add nuw i64 %32, 4
%51 = icmp eq i64 %50, %21
br i1 %51, label %52, label %30
52: ; preds = %30, %11
%53 = phi i64 [ 0, %11 ], [ %49, %30 ]
%54 = icmp eq i64 %18, 0
br i1 %54, label %68, label %55
55: ; preds = %52
%56 = getelementptr inbounds float, float* %0, i64 -3
%57 = shufflevector <4 x float> %14, <4 x float> poison, <16 x i32> zeroinitializer
br label %58
58: ; preds = %58, %55
%59 = phi i64 [ %53, %55 ], [ %65, %58 ]
%60 = phi i64 [ 0, %55 ], [ %66, %58 ]
%61 = shl i64 %59, 2
%62 = or i64 %61, 3
%63 = getelementptr inbounds float, float* %56, i64 %62
%64 = bitcast float* %63 to <16 x float>*
store <16 x float> %57, <16 x float>* %64
%65 = add nuw i64 %59, 4
%66 = add i64 %60, 1
%67 = icmp eq i64 %66, %18
br i1 %67, label %68, label %58
68: ; preds = %58, %52
%69 = icmp eq i64 %9, %12
br i1 %69, label %72, label %70
70: ; preds = %6, %68
%71 = phi i64 [ 0, %6 ], [ %13, %68 ]
br label %139
72: ; preds = %139, %68, %3
%73 = phi i64 [ 0, %3 ], [ %13, %68 ], [ %148, %139 ]
%74 = icmp slt i64 %73, %2
br i1 %74, label %75, label %155
75: ; preds = %72
%76 = sub i64 %2, %73
%77 = icmp ult i64 %76, 8
br i1 %77, label %137, label %78
78: ; preds = %75
%79 = and i64 %76, -8
%80 = add i64 %73, %79
%81 = insertelement <4 x float> poison, float %1, i64 0
%82 = shufflevector <4 x float> %81, <4 x float> poison, <4 x i32> zeroinitializer
%83 = insertelement <4 x float> poison, float %1, i64 0
%84 = shufflevector <4 x float> %83, <4 x float> poison, <4 x i32> zeroinitializer
%85 = add i64 %79, -8
%86 = lshr exact i64 %85, 3
%87 = add nuw nsw i64 %86, 1
%88 = and i64 %87, 3
%89 = icmp ult i64 %85, 24
br i1 %89, label %121, label %90
90: ; preds = %78
%91 = and i64 %87, 4611686018427387900
br label %92
92: ; preds = %92, %90
%93 = phi i64 [ 0, %90 ], [ %118, %92 ]
%94 = phi i64 [ 0, %90 ], [ %119, %92 ]
%95 = add i64 %73, %93
%96 = getelementptr inbounds float, float* %0, i64 %95
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %82, <4 x float>* %97
%98 = getelementptr inbounds float, float* %96, i64 4
%99 = bitcast float* %98 to <4 x float>*
store <4 x float> %84, <4 x float>* %99
%100 = or i64 %93, 8
%101 = add i64 %73, %100
%102 = getelementptr inbounds float, float* %0, i64 %101
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> %82, <4 x float>* %103
%104 = getelementptr inbounds float, float* %102, i64 4
%105 = bitcast float* %104 to <4 x float>*
store <4 x float> %84, <4 x float>* %105
%106 = or i64 %93, 16
%107 = add i64 %73, %106
%108 = getelementptr inbounds float, float* %0, i64 %107
%109 = bitcast float* %108 to <4 x float>*
store <4 x float> %82, <4 x float>* %109
%110 = getelementptr inbounds float, float* %108, i64 4
%111 = bitcast float* %110 to <4 x float>*
store <4 x float> %84, <4 x float>* %111
%112 = or i64 %93, 24
%113 = add i64 %73, %112
%114 = getelementptr inbounds float, float* %0, i64 %113
%115 = bitcast float* %114 to <4 x float>*
store <4 x float> %82, <4 x float>* %115
%116 = getelementptr inbounds float, float* %114, i64 4
%117 = bitcast float* %116 to <4 x float>*
store <4 x float> %84, <4 x float>* %117
%118 = add nuw i64 %93, 32
%119 = add i64 %94, 4
%120 = icmp eq i64 %119, %91
br i1 %120, label %121, label %92
121: ; preds = %92, %78
%122 = phi i64 [ 0, %78 ], [ %118, %92 ]
%123 = icmp eq i64 %88, 0
br i1 %123, label %135, label %124
124: ; preds = %121, %124
%125 = phi i64 [ %132, %124 ], [ %122, %121 ]
%126 = phi i64 [ %133, %124 ], [ 0, %121 ]
%127 = add i64 %73, %125
%128 = getelementptr inbounds float, float* %0, i64 %127
%129 = bitcast float* %128 to <4 x float>*
store <4 x float> %82, <4 x float>* %129
%130 = getelementptr inbounds float, float* %128, i64 4
%131 = bitcast float* %130 to <4 x float>*
store <4 x float> %84, <4 x float>* %131
%132 = add nuw i64 %125, 8
%133 = add i64 %126, 1
%134 = icmp eq i64 %133, %88
br i1 %134, label %135, label %124
135: ; preds = %124, %121
%136 = icmp eq i64 %76, %79
br i1 %136, label %155, label %137
137: ; preds = %75, %135
%138 = phi i64 [ %73, %75 ], [ %80, %135 ]
br label %150
139: ; preds = %70, %139
%140 = phi i64 [ %148, %139 ], [ %71, %70 ]
%141 = getelementptr inbounds float, float* %0, i64 %140
store float %1, float* %141
%142 = or i64 %140, 1
%143 = getelementptr inbounds float, float* %0, i64 %142
store float %1, float* %143
%144 = or i64 %140, 2
%145 = getelementptr inbounds float, float* %0, i64 %144
store float %1, float* %145
%146 = or i64 %140, 3
%147 = getelementptr inbounds float, float* %0, i64 %146
store float %1, float* %147
%148 = add nuw nsw i64 %140, 4
%149 = icmp slt i64 %148, %4
br i1 %149, label %139, label %72
150: ; preds = %137, %150
%151 = phi i64 [ %153, %150 ], [ %138, %137 ]
%152 = getelementptr inbounds float, float* %0, i64 %151
store float %1, float* %152
%153 = add nuw nsw i64 %151, 1
%154 = icmp eq i64 %153, %2
br i1 %154, label %155, label %150
155: ; preds = %150, %135, %72
ret void
}