(decomp): Optimize the statement insertor (#198)

* rewrite the expensive part of the statement insertor

* cleanup

* final cleanup and documentation.

Author: sifislag

logic/statement_insertor.dl

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "global_components.dl"
-#define MAX_INSERTS 5
 
 
 #define COPY_OUTPUT(to, from)\
@@ -34,6 +33,14 @@ INITIALIZE_STATEMENT_INSERTOR(_insertor, to)
   .decl Out_Statement_Next(stmt: Statement, next: Statement)
   .decl Out_Statement_Opcode(stmt: Statement, op: Opcode)
   .decl Out_PushValue(stmt: Statement, value: Value)
+
+  // The last `statement` in the original bytecode, start adding cloned code after it.
+  .decl MaxOriginalStatement(statement: Statement)
+
+  MaxOriginalStatement(as(maxStmt, Statement)):-
+    maxStmtNumber = max stmtNumber : { Statement_Opcode(stmt, _), stmtNumber = @hex_to_number(stmt)},
+    maxStmt = @number_to_hex(2*maxStmtNumber).
+
 }
 
 .comp StatementInsertor : CodeTransformer {
@@ -67,42 +74,29 @@ INITIALIZE_STATEMENT_INSERTOR(_insertor, to)
   insertOpsN(stmt, rest, n+1) :-
    insertOpsN(stmt, [[op, value], rest], n).
 
-
-  .decl PreInsertedOpNewStatementNum(stmt: Statement, order: number, newStmt: number)
-  
-  PreInsertedOpNewStatementNum(stmt, order, @hex_to_number(stmt) * MAX_INSERTS + order) :-
-    insertOp(stmt, _, _, order).
-
-  .decl PreInsertedOpMissingStmt(n : number)
-
-  PreInsertedOpMissingStmt(newStmt - 1) :-
-     PreInsertedOpNewStatementNum(_, _, newStmt), newStmt > 0,
-     !PreInsertedOpNewStatementNum(_, _, newStmt - 1).
-
-  PreInsertedOpMissingStmt(newStmt - 1) :-
-     PreInsertedOpMissingStmt(newStmt), newStmt > 0,
-     !PreInsertedOpNewStatementNum(_, _, newStmt - 1).
-
-   .decl MaxStmt(n: number)
-   MaxStmt(n) :- n = max @hex_to_number(stmt) : Statement_Opcode(stmt, _).
+  // Random order of the insertions using the choice-domain 
+  .decl Insertion_Next(ins: Statement, next: Statement) choice-domain ins, next
+  Insertion_Next("nil", "head").
+  Insertion_Next(prev, next):-
+    Insertion_Next(_, prev),
+    insertOp(next, _, _, _).
 
   .decl InsertedOpNewStatement(stmt: Statement, order: number, newStmt: Statement)
 
-  .decl WastedSlots(newStmt: number, n: number)
+  InsertedOpNewStatement(stmt, 0, as(@add_256(maxStmt, "0x20"), Statement)):-
+    insertOp(stmt, _, _, 0),
+    Insertion_Next("head", stmt),
+    MaxOriginalStatement(maxStmt).
 
-  .decl TempPreInsertedOpNewAndMissingStatementNum(smallerThanNewStmt: number, newStmt: number)
-  TempPreInsertedOpNewAndMissingStatementNum(smallerThanNewStmt, newStmt) :-
-     PreInsertedOpNewStatementNum(_, _, newStmt),
-     PreInsertedOpMissingStmt(smallerThanNewStmt), smallerThanNewStmt < newStmt.
-     
-  WastedSlots(newStmt, n) :-
-     PreInsertedOpNewStatementNum(_, _, newStmt),
-     n = count : { TempPreInsertedOpNewAndMissingStatementNum(_, newStmt) }.
+  InsertedOpNewStatement(stmt, order + 1, as(@add_256(newPrevStmt, "0x20"), Statement)):-
+    InsertedOpNewStatement(stmt, order, newPrevStmt),
+    insertOp(stmt, _, _, order),
+    insertOp(stmt, _, _, order + 1).
 
-  InsertedOpNewStatement(stmt, order, as(@number_to_hex(newStmt - n + maxStmt + 1), Statement)) :-
-    PreInsertedOpNewStatementNum(stmt, order, newStmt),
-    MaxStmt(maxStmt),
-    WastedSlots(newStmt, n).
+  // Note: Insertions are placed 80 slots from each other, can make more precise
+  InsertedOpNewStatement(stmt, 0, as(@add_256(newPrevStmt, "0xa00"), Statement)):-
+    InsertedOpNewStatement(prevStmt, 0, newPrevStmt),
+    Insertion_Next(prevStmt, stmt).
 
   Out_Statement_Opcode(stmt, op) :-
     Statement_Opcode(stmt, op),
@@ -250,9 +244,6 @@ INITIALIZE_STATEMENT_INSERTOR(_insertor, to)
   .decl Prev_Block_OriginalBlock(block: Block, originalBlock: Block)
   .decl In_Block_OriginalBlock(block: Block, originalBlock: Block)
 
-  // The last `statement` in the original bytecode, start adding cloned code after it.
-  .decl MaxOriginalStatement(statement: Statement)
-
   // compute the block size to use on the cloned blocks
   .decl BlockSize(block: Block, size: number)
 
@@ -313,9 +304,6 @@ INITIALIZE_STATEMENT_INSERTOR(_insertor, to)
   DEBUG_OUTPUT(Block_OriginalBlock)
   DEBUG_OUTPUT(BlockToClone)
 
-  MaxOriginalStatement(as(maxStmt, Statement)):-
-    maxStmtNumber = max stmtNumber : { Statement_Opcode(stmt, _), stmtNumber = @hex_to_number(stmt)},
-    maxStmt = @number_to_hex(2*maxStmtNumber).
 
   // New definition, makes it pre cloning insertion safe
   BlockSize(block, maxStmt - @hex_to_number(block)):-