Re: [Qemu-devel] Re: [PATCH] Updated Sparc support

[Fabrice Bellard <fabrice.bellard@free.fr>]

Rusty Russell wrote:
> In message <3EC0E59A.5070907@free.fr> you write:
> 
>>I also plan to add direct block chaining. I will try to make it portable 
>>by using the 'goto *' gcc extension, but I don't know yet if it will 
>>work on every CPU. The direct block chaining will generate something like:
>>
>>  'goto *addr'
>>
>>at the end of some translated blocks to jump either to the CPU core or 
>>directly to the next translated block. 'addr' will be a global 'void *' 
>>variable. Since no code will be patched to change block chaining, it 
>>will simplify the instruction cache invalidation issues and the 
>>threading issues.
> 
> 
> Hmm, I had a more ambitious idea, and that was to keep simple stats on
> which block last followed each block: if it goes to the same block
> more than N times in a row, coalesce/chain them.
> 
> As blocks get longer, you have more opportunities for register
> lifetime analsis, which could eliminate redundant stores to registers
> in particular.
> 
> I haven't got actual code, so I haven't mentioned it before...
> 
> Thoughts?

It could be interesting to avoid some condition codes computations. 
Currently it is not possible to do more because qemu has no generic IR 
and I think I won't have the time to add one. Julian Seward (of the 
valgrind project) is thinking about adding a more generic IR in valgrind 
to allow cross debugging, so it might be interesting for valgrind.

BUT, I have a much simpler approach "a la FX!32" which has the advantage 
of being very simple and which needs very little modification in qemu:

You can launch your executable a first time to record statistics. Then 
you launch a special tool 'qemuopt' which statically generates a dynamic 
library with gcc containing the host cpu code of the most used basic 
block chains.

'qemuopt' is very easy to do : I discovered that by noting that gcc 
optimizes very well 'static inline' local functions. So you just have to 
generate a C source containing approximately:

void genfunc(CPUX86State *env)
{
     uint32_t T0, EAX, EBX, ...;

     EAX = env->regs[R_EAX];
     EBX = env->regs[R_EBX];

#define OPPROTO 'static inline'
#include "op-i386.c"

     op_movl_T0_EAX();
     op_movl_EBX_T0();

     env->regs[R_EAX] = EAX;
     env->regs[R_EBX] = EBX;
}

Then gcc does all the hard work for us :-)

Fabrice.