Interpolate kernel bitcode - Julia vs C++

interpolate.c++.ll

define float @interpolate(%"class.Eigen::Matrix"* nocapture readonly %source, %"class.Eigen::Matrix.2"* nocapture readonly %p) #3 {
  %x_int = alloca float, align 4
  %y_int = alloca float, align 4
  %1 = getelementptr inbounds %"class.Eigen::Matrix.2"* %p, i64 0, i32 0, i32 0, i32 0, i32 0, i64 0
  %2 = load float* %1, align 4
  %3 = call float @modff(float %2, float* %x_int) #2
  %4 = getelementptr inbounds %"class.Eigen::Matrix.2"* %p, i64 0, i32 0, i32 0, i32 0, i32 0, i64 1
  %5 = load float* %4, align 4
  %6 = call float @modff(float %5, float* %y_int) #2
  %7 = load float* %y_int, align 4
  %8 = fptosi float %7 to i64
  %9 = load float* %x_int, align 4
  %10 = fptosi float %9 to i64
  %11 = getelementptr inbounds %"class.Eigen::Matrix"* %source, i64 0, i32 0, i32 0, i32 1
  %12 = load i64* %11, align 8
  %13 = mul nsw i64 %12, %10
  %14 = add nsw i64 %13, %8
  %15 = getelementptr inbounds %"class.Eigen::Matrix"* %source, i64 0, i32 0, i32 0, i32 0
  %16 = load float** %15, align 8
  %17 = getelementptr inbounds float* %16, i64 %14
  %18 = load float* %17, align 4
  %19 = fsub float 1.000000e+00, %3
  %20 = fmul float %19, %18
  %21 = fsub float 1.000000e+00, %6
  %22 = fmul float %21, %20
  %23 = fadd float %9, 1.000000e+00
  %24 = fptosi float %23 to i64
  %25 = mul nsw i64 %24, %12
  %26 = add nsw i64 %25, %8
  %27 = getelementptr inbounds float* %16, i64 %26
  %28 = load float* %27, align 4
  %29 = fmul float %3, %28
  %30 = fmul float %21, %29
  %31 = fadd float %22, %30
  %32 = fadd float %7, 1.000000e+00
  %33 = fptosi float %32 to i64
  %34 = add nsw i64 %13, %33
  %35 = getelementptr inbounds float* %16, i64 %34
  %36 = load float* %35, align 4
  %37 = fmul float %19, %36
  %38 = fmul float %6, %37
  %39 = fadd float %31, %38
  %40 = add nsw i64 %25, %33
  %41 = getelementptr inbounds float* %16, i64 %40
  %42 = load float* %41, align 4
  %43 = fmul float %3, %42
  %44 = fmul float %6, %43
  %45 = fadd float %39, %44
  ret float %45
}

interpolate.julia.ll

define float @julia_interpolate17748(%jl_value_t*, %Point) {
top:
  %2 = getelementptr inbounds %jl_value_t* %0, i64 1, i32 0
  %3 = load %jl_value_t** %2, align 8
  %4 = getelementptr inbounds %jl_value_t* %0, i64 4, i32 0
  %5 = load %jl_value_t** %4, align 8
  %6 = extractvalue %Point %1, 0
  %7 = call float inttoptr (i64 139687377738416 to float (float)*)(float %6)
  %8 = extractvalue %Point %1, 1
  %9 = call float inttoptr (i64 139687377738416 to float (float)*)(float %8)
  %10 = fptosi float %7 to i64
  %11 = fpext float %7 to double
  %12 = sitofp i64 %10 to double
  %13 = fptosi double %12 to i64
  %14 = icmp eq i64 %10, %13
  %15 = fcmp oeq double %11, %12
  %16 = and i1 %15, %14
  br i1 %16, label %pass, label %fail

fail:
  %17 = load %jl_value_t** @jl_inexact_exception, align 8
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %17, i32 12)
  unreachable

pass:
  %18 = fptosi float %9 to i64
  %19 = fpext float %9 to double
  %20 = sitofp i64 %18 to double
  %21 = fptosi double %20 to i64
  %22 = icmp eq i64 %18, %21
  %23 = fcmp oeq double %19, %20
  %24 = and i1 %23, %22
  br i1 %24, label %pass4, label %fail1

fail1:
  %25 = load %jl_value_t** @jl_inexact_exception, align 8
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %25, i32 12)
  unreachable

pass4:
  %26 = fadd float %9, 1.000000e+00
  %27 = fptosi float %26 to i64
  %28 = fpext float %26 to double
  %29 = sitofp i64 %27 to double
  %30 = fptosi double %29 to i64
  %31 = icmp eq i64 %27, %30
  %32 = fcmp oeq double %28, %29
  %33 = and i1 %32, %31
  br i1 %33, label %pass6, label %fail5

fail5:
  %34 = load %jl_value_t** @jl_inexact_exception, align 8
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %34, i32 12)
  unreachable

pass6:
  %35 = fadd float %7, 1.000000e+00
  %36 = fptosi float %35 to i64
  %37 = fpext float %35 to double
  %38 = sitofp i64 %36 to double
  %39 = fptosi double %38 to i64
  %40 = icmp eq i64 %36, %39
  %41 = fcmp oeq double %37, %38
  %42 = and i1 %41, %40
  br i1 %42, label %pass14, label %fail7

fail7:
  %43 = load %jl_value_t** @jl_inexact_exception, align 8
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %43, i32 12)
  unreachable

pass14:
  %44 = bitcast %jl_value_t* %3 to float*
  %45 = ptrtoint %jl_value_t* %5 to i64
  %46 = frem float %6, 1.000000e+00
  %47 = frem float %8, 1.000000e+00
  %48 = add i64 %10, -1
  %49 = add i64 %18, -1
  %50 = mul i64 %49, %45
  %51 = add i64 %48, %50
  %52 = getelementptr float* %44, i64 %51
  %53 = load float* %52, align 4
  %54 = add i64 %27, -1
  %55 = mul i64 %54, %45
  %56 = add i64 %48, %55
  %57 = getelementptr float* %44, i64 %56
  %58 = load float* %57, align 4
  %59 = add i64 %36, -1
  %60 = add i64 %59, %50
  %61 = getelementptr float* %44, i64 %60
  %62 = load float* %61, align 4
  %63 = add i64 %59, %55
  %64 = getelementptr float* %44, i64 %63
  %65 = load float* %64, align 4
  %66 = fsub float 1.000000e+00, %47
  %67 = fmul float %66, %53
  %68 = fsub float 1.000000e+00, %46
  %69 = fmul float %68, %67
  %70 = fmul float %47, %58
  %71 = fmul float %68, %70
  %72 = fadd float %69, %71
  %73 = fmul float %66, %62
  %74 = fmul float %46, %73
  %75 = fadd float %72, %74
  %76 = fmul float %47, %65
  %77 = fmul float %46, %76
  %78 = fadd float %75, %77
  ret float %78
}