@@@ A Serious Question @@@

[sugaray]

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077

#include <stdio.h>

int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;

printf("%d\n",b);

return 0;
}

and after disassembled, it became

_main proc near ; modified version with my comments
nB = dword ptr -8
nA = dword ptr -4

push ebp
mov ebp, esp
sub esp, 8
mov [ebp+nA], 0 ; nA=0
cmp [ebp+nA], 0
jge short GE ; if(nA >= 0) then goto GE
mov [ebp+nB], -5
jmp short Handle
GE:
cmp [ebp+nA], 0
jle short LE ; if(nA <= 0) then goto LE
mov [ebp+nB], 5 ; here only can be nA>0 is true
jmp short Handle
LE:
mov [ebp+nB], 0 ; if (nA >= 0 && nA <= 0 ) then
Handle:
mov eax, [ebp+nB]
push eax
push offset format ; "%d\n"
call _printf
add esp, 8
xor eax, eax
mov esp, ebp
pop ebp
retn
_main endp

which using some kinda non-straightforward logic like this

if(a>=0) {
if(a<=0) b=0;
else b=5;
} else b=-5;

and after I rewrite the original C code in a more succinct way
only in one line statement like this

b=(a<0)?-5:((a>0)?5:0);

then the disassembled code changed accordingly like this

_main proc near
nB = dword ptr -0Ch
nTmp = dword ptr -8
nA = dword ptr -4

push ebp
mov ebp, esp
sub esp, 0Ch ; Set up stack frame
mov [ebp+nA], 0 ; nA=0
cmp [ebp+nA], 0 ; compare nA with 0
jge short GE ; if (nA >= 0) then goto GE
mov [ebp+nB], -5 ; if (nA < 0) then nB=-5
jmp short Handle
GE:
xor eax, eax ; IT'S KINDA TRICKY, ANY COMMENTS
cmp [ebp+nA], 0 ; OBSERVATIONS WOULD BE WELCOME !!!!
setle al ; if <= then AL=1
dec eax ; EAX-- ;ESPECIALLY ON HOW AND WHY
and eax, 5
mov [ebp+nB], eax
Handle:
mov ecx, [ebp+nB]
mov [ebp+nTmp], ecx ;WHY USE A TEMPORARY VARIABLE ?
mov edx, [ebp+nTmp] ; store nB to EDX
push edx ; pass nB as parameter of _printf
push offset aD ; "%d\n"
call _printf ; print out the value
add esp, 8 ; restore stack
xor eax, eax ; set return value to 0
mov esp, ebp ; restore stack pointer
pop ebp ; retore EBP with original value
retn ; return
_main endp

my question is: 1) refer to the comment parts
2) was it any good, probably for the optimization purpose ?
3) what kinda logic style would you prefer ?
4) if asked, how would you write this program in assembly ?

[Nudge]

sugaray wrote:

and after disassembled, it became

It seems that your questions would be more appropriate in
comp.lang.asm.x86 instead of comp.lang.c

[Jens.Toerring]

sugaray <ru****@sohu.com> wrote:

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 #include <stdio.h> int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;
This branch never can be taken, whatever value 'a' has.
printf("%d\n",b);

return 0;
}

You don't need to look at the disassembled code to optimize this
program, just write it as

#include <stdio.h>
#include <stdlib.h>

int main( void )
{
puts( "5" );
return EXIT_SUCCESS;
}

which is all it boils down to. And that's what a clever compiler with
optimization should easily find out. But to what kind of machine code
the compiler translates your program to is off-topic on clc.

Regards, Jens
--
_ _____ _____
| ||_ _||_ _| Je***********@physik.fu-berlin.de
_ | | | | | |
| |_| | | | | | http://www.physik.fu-berlin.de/~toerring
\___/ens|_|homs|_|oerring

[Martin Ambuhl]

sugaray wrote a question about micro-optimization with <ot>assembly code
inspection</ot>:

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077

#include <stdio.h>

int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;

I cannot believe that someone who would write the above gives a rat's ass
about optimization. If !(a<0) then (a>=0). That means that the above
conditionals collapse to
if (a < 0) b = -5; else b = 5;
or
b = (a < 0) ? -5 : 5 ;

The second 'if' is useless, as is the second 'else'.
--
Martin Ambuhl

[Thomas Matthews]

Martin Ambuhl wrote:

sugaray wrote a question about micro-optimization with <ot>assembly code
inspection</ot>:

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077

#include <stdio.h>

int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;

I cannot believe that someone who would write the above gives a rat's
ass about optimization. If !(a<0) then (a>=0). That means that the
above conditionals collapse to
if (a < 0) b = -5; else b = 5;
or
b = (a < 0) ? -5 : 5 ;

The second 'if' is useless, as is the second 'else'.

One could simplify even futher.
Given that a==0 and not altered in the main() function,
the result is:
b = 5
So, the program can be simplified to:
int main(void)
{
int b = 5;
printf("%d\n",b);

return 0;
}

or just:
int main(void)
{
printf("5\n", b);
return 0;
}

Since none of printf's formatting functions are used,
this is simplified as:
int main(void)
{
puts("5");
return 0;
}

Hmm, is this what the compiler finally generated???

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book

[Thomas Matthews]

sugaray wrote:

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077

#include <stdio.h>

int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;

printf("%d\n",b);

return 0;
}

Let's talk optimization here.
Since the variable 'a' is not changed after its assignment,
the compiler is free to set b to 5.

