static void Transform(ILASTExpression expr, ILASTTransformer tr)
{
if (expr.ILCode != Code.Ldnull)
{
return;
}
expr.ILCode = Code.Ldc_I4;
expr.Operand = 0;
}
public void Transform(ILASTTransformer tr)
{
var module = tr.Method.Module;
tr.Tree.TraverseTree(Transform, module);
for (int i = 0; i < tr.Tree.Count; i++)
{
var st = tr.Tree[i];
var expr = VariableInlining.GetExpression(st);
if (expr == null)
{
continue;
}
switch (expr.ILCode)
{
case Code.Stelem:
TransformSTELEM(expr, module, (ITypeDefOrRef)expr.Operand, tr.Tree, ref i);
break;
case Code.Stelem_I1:
TransformSTELEM(expr, module, module.CorLibTypes.SByte.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_I2:
TransformSTELEM(expr, module, module.CorLibTypes.Int16.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_I4:
TransformSTELEM(expr, module, module.CorLibTypes.Int32.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_I8:
TransformSTELEM(expr, module, module.CorLibTypes.Int64.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_R4:
TransformSTELEM(expr, module, module.CorLibTypes.Single.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_R8:
TransformSTELEM(expr, module, module.CorLibTypes.Double.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_I:
TransformSTELEM(expr, module, module.CorLibTypes.IntPtr.ToTypeDefOrRef(), tr.Tree, ref i);
break;
case Code.Stelem_Ref:
TransformSTELEM(expr, module, module.CorLibTypes.Object.ToTypeDefOrRef(), tr.Tree, ref i);
break;
}
}
}
public void Transform(ILASTTransformer tr)
{
foreach (IILASTStatement st in tr.Tree)
{
if (st is ILASTExpression)
{
this.ProcessExpression((ILASTExpression)st);
}
else if (st is ILASTAssignment assignment)
{
assignment.Variable.Type = this.ProcessExpression(assignment.Value).Value;
}
else if (st is ILASTPhi)
{
this.ProcessPhiNode((ILASTPhi)st);
}
}
}
public void Transform(ILASTTransformer tr)
{
foreach (var st in tr.Tree)
{
if (st is ILASTExpression)
{
ProcessExpression((ILASTExpression)st);
}
else if (st is ILASTAssignment)
{
var assignment = (ILASTAssignment)st;
assignment.Variable.Type = ProcessExpression(assignment.Value).Value;
}
else if (st is ILASTPhi)
{
ProcessPhiNode((ILASTPhi)st);
}
}
}
static void Transform(ILASTExpression expr, ILASTTransformer tr)
{
if (expr.ILCode != Code.Ldstr)
{
return;
}
var operand = (string)expr.Operand;
expr.ILCode = Code.Box;
expr.Operand = tr.Method.Module.CorLibTypes.String.ToTypeDefOrRef();
expr.Arguments = new IILASTNode[] {
new ILASTExpression {
ILCode = Code.Ldc_I4,
Operand = (int)tr.VM.Data.GetId(operand),
Arguments = new IILASTNode[0]
}
};
}
public void Transform(ILASTTransformer tr)
{
tr.Tree.TraverseTree(Transform, tr.Method.Module);
}
public void Initialize(ILASTTransformer tr)
{
}
public void Transform(ILASTTransformer tr)
{
tr.Tree.TraverseTree(Transform, tr);
}
public void Transform(ILASTTransformer tr)
{
var varUsage = new Dictionary <ILASTVariable, int>();
for (var i = 0; i < tr.Tree.Count; i++)
{
var st = tr.Tree[i];
var expr = GetExpression(st);
if (expr == null)
{
continue;
}
if (st is ILASTExpression && expr.ILCode == Code.Nop)
{
tr.Tree.RemoveAt(i);
i--;
continue;
}
if (st is ILASTAssignment)
{
var assignment = (ILASTAssignment)st;
if (Array.IndexOf(tr.Tree.StackRemains, assignment.Variable) != -1)
{
continue;
}
Debug.Assert(assignment.Variable.VariableType == ILASTVariableType.StackVar);
}
foreach (var arg in expr.Arguments)
{
Debug.Assert(arg is ILASTVariable);
var argVar = (ILASTVariable)arg;
if (argVar.VariableType == ILASTVariableType.StackVar)
{
varUsage.Increment(argVar);
}
}
}
// If a variable is remained on stack, it cannot be inlined since it would be pushed on the stack.
foreach (var remain in tr.Tree.StackRemains)
{
varUsage.Remove(remain);
}
var simpleVars = new HashSet <ILASTVariable>(varUsage.Where(usage => usage.Value == 1).Select(pair => pair.Key));
bool modified;
do
{
modified = false;
for (var i = 0; i < tr.Tree.Count - 1; i++)
{
var assignment = tr.Tree[i] as ILASTAssignment;
if (assignment == null)
{
continue;
}
if (!simpleVars.Contains(assignment.Variable))
{
continue;
}
var expr = GetExpression(tr.Tree[i + 1]);
if (expr == null || expr.ILCode.ToOpCode().Name.StartsWith("stelem"))
{
continue;
}
for (var argIndex = 0; argIndex < expr.Arguments.Length; argIndex++)
{
var argVar = expr.Arguments[argIndex] as ILASTVariable;
// If previous arguments are not variables (ie. expression),
// there might be side-effect inlining succeeding arguments.
if (argVar == null)
{
break;
}
if (argVar == assignment.Variable)
{
expr.Arguments[argIndex] = assignment.Value;
tr.Tree.RemoveAt(i);
i--;
modified = true;
break;
}
}
// Ensure the block is processed sequentially.
if (modified)
{
break;
}
}
} while(modified);
}
protected virtual void TransformILAST()
{
var transformer = new ILASTTransformer(Method, RootScope, Runtime);
transformer.Transform();
}
