Re: about arrays initialization

[Bob Plantz <plantz at cds1 dot net>]

As I noted in my previous message, the right hand side must be evaluated 
before the assignment can occur. I have added comments to the assembly 
language below to show how this occurs....

On 08/27/2011 05:57 PM, uulinux wrote:
> Dear Maciej:
>
> Thanks very mach. I am so glad to get a replay. I seem to know what 
> you mean. The auto variable allocated from stack, whose value is 
> initialized by code in runtime, not by compiler.
>
> But look the assembler code compiled by gcc-4.4.5.
> =========================================================
>     .file    "main.c"
>     .section    .rodata
> .LC0:
>     .string    "\t%d"
>     .text
> .globl main
>     .type    main, @function
> main:
>     pushl    %ebp
>     movl    %esp, %ebp
>     andl    $-16, %esp
>     subl    $48, %esp            # allocate space for array on stack
>     movl    32(%esp), %eax       # fetch value in a[2]  (which has not 
> yet been initialized)
>     movl    24(%esp), %ecx       # fetch value in a[0]  (which has not 
> yet been initialized)
>     movl    28(%esp), %edx       # fetch value in a[1]  (which has not 
> yet been initialized)
>     leal    (%ecx,%edx), %edx    # compute a[0] + a[1]  (meaningless 
> value)
# Now the necessary arithmetic has been completed to evaluate the right 
hand side. The other three values are literals.
>     movl    $1, 24(%esp)         # a[0] = 1   (literal value, so no 
> fetching or computation needed)
>     movl    $2, 28(%esp)         # a[1] = 2   (literal value, so no 
> fetching or computation needed)
>     movl    $3, 32(%esp)         # a[2] = 3   (literal value, so no 
> fetching or computation needed)
>     movl    %eax, 36(%esp)       # a[3] = a[2]   (previously computed 
> above]
>     movl    %edx, 40(%esp)       # a[4] = a[0] + a[1]   (previously 
> computed above]
>     movl    $0, 44(%esp)         # a[5] = 0
>     movl    $0, 44(%esp)         # a[5] = 0
# I have no idea why 0 is stored beyond the end of the array or why it 
is done twice. But the
# assignment to the elements of the array occur as I have always 
expected in C.
>     jmp    .L2
> .L3:
>     movl    44(%esp), %eax
>     movl    24(%esp,%eax,4), %edx
>     movl    $.LC0, %eax
>     movl    %edx, 4(%esp)
>     movl    %eax, (%esp)
>     call    printf
>     addl    $1, 44(%esp)
> .L2:
>     cmpl    $4, 44(%esp)
>     jle    .L3
>     movl    $10, (%esp)
>     call    putchar
>     movl    $0, %eax
>     leave
>     ret
>     .size    main, .-main
>     .ident    "GCC: (Gentoo 4.4.5 p1.2, pie-0.4.5) 4.4.5"
>     .section    .note.GNU-stack,"",@progbits
> =========================================================
>    Please notice this code compiled from "int a[5] = [1, 2, 3, a[2], 
> a[0]+a[1]]":
>     movl    $1, 24(%esp)
>     movl    $2, 28(%esp)
>     movl    $3, 32(%esp)
>     movl    %eax, 36(%esp)
>     movl    %edx, 40(%esp)
>    I just doubt whether there is something wrong or not very good. I 
> expect code as following:
>     movl    $1, 24(%esp)
>     movl    $2, 28(%esp)
>     movl    $3, 32(%esp)
>     movl    32(%esp), %eax
>     movl    %eax, 36(%esp)
>     movl    24(%esp), %edx
>     movl    28(%esp), %eax
>     leal    (%edx,%eax), %eax
>     movl    %eax, 40(%esp)
>    And I expect "int a[5] = [1, 2, 3, a[2], a[0]+a[1]]" is equivalent to:
>         int a[5] = [1, 2, 3];
>         a[3] = a[2];
>         a[4] = a[0]+a[1];
>    If the array is global variable and which will be put in .data 
> segment by compiler, gcc-4.4.5 will report error as following. But I 
> think this kind method of initialization is useful.
> =========================================================
> localhost array # gcc -o main main.c
> main.c:28: error: initializer element is not constant
> main.c:28: error: (near initialization for 'a[3]')
> main.c:28: error: initializer element is not constant
> main.c:28: error: (near initialization for 'a[4]')
> =========================================================