Pushes a value onto an implicit operand stack.
Inheritance: Statement, IPushStatement
Esempio n. 1
0
 private void TurnOperandStackIntoPushStatements(BasicBlock currentBlock)
 {
     int insertPoint = currentBlock.Statements.Count;
       while (this.operandStack.Count > 0) {
     Expression operand = this.PopOperandStack();
     MethodCall/*?*/ call = operand as MethodCall;
     if (call != null && call.MethodToCall.Type.TypeCode == PrimitiveTypeCode.Void) {
       ExpressionStatement expressionStatement = new ExpressionStatement();
       expressionStatement.Expression = operand;
       currentBlock.Statements.Insert(insertPoint, expressionStatement);
     } else {
       PushStatement push = new PushStatement();
       push.ValueToPush = operand;
       currentBlock.Statements.Insert(insertPoint, push);
     }
       }
 }
 private void TurnOperandStackIntoPushStatements(List<IStatement> statements) {
   Contract.Requires(statements != null);
   List<Expression> correspondingPops = null;
   int insertPoint = statements.Count;
   while (this.operandStack.Count > 0) {
     Expression operand = this.PopOperandStack();
     if (operand is PopValue) { this.operandStack.Push(operand); break; }
     Contract.Assume(!(operand.Type is Dummy));
     PushStatement push = new PushStatement();
     push.ValueToPush = operand;
     statements.Insert(insertPoint, push);
     if (correspondingPops == null) correspondingPops = new List<Expression>(this.operandStack.Count);
     correspondingPops.Add(new PopValue() { Type = operand.Type });
   }
   if (correspondingPops == null) return;
   for (int i = correspondingPops.Count-1; i >= 0; i--)
     this.operandStack.Push(correspondingPops[i]);
 }
Esempio n. 3
0
 private Statement ParseDup()
 {
     PushStatement result = new PushStatement();
       result.ValueToPush = new Dup();
       return result;
 }
Esempio n. 4
0
 /// <summary>
 /// Performs some computation with the given push statement.
 /// </summary>
 public override void Visit(IPushStatement pushStatement)
 {
     PushStatement mutablePushStatement = new PushStatement(pushStatement);
     this.resultStatement = this.myCodeCopier.DeepCopy(mutablePushStatement);
 }
Esempio n. 5
0
 /// <summary>
 /// Visits the specified push statement.
 /// </summary>
 /// <param name="pushStatement"></param>
 /// <returns></returns>
 protected virtual IStatement DeepCopy(PushStatement pushStatement)
 {
     pushStatement.ValueToPush = this.Substitute(pushStatement.ValueToPush);
       return pushStatement;
 }
