Hello Ian,
If the casting is done in the callee function (and not in the caller
function), my program is reduced by 5%.
I think that all the users compiling with -Os option will be please to
implement the casting inside the callee function.
What is your feeling?
Laurent
On 25/10/2010 14:59, Jorge PEREZ wrote:
> Hello Laurent & Ian
>
> I'm actually very interested in the point you're making here.
>
> I checked the example in the first Laurent's email and I agree with the
> fact that for embedded systems, where code size is critical, the cast on
> the callers side (rather than the callee's) seems not very helpful.
>
> The compilation of the test using LLVM (not sure it's a good enough
> reference but that's all I got) gives the following results
>
> ------------------------> C code:
>
> short somme(char a, short b){
> int i;
> for (i=0; i<b; i++){
> a+=a;
> }
> return a+b;
> }
>
> short somme2(char a, short b){
> int i;
> for (i=0; i<b; i++){
> a+=b;
> }
> return a+2*b;
> }
>
> int main(){
> volatile short b=1;
> volatile char a=1, c=1;
> b=somme(a,b);
> b=somme(c,b);
> b=somme(a,c);
> b=somme2(a,b);
> b=somme2(c,b);
> b=somme2(a,c);
> b=somme2(a,c*2);
> b=somme2(a,c*3);
> b=somme2(a,c*4);
> return 0;
> }
>
>
> ------------------------> GCC 3.4.4 partial dissassembly:
>
> 40001168 <somme>:
> 40001168: 83 2a 60 10 sll %o1, 0x10, %g1
> 4000116c: 83 38 60 10 sra %g1, 0x10, %g1
> 40001170: 80 a0 60 00 cmp %g1, 0
> 40001174: 24 80 00 06 ble,a 4000118c <somme+0x24>
> 40001178: 91 2a 20 18 sll %o0, 0x18, %o0
> 4000117c: 82 80 7f ff addcc %g1, -1, %g1
> 40001180: 12 bf ff ff bne 4000117c <somme+0x14>
> 40001184: 90 02 00 08 add %o0, %o0, %o0
> 40001188: 91 2a 20 18 sll %o0, 0x18, %o0
> 4000118c: 91 3a 20 18 sra %o0, 0x18, %o0
> 40001190: 90 02 00 09 add %o0, %o1, %o0
> 40001194: 91 2a 20 10 sll %o0, 0x10, %o0
> 40001198: 81 c3 e0 08 retl
> 4000119c: 91 3a 20 10 sra %o0, 0x10, %o0
>
> 400011e4 <main>:
> 400011e4: 9d e3 bf 90 save %sp, -112, %sp
> 400011e8: 82 10 20 01 mov 1, %g1
> 400011ec: c2 37 bf f6 sth %g1, [ %fp + -10 ]
> 400011f0: c2 2f bf f5 stb %g1, [ %fp + -11 ]
> 400011f4: c2 2f bf f4 stb %g1, [ %fp + -12 ]
> 400011f8: d0 0f bf f5 ldub [ %fp + -11 ], %o0
> ******************** 1
> 400011fc: d2 17 bf f6 lduh [ %fp + -10 ], %o1
> ******************** 2
> 40001200: 91 2a 20 18 sll %o0, 0x18, %o0
> ******************** 3
> 40001204: 93 2a 60 10 sll %o1, 0x10, %o1
> ******************** 4
> 40001208: 93 3a 60 10 sra %o1, 0x10, %o1
> ******************** 5
> 4000120c: 7f ff ff d7 call 40001168 <somme>
> ******************** 6
> 40001210: 91 3a 20 18 sra %o0, 0x18, %o0
> ******************** 7
> 40001214: d0 37 bf f6 sth %o0, [ %fp + -10 ]
> ******************** 8
> 40001218: d0 0f bf f4 ldub [ %fp + -12 ], %o0
> 4000121c: d2 17 bf f6 lduh [ %fp + -10 ], %o1
> 40001220: 91 2a 20 18 sll %o0, 0x18, %o0
> 40001224: 93 2a 60 10 sll %o1, 0x10, %o1
> 40001228: 93 3a 60 10 sra %o1, 0x10, %o1
> 4000122c: 7f ff ff cf call 40001168 <somme>
> 40001230: 91 3a 20 18 sra %o0, 0x18, %o0
> 40001234: d0 37 bf f6 sth %o0, [ %fp + -10 ]
> 40001238: d0 0f bf f5 ldub [ %fp + -11 ], %o0
> 4000123c: d2 0f bf f4 ldub [ %fp + -12 ], %o1
> ...
>
> ------------------------> LLVM partial dissassembly:
>
> Disassembly of section .text:
>
> 00000000 : --> This would be
> the "somme" function
> 0: 9d e3 bf a0 save %sp, -96, %sp
> 4: a0 a6 60 01 subcc %i1, 1, %l0
> 8: 06 80 00 10 bl 48
> c: 01 00 00 00 nop
> 10: 10 80 00 02 b 18
> 14: 01 00 00 00 nop
> 18: a0 10 00 19 mov %i1, %l0
> 1c: a2 10 00 18 mov %i0, %l1
> 20: a2 0c 60 ff and %l1, 0xff, %l1
> 24: a2 04 40 18 add %l1, %i0, %l1
> 28: a5 2c 60 18 sll %l1, 0x18, %l2
> 2c: b1 3c a0 18 sra %l2, 0x18, %i0
> 30: a0 04 3f ff add %l0, -1, %l0
> 34: a4 a4 20 00 subcc %l0, 0, %l2
> 38: 12 bf ff fa bne 20
> 3c: 01 00 00 00 nop
> 40: 10 80 00 02 b 48
> 44: 01 00 00 00 nop
> 48: a0 06 00 19 add %i0, %i1, %l0
> 4c: a1 2c 20 10 sll %l0, 0x10, %l0
> 50: b1 3c 20 10 sra %l0, 0x10, %i0
> 54: 81 e8 00 00 restore
> 58: 81 c3 e0 08 retl
> 5c: 01 00 00 00 nop
>
> 000000cc :
> cc: 9d e3 bf 98 save %sp, -104, %sp
> d0: a0 10 20 01 mov 1, %l0
> d4: e0 37 bf fe sth %l0, [ %fp + -2 ]
> d8: e0 2f bf fd stb %l0, [ %fp + -3 ]
> dc: e0 2f bf fc stb %l0, [ %fp + -4 ]
> e0: d0 4f bf fd ldsb [ %fp + -3 ], %o0 ******************** 1
> e4: d2 57 bf fe ldsh [ %fp + -2 ], %o1 ******************** 2
> e8: 40 00 00 00 call e8 ******************** 3
> ec: 01 00 00 00 nop ******************** 4
> f0: d0 37 bf fe sth %o0, [ %fp + -2 ]
> f4: d0 4f bf fc ldsb [ %fp + -4 ], %o0
> f8: d2 57 bf fe ldsh [ %fp + -2 ], %o1
> fc: 40 00 00 00 call fc
> 100: 01 00 00 00 nop
> 104: d0 37 bf fe sth %o0, [ %fp + -2 ]
> 108: d0 4f bf fd ldsb [ %fp + -3 ], %o0
> 10c: d2 4f bf fc ldsb [ %fp + -4 ], %o1
> 110: 40 00 00 00 call 110
> 114: 01 00 00 00 nop
> 118: d0 37 bf fe sth %o0, [ %fp + -2 ]
> ...
>
>
> A couple observations from this:
>
> - in the case of LLVM only 4 instructions (the NOP is a waste since the
> delay slot is not correctly implemented) are required per call (since
> the cast is on the callee side).
> - in the case of GCC there are 8 instructions required due to the
> duplication of the cast in the caller and the callee.
>
> Based on this, it seems quite interesting to KEEP the cast only in the
> CALLEE's side rather than the caller's. Since there are 9 calls in the
> main, this requires 9*8=47 instructions with GCC, whereas it only
> requires 9*4=36 instructions using LLVM, this is a huge difference when
> code size matters. I guess we can assume that in the callee's side the
> code size is similar in both cases since a casting is always performed.
>
> In conclusion, the SPARC code size could be reduced by approx. (4
> instructions) x (number of calls) if the cast is done exclusively on the
> CALLEE's side. So, is it really necessary to keep it on the caller's
> side or can we try to do it only on the callee's side?
>
>
> PS: since I work with LEON, I permitted myself to put in CC the guys
> concerned by this thread http://gcc.gnu.org/ml/gcc/2010-09/msg00014.html
> I hope it doesn't bother anyone
>
> Have a good day,
>
>
> George
>
>
>
> Ian Lance Taylor wrote:
>
>> laurent <laurent.poche@xxxxxxxxx> writes:
>>
>>
>>
>>> When a caller function calls a callee function with short or char
>>> arguments, the arguments are casted twice: inside the caller function
>>> and inside the callee function, see the example. It is a waste of
>>> performance in code density and speed!
>>>
>>> I don't understand why there is a double casting. Is there any
>>> optimization I could activate in GCC to remove it?
>>>
>>>
>> It's basically a bug. gcc should only do it on the caller side. Doing
>> it on the callee side is a holdover from the good pre-C90 days, when
>> code like
>>
>> int f(i)
>> char i;
>> {
>> ...
>> }
>>
>> had to be treated as equivalent to
>>
>> int f(int passed_i)
>> {
>> char i = (char) passed_i;
>> ...
>> }
>>
>> These days I think we can just drop the cast on the callee side. As I
>> recall that was done for x86 a while back, somebody just needs to do it
>> for SPARC.
>>
>> Please file a bug report according to the instructions at
>> http://gcc.gnu.org/bugs/ (unless there is already a bug report for
>> this). Thanks.
>>
>> Ian
>>
>>
>>
>
