Re: basic question about runtime query parsing

Laurence Finston wrote:


> On Tue, 26 Jul 2005, Chris Dollin wrote:


>> Run-time code generation eg JIT.
>
> Sorry, I don't know what this is.


JIT - "just in time" code generation - is where you generate the
native code for some program/method just before you run it, or
sometimes, only after you've run it enough times to be convinced that
it's worth it.


> Please correct me if I'm wrong, but I would assume that "code
> generation" means that new code is created, not that existing code
> in memory is overwritten while the program is running.


Generally, yes. But sometimes you want to update existing code. For
example, you may have compiled a call to some method M with a single
definition as a `call address-of-M` instruction. When a later dynamic
load introduces a new definition of M - say, as an over-riding method
in some subclass - you have to either (a) patch the call instructions
to refer to a new (dispatch) method or (b) patch the code at
address-of-M to do additional work.


[You might have chosen to do some kind of indirect call instead,
  but then when M is never overridden every call is paying a penalty.
  It All Depends.]


Or consider garbage-collecting dead methods. If you relocate the
remaining methods, you may well have to patch them with new
addresses. If you don't, you may want to re-use the empty space where
the dead methods lived.


Even if you're not garbage-collecting, you may have a situation where
the efficient solution to your problem is to generate specialised
code, execute it, and discard it, re-using the space for the next
chunk of specialised code. I have this vague recall of ... live code
generation for fast bitblts? ... from multiple years ago.


So you may not /have/ to do self-modifying code. But it may be a
reasonable solution to a problem.


--
Chris "electric hedgehog" Dollin
predicting self-predictors' predictions is predictably unpredictable.

Return to the comp.compilers page.
Search the comp.compilers archives again.