about arrays initialization

[uulinux]

Dear Bob plantz:

Thank you very mach. You are very enthusiastic and friendly, and your 
analysis is very good. The C code is as following:
===============================================
         #include   <stdio.h>
         int main()
         {
                 int a[5]={1, 2, 3, a[2], a[0]+a[1]};
                 int i=0;

                 for (i=0; i<5; i++) {
                         printf("\t%d", a[i]);
                 }
                 return 0;
         }
===============================================
    So, please read the following again.
 >> 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.
    It is not a[5] = 0. It is i=0; But I also have no idea about why it 
is done twice.

    I have known the reason of this issue is "a[3], a[4]" has not 
evaluated before the assignment occurred. So the result of this action 
is not fixed? And the result of this action is determined by the 
compiler. But there is still a question in my head. Why gcc put 
"a[3]=a[2]; a[4]=a[0]+a[1];" operation in the front of "a[0]=1; a[1]=2; 
a[2]=3;"? Is not the array has initialized from a[0] to a[n]?  I just 
wonder why not put "a[0]=1; a[1]=2; a[2]=3;" operation in the front of 
"a[3]=a[2]; a[4]=a[0]+a[1];".

    Is there a method to achieve “a[3] = a[2]; a[4]=a[0]+a[1]” for 
global variable. So, I just need to update the value of a[0]…a[1] when 
the value should be changed. I think it is useful when the arithmetic 
expression is very complex. The value of some elements in a array will 
be auto updated by compiler, just like this:
===============================================
	static int a[6]={1, 2, 3, a[2], a[0]+a[1], sin(a[4])}; // gcc-4.4.5 
report error !

         #include   <stdio.h>
         int main()
         {
                 int i=0;

                 for (i=0; i<6; i++) {
                         printf("\t%d", a[i]);
                 }
                 return 0;
         }
===============================================

于 2011/8/28 上午 10:20, Bob Plantz 写道:
> 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]')
>> =========================================================
>