Large amounts of code generated when using keyword arguments

[staticfloat]

Is this expected?

julia> foo(x; a=2.0) = a * x
foo (generic function with 1 method)

julia> @code_native foo(1.0)
        .text
Filename: REPL[1]
        pushq   %rbp
        movq    %rsp, %rbp
Source line: 1
        vaddsd  %xmm0, %xmm0, %xmm0
        popq    %rbp
        retq
        nopw    (%rax,%rax)

julia> @code_native foo(1.0, a=2.0)
        .text
Filename: <missing>
        pushq   %rbp
        movq    %rsp, %rbp
        pushq   %r15
        pushq   %r14
        pushq   %r13
        pushq   %r12
        pushq   %rbx
        subq    $120, %rsp
        vmovsd  %xmm0, -48(%rbp)
        movq    %rdi, %r14
        movabsq $139884898147504, %r13  # imm = 0x7F397DA9DCB0
        movq    %fs:0, %r15
        addq    $-10888, %r15           # imm = 0xD578
        leaq    -72(%rbp), %r12
        vxorpd  %xmm0, %xmm0, %xmm0
        vmovupd %xmm0, -72(%rbp)
        movq    $0, -56(%rbp)
        vxorpd  %ymm0, %ymm0, %ymm0
        vmovupd %ymm0, -112(%rbp)
        vmovupd %ymm0, -144(%rbp)
        movq    $24, -160(%rbp)
        movq    (%r15), %rax
        movq    %rax, -152(%rbp)
        leaq    -160(%rbp), %rax
        movq    %rax, (%r15)
        movq    $0, -80(%rbp)
Source line: 0
        movq    $0, -120(%rbp)
        movq    8(%r14), %rcx
        sarq    %rcx
        testq   %rcx, %rcx
        jle     L268
        movq    (%r14), %rdx
        movq    24(%r14), %rsi
        movl    $1, %eax
        leaq    320969400(%r13), %rdi
        nopw    (%rax,%rax)
L176:
        leaq    -1(%rax), %rbx
        cmpq    %rsi, %rbx
        jae     L482
        movq    -8(%rdx,%rax,8), %rbx
        testq   %rbx, %rbx
        je      L391
        movq    %rbx, -144(%rbp)
        movq    %rbx, -136(%rbp)
        cmpq    %rdi, %rbx
        jne     L519
        cmpq    %rsi, %rax
        jae     L416
        movq    (%rdx,%rax,8), %rbx
        testq   %rbx, %rbx
        je      L457
        movq    %rbx, -128(%rbp)
        movq    %rbx, -120(%rbp)
        addq    $2, %rax
        addq    $-1, %rcx
        jne     L176
        jmp     L275
L268:
        movq    %r13, -120(%rbp)
        movq    %r13, %rbx
L275:
        movq    %rbx, -80(%rbp)
        leaq    323633560(%r13), %rax
        movq    %rax, -72(%rbp)
        movq    %rbx, -64(%rbp)
        movabsq $jl_gc_pool_alloc, %rax
        movl    $1432, %esi             # imm = 0x598
        movl    $16, %edx
        movq    %r15, %rdi
        vzeroupper
        callq   *%rax
        addq    $323623360, %r13        # imm = 0x134A19C0
        movq    %r13, -8(%rax)
        vmovsd  -48(%rbp), %xmm0        # xmm0 = mem[0],zero
        vmovsd  %xmm0, (%rax)
        movq    %rax, -56(%rbp)
        movabsq $jl_apply_generic, %rax
        movl    $3, %esi
        movq    %r12, %rdi
        callq   *%rax
        movq    -152(%rbp), %rcx
        movq    %rcx, (%r15)
        leaq    -40(%rbp), %rsp
        popq    %rbx
        popq    %r12
        popq    %r13
        popq    %r14
        popq    %r15
        popq    %rbp
        retq
L391:
        addq    $330295000, %r13        # imm = 0x13AFE6D8
        movabsq $jl_throw, %rax
        movq    %r13, %rdi
        vzeroupper
        callq   *%rax
L416:
        movq    %rsp, %rcx
        leaq    -16(%rcx), %rsi
        movq    %rsi, %rsp
        addq    $1, %rax
        movq    %rax, -16(%rcx)
        movabsq $jl_bounds_error_ints, %rax
        movl    $1, %edx
        movq    %r14, %rdi
        vzeroupper
        callq   *%rax
L457:
        addq    $330295000, %r13        # imm = 0x13AFE6D8
        movabsq $jl_throw, %rax
        movq    %r13, %rdi
        vzeroupper
        callq   *%rax
L482:
        movq    %rsp, %rcx
        leaq    -16(%rcx), %rsi
        movq    %rsi, %rsp
        movq    %rax, -16(%rcx)
        movabsq $jl_bounds_error_ints, %rax
        movl    $1, %edx
        movq    %r14, %rdi
        vzeroupper
        callq   *%rax