Otherwise, note that the opposite of "<" is ">=", so
that the final else clause (b = 0;) will never be executed.
Thus your program is reduced to:
int main(void)
{
int a = 0;
int b;

if (a < 0)
b = -5;
else
b = 5;
printf("%d\n", b);
return 0;
}

The 'if' statement may be replaced by a condition statement:
b = (a < 0) ? -5 : 5;
Plugging in the above replacement, the program is reduced to:
int main(void)
{
int a = 0;
b = (a < 0) ? -5 : 5;
printf("%d\n", b);
return 0;
}

Since the variable 'b' is not modified between the assignment
and the printf, the right-hand side of the assignement can
be substituted into the printf call:
int main(void)
{
int a = 0;
printf("%d\n", ((a < 0) ? -5 : 5));
return 0;
}

As you can see, there are various stages in the optimization
process. Your compiler is allowed to generate any one of
them (or any other equivalent functionality) before generating
the assembly language listing.

The variable 'a' is not altered in the program, so here is
my final optimization:
int main(void)
{
printf("%d\n", 5);
return 0;
}

The printf statement can be replaced by a call to the simpler
function puts since the argument to "printf" is constant and
the formatting string does not change. But I think that is
becoming a bit too pedantic.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book

[CBFalconer]

Thomas Matthews wrote:

.... snip ...
The variable 'a' is not altered in the program, so here is
my final optimization:
int main(void)
{
printf("%d\n", 5);
return 0;
}

The printf statement can be replaced by a call to the simpler
function puts since the argument to "printf" is constant and
the formatting string does not change. But I think that is
becoming a bit too pedantic.

Nah. However I prefer reduction to:

#include <stdio.h>
int main(void) {putchar('5'); putchar('\n'); return 0}

which might well generate a significantly smaller load module.
Try it and see.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Mike Wahler]

"Thomas Matthews" <Th**********************@sbcglobal.net> wrote in message
news:7M*******************@newssvr32.news.prodigy. com...

Martin Ambuhl wrote:

sugaray wrote a question about micro-optimization with <ot>assembly code
inspection</ot>:

Hi folks, I wrote the following C code, and compiled using
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077

#include <stdio.h>

int main(void) {
int a=0;
int b;

if(a<0) b=-5;
else if(a>=0) b=5;
else b=0;

I cannot believe that someone who would write the above gives a rat's
ass about optimization. If !(a<0) then (a>=0). That means that the
above conditionals collapse to
if (a < 0) b = -5; else b = 5;
or
b = (a < 0) ? -5 : 5 ;

The second 'if' is useless, as is the second 'else'.

One could simplify even futher.
Given that a==0 and not altered in the main() function,
the result is:
b = 5
So, the program can be simplified to:
int main(void)
{
int b = 5;
printf("%d\n",b);

return 0;
}

or just:
int main(void)
{
printf("5\n", b);
return 0;
}

Since none of printf's formatting functions are used,
this is simplified as:
int main(void)
{
puts("5");

putchar('5');

:-)

return 0;
}

-Mike

[goose]

Thomas Matthews <Th**********************@sbcglobal.net> wrote in message news:<7M*******************@newssvr32.news.prodigy .com>...

<snipped>

or just:
int main(void)
{
printf("5\n", b);

itym
printf ("5\n");

<snipped>

goose,

[Irrwahn Grausewitz]

"Mike Wahler" <mk******@mkwahler.net> wrote:

"Thomas Matthews" <Th**********************@sbcglobal.net> wrote:

int main(void)
{
puts("5");
putchar('5');

:-)

followed by:

putchar( '\n' );

or

fflush( stdout );

;-)

return 0;
}

--
Irrwahn
(ir*******@freenet.de)

[Alan Balmer]

On Tue, 18 Nov 2003 11:41:20 +0100, Irrwahn Grausewitz
<ir*******@freenet.de> wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote:

"Thomas Matthews" <Th**********************@sbcglobal.net> wrote:

>
> int main(void)
> {
> puts("5");

putchar('5');

:-)

followed by:

putchar( '\n' );

or

fflush( stdout );

;-)

> return 0;
> }

Exiting the program will surely flush the buffer. Even if the standard
doesn't say so :-)
--
Al Balmer
Balmer Consulting
re************************@att.net

[Dan Pop]

In <93********************************@4ax.com> Alan Balmer <al******@att.net> writes:

Exiting the program will surely flush the buffer. Even if the standard
doesn't say so :-)

The standard does say so.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Irrwahn Grausewitz]

Alan Balmer <al******@att.net> wrote:

On Tue, 18 Nov 2003 11:41:20 +0100, Irrwahn Grausewitz wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote:

"Thomas Matthews" <Th**********************@sbcglobal.net> wrote:
> int main(void)
> {
> puts("5");
putchar('5');
followed by:
putchar( '\n' );
or
fflush( stdout );

> return 0;
> }

Exiting the program will surely flush the buffer.

Err, stupid me; yes, you're right.
Even if the standard
doesn't say so :-)

Oh, it does:
in ISO/IEC 9899:1999 5.1.2.2.3, by reference to 7.20.4.3.

However, there's still the problem that it's implementation defined
if the last line of output requires a terminating new-line character
for text streams. Reference: 7.19.2#2

IMHO that makes

putchar( '5' ); putchar( '\n' );
or
puts( "5" );
or
printf( "5\n" );

portable alternatives here.

;-D

Regards
--
Irrwahn
(ir*******@freenet.de)