Merge pull request #197 from nevillegrech/simplify_global

Various optimizations at the local and global analysis levels

Author: sifislag

logic/functions.dl

@@ -107,7 +107,7 @@ PossibleReturnAddressWithPos(targetSetter, retCtx, retBlock, retTarget, pos) :-
   postTrans.Statement_Block(targetSetStatement, targetSetter),
   postTrans.BasicBlock_Tail(targetSetter, jumpStmt),
   postTrans.JUMP(jumpStmt),
-  postTrans.BeforeLocalStackContents(jumpStmt, pos, targetVariable).
+  postTrans.BlockOutLocalStackContents(targetSetter, pos, targetVariable).
 
 /**
   This pattern is prominent in 0.8.x code:
@@ -140,7 +140,7 @@ PossibleReturnAddressWithPos(as(next, Block), retCtx, retBlock, retTarget, pos)
   postTrans.StaticBlockJumpTarget(targetSetter, next),
   postTrans.BasicBlock_Tail(as(next, Block), jumpStmt),
   postTrans.JUMP(jumpStmt),
-  postTrans.BeforeLocalStackContents(jumpStmt, pos, stackIndex),
+  postTrans.BlockOutLocalStackContents(as(next, Block), pos, stackIndex),
   // filter out cases where the function is called directly
   !postTrans.IsJumpBlockPrivateFunctionCall(_, as(next, Block)).
 
@@ -833,6 +833,11 @@ IRLocalStackContents(irstmt, n, varOrStackIndex) :-
   Statement_IRStatement(stmt, _, irstmt).
 
 
+.decl IRBlockOutLocalStackContents(irBlock: IRBlock, n: StackIndex, varOrStackIndex: VariableOrStackIndex)
+IRBlockOutLocalStackContents(irBlock, n, varOrStackIndex) :-
+  postTrans.BlockOutLocalStackContents(block, n, varOrStackIndex),
+  Block_IRBlock(block, _, irBlock).
+
 /***********
  * Discovery of arguments accepted by a function   
  ***********/
@@ -1154,28 +1159,40 @@ BeforeFunctionCallFunctionalBlockOutputContents(block, index, realVariable) :-
   CheckIsStackIndex(stackIndex).
 
 
-// TODO, check case for function call
+// uses of the jump/call stmt
 FunctionalStatement_Uses_Local(stmt, varOrStackIndex, n) :-
   IRFunctionCall(block, func),
   IRBasicBlock_Tail(block, stmt),
   IRStatement_Opcode(stmt, opcode),
   OpcodePopWords(opcode, m),
-//// REVIEW
-//  PossibleNumberOfFunctionArguments(func, n_in),
+  NumberOfFunctionArguments(func, _),
+  IRBeforeLocalStackContents(stmt, n, varOrStackIndex), n < m.
+
+// function args
+FunctionalStatement_Uses_Local(stmt, varOrStackIndex, n + m) :-
+  IRFunctionCall(block, func),
+  IRBasicBlock_Tail(block, stmt),
+  IRStatement_Opcode(stmt, opcode),
+  OpcodePopWords(opcode, m),
   NumberOfFunctionArguments(func, n_in),
-  IsStackIndexLessThan(n, m+n_in),
-  IRBeforeLocalStackContents(stmt, n, varOrStackIndex).
+  IRBlockOutLocalStackContents(block, n, varOrStackIndex),  n < n_in.
 
 // TODO, check case for function return
 FunctionalStatement_Uses_Local(stmt, varOrStackIndex, n) :-
-//// REVIEW
+  NumberOfFunctionReturnArguments(func, _),
+  IRFunction_Return(func, retBlock),
+  IRBasicBlock_Tail(retBlock, stmt),
+  IRStatement_Opcode(stmt, opcode),
+  OpcodePopWords(opcode, m),
+  IRBeforeLocalStackContents(stmt, n, varOrStackIndex), n < m.
+
+FunctionalStatement_Uses_Local(stmt, varOrStackIndex, n + m) :-
   NumberOfFunctionReturnArguments(func, n_out),
   IRFunction_Return(func, retBlock),
   IRBasicBlock_Tail(retBlock, stmt),
   IRStatement_Opcode(stmt, opcode),
   OpcodePopWords(opcode, m),
-  IsStackIndexLessThan(n, m+n_out),
-  IRBeforeLocalStackContents(stmt, n, varOrStackIndex).
+  IRBlockOutLocalStackContents(retBlock, n, varOrStackIndex), n < n_out.
 
 FunctionalStatement_Uses_Local(irstmt, varOrStackIndex, n) :-
    postTrans.Statement_Uses_Local(stmt, varOrStackIndex, n),

logic/global_components.dl

@@ -132,30 +132,18 @@
     BlockOutputContents(callerCtx, caller, index, variable),
     BlockEdge(callerCtx, caller, calleeCtx, callee).
     .plan 1:(2,1)
