Inefficient stack usage

[Hiroshi Shimamoto]

Hello,

I noticed that the stack usage of the code gcc-4.x generated looks inefficient
on x86 and x86_64. I found this looking the assemble code of Linux kernel.
Is this inefficient stack usage a regression?
I made a simple test case.

test.c:
#define copy_from_asm(x, addr, err)	\
asm volatile(				\
	"1:\tmovl %2, %1\n"		\
	"2:\n"				\
	".section .fixup,\"ax\"\n"	\
	"\txor %1,%1\n"			\
	"\tmov $1,%0\n"			\
	"\tjmp 2b\n"			\
	".previous\n"			\
	: "=r" (err), "=r" (x)		\
	: "m" (*(int*)(addr)))

#define copy_from(x, addr, err)	do {		\
	(err) = 0;				\
	copy_from_asm((x), (addr), (err));	\
} while (0)

#define copy(x, addr)	({		\
	int __err;			\
	copy_from((x), (addr), __err);	\
	__err;				\
})

int src[32];
int dst[32];

#define my_copy(x)	do { err |= copy(dst[x], &src[x]); } while (0)

int test(void)
{
	int err = 0;

	my_copy( 0); my_copy( 1); my_copy( 2); my_copy( 3);
	my_copy( 4); my_copy( 5); my_copy( 6); my_copy( 7);
	my_copy( 8); my_copy( 9); my_copy(10); my_copy(11);
	my_copy(12); my_copy(13); my_copy(14); my_copy(15);
	my_copy(16); my_copy(17); my_copy(18); my_copy(19);
	my_copy(20); my_copy(21); my_copy(22); my_copy(23);
	my_copy(24); my_copy(25); my_copy(26); my_copy(27);
	my_copy(28); my_copy(29); my_copy(30); my_copy(31);

	return err;
}

I compiled this gcc-3.4.6, 4.2.4, 4.3.2 and 4.4.0-20081205 with compile
option "-g -Os -mno-red-zone".
The code size of objects below.
$ size test.o.*
   text	   data	    bss	    dec	    hex	filename
    879	      0	      0	    879	    36f	test.o.34
   1085	      0	      0	   1085	    43d	test.o.42
   1061	      0	      0	   1061	    425	test.o.43
   1137	      0	      0	   1137	    471	test.o.44

gcc-3.4.6 generates
   0:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 6 <test+0x6>
   6:	89 15 00 00 00 00    	mov    %edx,0x0(%rip)        # c <test+0xc>
   c:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 12 <test+0x12>
  12:	89 15 00 00 00 00    	mov    %edx,0x0(%rip)        # 18 <test+0x18>
  18:	09 c8                	or     %ecx,%eax
  1a:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 20 <test+0x20>
  20:	89 15 00 00 00 00    	mov    %edx,0x0(%rip)        # 26 <test+0x26>
  26:	09 c8                	or     %ecx,%eax
  28:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 2e <test+0x2e>
  2e:	89 15 00 00 00 00    	mov    %edx,0x0(%rip)        # 34 <test+0x34>
  34:	09 c8                	or     %ecx,%eax
...

and gcc-4.2 generates
   0:	41 57                	push   %r15
   2:	41 56                	push   %r14
   4:	41 55                	push   %r13
   6:	41 54                	push   %r12
   8:	55                   	push   %rbp
   9:	53                   	push   %rbx
   a:	48 83 ec 48          	sub    $0x48,%rsp
   e:	8b 05 00 00 00 00    	mov    0x0(%rip),%eax        # 14 <test+0x14>
  14:	89 14 24             	mov    %edx,(%rsp)
  17:	89 05 00 00 00 00    	mov    %eax,0x0(%rip)        # 1d <test+0x1d>
  1d:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 23 <test+0x23>
  23:	89 15 00 00 00 00    	mov    %edx,0x0(%rip)        # 29 <test+0x29>
  29:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 2f <test+0x2f>
...
 1d8:	0b 44 24 04          	or     0x4(%rsp),%eax
 1dc:	0b 44 24 08          	or     0x8(%rsp),%eax
 1e0:	0b 44 24 0c          	or     0xc(%rsp),%eax
 1e4:	0b 44 24 10          	or     0x10(%rsp),%eax
 1e8:	0b 44 24 14          	or     0x14(%rsp),%eax
...

On gcc-4.x error values stored to stack and at last "or" all stored data.
On the other hand gcc-3.4.6, error value is evaluated each time.

Thanks,
Hiroshi