XPost: comp.theory, sci.logic
From: polcott333@gmail.com
On 7/29/2025 11:22 PM, Alan Mackenzie wrote:
> In comp.theory olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
>
>> It is not any lack of technical ability that determines
>> whether or not DDD correctly simulated by HHH can or
>> cannot reach its own "return" instruction final halt state.
>
> It is a lack of technical ability on your part which is unable to judge
> whether such a correct simulation is possible. Everybody else sees that
> it is not, so further questions about it are non-sensical.
>
The notion of cooperative multi-tasking should be fully
understood by anyone with a computer science degree. If
most people here have much less than that then this may
be very difficult to understand.
https://en.wikipedia.org/wiki/Cooperative_multitasking
I wrote a time slicing x86 function for the original
MSDOS 3.0. This required intercepting the clock interrupt.
I did a lot of interrupt intercept programming back in
the 1980's.
I used this to create the Software Master program that
enabled one program to control another through the command
line interface. Much more powerful than a DOS batch file
because it could see the text on the display screen at
the B800:0000H fixed address. Then MS Windows came out making
Software Master Obsolete.
The x86utm operating system that I wrote uses cooperative
multi-tasking. It enables any C function to emulate the
x86 machine language of another other C function in debug
step mode.
Before it does this it creates a separate simulation
context having its own set of 16 virtual registers and
its own virtual stack.
_DDD()
[0000219e] 55 push ebp
[0000219f] 8bec mov ebp,esp
[000021a1] 689e210000 push 0000219e // push DDD
[000021a6] e843f4ffff call 000015ee // call HHH
[000021ab] 83c404 add esp,+04
[000021ae] 5d pop ebp
[000021af] c3 ret
Size in bytes:(0018) [000021af]
HHH emulates DDD in a separate process context. When
this DDD calls HHH(DDD) the original HHH emulates this
HHH in the DDD process context.
This emulated HHH creates yet another process context
to emulate its own DDD. When this DDD calls yet another
HHH(DDD) this provides enough execution trace that the
repeating pattern can be seen.
*The above is proven right here*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Directly executed HHH emulates DDD that calls an emulated HHH(DDD)
that emulates another DDD instance that calls another HHH(DDD).
machine stack stack machine assembly
address address data code language
======== ======== ======== ========== =============
[000021be][00103872][00000000] 55 push ebp
[000021bf][00103872][00000000] 8bec mov ebp,esp
[000021c1][0010386e][0000219e] 689e210000 push 0000219e // push DDD
[000021c6][0010386a][000021cb] e823f4ffff call 000015ee // call HHH
New slave_stack at:103916
Begin Local Halt Decider Simulation Execution Trace Stored at:11391e
[0000219e][0011390e][00113912] 55 push ebp
[0000219f][0011390e][00113912] 8bec mov ebp,esp
[000021a1][0011390a][0000219e] 689e210000 push 0000219e // push DDD
[000021a6][00113906][000021ab] e843f4ffff call 000015ee // call HHH
New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55 push ebp
[0000219f][0015e336][0015e33a] 8bec mov ebp,esp
[000021a1][0015e332][0000219e] 689e210000 push 0000219e // push DDD
[000021a6][0015e32e][000021ab] e843f4ffff call 000015ee // call HHH
176 pages of the full execution trace are shown here.
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- SoupGate-Win32 v1.05
* Origin: you cannot sedate... all the things you hate (1:229/2)
|
