void mult_row(int r_num, double f, int order_c, double matrix[]) {
  int i;
  for (i = ((r_num)*order_c); i <= ((order_c) * (r_num + 1)) - 1; ++i) {
    double t, t1;
    t = matrix[i];
    t1 = f * matrix[i];
    matrix[i] = t1;
  }
}


x86 assembly (clang, -O0):
<mult_row>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1180 <mult_row+0x80>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111d <mult_row+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mult_row>:
mov    %esi,%eax
imul   %edi,%eax
add    $0x1,%edi
imul   %esi,%edi
cmp    %edi,%eax
jge    11f7 <mult_row+0xf7>
cltq
movslq %edi,%r11
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     11e0 <mult_row+0xe0>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     11f8 <mult_row+0xf8>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdx,%rax,8),%rcx
add    $0x30,%rcx
xor    %edi,%edi
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
movupd -0x10(%rcx,%rdi,8),%xmm4
movupd (%rcx,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rcx,%rdi,8)
movupd %xmm3,-0x20(%rcx,%rdi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rcx,%rdi,8)
movupd %xmm5,(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1160 <mult_row+0x60>
test   $0x1,%r9b
je     11cf <mult_row+0xcf>
add    %rax,%rdi
movupd (%rdx,%rdi,8),%xmm2
movupd 0x10(%rdx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rdi,8)
movupd %xmm3,0x10(%rdx,%rdi,8)
cmp    %r8,%r10
je     11f7 <mult_row+0xf7>
add    %r8,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    11e0 <mult_row+0xe0>
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    11ae <mult_row+0xae>
jmp    11cf <mult_row+0xcf>

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

LLVM IR (-O2):
define void @mult_row(i32 %0, double %1, i32 %2, double* nocapture %3) {
%5 = mul i32 %2, %0
%6 = add nsw i32 %0, 1
%7 = mul i32 %6, %2
%8 = icmp slt i32 %5, %7
br i1 %8, label %9, label %83
9: ; preds = %4
%10 = sext i32 %5 to i64
%11 = sext i32 %7 to i64
%12 = sub nsw i64 %11, %10
%13 = icmp ult i64 %12, 4
br i1 %13, label %74, label %14
14: ; preds = %9
%15 = and i64 %12, -4
%16 = add nsw i64 %15, %10
%17 = insertelement <2 x double> poison, double %1, i64 0
%18 = shufflevector <2 x double> %17, <2 x double> poison, <2 x i32> zeroinitializer
%19 = insertelement <2 x double> poison, double %1, i64 0
%20 = shufflevector <2 x double> %19, <2 x double> poison, <2 x i32> zeroinitializer
%21 = add nsw i64 %15, -4
%22 = lshr exact i64 %21, 2
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 1
%25 = icmp eq i64 %21, 0
br i1 %25, label %57, label %26
26: ; preds = %14
%27 = and i64 %23, 9223372036854775806
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %54, %28 ]
%30 = phi i64 [ 0, %26 ], [ %55, %28 ]
%31 = add i64 %29, %10
%32 = getelementptr inbounds double, double* %3, i64 %31
%33 = bitcast double* %32 to <2 x double>*
%34 = load <2 x double>, <2 x double>* %33
%35 = getelementptr inbounds double, double* %32, i64 2
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = fmul <2 x double> %34, %18
%39 = fmul <2 x double> %37, %20
%40 = bitcast double* %32 to <2 x double>*
store <2 x double> %38, <2 x double>* %40
%41 = bitcast double* %35 to <2 x double>*
store <2 x double> %39, <2 x double>* %41
%42 = or i64 %29, 4
%43 = add i64 %42, %10
%44 = getelementptr inbounds double, double* %3, i64 %43
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = getelementptr inbounds double, double* %44, i64 2
%48 = bitcast double* %47 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = fmul <2 x double> %46, %18
%51 = fmul <2 x double> %49, %20
%52 = bitcast double* %44 to <2 x double>*
store <2 x double> %50, <2 x double>* %52
%53 = bitcast double* %47 to <2 x double>*
store <2 x double> %51, <2 x double>* %53
%54 = add nuw i64 %29, 8
%55 = add i64 %30, 2
%56 = icmp eq i64 %55, %27
br i1 %56, label %57, label %28
57: ; preds = %28, %14
%58 = phi i64 [ 0, %14 ], [ %54, %28 ]
%59 = icmp eq i64 %24, 0
br i1 %59, label %72, label %60
60: ; preds = %57
%61 = add i64 %58, %10
%62 = getelementptr inbounds double, double* %3, i64 %61
%63 = bitcast double* %62 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = getelementptr inbounds double, double* %62, i64 2
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = fmul <2 x double> %64, %18
%69 = fmul <2 x double> %67, %20
%70 = bitcast double* %62 to <2 x double>*
store <2 x double> %68, <2 x double>* %70
%71 = bitcast double* %65 to <2 x double>*
store <2 x double> %69, <2 x double>* %71
br label %72
72: ; preds = %57, %60
%73 = icmp eq i64 %12, %15
br i1 %73, label %83, label %74
74: ; preds = %9, %72
%75 = phi i64 [ %10, %9 ], [ %16, %72 ]
br label %76
76: ; preds = %74, %76
%77 = phi i64 [ %81, %76 ], [ %75, %74 ]
%78 = getelementptr inbounds double, double* %3, i64 %77
%79 = load double, double* %78
%80 = fmul double %79, %1
store double %80, double* %78
%81 = add nsw i64 %77, 1
%82 = icmp eq i64 %81, %11
br i1 %82, label %83, label %76
83: ; preds = %76, %72, %4
ret void
}