Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c++ > #79003 > unrolled thread
| Started by | olcott <NoOne@nospicedham.NoWhere.com> |
|---|---|
| First post | 2021-04-17 09:15 -0500 |
| Last post | 2021-04-17 17:12 -0500 |
| Articles | 17 — 8 participants |
Back to article view | Back to comp.lang.c++
Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 09:15 -0500
Re: Infinite recursion detection criteria (Please correct me if I am MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz - 2021-04-17 15:16 +0000
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 10:22 -0500
Re: Infinite recursion detection criteria (Please correct me if I am MrSpook_ejo78o@4t98owsqx2nlg6yp.com - 2021-04-17 15:32 +0000
Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-17 15:41 +0000
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:02 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:23 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Real Troll <rel.troll@trolls.com> - 2021-04-17 20:38 +0100
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 15:01 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:57 +0000
Re: Infinite recursion detection criteria (dodging the point?) olcott <NoOne@NoWhere.com> - 2021-04-17 15:56 -0500
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 11:01 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@nospicedham.kylheku.com> - 2021-04-17 15:01 +0000
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 17:30 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:58 +0000
Re: Infinite recursion detection criteria (Please correct me if I am Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-18 00:03 +0200
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 17:12 -0500
| From | olcott <NoOne@nospicedham.NoWhere.com> |
|---|---|
| Date | 2021-04-17 09:15 -0500 |
| Subject | Infinite recursion detection criteria (Please correct me if I am |
| Message-ID | <HridnZf_Jp3tcOf9nZ2dnUU7-KfNnZ2d@giganews.com> |
If a function X() is called by function Y() twice in sequence from the same machine address of Y() with the same parameters to X() and the execution trace shows no conditional branch instructions in Y() or function call returns in X() then the function call from Y() to X() is infinitely recursive unless X() stops it. The referenced excution trace is on x86 machine language, disassembled for human consumption. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [next] | [standalone]
| From | MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz |
|---|---|
| Date | 2021-04-17 15:16 +0000 |
| Message-ID | <s5eu3m$o2g$1@gioia.aioe.org> |
| In reply to | #79003 |
On Sat, 17 Apr 2021 09:15:14 -0500 olcott <NoOne@nospicedham.NoWhere.com> wrote: >Copyright 2021 Pete Olcott Pretentious twat.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 10:22 -0500 |
| Message-ID | <m_2dnR2eBu7ZYOf9nZ2dnUU7-aednZ2d@giganews.com> |
| In reply to | #79004 |
On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote: > On Sat, 17 Apr 2021 09:15:14 -0500 > olcott <NoOne@nospicedham.NoWhere.com> wrote: >> Copyright 2021 Pete Olcott > > Pretentious twat. > ad hominem the favorite reply of ignoramuses. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | MrSpook_ejo78o@4t98owsqx2nlg6yp.com |
|---|---|
| Date | 2021-04-17 15:32 +0000 |
| Message-ID | <s5ev1q$15r3$1@gioia.aioe.org> |
| In reply to | #79005 |
On Sat, 17 Apr 2021 10:22:47 -0500 olcott <NoOne@NoWhere.com> wrote: >On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote: >> On Sat, 17 Apr 2021 09:15:14 -0500 >> olcott <NoOne@nospicedham.NoWhere.com> wrote: >>> Copyright 2021 Pete Olcott >> >> Pretentious twat. >> > >ad hominem the favorite reply of ignoramuses. > >Copyright 2021 Pete Olcott > >"Great spirits have always encountered violent opposition from mediocre >minds." Einstein Self aggrandisement, the favourite approach of Dunning-Kruger types.
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-04-17 15:41 +0000 |
| Message-ID | <20210417084019.443@kylheku.com> |
| In reply to | #79005 |
On 2021-04-17, olcott <NoOne@NoWhere.com> wrote: > On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote: >> On Sat, 17 Apr 2021 09:15:14 -0500 >> olcott <NoOne@nospicedham.NoWhere.com> wrote: >>> Copyright 2021 Pete Olcott >> >> Pretentious twat. > > ad hominem the favorite reply of ignoramuses. I see you have not yet read the exellent article: https://laurencetennant.com/bonds/adhominem.html
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 14:02 -0500 |
| Subject | Re: Infinite recursion detection criteria (Please correct me if I am wrong) |
| Message-ID | <ea-dnTKCu759reb9nZ2dnUU7-e_NnZ2d@giganews.com> |
| In reply to | #79007 |
On 4/17/2021 10:41 AM, Kaz Kylheku wrote:
> On 2021-04-17, olcott <NoOne@NoWhere.com> wrote:
>> On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>>> On Sat, 17 Apr 2021 09:15:14 -0500
>>> olcott <NoOne@nospicedham.NoWhere.com> wrote:
>>>> Copyright 2021 Pete Olcott
>>>
>>> Pretentious twat.
>>
>> ad hominem the favorite reply of ignoramuses.
>
> I see you have not yet read the exellent article:
>
> https://laurencetennant.com/bonds/adhominem.html
>
In any case back to the actual point the following <is> confirmed to be
correct halt deciding criteria in the case of infinite recursion.
If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the
execution trace shows no conditional branch instructions in Y() or a
function call returns from X() then the function call from Y() to X() is
infinitely recursive unless X() stops it.
The referenced execution trace is on x86 machine language, disassembled
for human consumption.
When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is
invoking X() in infinite recursion.
On this basis Halts() can stop simulating Y() and report that Y() would
not halt unless its execution was aborted by Halts().
void Y(u32 P)
{
Halts(P, P);
}
int main()
{
Halts((u32)Y, (u32)Y);
}
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 14:23 -0500 |
| Subject | Re: Infinite recursion detection criteria (Please correct me if I am wrong) |
| Message-ID | <XsGdnb9T0vcLqOb9nZ2dnUU7-U_NnZ2d@giganews.com> |
| In reply to | #79007 |
On 4/17/2021 2:14 PM, Kaz Kylheku wrote: > On 2021-04-17, olcott <NoOne@NoWhere.com> wrote: >> On 4/17/2021 1:37 PM, Kaz Kylheku wrote: >>> On 2021-04-17, olcott <NoOne@NoWhere.com> wrote: >>>>> >>>>> "Pretentious twat" is not inherently ad hominem, though it's a personal >>>>> attack. >>>> >>>> It is at the bottom of the most fallacious instances argumentation. >>>> >>>> https://en.wikipedia.org/wiki/Ad_hominem#Fallacious_types_of_ad_hominem_arguments >>> >>> I don't know what you're looking at, but I see in that section of the >>> page a very clear pyramid diagram. >>> >>> In that diagram, the bottom layer is "name calling". >>> "Ad hominem" is immediately above it, second from bottom. >>> >>> I.e. ad hominem is distinct from name calling. >>> >>> (Do you have any other URL you are confused about that you'd like me >>> or anyone else to explain, in the Wikipedia or elsewhere?) >>> >> >> On the validity versus fallaciousness hierarchy name calling is more > > This is a term you made up. > > What we are actually looking at is "Paul Graham's hierarchy of > disagreement", not "validity versus fallaciousness hierarchy". > >> fallacious than ad hominem. > > There is no such thing as "more fallacious". Any argument that is false > due to any error of inference is exactly as false (and thus fallacious) > as any other. > > Name calling isn't an argument; therefore we might say that it's "not > even fallacious". Can we get back to the actual point or are you afraid to do this because when a point is correct there is no basis for rebuttal? The halt deciding principle If a function X() is called by function Y() twice in sequence from the same machine address of Y() with the same parameters to X() and the execution trace shows no conditional branch instructions in Y() or function call returns from X() then the function call from Y() to X() is infinitely recursive unless X() stops it. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Real Troll <rel.troll@trolls.com> |
|---|---|
| Date | 2021-04-17 20:38 +0100 |
| Subject | Re: Infinite recursion detection criteria (Please correct me if I am wrong) |
| Message-ID | <s5fdng$4oa$1@gioia.aioe.org> |
| In reply to | #79012 |
On 17/04/2021 20:23, olcott wrote: > > > The halt deciding principle > If a function X() is called by function Y() twice in sequence from the > same machine address of Y() with the same parameters to X() and the > execution trace shows no conditional branch instructions in Y() or > function call returns from X() then the function call from Y() to X() > is infinitely recursive unless X() stops it. > Does this not depend on what the functions are doing? If the function gets a value and uses it for something else then as far as I can see that's it. If you call the same function second time then it will do the same [again]. Either use the value or simply ignores it and stops. I am not sure what has this got to do with recursion? Have you got a concrete example to try it? Cross posting to comp.theory removed as it has nothing to do on my machine!!
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 15:01 -0500 |
| Subject | Re: Infinite recursion detection criteria (Please correct me if I am wrong) |
| Message-ID | <-tqdnSci1I_io-b9nZ2dnUU7-KHNnZ2d@giganews.com> |
| In reply to | #79014 |
On 4/17/2021 2:38 PM, Real Troll wrote:
> On 17/04/2021 20:23, olcott wrote:
>>
>>
>> The halt deciding principle
>> If a function X() is called by function Y() twice in sequence from the
>> same machine address of Y() with the same parameters to X() and the
>> execution trace shows no conditional branch instructions in Y() or
>> function call returns from X() then the function call from Y() to X()
>> is infinitely recursive unless X() stops it.
>>
>
> Does this not depend on what the functions are doing? If the function
> gets a value and uses it for something else then as far as I can see
> that's it. If you call the same function second time then it will do
> the same [again]. Either use the value or simply ignores it and stops.
> I am not sure what has this got to do with recursion? Have you got a
> concrete example to try it?
>
> Cross posting to comp.theory removed as it has nothing to do on my machine!!
>
I am trying to make a halt decider that can correctly detect infinite
recursion. Here are some more key details:
When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is
invoking X() in infinite recursion. On this basis it can stop simulating
Y() and report that Y() would not halt unless its execution was aborted
by Halts().
void Y(u32 P)
{
Halts(P, P);
}
int main()
{
Halts((u32)Y, (u32)Y);
}
http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-04-18 01:57 +0000 |
| Subject | Re: Infinite recursion detection criteria (Please correct me if I am wrong) |
| Message-ID | <20210417183423.843@kylheku.com> |
| In reply to | #79012 |
On 2021-04-17, olcott <NoOne@NoWhere.com> wrote: > Can we get back to the actual point or are you afraid to do this because > when a point is correct there is no basis for rebuttal? > > The halt deciding principle > If a function X() is called by function Y() twice in sequence from the > same machine address of Y() with the same parameters to X() and the > execution trace shows no conditional branch instructions in Y() or > function call returns from X() then the function call from Y() to X() is > infinitely recursive unless X() stops it. No, I do not agree. If the execution trace shows no conditional branch instructions, then the situation is runaway recursive, period. Nothing will stop it but stack exhaustion. X doesn't do anything such as making a decision to terminate. If it did, that would contradict the assumption that there are no conditional instructions being executed in the recursive loop. In your implementation of this, there are gaps in the instruction trace. Y (called _H_Hat) invokes X (_Halts) via a CALL 00000883 instruction. But the next element in the trace is not the address 00000833 which was called, but, unexpectedy, but the address of _H_Hat itself, 00000a63. There is a "trace black out" starting with 00000833 until 00000a63. Your document also does not not show the disassembly listing of the procedure at 00000833. (I suspect that CALL 0000833 isn't a function call at all; the simulator is rigged to recognize this address. You've hinted at the fact that _Halts is a built-in simulation primitive and not an actual function.) What you must do is provide a complete diassembly listing of all code that is invoked. That code must be executed in accordance with the x86 instruction set architecture from Intel without any sneaky extensions. There must be no puzzing gaps in the execution traces. If there is a CALL X, the next instruction to be traced must be X. You must also trace the value of every register. I.e add columns to the trace for EAX, EBX, ... to show nothing is messing with their contents. Just like your current trace has a surprising discontinuity in the EIP register, any other register could have a surprising change not reflected in what the instructions are doing.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 15:56 -0500 |
| Subject | Re: Infinite recursion detection criteria (dodging the point?) |
| Message-ID | <CNmdnSs_8eT71ub9nZ2dnUU7-bfNnZ2d@giganews.com> |
| In reply to | #79007 |
On 4/17/2021 3:47 PM, Malcolm McLean wrote: > On Saturday, 17 April 2021 at 20:14:18 UTC+1, Kaz Kylheku wrote: >> On 2021-04-17, olcott <No...@NoWhere.com> wrote: >> >>> >>> On the validity versus fallaciousness hierarchy name calling is more >> This is a term you made up. >> >> What we are actually looking at is "Paul Graham's hierarchy of >> disagreement", not "validity versus fallaciousness hierarchy". >> >>> fallacious than ad hominem. >> >> There is no such thing as "more fallacious". Any argument that is false >> due to any error of inference is exactly as false (and thus fallacious) >> as any other. >> > Firstly, you have to adopt most of the famous logical fallacies as > a mode for everyday life. If a well-respected scientist fails to replicate > a published result, the paper is seriously under question. If a high school > student fails to do the same, that carries little or no weight. Otherwise > scientists would be constantly chasing their tails following false leads > from beginners. > > Then dismissing a startling claim from a person with a history of making > similar claims with poor evidence isn't the same as dismissing a fairly > modest claim from someone with a reputation in the field, but maybe whom > you don't like. It's the same underlying fallacy, but the second is a higher dose > and far more likely to lead to a false conclusion. > It seems to me that everyone dodges this point because I am correct The halt deciding principle for infinite recursion If a function X() is called by function Y() twice in sequence from the same machine address of Y() with the same parameters to X() and the execution trace shows no conditional branch instructions in Y() or a function call returns from X() then the function call from Y() to X() is infinitely recursive unless X() stops it. http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@nospicedham.NoWhere.com> |
|---|---|
| Date | 2021-04-17 11:01 -0500 |
| Message-ID | <4LKdnStuf-7-m-b9nZ2dnUU7-e_NnZ2d@giganews.com> |
| In reply to | #79003 |
On 4/17/2021 9:15 AM, olcott wrote:
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the
> execution trace shows no conditional branch instructions in Y() or
> function call returns in X() then the function call from Y() to X() is
> infinitely recursive unless X() stops it.
>
> The referenced execution trace is on x86 machine language, disassembled
> for human consumption.
>
When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is
invoking X() in infinite recursion. On this basis it can stop simulating
Y() and report that Y() would not halt unless its execution was aborted
by Halts().
void Y(u32 P)
Halts(P, P);
}
int main()
{
Halts((u32)Y, (u32)Y);
}
_Y()
[000009ac](01) 55 push ebp
[000009ad](02) 8bec mov ebp,esp
[000009af](03) 8b4508 mov eax,[ebp+08]
[000009b2](01) 50 push eax
[000009b3](03) 8b4d08 mov ecx,[ebp+08]
[000009b6](01) 51 push ecx
[000009b7](05) e840feffff call 000007fc
[000009bc](03) 83c408 add esp,+08
[000009bf](01) 5d pop ebp
[000009c0](01) c3 ret
Size in bytes:(0021) [000009c0]
_main()
[000009cc](01) 55 push ebp
[000009cd](02) 8bec mov ebp,esp
[000009cf](05) 68ac090000 push 000009ac
[000009d4](05) 68ac090000 push 000009ac
[000009d9](05) e81efeffff call 000007fc
[000009de](03) 83c408 add esp,+08
[000009e1](02) 33c0 xor eax,eax
[000009e3](01) 5d pop ebp
[000009e4](01) c3 ret
Size in bytes:(0025) [000009e4]
===============================
....[000009cc][00011278][00000000](01) 55 push ebp
....[000009cd][00011278][00000000](02) 8bec mov ebp,esp
....[000009cf][00011274][000009ac](05) 68ac090000 push 000009ac
....[000009d4][00011270][000009ac](05) 68ac090000 push 000009ac
....[000009d9][0001126c][000009de](05) e81efeffff call 000007fc
Begin Local Halt Decider Simulation at Machine Address:9ac
....[000009ac][00031318][0003131c](01) 55 push ebp
....[000009ad][00031318][0003131c](02) 8bec mov ebp,esp
....[000009af][00031318][0003131c](03) 8b4508 mov
eax,[ebp+08]
....[000009b2][00031314][000009ac](01) 50 push eax
....[000009b3][00031314][000009ac](03) 8b4d08 mov
ecx,[ebp+08]
....[000009b6][00031310][000009ac](01) 51 push ecx
....[000009b7][0003130c][000009bc](05) e840feffff call 000007fc
....[000009ac][0007bd40][0007bd44](01) 55 push ebp
....[000009ad][0007bd40][0007bd44](02) 8bec mov ebp,esp
....[000009af][0007bd40][0007bd44](03) 8b4508 mov
eax,[ebp+08]
....[000009b2][0007bd3c][000009ac](01) 50 push eax
....[000009b3][0007bd3c][000009ac](03) 8b4d08 mov
ecx,[ebp+08]
....[000009b6][0007bd38][000009ac](01) 51 push ecx
....[000009b7][0007bd34][000009bc](05) e840feffff call 000007fc
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
....[000009de][00011278][00000000](03) 83c408 add esp,+08
....[000009e1][00011278][00000000](02) 33c0 xor eax,eax
....[000009e3][0001127c][00010000](01) 5d pop ebp
....[000009e4][00011280][00000058](01) c3 ret
Number_of_User_Instructions(23)
Number of Instructions Executed(16920)
sizeof(Decoded_Line_Of_Code)(24)
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@nospicedham.kylheku.com> |
|---|---|
| Date | 2021-04-17 15:01 +0000 |
| Message-ID | <20210417074758.258@kylheku.com> |
| In reply to | #79003 |
On 2021-04-17, olcott <NoOne@nospicedham.NoWhere.com> wrote: > If a function X() is called by function Y() twice in sequence from the > same machine address of Y() with the same parameters to X() and the > execution trace shows no conditional branch instructions in Y() or The problem is, the execution trace only shows no such instructions because you have concealed them. You have declared that X is part of the "operating system" and not part of the test case. So in your trace there is an illegal discontinuity. There is a JSR Halts instruction executed, but then the next instruction which is traced is not inside Halts, but inside H_Hat. The address does not match. > function call returns in X() then the function call from Y() to X() is > infinitely recursive unless X() stops it. Problem is, the above decision about the traces is being made by X itself. It is accessing these global tracers, which make X not a function, but an imperative procedure. Below is a quote from the following idiotic document: http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf Note how after every "call 00000833", the next instruction being traced is not 00000833, but 00000A63. A63 is _H_Hat. The document does not reveal the disassembly of code at 833, so we have no idea what instructions are there. However, those instructions have to do with the decision that leads to "Infinite Recursion Detected", which is not possible without conditionals. (01)[00000a93][000114f7][00000000] (01) 55 push ebp (02)[00000a94][000114f7][00000000] (02) 8bec mov ebp,esp (03)[00000a96][000114f3][00000000] (01) 51 push ecx (04)[00000a97][000114ef][00000a63] (05) 68630a0000 push 00000a63 (05)[00000a9c][000114eb][00000a63] (05) 68630a0000 push 00000a63 (06)[00000aa1][000114e7][00000aa6] (05) e8ddfdffff call 00000883 (07)[00000a63][00031577][0003157b] (01) 55 push ebp (08)[00000a64][00031577][0003157b] (02) 8bec mov ebp,esp (09)[00000a66][00031573][00021547] (01) 51 push ecx (10)[00000a67][00031573][00021547] (03) 8b4508 mov eax,[ebp+08] (11)[00000a6a][0003156f][00000a63] (01) 50 push eax (12)[00000a6b][0003156f][00000a63] (03) 8b4d08 mov ecx,[ebp+08] (13)[00000a6e][0003156b][00000a63] (01) 51 push ecx (14)[00000a6f][00031567][00000a74] (05) e80ffeffff call 00000883 (15)[00000a63][0004271f][00042723] (01) 55 push ebp (16)[00000a64][0004271f][00042723] (02) 8bec mov ebp,esp (17)[00000a66][0004271b][000326ef] (01) 51 push ecx (18)[00000a67][0004271b][000326ef] (03) 8b4508 mov eax,[ebp+08] (19)[00000a6a][00042717][00000a63] (01) 50 push eax (20)[00000a6b][00042717][00000a63] (03) 8b4d08 mov ecx,[ebp+08] (21)[00000a6e][00042713][00000a63] (01) 51 push ecx (22)[00000a6f][0004270f][00000a74] (05) e80ffeffff call 00000883 Infinite Recursion Detected Simulation Stopped -- TXR Programming Language: http://nongnu.org/txr Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 17:30 -0500 |
| Message-ID | <io6dnc21a4QY_Ob9nZ2dnUU7-fmdnZ2d@giganews.com> |
| In reply to | #79017 |
On 4/17/2021 10:01 AM, Kaz Kylheku wrote: > On 2021-04-17, olcott <NoOne@nospicedham.NoWhere.com> wrote: >> If a function X() is called by function Y() twice in sequence from the >> same machine address of Y() with the same parameters to X() and the >> execution trace shows no conditional branch instructions in Y() or > > The problem is, the execution trace only shows no such instructions > because you have concealed them. You are responding with boiler-plate that does not account for my reconfiguration. A halt deciding principle that detects infinite recursion If a function X() is called by function Y() twice in sequence from the same machine address of Y() with the same parameters to X() and the execution trace shows no conditional branch instructions in Y() or a function call returns from X() then the function call from Y() to X() is infinitely recursive unless X() stops it. The above specification need not look inside X() at all as long is we have the assurance that the execution trace of X() does not include any "ret" instructions. I modified my halt decider to makes sure that this part works correctly. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-04-18 01:58 +0000 |
| Message-ID | <20210417185712.138@kylheku.com> |
| In reply to | #79021 |
On 2021-04-17, olcott <NoOne@NoWhere.com> wrote: > On 4/17/2021 10:01 AM, Kaz Kylheku wrote: >> On 2021-04-17, olcott <NoOne@nospicedham.NoWhere.com> wrote: >>> If a function X() is called by function Y() twice in sequence from the >>> same machine address of Y() with the same parameters to X() and the >>> execution trace shows no conditional branch instructions in Y() or >> >> The problem is, the execution trace only shows no such instructions >> because you have concealed them. > You are responding with boiler-plate that does not account for my > reconfiguration. > > A halt deciding principle that detects infinite recursion > If a function X() is called by function Y() twice in sequence from the > same machine address of Y() with the same parameters to X() and the > execution trace shows no conditional branch instructions in Y() or a > function call returns from X() then the function call from Y() to X() is > infinitely recursive unless X() stops it. Correction: "execution trace shows no conditional branch instructions anywhere; not in Y, not in X" continue ...
[toc] | [prev] | [next] | [standalone]
| From | Bonita Montero <Bonita.Montero@gmail.com> |
|---|---|
| Date | 2021-04-18 00:03 +0200 |
| Message-ID | <s5flun$t52$1@dont-email.me> |
| In reply to | #79003 |
STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!! STOP POSTING IN comp.lang.c/c++ !!!
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-17 17:12 -0500 |
| Message-ID | <4pOdncujsYfVwOb9nZ2dnUU7-WGdnZ2d@giganews.com> |
| In reply to | #79019 |
On 4/17/2021 5:03 PM, Bonita Montero wrote: > STOP POSTING IN comp.lang.c/c++ !!! KNOW !!! -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [standalone]
Back to top | Article view | comp.lang.c++
csiph-web