Re: Self-modifying code, Function pointers & { Safety, Security}

On Thursday, March 20, 2014 2:42:20 AM UTC-5, seim...@gmail.com wrote:
> I was planning to discontinue self-modifying code entirely.
> For runtime code generation, I was planning to bank entirely
> upon runtime hooks(mapping instructions of an interpreter to
> API hooks).


I think the brunt of the Halting Problem comes down to this very matter and
can probably be summed up in a simple way that there are no finite number of
fixes that completely account for all the things you may want or *need* to do
with self-modifying code. Instead, you have a set of standard "fixes" that
appear to meet most needs (e.g. the "loader" for run-time loading a program,
the "branch prediction" of some CPU's for handling the "nop" to jump
conversion at run-time, the "relocator" for handling "nop" to op at load time,
etc.). But no finite set of "standard fixes" or "utilities" for the various
special cases (nor even an *infinite* set of such fixes, if they are
recursively enumerable) will exhaust all the things you may want or need to
do.


What I'm not sure of is this question: is there way of actually defining
"no-modifying" algorithms that leads to a *positive* resolution for the
halting problem? I suspect there is and that it may be directly tied to the
formalism for linearly bounded automata (the automata for context-sensitive
languages).


Tha halting problem is solvable for linearly bounded automata.

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