Re: No decider is ever accountable for the behavior of the computation that itself is contained within DETAILS

On 7/27/2024 3:59 AM, Mad Hamish wrote:

On Fri, 26 Jul 2024 11:28:43 -0500, olcott <polcott333@gmail.com>
wrote:
 

No decider is ever accountable for the behavior of the
computation that itself is contained within.>
It is only accountable for computing the mapping from the
input finite string to the actual behavior that this finite
string specifies.
>

 You might want to actually work on definitions rather than shouting
out word salad

Which definitions do you need?
Computing the mapping from a finite string of x86 machine
language to its actual behavior is the most difficult one.
Because HHH is an x86 emulator it merely emulates its input
including emulating itself emulating its input. That is how
the mapping is computed.
Knowing the semantics of the x86 language is also required, the
best that I can do here is annotate the code. I provide the C
source code to make that easier.
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
   HHH(DDD);
}
int main()
{
   DDD();
}
*H is a termination analyzer based on an x86 emulator*
The only two things that need to be known about HHH is that:
(a) It emulates its input in DebugStep() mode
(b) It stops emulating its input when it seen a
non-terminating behavior pattern.
*Here is the C source code of DDD, HHH and supporting functions*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
*This function switches process context from HHH to DDD*
*to emulate one x86 machine language instruction of DDD*
*then switches back to HHH*
u32  DebugStep(Registers* master_state,
                Registers* slave_state,
                Decoded_Line_Of_Code* decoded) { return 0; }
typedef struct Decoded
{
   u32 Address;
   u32 ESP;          // Current value of ESP
   u32 TOS;          // Current value of Top of Stack
   u32 NumBytes;
   u32 Simplified_Opcode;
   u32 Decode_Target;
} Decoded_Line_Of_Code;
Immediately before an instruction is emulated HHH
searches a scratch build std::vector<Decoded> execution_trace;
Looking for a non-halting behavior pattern.
An x86utm operating system function provides PushBack()
void PushBack(u32 stdvector, u32 data_ptr, u32 size_in_bytes) {}
An x86utm operating system function allocated memory
u32* Allocate(u32 size) { return 0; }
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer