Re: Overhead of SSA operands

[Steven Bosscher <stevenb at suse dot de>]

On Tuesday 16 November 2004 09:26, Steven Bosscher wrote:
> Here is the code we produce for this loop, including initialization:

*sigh* When I'm going to dump assembly in a mail, I should make sure I
pick the right file.  That asm was for GCC 3.3.3.  Sorry about that :-/

For 4.0 we do this:

L881:
        leal    20(%eax), %edi  #, iter$ops
        movl    4(%edi), %ebx   # <variable>.use_ops, D.25711
        movl    $0, -28(%ebp)   #, iter$num_use
        testl   %ebx, %ebx      # D.25711
        je      .L885   #,
        movl    (%ebx), %ecx    # <variable>.num_uses,
        movl    %ecx, -28(%ebp) #, iter$num_use
.L885:
        movl    12(%edi), %ecx  # <variable>.vuse_ops, D.25719
        movl    $0, -32(%ebp)   #, iter$num_vuse
        testl   %ecx, %ecx      # D.25719
        je      .L888   #,
        movl    (%ecx), %esi    # <variable>.num_vuses,
        movl    %esi, -32(%ebp) #, iter$num_vuse
.L888:
        movl    8(%edi), %edx   # <variable>.v_may_def_ops, D.25727
        movl    $0, -36(%ebp)   #, iter$num_v_mayu
        testl   %edx, %edx      # D.25727
        je      .L891   #,
        movl    (%edx), %eax    # <variable>.num_v_may_defs,
        movl    %eax, -36(%ebp) #, iter$num_v_mayu
.L891:
        movl    16(%edi), %eax  # <variable>.v_must_def_ops, D.25741
        movl    $0, -44(%ebp)   #, iter$num_v_mustu
        testl   %eax, %eax      # D.25741
        je      .L894   #,
        movl    (%eax), %esi    # <variable>.num_v_must_defs,
        movl    %esi, -44(%ebp) #, iter$num_v_mustu
.L894:
        movl    -28(%ebp), %esi # iter$num_use,
        testl   %esi, %esi      #
        jle     .L895   #,
        movl    4(%ebx), %ebx   # <variable>.use, use_p$use
        movl    $1, %esi        #, iter$use_i
        movl    $0, -64(%ebp)   #, iter$v_mustu_i
        movl    $0, -56(%ebp)   #, iter$v_mayu_i
        movl    $0, -52(%ebp)   #, iter$vuse_i
        movb    $0, -18(%ebp)   #, iter$done
.L897:
        cmpb    $0, -18(%ebp)   # iter$done
        jne     .L904   #,
        jmp     .L947   #
        .p2align 4,,7
.L954:
        movl    4(%edi), %eax   # <variable>.use_ops, <variable>.use_ops
        movl    %esi, %edx      # iter$use_i, index
        incl    %esi    # iter$use_i
        movl    4(%eax,%edx,4), %ebx    # <variable>.use, use_p$use
.L910:
        cmpb    $0, -18(%ebp)   # iter$done
        jne     .L904   #,
.L947:
        movl    (%ebx), %eax    #* use_p$use, D.21875
        cmpb    $-113, 12(%eax) #, <variable>.common.code
        je      .L906   #,
        call    get_reaching_def        #
        movl    %eax, (%ebx)    # D.21879,* use_p$use
.L906:
        cmpl    %esi, -28(%ebp) # iter$use_i, iter$num_use
        jg      .L954   #,
        movl    -52(%ebp), %eax # iter$vuse_i,
        cmpl    %eax, -32(%ebp) #, iter$num_vuse
        jle     .L911   #,
        movl    %eax, %edx      #, index
        incl    %eax    #
        movl    %eax, -52(%ebp) #, iter$vuse_i
        movl    12(%edi), %eax  # <variable>.vuse_ops, tmp125
        addl    $4, %eax        #, tmp125
        cmpb    $0, -18(%ebp)   # iter$done
        leal    (%eax,%edx,4), %ebx     #, use_p$use
        je      .L947   #,
        .p2align 4,,15
.L904:

        (...)
	
.L911:
        movl    -56(%ebp), %edx # iter$v_mayu_i,
        cmpl    %edx, -36(%ebp) #, iter$num_v_mayu
        jle     .L913   #,
        movl    8(%edi), %eax   # <variable>.v_may_def_ops, <variable>.v_may_def_ops
        incl    -56(%ebp)       # iter$v_mayu_i
        leal    8(%eax,%edx,8), %ebx    #, use_p$use
        jmp     .L910   #
        .p2align 4,,7

        (...)

.L913:
        movl    -64(%ebp), %ecx # iter$v_mustu_i,
        cmpl    %ecx, -44(%ebp) #, iter$num_v_mustu
        jg      .L957   #,
        movl    NULL_USE_OPERAND_P, %ebx        # NULL_USE_OPERAND_P.use, use_p$use
        movb    $1, -18(%ebp)   #, iter$done
        jmp     .L910   #
        .p2align 4,,7

The loop starts at .L910 now.  Much better, but still a lot of overhead
with the loop tests.

Gr.
Steven