optimization options not working

optimization options not working

[rohitgeek]

Hi ,

I am a newbie in compilers, recently came across a problem that when i try
to use optimization options( -O_   ) during compilation , i do not get the
asembly for the processor that i am porting gcc to. Is there a simple thing
i am missing somewhere? 
Secondly, are there some macros i need to define in regard with
optimization.

Kindly clarify the doubts and provide any other basic information that i
need to have regarding optimizations, specifically peephole.

Thanks
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27637400.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[Andrew Haley]

On 02/18/2010 12:03 PM, rohitgeek wrote:

> I am a newbie in compilers, recently came across a problem that when i try
> to use optimization options( -O_   ) during compilation , i do not get the
> asembly for the processor that i am porting gcc to. Is there a simple thing
> i am missing somewhere? 

Probably.  Tell us exactly what you did, with full details.

http://catb.org/~esr/faqs/smart-questions.html

> Secondly, are there some macros i need to define in regard with
> optimization.

No.

Andrew.

Re: optimization options not working

[rohitgeek]

hi 

this is what i am doing :-

1. Created the machine description files
2. Build my target (successful)
3. Compile 
       Now this step works correctly i.e. generate correct assembly if i do
not put any optimization option.
   
     command : ----    ./target-gcc -S test.c     -> works
                              ./target-gcc -O1/2/3 -S test.c    -> no
assembly corresponding to the variable assignment and all other operations
i.e. it generates only prologue and epilogue(if i am correct for later
part).

Give me some insight into working of peephole optimizations, how do i start
doing that.

Rohit




 

Andrew Haley wrote:
> 
> On 02/18/2010 12:03 PM, rohitgeek wrote:
> 
>> I am a newbie in compilers, recently came across a problem that when i
>> try
>> to use optimization options( -O_   ) during compilation , i do not get
>> the
>> asembly for the processor that i am porting gcc to. Is there a simple
>> thing
>> i am missing somewhere? 
> 
> Probably.  Tell us exactly what you did, with full details.
> 
> http://catb.org/~esr/faqs/smart-questions.html
> 
>> Secondly, are there some macros i need to define in regard with
>> optimization.
> 
> No.
> 
> Andrew.
> 
> 

-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27650186.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[Ian Lance Taylor]

rohitgeek <rohit23taneja@gmail.com> writes:

> 1. Created the machine description files
> 2. Build my target (successful)
> 3. Compile 
>        Now this step works correctly i.e. generate correct assembly if i do
> not put any optimization option.
>    
>      command : ----    ./target-gcc -S test.c     -> works
>                               ./target-gcc -O1/2/3 -S test.c    -> no
> assembly corresponding to the variable assignment and all other operations
> i.e. it generates only prologue and epilogue(if i am correct for later
> part).

You didn't show us test.c.  You have to tell us what you did if you
expect a good answer to your question.

Without seeing test.c, I would guess that the variables are not used,
and were removed by the optimizers.


> Give me some insight into working of peephole optimizations, how do i start
> doing that.

Peephole optimization is a specific type of optimization.  See
define_peephole and define_peephole2 in the internals documentation.
See many examples in the existing backends.


Ian

Re: optimization options not working

[rohitgeek]

Ian Lance Taylor-3 wrote:
> 
> rohitgeek <rohit23taneja@gmail.com> writes:
> 
>> 1. Created the machine description files
>> 2. Build my target (successful)
>> 3. Compile 
>>        Now this step works correctly i.e. generate correct assembly if i
>> do
>> not put any optimization option.
>>    
>>      command : ----    ./target-gcc -S test.c     -> works
>>                               ./target-gcc -O1/2/3 -S test.c    -> no
>> assembly corresponding to the variable assignment and all other
>> operations
>> i.e. it generates only prologue and epilogue(if i am correct for later
>> part).
> 
> You didn't show us test.c.  You have to tell us what you did if you
> expect a good answer to your question.
> 
> Without seeing test.c, I would guess that the variables are not used,
> and were removed by the optimizers.
> 
> 
>> Give me some insight into working of peephole optimizations, how do i
>> start
>> doing that.
> 
> Peephole optimization is a specific type of optimization.  See
> define_peephole and define_peephole2 in the internals documentation.
> See many examples in the existing backends.
> 
> 
> Ian
> 
> 




I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714100.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

Ian Lance Taylor-3 wrote:
> 
> rohitgeek <rohit23taneja@gmail.com> writes:
> 
>> 1. Created the machine description files
>> 2. Build my target (successful)
>> 3. Compile 
>>        Now this step works correctly i.e. generate correct assembly if i
>> do
>> not put any optimization option.
>>    
>>      command : ----    ./target-gcc -S test.c     -> works
>>                               ./target-gcc -O1/2/3 -S test.c    -> no
>> assembly corresponding to the variable assignment and all other
>> operations
>> i.e. it generates only prologue and epilogue(if i am correct for later
>> part).
> 
> You didn't show us test.c.  You have to tell us what you did if you
> expect a good answer to your question.
> 
> Without seeing test.c, I would guess that the variables are not used,
> and were removed by the optimizers.
> 
> 
>> Give me some insight into working of peephole optimizations, how do i
>> start
>> doing that.
> 
> Peephole optimization is a specific type of optimization.  See
> define_peephole and define_peephole2 in the internals documentation.
> See many examples in the existing backends.
> 
> 
> Ian
> 
> 




