I'm the lead developer on the embedded C++ library at cxx.uclibc.org. I have
g++ use my library through the use of the switches
-fno-builtin -nostdinc++ -nodefaultlibs -I/includedir -L/libdir -lc
I've noticed that the code created when compiled against my library is
different (and larger) than against GNU libstdc++, even when no such
difference should occur. For example, the class:
class base {
protected:
int a;
public:
base() : a(0){
printf("Executing default base class constructor. a: %i\n",
a);
}
virtual ~base(){
printf("Executing base class destructor\n");
}
virtual void print(){
printf("Base class print function with a=%i\n", a);
}
};
Under gcc 4.0 with my library, the code generated for the function
_ZN4baseC2Ev or base::base() is (from objdump):
08048c00 <_ZN4baseC2Ev>:
8048c00: 55 push %ebp
8048c01: 89 e5 mov %esp,%ebp
8048c03: 53 push %ebx
8048c04: 83 ec 14 sub $0x14,%esp
8048c07: e8 2d 04 00 00 call 8049039
<__i686.get_pc_thunk.bx>
8048c0c: 81 c3 38 1a 00 00 add $0x1a38,%ebx
8048c12: 8b 83 30 00 00 00 mov 0x30(%ebx),%eax
8048c18: 8d 50 08 lea 0x8(%eax),%edx
8048c1b: 8b 45 08 mov 0x8(%ebp),%eax
8048c1e: 89 10 mov %edx,(%eax)
8048c20: 8b 45 08 mov 0x8(%ebp),%eax
8048c23: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
8048c2a: 8b 45 08 mov 0x8(%ebp),%eax
8048c2d: 8b 40 04 mov 0x4(%eax),%eax
8048c30: 89 44 24 04 mov %eax,0x4(%esp,1)
8048c34: 8d 83 f0 ea ff ff lea 0xffffeaf0(%ebx),%eax
8048c3a: 89 04 24 mov %eax,(%esp,1)
8048c3d: e8 36 fa ff ff call 8048678 <_init+0x78>
8048c42: 83 c4 14 add $0x14,%esp
8048c45: 5b pop %ebx
8048c46: 5d pop %ebp
8048c47: c3 ret
The code generated against libstdc++ is:
08048ae2 <_ZN4baseC2Ev>:
8048ae2: 55 push %ebp
8048ae3: 89 e5 mov %esp,%ebp
8048ae5: 83 ec 08 sub $0x8,%esp
8048ae8: ba 88 8f 04 08 mov $0x8048f88,%edx
8048aed: 8b 45 08 mov 0x8(%ebp),%eax
8048af0: 89 10 mov %edx,(%eax)
8048af2: 8b 45 08 mov 0x8(%ebp),%eax
8048af5: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
8048afc: 8b 45 08 mov 0x8(%ebp),%eax
8048aff: 8b 40 04 mov 0x4(%eax),%eax
8048b02: 89 44 24 04 mov %eax,0x4(%esp,1)
8048b06: c7 04 24 94 8f 04 08 movl $0x8048f94,(%esp,1)
8048b0d: e8 3a fa ff ff call 804854c <_init+0x68>
8048b12: c9 leave
8048b13: c3 ret
The noticable difference is that the code generated against my library calls
<__i686.get_pc_thunk.bx>, plus additional setup code for a total of 20
additional bytes. Now this is very small, but when generating code for
embedded systems, 20 bytes time hundreds of functions becomes an issue.
Please advise on why this difference is occuring and what I can do to avoid
this occurance.
- Garrett Kajmowicz