-    
-  // Copy the stack variables untouched by the callee basic block
-  BlockOutputContents(calleeCtx, callee, index+delta, variable) :-
-    BlockInputContents(calleeCtx, callee, index, variable),
-    BlockPopDelta(callee, calleePopLen),
-    BlockStackDelta(callee, delta),
-    index >= calleePopLen,
-    index+delta <= MAX_STACK_HEIGHT.
 
   // Handle the proper variables pushed by this basic block
   BlockOutputContents(ctx, block, index, as(var, Variable)) :-
     ReachableContext(ctx, block),
-    BasicBlock_Tail(block, stmt),
-    LocalStackContents(stmt, index, var),
+    BlockOutLocalStackContents(block, index, var),
     CheckIsVariable(var).
 
-
-  // Handle the stackIndexes pushed by this basic block
+  // Handle the indexes: stack contents pushed by previous blocks
   BlockOutputContents(ctx, block, index, as(realVariable, Variable)) :-
     BlockInputContents(ctx, block, stackIndex, realVariable),
     CheckIsStackIndex(stackIndex),
-    BasicBlock_Tail(block, stmt),
-    LocalStackContents(stmt, index, stackIndex).
-
+    BlockOutLocalStackContents(block, index, stackIndex).
 
 
   BlockJumpTarget(ctx, block, var) :-

logic/local_components.dl

@@ -268,7 +268,12 @@ IsStackIndexLessThan(n, maximum) :- n = range(0, maximum, 1).
 
   // What is the difference in stack height after the execution of this `statement`
   .decl StatementStackDelta(statement: Statement, delta: number)
-  
+
+  // block-level stack behavior predicate: After the executin of block, stack `index` will hold
+  // `variableOrIndex` which is either a variable pushed by the block or a reference to a stackindex at its beginning
+  .decl BlockOutLocalStackContents(block: Block, index: StackIndex, variableOrIndex: VariableOrStackIndex)
+  DEBUG_OUTPUT(BlockOutLocalStackContents)
+
   ImmediateBlockJumpTarget(block, as(var, Variable)) :-
     BasicBlock_Tail(block, stmt),
     IsJump(stmt),
@@ -349,8 +354,7 @@ IsStackIndexLessThan(n, maximum) :- n = range(0, maximum, 1).
   LocalStackContents(stmt, m+1, other) :-
     BeforeLocalStackContents(stmt, m, other),
     Statement_Opcode(stmt, opcode),
-    DUPN(opcode, n),
-    IsStackIndexLessThan(m, n).
+    DUPN(opcode, n), m < n.
 
   /**
     Optimization: before local stack contents for swaps
@@ -372,7 +376,7 @@ IsStackIndexLessThan(n, maximum) :- n = range(0, maximum, 1).
 
   LocalStackContents(stmt, m, other) :-
     BeforeSwapLocalStackContents(stmt, n, m, other),
-    IsStackIndexLessThan(m, n), m > 0.
+    m < n, m > 0.
 
   /*
    ***********
@@ -398,7 +402,7 @@ IsStackIndexLessThan(n, maximum) :- n = range(0, maximum, 1).
     IsBasicBlockHead(stmt),
     Statement_Block(stmt, block),
     BlockPopDelta(block, delta),
-    IsStackIndexLessThan(stackIndex, delta + 10).
+    IsStackIndexLessThan(stackIndex, delta + 2).
 
    /*
    ***********
@@ -442,13 +446,22 @@ IsStackIndexLessThan(n, maximum) :- n = range(0, maximum, 1).
     BasicBlock_Tail(block, stmt),
     StatementPopDelta(stmt, delta).
 
+  BlockOutLocalStackContents(block, index, varOrIndex):-
+    BasicBlock_Tail(block, tail),
+    LocalStackContents(tail, index, varOrIndex).
+
+  BlockOutLocalStackContents(block, outIndex, as(outIndex - stackDelta, StackIndex)):-
+    BlockPopDelta(block, popDelta),
+    BlockStackDelta(block, stackDelta),
+    outIndex = range(popDelta + stackDelta + 1, MAX_STACK_HEIGHT + 1, 1).
+
   .decl Statement_Uses_Local(stmt:Statement, var:VariableOrStackIndex, n:StackIndex)
 
   Statement_Uses_Local(stmt, varOrStackIndex, n) :-
      Statement_Opcode(stmt, opcode),
      !TACNOP(stmt),
      OpcodePopWords(opcode, m),
-     IsStackIndexLessThan(n, m),
+     n < m,
      BeforeLocalStackContents(stmt, n, varOrStackIndex).
 
   // Identify low-level blocks that will always REVERT

logic/types_defs.dl

@@ -14,7 +14,7 @@
 #endif
 
 #define CheckIsVariable(v) ((v) < 0)
-#define CheckIsStackIndex(v) ((v) >= 0, (v) < MAX_STACK_HEIGHT)
+#define CheckIsStackIndex(v) ((v) >= 0, (v) <= MAX_STACK_HEIGHT)
 
 
 // The following 4 constants as also defined in src/common.py