public LocalVariable SetNewVReg(EvaluatorStack evaluator)
{
var newLocal = evaluator.SetNewVReg();
VirtRegs.Add(newLocal);
return(newLocal);
}
public void BranchIfFalse(int pushedIntValue, EvaluatorStack evaluator)
{
var firstVar = evaluator.Stack.Pop();
AddOperation(SimpleOperations.LocalOperation.Kinds.BranchOperator,
new BranchOperator(OpcodeBranchNames.BrFalse)
{
JumpTo = pushedIntValue,
CompareValue = firstVar
});
}
private void AssignValueToStack(object value, EvaluatorStack evaluator)
{
var result = SetNewVReg(evaluator);
var assign = new Assignment()
{
Left = result,
Right = new ConstValue(value)
};
result.FixedType = value.GetType();
AddOperation(SimpleOperations.LocalOperation.Kinds.Assignment, assign);
}
public void Dup(EvaluatorStack evaluator)
{
var variable = evaluator.Stack.Peek();
var vreg = SetNewVReg(evaluator);
var assign = new Assignment()
{
Left = vreg,
Right = variable
};
vreg.FixedType = variable.ComputedType();
AddOperation(LocalOperation.Kinds.Assignment, assign);
}
private void BranchTwoOperators(int jumpTo, EvaluatorStack evaluator, string opcode)
{
var firstVar = evaluator.Stack.Pop();
var secondVar = evaluator.Stack.Pop();
AddOperation(SimpleOperations.LocalOperation.Kinds.BranchOperator,
new BranchOperator(opcode)
{
JumpTo = jumpTo,
CompareValue = firstVar,
SecondValue = secondVar
});
}
public void LoadArgument(int pushedIntValue, EvaluatorStack evaluator)
{
var argument = Arguments[pushedIntValue];
var vreg = SetNewVReg(evaluator);
vreg.FixedType = argument.ComputedType();
var assignment = new Assignment()
{
Left = vreg,
Right = argument
};
AddOperation(LocalOperation.Kinds.LoadArgument, assignment);
}
public void NewObject(ConstructorInfo constructorInfo, EvaluatorStack evaluator)
{
var result = SetNewVReg(evaluator);
result.FixedType = constructorInfo.DeclaringType;
var assignment = new Assignment()
{
Left = result,
Right = new NewConstructedObject(constructorInfo)
};
ProgramData.Instance.UpdateType(constructorInfo.DeclaringType);
AddOperation(LocalOperation.Kinds.NewObject, assignment);
}
public void SetElement(EvaluatorStack evaluator, Type operand)
{
var value = evaluator.Pop();
var index = evaluator.Pop();
var array = evaluator.Pop();
var arrayVariable = new ArrayVariable(array, index);
var assignment = new Assignment
{
Left = arrayVariable,
Right = value
};
arrayVariable.FixedType = value.ComputedType();
AddOperation(LocalOperation.Kinds.SetArrayItem, assignment);
}
public void CopyLocalVariableIntoStack(int value, EvaluatorStack evaluator)
{
var locVar = _localVariables[value];
var vreg = SetNewVReg(evaluator);
var assingment = new Assignment
{
Left = vreg,
Right = locVar
};
vreg.FixedType = locVar.ComputedType();
AddOperation(SimpleOperations.LocalOperation.Kinds.Assignment, assingment);
}
public void Call(object operand, EvaluatorStack evaluator)
{
var methodInfo = (MethodBase)operand;
var methodData = new MethodData(methodInfo);
methodData.ExtractNeededValuesFromStack(evaluator);
if (!methodData.IsVoid)
{
var vreg = SetNewVReg(evaluator);
vreg.FixedType = methodInfo.GetReturnType();
methodData.Result = vreg;
}
methodData.FixedType = methodInfo.GetReturnType();
AddOperation(SimpleOperations.LocalOperation.Kinds.Call, methodData);
}
public void NewArray(EvaluatorStack evaluator, Type typeArray)
{
var arrayLength = evaluator.Stack.Pop();
var result = SetNewVReg(evaluator);
var assignment = new Assignment
{
Left = result,
Right = new NewArrayObject()
{
TypeArray = typeArray,
ArrayLength = arrayLength
}
};
result.FixedType = typeArray.MakeArrayType();
AddOperation(LocalOperation.Kinds.NewArray, assignment);
}
public void StoreField(FieldInfo fieldInfo, EvaluatorStack evaluator)
{
var secondVar = evaluator.Stack.Pop();
var firstVar = evaluator.Stack.Pop();
var fieldName = fieldInfo.Name;
var assignment = new Assignment()
{
Left = new FieldSetter()
{
Instance = firstVar,
FieldName = fieldName
},
Right = secondVar
};
assignment.Left.FixedType = secondVar.ComputedType();
AddOperation(SimpleOperations.LocalOperation.Kinds.SetField, assignment);
}
private void SetUnaryOperator(string operatorName, EvaluatorStack evaluator)
{
var firstVar = evaluator.Stack.Pop();
var addValue = new UnaryOperator(operatorName)
{
Left = firstVar,
FixedType = firstVar.ComputedType()
};
var result = SetNewVReg(evaluator);
var assign = new Assignment()
{
Left = result,
Right = addValue
};
assign.Left.FixedType = addValue.ComputedType();
AddOperation(SimpleOperations.LocalOperation.Kinds.Operator, assign);
}
public void LoadReferenceInArray(EvaluatorStack evaluator)
{
var secondVar = evaluator.Stack.Pop();
var firstVar = evaluator.Stack.Pop();
var result = SetNewVReg(evaluator);
result.FixedType = firstVar.FixedType.GetElementType();
var arrayVariable = new ArrayVariable(firstVar, secondVar);
var assignment = new Assignment()
{
Left = result,
Right = arrayVariable
};
result.FixedType = arrayVariable.GetElementType();
AddOperation(SimpleOperations.LocalOperation.Kinds.GetArrayItem, assignment);
}
public void LoadField(string fieldName, EvaluatorStack evaluator)
{
var firstVar = evaluator.Stack.Pop();
var vreg = SetNewVReg(evaluator);
vreg.FixedType = firstVar.ComputedType().LocateField(fieldName).FieldType;
ProgramData.Instance.UpdateType(vreg.FixedType);
var assignment = new Assignment
{
Left = vreg,
Right = new FieldGetter()
{
FieldName = fieldName,
Instance = firstVar
}
};
AddOperation(SimpleOperations.LocalOperation.Kinds.GetField, assignment);
}
public void CopyStackIntoLocalVariable(int value, EvaluatorStack evaluator)
{
var topVariable = evaluator.Stack.Peek();
var newLocal = new LocalVariable
{
Kind = VariableKind.Local,
Id = value
};
evaluator.Stack.Pop();
_localVariables[value] = newLocal;
var assingment = new Assignment
{
Left = newLocal,
Right = topVariable
};
newLocal.FixedType = topVariable.ComputedType();
AddOperation(SimpleOperations.LocalOperation.Kinds.Assignment, assingment);
}
public void ExtractNeededValuesFromStack(EvaluatorStack evaluatorStack)
{
var methodParams = Info.GetParameters();
if (Info.IsConstructor)
{
Parameters.Insert(0, evaluatorStack.Pop());
foreach (var t in methodParams)
{
Parameters.Insert(1, evaluatorStack.Pop());
}
return;
}
foreach (var t in methodParams)
{
Parameters.Insert(0, evaluatorStack.Pop());
}
if (!Info.IsStatic)
{
Parameters.Insert(0, evaluatorStack.Pop());
}
}
public void Process(CrRuntimeLibrary crRuntime)
{
if (Kind != MethodKind.Default)
{
return;
}
if (Interpreted)
{
return;
}
if (HandlePlatformInvokeMethod(Method))
{
return;
}
if (Method.GetMethodBody() == null)
{
return;
}
var instructions = MethodBodyReader.GetInstructions(Method);
var labelList = ComputeLabels(Method);
MidRepresentation.Method = Method;
MidRepresentation.Vars.SetupLocalVariables(Method);
var evaluator = new EvaluatorStack();
var operationFactory = new MetaMidRepresentationOperationFactory(MidRepresentation, evaluator);
for (var index = 0; index < instructions.Length; index++)
{
var instruction = instructions[index];
EvaluateInstuction(instruction, operationFactory, labelList, crRuntime);
}
//Ensure.IsTrue(evaluator.Count == 0, "Stack not empty!");
AnalyzeProperties.Setup(MidRepresentation.Vars.Arguments, MidRepresentation.Vars.VirtRegs,
MidRepresentation.Vars.LocalVars);
Interpreted = true;
}
public void LoadLength(EvaluatorStack evaluator)
{
SetUnaryOperator(OpcodeOperatorNames.LoadLen, evaluator);
evaluator.Top.FixedType = typeof(int);
}
public void Ceq(EvaluatorStack evaluator)
{
SetBinaryOperator("ceq", evaluator);
}
public MetaMidRepresentationOperationFactory(MetaMidRepresentation representation, EvaluatorStack evaluator)
{
_representation = representation;
_evaluator = evaluator;
}
public void PushString(string value, EvaluatorStack evaluator)
{
AssignValueToStack(value, evaluator);
}
public void Clt(EvaluatorStack evaluator)
{
SetBinaryOperator("clt", evaluator);
}
public void PushDouble(double value, EvaluatorStack evaluator)
{
AssignValueToStack(value, evaluator);
}
public void PushInt4(int value, EvaluatorStack evaluator)
{
AssignValueToStack(value, evaluator);
}
public void BranchIfGreater(int jumpTo, EvaluatorStack evaluator)
{
BranchTwoOperators(jumpTo, evaluator, OpcodeBranchNames.Bgt);
}
public void BranchIfLess(int jumpTo, EvaluatorStack evaluator)
{
BranchTwoOperators(jumpTo, evaluator, OpcodeBranchNames.Blt);
}
public void BranchIfNotEqual(int jumpTo, EvaluatorStack evaluator)
{
BranchTwoOperators(jumpTo, evaluator, OpcodeBranchNames.Bne);
}
public void ConvI4(EvaluatorStack evaluator)
{
SetUnaryOperator(OpcodeOperatorNames.ConvI4, evaluator);
evaluator.Top.FixedType = typeof(int);
}
public void ConvR8(EvaluatorStack evaluator)
{
SetUnaryOperator(OpcodeOperatorNames.ConvR8, evaluator);
evaluator.Top.FixedType = typeof(double);
}