L519:
        movabsq $jl_gc_pool_alloc, %rax
        movl    $1456, %esi             # imm = 0x5B0
        movl    $32, %edx
        movq    %r15, %rdi
        vzeroupper
        callq   *%rax
        movq    %rax, %rbx
        leaq    324426656(%r13), %rax
        movq    %rax, -8(%rbx)
        movq    %rbx, -112(%rbp)
        vxorpd  %xmm0, %xmm0, %xmm0
        vmovupd %xmm0, (%rbx)
        movq    138528(%r13), %rax
        movq    56(%rax), %rax
        testq   %rax, %rax
        jne     L611
        addq    $330295000, %r13        # imm = 0x13AFE6D8
        movabsq $jl_throw, %rax
        movq    %r13, %rdi
        callq   *%rax
L611:
        movq    %rax, -104(%rbp)
        movq    %rax, -72(%rbp)
        leaq    320968968(%r13), %rax
        movq    %rax, -64(%rbp)
        movabsq $jl_f_getfield, %rax
        xorl    %edi, %edi
        movl    $2, %edx
        movq    %r12, %rsi
        callq   *%rax
        movq    %rax, -96(%rbp)
        movq    %rax, (%rbx)
        testq   %rax, %rax
        je      L695
        movl    -8(%rbx), %ecx
        notl    %ecx
        testb   $3, %cl
        jne     L695
        testb   $1, -8(%rax)
        jne     L695
        movabsq $jl_gc_queue_root, %rax
        movq    %rbx, %rdi
        callq   *%rax
L695:
        movl    $1456, %esi             # imm = 0x5B0
        movl    $32, %edx
        movq    %r15, %rdi
        movabsq $jl_gc_pool_alloc, %rax
        callq   *%rax
        addq    $6212864, %r13          # imm = 0x5ECD00
        movq    %r13, -8(%rax)
        movq    %rax, -88(%rbp)
        movq    %r14, (%rax)
        vmovsd  -48(%rbp), %xmm0        # xmm0 = mem[0],zero
        vmovsd  %xmm0, 8(%rax)
        movq    %rax, 8(%rbx)
        testq   %rax, %rax
        je      L781
        movl    -8(%rbx), %eax
        notl    %eax
        testb   $3, %al
        jne     L781
        movabsq $jl_gc_queue_root, %rax
        movq    %rbx, %rdi
        callq   *%rax
L781:
        movq    $-1, 16(%rbx)
        movabsq $jl_throw, %rax
        movq    %rbx, %rdi
        callq   *%rax
        nopw    %cs:(%rax,%rax)

Looking at @code_typed it looks like there's a bunch of array stuff going on, which may have to do with the internal implementation of kwargs?

@code_typed foo(1.0, a=2.0)
CodeInfo(:(begin 
        NewvarNode(:(a))
        #temp#@_9 = true
        SSAValue(2) = (Base.arraylen)(#temp#@_2)::Int64
        SSAValue(3) = (Base.select_value)((Base.sle_int)(0, 1)::Bool, (Base.ashr_int)(SSAValue(2), (Base.bitcast)(UInt64, 1))::Int64, (Base.shl_int)(SSAValue(2), (Base.bitcast)(UInt64, (Base.neg_int)(1)::Int64))::Int64)::Int64
        SSAValue(6) = (Base.select_value)((Base.sle_int)(1, SSAValue(3))::Bool, SSAValue(3), (Base.sub_int)(1, 1)::Int64)::Int64
        #temp#@_8 = 1
        7: 
        unless (Base.not_int)((#temp#@_8 === (Base.add_int)(SSAValue(6), 1)::Int64)::Bool)::Bool goto 25
        SSAValue(7) = #temp#@_8
        SSAValue(8) = (Base.add_int)(#temp#@_8, 1)::Int64
        #temp#@_5 = SSAValue(7)
        #temp#@_8 = SSAValue(8)
        #temp#@_6 = (Base.sub_int)((Base.mul_int)(#temp#@_5, 2)::Int64, 1)::Int64
        #temp#@_7 = (Core.arrayref)(#temp#@_2, #temp#@_6)
        unless (#temp#@_7 === :a)::Bool goto 19
        a = (Core.arrayref)(#temp#@_2, (Base.add_int)(#temp#@_6, 1)::Int64)
        #temp#@_9 = false
        goto 23
        19: 
        SSAValue(9) = 
        SSAValue(10) = x
        (Base.throw)($(Expr(:new, :(Base.MethodError), :((Core.getfield)((Core.getfield)((Core.getfield)(#foo, :name)::TypeName, :mt), :kwsorter)), :((Core.tuple)(#temp#@_2, SSAValue(9), SSAValue(10))::Tuple{Array{Any,1},#foo,Float64}), 0xffffffffffffffff)))::Union{}
        23: 
        goto 7
        25: 
        unless #temp#@_9 goto 28
        a = 2.0
        28: 
        SSAValue(5) = a
        return SSAValue(5) * x
    end))=>Any

Again, is this expected?

[yuyichao]

Yes. Dup of #9551 Will potentially be fixed by #21915.