I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714102.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

Ian Lance Taylor-3 wrote:
> 
> rohitgeek <rohit23taneja@gmail.com> writes:
> 
>> 1. Created the machine description files
>> 2. Build my target (successful)
>> 3. Compile 
>>        Now this step works correctly i.e. generate correct assembly if i
>> do
>> not put any optimization option.
>>    
>>      command : ----    ./target-gcc -S test.c     -> works
>>                               ./target-gcc -O1/2/3 -S test.c    -> no
>> assembly corresponding to the variable assignment and all other
>> operations
>> i.e. it generates only prologue and epilogue(if i am correct for later
>> part).
> 
> You didn't show us test.c.  You have to tell us what you did if you
> expect a good answer to your question.
> 
> Without seeing test.c, I would guess that the variables are not used,
> and were removed by the optimizers.
> 
> 
>> Give me some insight into working of peephole optimizations, how do i
>> start
>> doing that.
> 
> Peephole optimization is a specific type of optimization.  See
> define_peephole and define_peephole2 in the internals documentation.
> See many examples in the existing backends.
> 
> 
> Ian
> 
> 




I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714101.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714103.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714104.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714105.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714106.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714105.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714100.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[Andrew Haley]

On 02/24/2010 05:19 AM, rohitgeek wrote:
> 
> 
> This is test.c
> 
>  main()
>   {
>   int a,b,c;
>    a= 5;
>    b=10;
>    d=30;
>   c=  a*b + 30 ;
> }
> 
> now , suppose i build gcc for an ARM processor.
> After build, compile stage ---
> 
> with no optimization options as mentioned above, this is what i get in
> assembly.
> 
>         .file   "test1234.c"
>         .text
>         .align  2
>         .global main
>         .type   main, %function
> main:
>         @ args = 0, pretend = 0, frame = 16
>         @ frame_needed = 1, uses_anonymous_args = 0
>         mov     ip, sp
>         stmfd   sp!, {fp, ip, lr, pc}
>         sub     fp, ip, #4
>         sub     sp, sp, #16
>         mov     r3, #5
>         str     r3, [fp, #-28]
>         mov     r3, #10
>         str     r3, [fp, #-24]
>         mov     r3, #30
>         str     r3, [fp, #-16]
>         ldr     r2, [fp, #-28]
>         ldr     r3, [fp, #-24]
>         mul     r1, r3, r2
>         mov     r3, r1
>         mov     r2, r3, asl #2
>         mov     r3, r2, asl #5
>         rsb     r3, r2, r3
>         add     r3, r3, r1
>         mov     r2, r3, asl #2
>         add     r3, r3, r2
>         mov     r3, r3, asl #4
>         add     r3, r3, #299008
>         add     r3, r3, #992
>         str     r3, [fp, #-20]
>         sub     sp, fp, #12
>         ldmfd   sp, {fp, sp, pc}
>         .size   main, .-main
> 
> 
>  with optimization option turned on (mentioned in command line) 
>   
> assembly :- 
> 
>         .file   "test1234.c"
>         .text
>         .align  2
>         .global main
>         .type   main, %function
> main:
>         @ args = 0, pretend = 0, frame = 0
>         @ frame_needed = 0, uses_anonymous_args = 0
>         @ link register save eliminated.
>         bx      lr
>         .size   main, .-main
> 
> 
> Did i missed something during building time?

No.  It looks to me like the optimizer is working really well.  The
function doesn't do anything, so gcc has optimized away all its
statmements.

Andrew.

Re: optimization options not working

[rohitgeek]

I will try to be descriptive this time .

This is test.c

 main()
  {
  int a,b,c;
   a= 5;
   b=10;
   d=30;
  c=  a*b + 30 ;
}

now , suppose i build gcc for an ARM processor.
After build, compile stage ---

with no optimization options as mentioned above, this is what i get in
assembly.

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        mov     r3, #5
        str     r3, [fp, #-28]
        mov     r3, #10
        str     r3, [fp, #-24]
        mov     r3, #30
        str     r3, [fp, #-16]
        ldr     r2, [fp, #-28]
        ldr     r3, [fp, #-24]
        mul     r1, r3, r2
        mov     r3, r1
        mov     r2, r3, asl #2
        mov     r3, r2, asl #5
        rsb     r3, r2, r3
        add     r3, r3, r1
        mov     r2, r3, asl #2
        add     r3, r3, r2
        mov     r3, r3, asl #4
        add     r3, r3, #299008
        add     r3, r3, #992
        str     r3, [fp, #-20]
        sub     sp, fp, #12
        ldmfd   sp, {fp, sp, pc}
        .size   main, .-main


 with optimization option turned on (mentioned in command line) 
  
assembly :- 

        .file   "test1234.c"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        bx      lr
        .size   main, .-main


Did i missed something during building time?

Also bringing into notice the point of single instruction generation instead
of 2 instructions (multiply and accumulate), what part of gcc will do it and
how to proceed regarding that.


Thanks
   
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27714100.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[John S. Fine]

Andrew Haley gave you a perfectly good and correct answer the previous 
time you asked that question.

If you don't understand his answer, you should ask about it.  You seem 
to be assuming he didn't understand your question.  If that were true 
(unlikely) you really haven't improved the question enough to change 
anything.

I assume you want to test a specific optimization.  You are failing 
because you didn't construct the example carefully enough.  You allowed 
the optimizer to know the result of the computation at compile time and 
you allowed it to know that the result will be ignored.  So the 
optimizer can remove the whole computation.

If you want to examine the results of a specific optimization, you must 
keep the optimizer from knowing the input values at compile time and you 
must make the optimizer think the result could be used.

If you just want to see (not benchmark) the resulting asm code, you 
don't need a complete program, just a complete function.  If the 
inputs/outputs of your computation are inputs/outputs of the function 
(that you compile separate from any call) then the optimizer can't short 
circuit the computation.


rohitgeek wrote:
>
>
> I will try to be descriptive this time .
>
>
>   
...
> Also bringing into notice the point of single instruction generation instead
> of 2 instructions (multiply and accumulate), what part of gcc will do it and
> how to proceed regarding that.
>
>
>   

Re: optimization options not working

[Ian Lance Taylor]

rohitgeek <rohit23taneja@gmail.com> writes:

> This is test.c
>
>  main()
>   {
>   int a,b,c;
>    a= 5;
>    b=10;
>    d=30;
>   c=  a*b + 30 ;
> }

What everyone is trying to tell you is that that program is precisely
equivalent to this one:

main() { }

The optimizer is smart enough to reduce the former to the latter.

Ian

Re: optimization options not working

[rohitgeek]

Thanks John and Ian. 

@John  
Until you posted this, i never thought like that. I get what you have
mentioned in post and when tried with function rather than in main {} as
mentioned by Ian too, i get what i expect. But why does optimizer does so?
Where is the assembly or data gone when doing the earlier way, because if we
put some data into registers and done some manipulations, then where are
they gone from assembly. I think my question has answer in your post ( "
optimizer ignores the data and computation") , but i am still not getting it
correctly.
-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27752183.html
Sent from the gcc - Help mailing list archive at Nabble.com.

Re: optimization options not working

[Cedric Roux]

rohitgeek wrote:
> mentioned by Ian too, i get what i expect. But why does optimizer does so?

because it can with respect to the semantics of the compiled language.
Your statements assign values to local variables.
There is no side effect.
The values you assign are not used later on.
So they are completely useless. Computing them or not won't change
the semantics of your program. At all.
It's cool that gcc finds that out for cases where your code actually
does something, where optimization is useful. No?

> Where is the assembly or data gone when doing the earlier way, because if we

You write programs in C, not in assembly language. The C compiler
can compile the way it wants as long as the C semantics is
respected.

> put some data into registers and done some manipulations, then where are

This is what you don't understand I guess. Your program doesn't "put some data into
registers and [does] some manipulations." Your program assigns values to C variables.
This is another world.
C is not assembly language.

So in short, as others said, if you want the code to stay there
after optimization, be sure it does real stuff, like returning
the computed value. The computed value has to "escape" the local
scope for it to be "respected" by the optimization.

My .2 euros.

Re: optimization options not working

[rohitgeek]

Your .2 euros turned into  high value , i got the point. And yes, gcc got
the hidden talent.


Cedric Roux-4 wrote:
> 
> rohitgeek wrote:
>> mentioned by Ian too, i get what i expect. But why does optimizer does
>> so?
> 
> because it can with respect to the semantics of the compiled language.
> Your statements assign values to local variables.
> There is no side effect.
> The values you assign are not used later on.
> So they are completely useless. Computing them or not won't change
> the semantics of your program. At all.
> It's cool that gcc finds that out for cases where your code actually
> does something, where optimization is useful. No?
> 
>> Where is the assembly or data gone when doing the earlier way, because if
>> we
> 
> You write programs in C, not in assembly language. The C compiler
> can compile the way it wants as long as the C semantics is
> respected.
> 
>> put some data into registers and done some manipulations, then where are
> 
> This is what you don't understand I guess. Your program doesn't "put some
> data into
> registers and [does] some manipulations." Your program assigns values to C
> variables.
> This is another world.
> C is not assembly language.
> 
> So in short, as others said, if you want the code to stay there
> after optimization, be sure it does real stuff, like returning
> the computed value. The computed value has to "escape" the local
> scope for it to be "respected" by the optimization.
> 
> My .2 euros.
> 
> 

-- 
View this message in context: http://old.nabble.com/optimization-options-not-working-tp27637400p27755423.html
Sent from the gcc - Help mailing list archive at Nabble.com.