XPost: comp.theory, comp.lang.c++   
   From: dbush.mobile@gmail.com   
      
   On 11/12/2025 9:30 PM, olcott wrote:   
   > On 11/12/2025 8:16 PM, Kaz Kylheku wrote:   
   >> On 2025-11-12, olcott  wrote:   
   >>   
   >> You aren't doing that, by the way, in the latest   
   >> Needs_To_Be_Aborted_Trace_HH:   
   >   
   > *This is a FOREVER thing until someone admits the truth*   
   > *This is a FOREVER thing until someone admits the truth*   
   > *This is a FOREVER thing until someone admits the truth*   
   >   
   > int D()   
   > {   
   >    int Halt_Status = H(D);   
   >    if (Halt_Status)   
   >      HERE: goto HERE;   
   >    return Halt_Status;   
   > }   
   >   
   > Everyone here rejects that the execution trace   
   > of 5 statements of D simulated by H according to   
   > the semantics of C is this:   
   >   
   > (1)    H simulates D that calls H(D)   
   > (2) that simulates D that calls H(D)   
   > (3) that simulates D that calls H(D)   
   > (4) that simulates D that calls H(D)   
   > (5) that simulates D that calls H(D)   
      
   That the above make no attempt to explain why the below is wrong   
   constitutes your admission that the below is correct.   
      
   >   
   >>      if (current->Simplified_Opcode == CALL)   
   >>        if (current->Simplified_Opcode == traced->Simplified_Opcode)  // CALL   
   >>          if (current->Address == traced->Address)              // from same   
   address   
   >>            if (current->Decode_Target == traced->Decode_Target)// to Same   
   Function   
   >>              if (Count_Conditional_Branch_Instructions == 0)   // no escape   
   >>   
   >> It's just checking for repeated "CALL HHH".   
   >>   
   >> The CALL in struction doesn't include the arguments; they have to be   
   >> prepared in registers or pushed onto the stack (or both), depending on   
   >> the calling conventions.   
   >>   
   >> I imagine you tried doing that but ran into the problem that since   
   >> you are idiotically conflating multiple execution traces,   
   >>   
   >> The trace for the PUSH instruction which prepares the argument   
   >> for the CALL, in the Level [2] simulation will be separated   
   >> from its CALL by all the instruction traces of the DebugStep   
   >> loop of Level[1]!   
   >>   
   >> The Level[1] loop, itself being simulated, has to DebugStep a PUSH   
   >> instruction that prepares an argument. Then it has to go all way around   
   >> its loop, during which time execution traces are being looged for it.   
   >> Then it has to DebugStep the CALL instruction.   
   >>   
   >> If you did not conflate the instruction eents into a single buffer,   
   >> you could easily find the previous PUSH instruction for a given   
   >> CALL, in the private trace buffer of /that/ simulation.   
   >>   
   >> (It may be that Mike Terry has implemented that; I've not seen his   
   >> code.)   
   >>   
   >>   
   >>>> But, /all the instructions have to be from the same control flow/.   
   >>>>   
   >>>   
   >>> When DD calls HHH(DD) and HHH simulates DD this   
   >>> control flow is isomorphic to HHH invoking DD.   
   >>   
   >> I'm afraid your knowledge and skills here are limited to being able to   
   >> spell "isomorophic" and use it in a syntactically plausible sentence,   
   >> much like your LLM friends.   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)