C extension helpful for JITs

[dibyendumajumdar]

Hi @vnmakarov

I see that there is one test that uses the jcall/jret - but it is not clear to me whether it can be used the following way.

When I generate JITed code in C, there are often repeated chunks of code - but this is inserted linearly in the code.
What would be nice is the ability to move these chunks to common chunks - and be able to jump to them and back within the context of the current function.

That is suppose we could define:

int JIT()
{
   int a, b;
   int c;

   internal foo() 
   {
     c=a+b;
   }


  foo();
  ...

  foo();
}

Here foo() is just a reusable piece of code, and is not a function in its own right. In particular - it can access vars in the enclosing function.
When we call foo() - all we are doing is ensuring that the common code snippet is in one place, rather than duplicated inline as it would have been.

I don't know if I explained this well, or if this is even possible to do.

Regards

[dibyendumajumdar]

Here the code in foo() is essentially "inline" code - but moved to a common location.
It does mean that whatever registers etc this code uses has got to be the same everywhere it is called.
Also foo() is not a proper function so it cannot define local vars, take args or return values; it can access and see the variables that are in the enclosing function.

[vnmakarov]

I think it is possible if all variables referenced inside foo use the same hard regs around each call.
The only way right now to guarantee this is to bind the variables to particular hard regs. So it could look like

static  int a register("r12");
static int b register("r13");
static int c register("r14");
int JIT()
{

   internal foo() 
   {
     c=a+b;
   }


  foo();
  ...

  foo();
}

If there are many such variables, it will constrain the register allocator too much which might result in worse code generation or even impossibility to generate code.

If the variable leaves through some call, it should be bound to caller-saved hard register.

Also jret needs a return address which could be passed to foo too. It could be passed through memory or another variable (bound to some hard reg too).