Esempio n. 6
0
 private bool ReplaceShortCircuitAnd5(BlockStatement b) {
   Contract.Requires(b != null);
   bool replacedPattern = false;
   var statements = b.Statements;
   for (int i = 0; i < statements.Count; i++) {
     var ifStatement = statements[i] as ConditionalStatement;
     if (ifStatement == null) continue;
     var pushTrue = ifStatement.TrueBranch as IPushStatement;
     if (pushTrue == null) {
       var trueBlock = ifStatement.TrueBranch as BlockStatement;
       if (trueBlock != null && trueBlock.Statements.Count == 1)
         pushTrue = trueBlock.Statements[0] as IPushStatement;
     }
     if (pushTrue == null || pushTrue.ValueToPush.Type.TypeCode != PrimitiveTypeCode.Boolean) continue;
     var pushFalse = ifStatement.FalseBranch as IPushStatement;
     if (pushFalse == null) {
       var falseBlock = ifStatement.FalseBranch as BlockStatement;
       if (falseBlock != null && falseBlock.Statements.Count == 1)
         pushFalse = falseBlock.Statements[0] as IPushStatement;
     }
     if (pushFalse == null) continue;
     var falseCaseVal = pushFalse.ValueToPush as CompileTimeConstant;
     if (falseCaseVal == null || !(falseCaseVal.Value is int)) continue;
     if (0 != (int)falseCaseVal.Value) continue;
     var falseConst = new CompileTimeConstant() { Value = false, Type = this.host.PlatformType.SystemBoolean };
     statements[i] = new PushStatement() {
       ValueToPush = new Conditional() {
         Condition = ifStatement.Condition, ResultIfTrue = pushTrue.ValueToPush,
         ResultIfFalse = falseConst, Type = pushTrue.ValueToPush.Type
       }
     };
     replacedPattern = true;
   }
   return replacedPattern;
 }
    private ILocalDefinition ExtractExceptionContainer(DecompiledBlock nestedBlock, ITypeReference exceptionType) {
      Contract.Requires(nestedBlock != null);
      Contract.Requires(exceptionType != null);
      Contract.Ensures(Contract.Result<ILocalDefinition>() != null);

      Contract.Assume(nestedBlock.Statements.Count > 0);
      int i = 0;
      while (nestedBlock.Statements[i] is LocalDeclarationStatement) { i++; Contract.Assume(i < nestedBlock.Statements.Count); };
      var firstStatement = nestedBlock.Statements[i++];
      var firstBlock = firstStatement as DecompiledBlock;
      while (firstBlock != null) {
        Contract.Assume(firstBlock.Statements.Count > 0);
        i = 0;
        while (firstBlock.Statements[i] is LocalDeclarationStatement) { i++; Contract.Assume(i < firstBlock.Statements.Count); };
        firstStatement = firstBlock.Statements[i++];
        nestedBlock = firstBlock;
        firstBlock = firstStatement as DecompiledBlock;
      }
      //Ignoring any local declarations inserted for lexical scopes, any decompiled block that does not start with a nested block, starts with a label.
      Contract.Assume(firstStatement is LabeledStatement);
      if (nestedBlock.Statements.Count > i) {
        var exprStatement = nestedBlock.Statements[i] as ExpressionStatement;
        if (exprStatement != null) {
          nestedBlock.Statements.RemoveRange(i-1, 2);
          if (exprStatement.Expression is PopValue) return Dummy.LocalVariable;
          var assignment = exprStatement.Expression as Assignment;
          if (assignment != null && assignment.Source is PopValue) {
            var local = assignment.Target.Definition as ILocalDefinition;
            if (local != null) return local; //if not, this is not a recognized code pattern.
          }
        }
        // can't find the local, so just introduce one and leave its value on the stack
        var ld = new LocalDefinition() {
          Type = exceptionType,
        };
        var pushStatement = new PushStatement() {
          ValueToPush = new BoundExpression() {
            Definition = ld,
            Type = exceptionType,
          },
        };
        nestedBlock.Statements.Insert(0, pushStatement);
        return ld;
      } else {
        //Valid IL should always have at least one instruction to consume the exception value as well as a branch out of the handler block.
        Contract.Assume(false);
        return Dummy.LocalVariable;
      }
    }
Esempio n. 8
0
 /// <summary>
 /// Visits the specified push statement.
 /// </summary>
 /// <param name="pushStatement">The push statement.</param>
 /// <returns></returns>
 public virtual IStatement Visit(PushStatement pushStatement)
 {
     pushStatement.ValueToPush = Visit(pushStatement.ValueToPush);
       return pushStatement;
 }
Esempio n. 9
0
 /// <summary>
 /// Rewrites the children of the given push statement.
 /// </summary>
 public virtual void RewriteChildren(PushStatement pushStatement)
 {
     this.RewriteChildren((Statement)pushStatement);
       pushStatement.ValueToPush = this.Rewrite(pushStatement.ValueToPush);
 }
Esempio n. 10
0
 /// <summary>
 /// Performs some computation with the given push statement.
 /// </summary>
 /// <param name="pushStatement"></param>
 public override void Visit(IPushStatement pushStatement)
 {
     PushStatement mutablePushStatement = pushStatement as PushStatement;
     if (alwaysMakeACopy || mutablePushStatement == null) mutablePushStatement = new PushStatement(pushStatement);
     this.resultStatement = this.myCodeMutator.Visit(mutablePushStatement);
 }