Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES

On 6/19/2024 3:36 AM, Mikko wrote:

On 2024-06-18 18:55:21 +0000, olcott said:
 

On 6/18/2024 11:05 AM, Mikko wrote:

On 2024-06-18 12:57:21 +0000, olcott said:
 

On 6/18/2024 3:03 AM, Mikko wrote:

On 2024-06-17 13:03:56 +0000, olcott said:
 

On 6/17/2024 2:20 AM, Mikko wrote:

On 2024-06-16 12:47:09 +0000, olcott said:
 

On 6/16/2024 2:53 AM, Mikko wrote:

On 2024-06-15 16:22:09 +0000, olcott said:
 

On 6/13/2024 8:24 PM, Richard Damon wrote:
 > On 6/13/24 11:32 AM, olcott wrote:
 >>
 >> It is contingent upon you to show the exact steps of how H computes
 >> the mapping from the x86 machine language finite string input to
 >> H(D,D) using the finite string transformation rules specified by
 >> the semantics of the x86 programming language that reaches the
 >> behavior of the directly executed D(D)
 >>
 >
 > Why? I don't claim it can.
 The first six steps of this mapping are when instructions
at the machine address range of [00000cfc] to [00000d06]
are simulated/executed.
 After that the behavior of D correctly simulated by H diverges
from the behavior of D(D) because the call to H(D,D) by D
correctly simulated by H cannot possibly return to D.
 _D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]

 When you put "V2" or "V3" or something similar on the subject line
you should tell what is different from the original version.
 

 I ask what are the steps
I provide 6 steps and then ask what are the next steps.
I provide all of the steps.

 In which version?
 

 *This is the simplest possible version*
 void DDD()
{
   H0(DDD);
}
 After six steps of DDD are correctly emulated by H0
what machine address of DDD would it be at?
 _DDD()
[00001fd2] 55               push ebp      ; housekeeping
[00001fd3] 8bec             mov ebp,esp   ; housekeeping
[00001fd5] 68d21f0000       push 00001fd2 ; push DDD
[00001fda] e8f3f9ffff       call 000019d2 ; call H0
[00001fdf] 83c404           add esp,+04   ; housekeeping
[00001fe2] 5d               pop ebp       ; housekeeping
[00001fe3] c3               ret           ; return to caller
Size in bytes:(0018) [00001fe3]

 So how is this a difference between the original version and V2 and V3?
 

 No params thus easier to see that it pushes its own machine address.

 My question is still unanswered.
 

 When I answer the question that the difference
is that one of them had parameters and the other one
does not have parameters it is dishonest of you
to say that I did not answer the question.

 The qestion is not answered until you say which of the three versions
has parameters and which has not and how the third one differs from
the one that has parameters and from the one that nas not.
 

 typedef void (*ptr)();
int H0(ptr P);
int H(ptr P, ptr I);
 void DDD()
{
   H0(DDD);
}
 void DDDD(ptr x)
{
   H(x,x);
}
 That seems to be saying that you don't know enough about the C
programming language to know what a parameter is thus cannot
tell the difference between DDD that has no parameters and DDDD
that had one parameter.