paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-05 20:08:52 +02:00
Code Issues Packages Projects Releases Wiki Activity

Revert " * patch by J. Gareth Moreton: Nothing (NOP) node optimisation, resolves #38194"

Browse Source 
This reverts commit c2ff85ac5b.

That change duplicates the logic of tstatementnode.simplify in
tblocknode.simpify in a very complex way, and in case of issue #39336 results
in adding a non-tstatementnode in a tblocknode, which is illegal. If
tstatementnode.simplify cannot catch all cases, then that one should
preferably be improved instead (and if not possible, we can look into
catching those edge cases in tblocknode.simplify rather than duplicating
everything).

Resolves issue #39336
This commit is contained in:
Jonas Maebe 2021-09-25 20:59:22 +02:00
parent 8c57d20abc
commit 3e98429418
1 changed files with 24 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
compiler/nbas.pas
View File

@ -706,31 +706,10 @@ implementation
function tblocknode.simplify(forinline : boolean): tnode;
var
hp, nextp: TStatementNode;
lastp: TNode;
{$ifdef break_inlining}
var
a : array[0..3] of tstatementnode;
{$endif break_inlining}
procedure EraseCurrentStatement;
begin
{ make sure the nf_block_with_exit and nf_usercode_entry flags are safeguarded }
if Assigned(nextp) then
nextp.flags := nextp.flags + (hp.left.flags * [nf_block_with_exit, nf_usercode_entry]);
hp.right := nil;
hp.Free;
hp := nextp;
if not Assigned(lastp) then
Exit;
if lastp = Self then
TBlockNode(lastp).left := nextp
else
TStatementNode(lastp).right := nextp;
end;
begin
result := nil;
{ Warning: never replace a blocknode with another node type,
@ -738,93 +717,33 @@ implementation
main program body, and those nodes should always be blocknodes
since that's what the compiler expects elsewhere. }
lastp := Self;
hp := TStatementNode(left);
if Assigned(hp) then
if assigned(left) and
not assigned(tstatementnode(left).right) then
begin
if not assigned(tstatementnode(left).right) then
begin
{ Simplify single-statement blocks }
case tstatementnode(left).left.nodetype of
blockn:
begin
{ if the current block contains only one statement, and
this one statement only contains another block, replace
this block with that other block. }
result:=tstatementnode(left).left;
tstatementnode(left).left:=nil;
{ make sure the nf_block_with_exit and nf_usercode_entry flags are safeguarded }
result.flags:=result.flags+(flags*[nf_block_with_exit,nf_usercode_entry]);
exit;
end;
nothingn:
begin
{ if the block contains only a statement with a nothing node,
get rid of the statement }
left.Free;
left:=nil;
exit;
end;
else
;
case tstatementnode(left).left.nodetype of
blockn:
begin
{ if the current block contains only one statement, and
this one statement only contains another block, replace
this block with that other block. }
result:=tstatementnode(left).left;
tstatementnode(left).left:=nil;
{ make sure the nf_block_with_exit flag is safeguarded }
result.flags:=result.flags+(flags*[nf_block_with_exit,nf_usercode_entry]);
exit;
end;
end
else
repeat
nextp := TStatementNode(hp.Right);
case hp.left.nodetype of
blockn:
if not Assigned(TBlockNode(hp.left).left) then
begin
{ Empty block - delete statement (and block within),
but only if the nf_usercode_entry flag is not set}
if hp.left.flags * [nf_usercode_entry] = [] then
begin
EraseCurrentStatement;
Continue;
end;
end
else
begin
if (TStatementNode(TBlockNode(hp.left).left).left.nodetype = nothingn) and
not Assigned(TStatementNode(TBlockNode(hp.left).left).right) then
begin
{ Block contains only a statement->nothingn branch }
EraseCurrentStatement;
Continue;
end;
if not Assigned(nextp) then
begin
{ If the last statement contains a block, Merge them
(statements within will already be simplified) }
{ Internal error is triggered if the calling block only
had one statement - code flow should have exited
earlier. }
nextp := TStatementNode(TBlockNode(hp.left).left);
TBlockNode(hp.left).left := nil;
EraseCurrentStatement;
Continue;
end;
end;
nothingn:
{ Make sure it's not the only node left }
begin
{ Delete statement (and nothing node within) }
EraseCurrentStatement;
Continue;
end;
else
;
nothingn:
begin
{ if the block contains only a statement with a nothing node,
get rid of the statement }
left.Free;
left:=nil;
exit;
end;
lastp := hp;
hp := nextp;
until not Assigned(hp);
else
;
end;
end;
{$ifdef break_inlining}
{ simple sequence of tempcreate, assign and return temp.? }
if GetStatements(left,a) and