void derivs(float x, float y[], float dydx[]) {
  dydx[1] = -0.013 * y[1] - 1000.0 * y[1] * y[3];
  dydx[2] = -2500.0 * y[2] * y[3];
  dydx[3] = -0.013 * y[1] - 1000.0 * y[1] * y[3] - 2500.0 * y[2] * y[3];
}


x86 assembly (clang, -O0):
<derivs>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xedd(%rip),%xmm1
mulsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xea1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe87(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xe3b(%rip),%xmm0
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xdff(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xdda(%rip),%xmm0
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<derivs>:
movss  0x4(%rdi),%xmm0
movss  0xc(%rdi),%xmm1
cvtss2sd %xmm0,%xmm2
cvtss2sd %xmm1,%xmm1
movsd  0xee6(%rip),%xmm0
movaps %xmm2,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm3
movsd  0xedb(%rip),%xmm1
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%rsi)
movss  0x8(%rdi),%xmm2
movss  0xc(%rdi),%xmm3
cvtss2sd %xmm2,%xmm2
movsd  0xebc(%rip),%xmm4
mulsd  %xmm4,%xmm2
cvtss2sd %xmm3,%xmm3
mulsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,0x8(%rsi)
movss  0x4(%rdi),%xmm2
movss  0x8(%rdi),%xmm3
cvtss2sd %xmm2,%xmm2
movss  0xc(%rdi),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsi)
ret

LLVM IR (-O0):
define void @derivs(float %0, float* %1, float* %2) {
%4 = alloca float
%5 = alloca float*
%6 = alloca float*
store float %0, float* %4
store float* %1, float** %5
store float* %2, float** %6
%7 = load float*, float** %5
%8 = getelementptr inbounds float, float* %7, i64 1
%9 = load float, float* %8
%10 = fpext float %9 to double
%11 = load float*, float** %5
%12 = getelementptr inbounds float, float* %11, i64 1
%13 = load float, float* %12
%14 = fpext float %13 to double
%15 = fmul double 1.000000e+03, %14
%16 = load float*, float** %5
%17 = getelementptr inbounds float, float* %16, i64 3
%18 = load float, float* %17
%19 = fpext float %18 to double
%20 = fmul double %15, %19
%21 = fneg double %20
%22 = call double @llvm.fmuladd.f64(double -1.300000e-02, double %10, double %21)
%23 = fptrunc double %22 to float
%24 = load float*, float** %6
%25 = getelementptr inbounds float, float* %24, i64 1
store float %23, float* %25
%26 = load float*, float** %5
%27 = getelementptr inbounds float, float* %26, i64 2
%28 = load float, float* %27
%29 = fpext float %28 to double
%30 = fmul double -2.500000e+03, %29
%31 = load float*, float** %5
%32 = getelementptr inbounds float, float* %31, i64 3
%33 = load float, float* %32
%34 = fpext float %33 to double
%35 = fmul double %30, %34
%36 = fptrunc double %35 to float
%37 = load float*, float** %6
%38 = getelementptr inbounds float, float* %37, i64 2
store float %36, float* %38
%39 = load float*, float** %5
%40 = getelementptr inbounds float, float* %39, i64 1
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = load float*, float** %5
%44 = getelementptr inbounds float, float* %43, i64 1
%45 = load float, float* %44
%46 = fpext float %45 to double
%47 = fmul double 1.000000e+03, %46
%48 = load float*, float** %5
%49 = getelementptr inbounds float, float* %48, i64 3
%50 = load float, float* %49
%51 = fpext float %50 to double
%52 = fmul double %47, %51
%53 = fneg double %52
%54 = call double @llvm.fmuladd.f64(double -1.300000e-02, double %42, double %53)
%55 = load float*, float** %5
%56 = getelementptr inbounds float, float* %55, i64 2
%57 = load float, float* %56
%58 = fpext float %57 to double
%59 = fmul double 2.500000e+03, %58
%60 = load float*, float** %5
%61 = getelementptr inbounds float, float* %60, i64 3
%62 = load float, float* %61
%63 = fpext float %62 to double
%64 = fneg double %59
%65 = call double @llvm.fmuladd.f64(double %64, double %63, double %54)
%66 = fptrunc double %65 to float
%67 = load float*, float** %6
%68 = getelementptr inbounds float, float* %67, i64 3
store float %66, float* %68
ret void
}

LLVM IR (-O2):
define void @derivs(float %0, float* nocapture %1, float* nocapture writeonly %2) {
%4 = getelementptr inbounds float, float* %1, i64 1
%5 = load float, float* %4
%6 = fpext float %5 to double
%7 = getelementptr inbounds float, float* %1, i64 3
%8 = load float, float* %7
%9 = fpext float %8 to double
%10 = fmul double %6, -1.000000e+03
%11 = fmul double %10, %9
%12 = tail call double @llvm.fmuladd.f64(double %6, double -1.300000e-02, double %11)
%13 = fptrunc double %12 to float
%14 = getelementptr inbounds float, float* %2, i64 1
store float %13, float* %14
%15 = getelementptr inbounds float, float* %1, i64 2
%16 = load float, float* %15
%17 = fpext float %16 to double
%18 = fmul double %17, -2.500000e+03
%19 = load float, float* %7
%20 = fpext float %19 to double
%21 = fmul double %18, %20
%22 = fptrunc double %21 to float
%23 = getelementptr inbounds float, float* %2, i64 2
store float %22, float* %23
%24 = load float, float* %4
%25 = fpext float %24 to double
%26 = load float, float* %7
%27 = fpext float %26 to double
%28 = fmul double %25, -1.000000e+03
%29 = fmul double %28, %27
%30 = tail call double @llvm.fmuladd.f64(double %25, double -1.300000e-02, double %29)
%31 = load float, float* %15
%32 = fpext float %31 to double
%33 = fmul double %32, -2.500000e+03
%34 = tail call double @llvm.fmuladd.f64(double %33, double %27, double %30)
%35 = fptrunc double %34 to float
%36 = getelementptr inbounds float, float* %2, i64 3
store float %35, float* %36
ret void
}