MSX Programming Languages Showdown

Maybe the original test only tests one very narrow thing: can the compiler figure out that it's faster to count to 100 than to 10000, on an 8 bit processor, and that in this particular example it's possible to swap the order of the for loops without changing the output. Based on this test alone, I wouldn't make too many conclusions.

Actually, the fact SDCC is able to revert the loop to gain speed relaying on the fact the counter variable is not used is a very good feature. It makes the asm closer to the one a human would do.
Afterall, SDCC is still in development, Hitech C stopped its development in 2001.

Another possible optimization for SDCC could be to declass the counter variable j to unsigned char: again, once it is not used in the output, you can represent it internally in a more efficient way.

@Marq
Are you involved in the SDCC development ?

[edit]
@ yzi, I agree, the smartest thing is to compute the result offline and print it ;-)
Anyway, I did a quick test on gcc for x86 cmpiling the sample code.
It seems to do the true loop, so I wouldn't ever dare to ask for this level of optimization for a z80 corosscompiler.

4  	void testCode(void) {
0x00401334	push   %ebp
0x00401335	mov    %esp,%ebp
0x00401337	push   %edi
0x00401338	push   %esi
0x00401339	push   %ebx
0x0040133A	sub    $0x1c,%esp
5  		register unsigned int i,j,s;
6  		s = 0;
0x0040133D	mov    $0x0,%ebx
7  		for (i=0;i<10000;i++)
0x00401342	mov    $0x0,%edi
0x00401347	jmp    0x401357 [testCode+35]
0x00401356	inc    %edi
0x00401357	cmp    $0x270f,%edi
0x0040135D	jbe    0x401349 [testCode+21]
8  		  for(j=100;j>0;j--)
0x00401349	mov    $0x64,%esi
0x0040134E	jmp    0x401352 [testCode+30]
0x00401351	dec    %esi
0x00401352	test   %esi,%esi
0x00401354	jne    0x401350 [testCode+28]
9  		    s++;
0x00401350	inc    %ebx
10 		printf("%d\n",s);
0x0040135F	mov    %ebx,0x4(%esp)
0x00401363	movl   $0x403024,(%esp)
0x0040136A	call   0x401bb0 [printf]
11 	}
0x0040136F	add    $0x1c,%esp
0x00401372	pop    %ebx
0x00401373	pop    %esi
0x00401374	pop    %edi
0x00401375	pop    %ebp
0x00401376	ret

Quoting myself from a previous post:

"Well, I didn't mean this experiment as any conclusive test – just a fun one-afternoon test run of different compilers."

There are plenty of better test cases available all around the web, although many of them might rely on functionality (long ints, multiplications and so on) that aren't native to Z80. Tweaking the code to get better performance is kind of beside the point. For the sake of it, we could implement a bit more realistic open task or a set of tasks which would include at least:

• Nested loops
• Conditional jumps
• Array indexing
• Basic math
• Function calls

Can't make it awfully complex if it's to work with BASIC, too, so need to leave out structs etc.

If you publish a test suite I can run it on the Hitech cross compiler

PS
The unsigned char trick works very well for Hitech cross compiler. This code:

void testCode(void) {
	register unsigned char j;
	register unsigned int i,s;
	s = 0;
	for (i=10000;i;i--)
	  for(j=100;j;j--)
	    s++;
	printf("%d\n",s);
}

runs in 11 seconds (696 ticks) and corresponds to this asm:

    7   0000'                   _testCode:
    8                           ;main.c: 8: register unsigned char j;
    9                           ; _s allocated to de
   10   0000' 11 0000           	ld	de,0
   11                           ;main.c: 11: for (i=10000;i;i--)
   12                           ; _i allocated to bc
   13   0003' 01 2710           	ld	bc,02710h
   14   0006' 18 0B             	jp	l8
   15   0008'                   l5:
   16                           ;main.c: 12: for(j=100;j;j--)
   17                           ; _j allocated to l
   18   0008' 2E 64             	ld	l,064h
   19   000A' 18 02             	jp	l12
   20   000C'                   l9:
   21                           ;main.c: 13: s++;
   22   000C' 13                	inc	de
   23   000D' 2D                	dec	l
   24   000E'                   l12:
   25   000E' 7D                	ld	a,l
   26   000F' B7                	or	a
   27   0010' 20 FA             	jp	nz,l9
   28   0012' 0B                	dec	bc
   29   0013'                   l8:
   30   0013' 78                	ld	a,b
   31   0014' B1                	or	c
   32   0015' 20 F1             	jp	nz,l5
   33                           ;main.c: 14: printf("%d\n",s);
   34   0017' D5                	push	de
   35   0018' 21 0000'          	ld	hl,u19
   36   001B' E5                	push	hl
   37   001C' CD 0000*          	call	_printf
   38   001F' C1                	pop	bc
   39   0020' C1                	pop	bc
   40                           ;main.c: 15: }
   41   0021' C9                	ret	

yes, it forces the compiler to not reuse the value of variable in registers but to retrive it from ram

PS
a large collection of C compilers for z80
http://www.z80.eu/c-compiler.html