/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
/**
* @brief Wrapper class for ScriptMyILGen to do simple optimizations.
* The main one is to figure out which locals are active at the labels
* so the stack capture/restore code doesn't have to do everything.
* Second is it removes unnecessary back-to-back stloc/ldloc's.
*/
namespace OpenSim.Region.ScriptEngine.Yengine
{
/**
* @brief This is a list that keeps track of types pushed on the evaluation stack.
*/
public class StackDepth: List<Type>
{
public List<bool> isBoxeds = new List<bool>();
/**
* @brief Clear both stacks.
*/
public new void Clear()
{
base.Clear();
isBoxeds.Clear();
}
/**
* @brief Pop call parameters and validate the types.
*/
public void Pop(ParameterInfo[] pis)
{
int n = pis.Length;
int c = this.Count;
if(n > c)
throw new Exception("stack going negative");
for(int i = n; --i >= 0;)
{
--c;
ExpectedVsOnStack(pis[i].ParameterType, this[c], isBoxeds[c]);
}
Pop(n);
}
/**
* @brief Pop values and validate the types.
*/
public void Pop(Type[] ts)
{
int n = ts.Length;
int c = this.Count;
if(n > c)
throw new Exception("stack going negative");
for(int i = ts.Length; --i >= 0;)
{
--c;
ExpectedVsOnStack(ts[i], this[c], isBoxeds[c]);
}
Pop(n);
}
/**
* @brief Pop a single value and validate the type.
*/
public void Pop(Type t)
{
int c = this.Count;
if(c < 1)
throw new Exception("stack going negative");
ExpectedVsOnStack(t, this[c - 1], isBoxeds[c - 1]);
Pop(1);
}
/**
* @brief Pop a single value and validate that it is a numeric type.
*/
public Type PopNumVal()
{
int c = this.Count;
if(c < 1)
throw new Exception("stack going negative");
Type st = this[--c];
if(st == null)
{
throw new Exception("stack has null, expecting a numeric");
}
if(isBoxeds[c])
{
throw new Exception("stack is boxed " + st.Name + ", expecting a numeric");
}
if((st != typeof(bool)) && (st != typeof(char)) && (st != typeof(int)) &&
(st != typeof(long)) && (st != typeof(float)) && (st != typeof(double)))
{
throw new Exception("stack has " + st.Name + ", expecting a numeric");
}
return Pop(1);
}
/**
* @brief Pop a single value and validate that it is a reference type
*/
public Type PopRef()
{
int c = this.Count;
if(c < 1)
throw new Exception("stack going negative");
Type st = this[--c];
if((st != null) && !isBoxeds[c] && st.IsValueType)
{
throw new Exception("stack has " + st.Name + ", expecting a ref type");
}
return Pop(1);
}
/**
* @brief Pop a single value and validate that it is a value type
*/
public Type PopValue()
{
int c = this.Count;
if(c < 1)
throw new Exception("stack going negative");
Type st = this[--c];
if(st == null)
{
throw new Exception("stack has null, expecting a value type");
}
if(!st.IsValueType)
{
throw new Exception("stack has " + st.Name + ", expecting a value type");
}
if(isBoxeds[c])
{
throw new Exception("stack has boxed " + st.Name + ", expecting an unboxed value type");
}
return Pop(1);
}
// ex = what is expected to be on stack
// st = what is actually on stack (null for ldnull)
// stBoxed = stack value is boxed
public static void ExpectedVsOnStack(Type ex, Type st, bool stBoxed)
{
// ldnull pushed on stack can go into any pointer type
if(st == null)
{
if(ex.IsByRef || ex.IsPointer || ex.IsClass || ex.IsInterface)
return;
throw new Exception("stack has null, expect " + ex.Name);
}
// simple case of expecting an object
// ...so the stack can have object,string, etc
// but we cant allow int = boxed int here
if(ex.IsAssignableFrom(st) && !stBoxed)
return;
// case of expecting an enum on the stack
// but all the CIL code knows about are ints etc
// so convert the Enum type to integer or whatever
// and that should be assignable from what's on stack
if(ex.IsEnum && typeof(int).IsAssignableFrom(st))
return;
// bool, char, int are interchangeable on the stack
if((ex == typeof(bool) || ex == typeof(char) || ex == typeof(int)) &&
(st == typeof(bool) || st == typeof(char) || st == typeof(int)))
return;
// float and double are interchangeable on the stack
if((ex == typeof(float) || ex == typeof(double)) &&
(st == typeof(float) || st == typeof(double)))
return;
// object can accept any boxed type
if((ex == typeof(object)) && stBoxed)
return;
// otherwise, it is disallowed
throw new Exception("stack has " + StackTypeString(st, stBoxed) + ", expect " + ex.Name);
}
/**
* @brief Pop values without any validation.
*/
public Type Pop(int n)
{
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
Type lastPopped = null;
int c = this.Count;
if(n > c)
throw new Exception("stack going negative");
if(n > 0)
{
lastPopped = this[c - n];
this.RemoveRange(c - n, n);
isBoxeds.RemoveRange(c - n, n);
}
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
return lastPopped;
}
/**
* @brief Peek at the n'th stack value.
* n = 0 : top of stack
* 1 : next to top
* ...
*/
public Type Peek(int n)
{
int c = this.Count;
if(n > c - 1)
throw new Exception("stack going negative");
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
return this[c - n - 1];
}
public bool PeekBoxed(int n)
{
int c = isBoxeds.Count;
if(n > c - 1)
throw new Exception("stack going negative");
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
return isBoxeds[c - n - 1];
}
/**
* @brief Push a single value of the given type.
*/
public void Push(Type t)
{
Push(t, false);
}
public void Push(Type t, bool isBoxed)
{
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
this.Add(t);
isBoxeds.Add(isBoxed);
}
/**
* @brief See if the types at a given label exactly match those on the stack.
* We should have the stack types be the same no matter how we branched
* or fell through to a particular label.
*/
public void Matches(ScriptMyLabel label)
{
Type[] ts = label.stackDepth;
bool[] tsBoxeds = label.stackBoxeds;
int i;
if(this.Count != isBoxeds.Count)
throw new Exception("isBoxeds count bad");
if(ts == null)
{
label.stackDepth = this.ToArray();
label.stackBoxeds = isBoxeds.ToArray();
}
else if(ts.Length != this.Count)
{
throw new Exception("stack depth mismatch");
}
else
{
for(i = this.Count; --i >= 0;)
{
if(tsBoxeds[i] != this.isBoxeds[i])
goto mismatch;
if(ts[i] == this[i])
continue;
if((ts[i] == typeof(bool) || ts[i] == typeof(char) || ts[i] == typeof(int)) &&
(this[i] == typeof(bool) || this[i] == typeof(char) || this[i] == typeof(int)))
continue;
if((ts[i] == typeof(double) || ts[i] == typeof(float)) &&
(this[i] == typeof(double) || this[i] == typeof(float)))
continue;
goto mismatch;
}
}
return;
mismatch:
throw new Exception("stack type mismatch: " + StackTypeString(ts[i], tsBoxeds[i]) + " vs " + StackTypeString(this[i], this.isBoxeds[i]));
}
private static string StackTypeString(Type ts, bool isBoxed)
{
if(!isBoxed)
return ts.Name;
return "[" + ts.Name + "]";
}
}
/**
* @brief One of these per opcode and label in the function plus other misc markers.
* They form the CIL instruction stream of the function.
*/
public abstract class GraphNode
{
private static readonly bool DEBUG = false;
public const int OPINDENT = 4;
public const int OPDEBLEN = 12;
public ScriptCollector coll;
public GraphNodeBeginExceptionBlock tryBlock; // start of enclosing try block
// valid in the try section
// null in the catch/finally sections
// null outside of try block
// for the try node itself, links to outer try block
public GraphNodeBeginExceptionBlock excBlock; // start of enclosing try block
// valid in the try/catch/finally sections
// null outside of try/catch/finally block
// for the try node itself, links to outer try block
/*
* List of nodes in order as originally given.
*/
public GraphNode nextLin, prevLin;
public int linSeqNo;
/**
* @brief Save pointer to collector.
*/
public GraphNode(ScriptCollector coll)
{
this.coll = coll;
}
/**
* @brief Chain graph node to end of linear list.
*/
public virtual void ChainLin()
{
coll.lastLin.nextLin = this;
this.prevLin = coll.lastLin;
coll.lastLin = this;
this.tryBlock = coll.curTryBlock;
this.excBlock = coll.curExcBlock;
if(DEBUG)
{
StringBuilder sb = new StringBuilder("ChainLin*:");
sb.Append(coll.stackDepth.Count.ToString("D2"));
sb.Append(' ');
this.DebString(sb);
Console.WriteLine(sb.ToString());
}
}
/**
* @brief Append full info to debugging string for printing out the instruction.
*/
public void DebStringExt(StringBuilder sb)
{
int x = sb.Length;
sb.Append(this.linSeqNo.ToString().PadLeft(5));
sb.Append(": ");
this.DebString(sb);
if(this.ReadsLocal() != null)
ScriptCollector.PadToLength(sb, x + 60, " [read]");
if(this.WritesLocal() != null)
ScriptCollector.PadToLength(sb, x + 68, " [write]");
ScriptCollector.PadToLength(sb, x + 72, " ->");
bool first = true;
foreach(GraphNode nn in this.NextNodes)
{
if(first)
{
sb.Append(nn.linSeqNo.ToString().PadLeft(5));
first = false;
}
else
{
sb.Append(',');
sb.Append(nn.linSeqNo);
}
}
}
/**
* @brief See if it's possible for it to fall through to the next inline (nextLin) instruction.
*/
public virtual bool CanFallThrough()
{
return true;
}
/**
* @brief Append to debugging string for printing out the instruction.
*/
public abstract void DebString(StringBuilder sb);
public override string ToString()
{
StringBuilder sb = new StringBuilder();
this.DebString(sb);
return sb.ToString();
}
/**
* @brief See if this instruction reads a local variable.
*/
public virtual ScriptMyLocal ReadsLocal()
{
return null;
}
/**
* @brief See if this instruction writes a local variable.
*/
public virtual ScriptMyLocal WritesLocal()
{
return null;
}
/**
* @brief Write this instruction out to the wrapped object file.
*/
public abstract void WriteOutOne(ScriptMyILGen ilGen);
/**
* @brief Iterate through all the possible next nodes, including the next inline node, if any.
* The next inline code is excluded if the instruction never falls through, eg, return, unconditional branch.
* It includes a possible conditional branch to the beginning of the corresponding catch/finally of every
* instruction in a try section.
*/
private System.Collections.Generic.IEnumerable<GraphNode> nextNodes, nextNodesCatchFinally;
public System.Collections.Generic.IEnumerable<GraphNode> NextNodes
{
get
{
if(nextNodes == null)
{
nextNodes = GetNNEnumerable();
nextNodesCatchFinally = new NNEnumerableCatchFinally(this);
}
return nextNodesCatchFinally;
}
}
/**
* @brief This acts as a wrapper around all the other NNEnumerable's below.
* It assumes every instruction in a try { } can throw an exception so it
* says that every instruction in a try { } can conditionally branch to
* the beginning of the corresponding catch { } or finally { }.
*/
private class NNEnumerableCatchFinally: System.Collections.Generic.IEnumerable<GraphNode>
{
private GraphNode gn;
public NNEnumerableCatchFinally(GraphNode gn)
{
this.gn = gn;
}
System.Collections.Generic.IEnumerator<GraphNode> System.Collections.Generic.IEnumerable<GraphNode>.GetEnumerator()
{
return new NNEnumeratorCatchFinally(gn);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return new NNEnumeratorCatchFinally(gn);
}
}
private class NNEnumeratorCatchFinally: NNEnumeratorBase
{
private GraphNode gn;
private int index = 0;
private System.Collections.Generic.IEnumerator<GraphNode> realEnumerator;
public NNEnumeratorCatchFinally(GraphNode gn)
{
this.gn = gn;
this.realEnumerator = gn.nextNodes.GetEnumerator();
}
public override bool MoveNext()
{
// First off, return any targets the instruction can come up with.
if(realEnumerator.MoveNext())
{
nn = realEnumerator.Current;
return true;
}
// Then if this instruction is in a try section, say this instruction
// can potentially branch to the beginning of the corresponding
// catch/finally.
if((index == 0) && (gn.tryBlock != null))
{
index++;
nn = gn.tryBlock.catchFinallyBlock;
return true;
}
// That's all we can do.
nn = null;
return false;
}
public override void Reset()
{
realEnumerator.Reset();
index = 0;
nn = null;
}
}
/**
* @brief This default iterator always returns the next inline node as the one-and-only next node.
* Other instructions need to override it if they can possibly do other than that.
*/
/**
* @brief GetNNEnumerable() gets the nextnode enumerable part of a GraphNode,
* which in turn gives the list of nodes that can possibly be next in
* a flow-control sense. It simply instantiates the NNEnumerator sub-
* class which does the actual enumeration.
*/
protected virtual System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNode gn;
private int index;
public NNEnumerator(GraphNode gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
switch(index)
{
case 0:
{
index++;
nn = gn.nextLin;
return nn != null;
}
case 1:
{
nn = null;
return false;
}
}
throw new Exception();
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
/**
* @brief Things that derive from this are the beginning of a block.
* A block of code is that which begins with a label or is the beginning of all code
* and it contains no labels, ie, it can't be jumped into other than at its beginning.
*/
public abstract class GraphNodeBlock: GraphNode
{
public List<ScriptMyLocal> localsWrittenBeforeRead = new List<ScriptMyLocal>();
public List<ScriptMyLocal> localsReadBeforeWritten = new List<ScriptMyLocal>();
public int hasBeenResolved;
public GraphNodeBlock(ScriptCollector coll) : base(coll) { }
}
/**
* @brief This placeholder is at the beginning of the code so the first few instructions
* belong to some block.
*/
public class GraphNodeBegin: GraphNodeBlock
{
public GraphNodeBegin(ScriptCollector coll) : base(coll) { }
public override void DebString(StringBuilder sb)
{
sb.Append("begin");
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
}
}
/**
* @brief Beginning of try block.
*/
public class GraphNodeBeginExceptionBlock: GraphNodeBlock
{
public GraphNodeBeginExceptionBlock outerTryBlock; // next outer try opcode or null
public GraphNodeCatchFinallyBlock catchFinallyBlock; // start of associated catch or finally
public GraphNodeEndExceptionBlock endExcBlock; // end of associated catch or finally
public int excBlkSeqNo; // debugging
public GraphNodeBeginExceptionBlock(ScriptCollector coll) : base(coll)
{
}
public override void ChainLin()
{
base.ChainLin();
// we should always start try blocks with nothing on stack
// ...as CLI wipes stack for various conditions
if(coll.stackDepth.Count != 0)
{
throw new Exception("stack depth " + coll.stackDepth.Count);
}
}
public override void DebString(StringBuilder sb)
{
sb.Append(" beginexceptionblock_");
sb.Append(excBlkSeqNo);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.BeginExceptionBlock();
}
}
/**
* @brief Beginning of catch or finally block.
*/
public abstract class GraphNodeCatchFinallyBlock: GraphNodeBlock
{
public GraphNodeCatchFinallyBlock(ScriptCollector coll) : base(coll)
{
}
public override void ChainLin()
{
base.ChainLin();
// we should always start catch/finally blocks with nothing on stack
// ...as CLI wipes stack for various conditions
if(coll.stackDepth.Count != 0)
{
throw new Exception("stack depth " + coll.stackDepth.Count);
}
}
}
/**
* @brief Beginning of catch block.
*/
public class GraphNodeBeginCatchBlock: GraphNodeCatchFinallyBlock
{
public Type excType;
public GraphNodeBeginCatchBlock(ScriptCollector coll, Type excType) : base(coll)
{
this.excType = excType;
}
public override void ChainLin()
{
base.ChainLin();
// catch block always enters with one value on stack
if(coll.stackDepth.Count != 0)
{
throw new Exception("stack depth " + coll.stackDepth.Count);
}
coll.stackDepth.Push(excType);
}
public override void DebString(StringBuilder sb)
{
sb.Append(" begincatchblock_");
sb.Append(excBlock.excBlkSeqNo);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.BeginCatchBlock(excType);
}
/**
* @brief The beginning of every catch { } conditinally branches to the beginning
* of all outer catch { }s up to and including the next outer finally { }.
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeBeginCatchBlock gn;
private int index;
public NNEnumerator(GraphNodeBeginCatchBlock gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
while(true)
{
switch(index)
{
case 0:
{
// start with the fallthru
nn = gn.nextLin;
index++;
return true;
}
case 1:
{
// get the first outer catch { } or finally { }
// pretend we last returned beginning of this catch { }
// then loop back to get next outer catch { } or finally { }
nn = gn;
break;
}
case 2:
{
// nn points to a catch { } previously returned
// get the corresponding try { }
GraphNodeBeginExceptionBlock nntry = nn.excBlock;
// step out to next outer try { }
nntry = nntry.excBlock;
if(nntry == null)
break;
// return corresponding catch { } or finally { }
nn = nntry.catchFinallyBlock;
// if it's a finally { } we don't do anything after that
if(nn is GraphNodeBeginFinallyBlock)
index++;
return true;
}
case 3:
{
// we've returned the fallthru, catches and one finally
// so there's nothing more to say
nn = null;
return false;
}
default:
throw new Exception();
}
index++;
}
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
/**
* @brief Beginning of finally block.
*/
public class GraphNodeBeginFinallyBlock: GraphNodeCatchFinallyBlock
{
// leaveTargets has a list of all the targets of any contained
// leave instructions, ie, where an endfinally can possibly jump.
// But only those targets within the next outer finally { }, we
// don't contain any targets outside of that, those targets are
// stored in the actual finally that will jump to the target.
// The endfinally enumerator assumes that it is always possible
// for it to jump to the next outer finally (as would happen for
// an uncaught exception), so no need to do anything special.
public List<GraphNodeBlock> leaveTargets = new List<GraphNodeBlock>();
public GraphNodeBeginFinallyBlock(ScriptCollector coll) : base(coll)
{
}
public override void DebString(StringBuilder sb)
{
sb.Append(" beginfinallyblock_");
sb.Append(excBlock.excBlkSeqNo);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.BeginFinallyBlock();
}
}
/**
* @brief End of try/catch/finally block.
*/
public class GraphNodeEndExceptionBlock: GraphNode
{
public GraphNodeEndExceptionBlock(ScriptCollector coll) : base(coll)
{
}
public override void ChainLin()
{
base.ChainLin();
// we should always end exception blocks with nothing on stack
// ...as CLI wipes stack for various conditions
if(coll.stackDepth.Count != 0)
{
throw new Exception("stack depth " + coll.stackDepth.Count);
}
}
public override void DebString(StringBuilder sb)
{
sb.Append(" endexceptionblock_");
sb.Append(excBlock.excBlkSeqNo);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.EndExceptionBlock();
}
}
/**
* @brief Actual instruction emits...
*/
public abstract class GraphNodeEmit: GraphNode
{
public OpCode opcode;
public Token errorAt;
public GraphNodeEmit(ScriptCollector coll, Token errorAt, OpCode opcode) : base(coll)
{
this.opcode = opcode;
this.errorAt = errorAt;
}
public override void ChainLin()
{
base.ChainLin();
// compute resultant stack depth
int stack = coll.stackDepth.Count;
if((stack != 0) && ((opcode == OpCodes.Endfinally) || (opcode == OpCodes.Leave) || (opcode == OpCodes.Rethrow)))
{
throw new Exception(opcode + " stack depth " + stack);
}
if((stack != 1) && (opcode == OpCodes.Throw))
{
throw new Exception(opcode + " stack depth " + stack);
}
}
/**
* @brief See if it's possible for it to fall through to the next inline (nextLin) instruction.
*/
public override bool CanFallThrough()
{
switch(opcode.FlowControl)
{
case FlowControl.Branch:
return false; // unconditional branch
case FlowControl.Break:
return true; // break
case FlowControl.Call:
return true; // call
case FlowControl.Cond_Branch:
return true; // conditional branch
case FlowControl.Next:
return true; // falls through to next instruction
case FlowControl.Return:
return false; // return
case FlowControl.Throw:
return false; // throw
default:
{
string op = opcode.ToString();
if(op == "volatile.")
return true;
throw new Exception("unknown flow control " + opcode.FlowControl + " for " + op);
}
}
}
// if followed by OpCodes.Pop, it can be discarded
public bool isPoppable
{
get
{
return
((opcode.StackBehaviourPop == StackBehaviour.Pop0) && // ldarg,ldloc,ldsfld
(opcode.StackBehaviourPush == StackBehaviour.Push1)) ||
((opcode.StackBehaviourPop == StackBehaviour.Pop0) && // ldarga,ldloca,ldc,ldsflda,...
(opcode.StackBehaviourPush == StackBehaviour.Pushi)) ||
(opcode == OpCodes.Ldnull) ||
(opcode == OpCodes.Ldc_R4) ||
(opcode == OpCodes.Ldc_R8) ||
(opcode == OpCodes.Ldstr) ||
(opcode == OpCodes.Ldc_I8) ||
(opcode == OpCodes.Dup);
}
}
public override void DebString(StringBuilder sb)
{
sb.Append("".PadRight(OPINDENT));
sb.Append(opcode.ToString().PadRight(OPDEBLEN));
}
/**
* @brief If instruction is terminating, we say there is nothing following (eg, return).
* Otherwise, say the one-and-only next instruction is the next instruction inline.
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeEmit gn;
private int index;
public NNEnumerator(GraphNodeEmit gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
switch(index)
{
case 0:
{
if(gn.CanFallThrough())
{
index++;
nn = gn.nextLin;
return nn != null;
}
return false;
}
case 1:
{
nn = null;
return false;
}
}
throw new Exception();
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
public class GraphNodeEmitNull: GraphNodeEmit
{
public GraphNodeEmitNull(ScriptCollector coll, Token errorAt, OpCode opcode) : base(coll, errorAt, opcode)
{
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "nop":
break;
case "break":
break;
case "volatile.":
break;
case "ldarg.0":
coll.stackDepth.Push(coll.wrapped.argTypes[0]);
break;
case "ldarg.1":
coll.stackDepth.Push(coll.wrapped.argTypes[1]);
break;
case "ldarg.2":
coll.stackDepth.Push(coll.wrapped.argTypes[2]);
break;
case "ldarg.3":
coll.stackDepth.Push(coll.wrapped.argTypes[3]);
break;
case "ldnull":
coll.stackDepth.Push(null);
break;
case "ldc.i4.m1":
case "ldc.i4.0":
case "ldc.i4.1":
case "ldc.i4.2":
case "ldc.i4.3":
case "ldc.i4.4":
case "ldc.i4.5":
case "ldc.i4.6":
case "ldc.i4.7":
case "ldc.i4.8":
{
coll.stackDepth.Push(typeof(int));
break;
}
case "dup":
{
Type t = coll.stackDepth.Peek(0);
bool b = coll.stackDepth.PeekBoxed(0);
coll.stackDepth.Push(t, b);
break;
}
case "pop":
{
coll.stackDepth.Pop(1);
break;
}
case "ret":
{
int sd = (coll.wrapped.retType != typeof(void)) ? 1 : 0;
if(coll.stackDepth.Count != sd)
throw new Exception("bad stack depth");
if(sd > 0)
{
coll.stackDepth.Pop(coll.wrapped.retType);
}
break;
}
case "add":
case "sub":
case "mul":
case "div":
case "div.un":
case "rem":
case "rem.un":
case "and":
case "or":
case "xor":
case "shl":
case "shr":
case "shr.un":
case "add.ovf":
case "add.ovf.un":
case "mul.ovf":
case "mul.ovf.un":
case "sub.ovf":
case "sub.ovf.un":
{
coll.stackDepth.PopNumVal();
Type t = coll.stackDepth.PopNumVal();
coll.stackDepth.Push(t);
break;
}
case "neg":
case "not":
{
Type t = coll.stackDepth.PopNumVal();
coll.stackDepth.Push(t);
break;
}
case "conv.i1":
case "conv.i2":
case "conv.i4":
case "conv.i8":
case "conv.r4":
case "conv.r8":
case "conv.u4":
case "conv.u8":
case "conv.r.un":
case "conv.ovf.i1.un":
case "conv.ovf.i2.un":
case "conv.ovf.i4.un":
case "conv.ovf.i8.un":
case "conv.ovf.u1.un":
case "conv.ovf.u2.un":
case "conv.ovf.u4.un":
case "conv.ovf.u8.un":
case "conv.ovf.i.un":
case "conv.ovf.u.un":
case "conv.ovf.i1":
case "conv.ovf.u1":
case "conv.ovf.i2":
case "conv.ovf.u2":
case "conv.ovf.i4":
case "conv.ovf.u4":
case "conv.ovf.i8":
case "conv.ovf.u8":
case "conv.u2":
case "conv.u1":
case "conv.i":
case "conv.ovf.i":
case "conv.ovf.u":
case "conv.u":
{
coll.stackDepth.PopNumVal();
coll.stackDepth.Push(ConvToType(opcode));
break;
}
case "throw":
{
if(coll.stackDepth.Count != 1)
throw new Exception("bad stack depth " + coll.stackDepth.Count);
coll.stackDepth.PopRef();
break;
}
case "ldlen":
{
coll.stackDepth.Pop(typeof(string));
coll.stackDepth.Push(typeof(int));
break;
}
case "ldelem.i1":
case "ldelem.u1":
case "ldelem.i2":
case "ldelem.u2":
case "ldelem.i4":
case "ldelem.u4":
case "ldelem.i8":
case "ldelem.i":
case "ldelem.r4":
case "ldelem.r8":
case "ldelem.ref":
{
Type t = coll.stackDepth.Peek(1).GetElementType();
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(t.MakeArrayType());
coll.stackDepth.Push(t);
break;
}
case "stelem.i":
case "stelem.i1":
case "stelem.i2":
case "stelem.i4":
case "stelem.i8":
case "stelem.r4":
case "stelem.r8":
case "stelem.ref":
{
Type t = coll.stackDepth.Peek(2).GetElementType();
coll.stackDepth.Pop(t);
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(t.MakeArrayType());
break;
}
case "endfinally":
case "rethrow":
{
if(coll.stackDepth.Count != 0)
throw new Exception("bad stack depth " + coll.stackDepth.Count);
break;
}
case "ceq":
{
Type t = coll.stackDepth.Pop(1);
if(t == null)
{
coll.stackDepth.PopRef();
}
else
{
coll.stackDepth.Pop(t);
}
coll.stackDepth.Push(typeof(int));
break;
}
case "cgt":
case "cgt.un":
case "clt":
case "clt.un":
{
coll.stackDepth.PopNumVal();
coll.stackDepth.PopNumVal();
coll.stackDepth.Push(typeof(int));
break;
}
case "ldind.i4":
{
coll.stackDepth.Pop(typeof(int).MakeByRefType());
coll.stackDepth.Push(typeof(int));
break;
}
case "stind.i4":
{
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(typeof(int).MakeByRefType());
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
private static Type ConvToType(OpCode opcode)
{
string s = opcode.ToString();
s = s.Substring(5); // strip off "conv."
if(s.StartsWith("ovf."))
s = s.Substring(4);
if(s.EndsWith(".un"))
s = s.Substring(0, s.Length - 3);
switch(s)
{
case "i":
return typeof(IntPtr);
case "i1":
return typeof(sbyte);
case "i2":
return typeof(short);
case "i4":
return typeof(int);
case "i8":
return typeof(long);
case "r":
case "r4":
return typeof(float);
case "r8":
return typeof(double);
case "u1":
return typeof(byte);
case "u2":
return typeof(ushort);
case "u4":
return typeof(uint);
case "u8":
return typeof(ulong);
case "u":
return typeof(UIntPtr);
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode);
}
}
public class GraphNodeEmitNullEndfinally: GraphNodeEmitNull
{
public GraphNodeEmitNullEndfinally(ScriptCollector coll, Token errorAt) : base(coll, errorAt, OpCodes.Endfinally)
{
}
/**
* @brief Endfinally can branch to:
* 1) the corresponding EndExceptionBlock
* 2) any of the corresponding BeginFinallyBlock's leaveTargets
* 3) the next outer BeginFinallyBlock
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeEmitNullEndfinally gn;
private IEnumerator<GraphNodeBlock> leaveTargetEnumerator;
private int index;
public NNEnumerator(GraphNodeEmitNullEndfinally gn)
{
this.gn = gn;
// endfinally instruction must be within some try/catch/finally mess
GraphNodeBeginExceptionBlock thistry = gn.excBlock;
// endfinally instruction must be within some finally { } mess
GraphNodeBeginFinallyBlock thisfin = (GraphNodeBeginFinallyBlock)thistry.catchFinallyBlock;
// get the list of the finally { } leave instruction targets
this.leaveTargetEnumerator = thisfin.leaveTargets.GetEnumerator();
}
public override bool MoveNext()
{
while(true)
{
switch(index)
{
// to start, return end of our finally { }
case 0:
{
GraphNodeBeginExceptionBlock thistry = gn.excBlock;
nn = thistry.endExcBlock;
if(nn == null)
throw new NullReferenceException("thistry.endExcBlock");
index++;
return true;
}
// return next one of our finally { }'s leave targets
// ie, where any leave instructions in the try { } want
// the finally { } to go to when it finishes
case 1:
{
if(this.leaveTargetEnumerator.MoveNext())
{
nn = this.leaveTargetEnumerator.Current;
if(nn == null)
throw new NullReferenceException("this.leaveTargetEnumerator.Current");
return true;
}
break;
}
// return beginning of next outer finally { }
case 2:
{
GraphNodeBeginExceptionBlock nntry = gn.excBlock;
while((nntry = nntry.excBlock) != null)
{
if(nntry.catchFinallyBlock is GraphNodeBeginFinallyBlock)
{
nn = nntry.catchFinallyBlock;
if(nn == null)
throw new NullReferenceException("nntry.catchFinallyBlock");
index++;
return true;
}
}
break;
}
// got nothing more
case 3:
{
return false;
}
default:
throw new Exception();
}
index++;
}
}
public override void Reset()
{
leaveTargetEnumerator.Reset();
index = 0;
nn = null;
}
}
}
public class GraphNodeEmitField: GraphNodeEmit
{
public FieldInfo field;
public GraphNodeEmitField(ScriptCollector coll, Token errorAt, OpCode opcode, FieldInfo field) : base(coll, errorAt, opcode)
{
this.field = field;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldfld":
PopPointer();
coll.stackDepth.Push(field.FieldType);
break;
case "ldflda":
PopPointer();
coll.stackDepth.Push(field.FieldType.MakeByRefType());
break;
case "stfld":
coll.stackDepth.Pop(field.FieldType);
PopPointer();
break;
case "ldsfld":
coll.stackDepth.Push(field.FieldType);
break;
case "ldsflda":
coll.stackDepth.Push(field.FieldType.MakeByRefType());
break;
case "stsfld":
coll.stackDepth.Pop(field.FieldType);
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
private void PopPointer()
{
Type t = field.DeclaringType; // get class/field type
if(t.IsValueType)
{
Type brt = t.MakeByRefType(); // if value type, eg Vector, it can be pushed by reference or by value
int c = coll.stackDepth.Count;
if((c > 0) && (coll.stackDepth[c - 1] == brt))
t = brt;
}
coll.stackDepth.Pop(t); // type of what should be on the stack pointing to object or struct
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(field.Name);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, field);
}
}
public class GraphNodeEmitLocal: GraphNodeEmit
{
public ScriptMyLocal myLocal;
public GraphNodeEmitLocal(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLocal myLocal) : base(coll, errorAt, opcode)
{
this.myLocal = myLocal;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldloc":
coll.stackDepth.Push(myLocal.type);
break;
case "ldloca":
coll.stackDepth.Push(myLocal.type.MakeByRefType());
break;
case "stloc":
coll.stackDepth.Pop(myLocal.type);
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(myLocal.name);
}
public override ScriptMyLocal ReadsLocal()
{
if(opcode == OpCodes.Ldloc)
return myLocal;
if(opcode == OpCodes.Ldloca)
return myLocal;
if(opcode == OpCodes.Stloc)
return null;
throw new Exception("unknown opcode " + opcode);
}
public override ScriptMyLocal WritesLocal()
{
if(opcode == OpCodes.Ldloc)
return null;
if(opcode == OpCodes.Ldloca)
return myLocal;
if(opcode == OpCodes.Stloc)
return myLocal;
throw new Exception("unknown opcode " + opcode);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, myLocal);
}
}
public class GraphNodeEmitType: GraphNodeEmit
{
public Type type;
public GraphNodeEmitType(ScriptCollector coll, Token errorAt, OpCode opcode, Type type) : base(coll, errorAt, opcode)
{
this.type = type;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "castclass":
case "isinst":
{
coll.stackDepth.PopRef();
coll.stackDepth.Push(type, type.IsValueType);
break;
}
case "box":
{
if(!type.IsValueType)
throw new Exception("can't box a non-value type");
coll.stackDepth.Pop(type);
coll.stackDepth.Push(type, true);
break;
}
case "unbox":
case "unbox.any":
{
if(!type.IsValueType)
throw new Exception("can't unbox to a non-value type");
coll.stackDepth.PopRef();
coll.stackDepth.Push(type);
break;
}
case "newarr":
{
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Push(type.MakeArrayType());
break;
}
case "sizeof":
{
coll.stackDepth.Pop(1);
coll.stackDepth.Push(typeof(int));
break;
}
case "ldelem":
{
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(type.MakeArrayType());
coll.stackDepth.Push(type);
break;
}
case "ldelema":
{
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(type.MakeArrayType());
coll.stackDepth.Push(type.MakeByRefType());
break;
}
case "stelem":
{
coll.stackDepth.Pop(type);
coll.stackDepth.Pop(typeof(int));
coll.stackDepth.Pop(type.MakeArrayType());
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(type.Name);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, type);
}
}
public class GraphNodeEmitLabel: GraphNodeEmit
{
public ScriptMyLabel myLabel;
public GraphNodeEmitLabel(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLabel myLabel) : base(coll, errorAt, opcode)
{
this.myLabel = myLabel;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "brfalse.s":
case "brtrue.s":
case "brfalse":
case "brtrue":
{
coll.stackDepth.Pop(1);
break;
}
case "beq.s":
case "bge.s":
case "bgt.s":
case "ble.s":
case "blt.s":
case "bne.un.s":
case "bge.un.s":
case "bgt.un.s":
case "ble.un.s":
case "blt.un.s":
case "beq":
case "bge":
case "bgt":
case "ble":
case "blt":
case "bne.un":
case "bge.un":
case "bgt.un":
case "ble.un":
case "blt.un":
{
coll.stackDepth.PopNumVal();
coll.stackDepth.PopNumVal();
break;
}
case "br":
case "br.s":
break;
case "leave":
{
if(coll.stackDepth.Count != 0)
throw new Exception("bad stack depth " + coll.stackDepth.Count);
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
// if a target doesn't have a depth yet, set its depth to the depth after instruction executes
// otherwise, make sure it matches all other branches to that target and what fell through to it
coll.stackDepth.Matches(myLabel);
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(myLabel.name);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, myLabel);
}
/**
* @brief Conditional branches return the next inline followed by the branch target
* Unconditional branches return only the branch target
* But if the target is outside our scope (eg __retlbl), omit it from the list
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeEmitLabel gn;
private int index;
public NNEnumerator(GraphNodeEmitLabel gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
switch(gn.opcode.FlowControl)
{
case FlowControl.Branch:
{
// unconditional branch just goes to target and nothing else
switch(index)
{
case 0:
{
nn = gn.myLabel.whereAmI;
index++;
return nn != null;
}
case 1:
{
return false;
}
}
throw new Exception();
}
case FlowControl.Cond_Branch:
{
// conditional branch goes inline and to target
switch(index)
{
case 0:
{
nn = gn.nextLin;
index++;
return true;
}
case 1:
{
nn = gn.myLabel.whereAmI;
index++;
return nn != null;
}
case 2:
{
return false;
}
}
throw new Exception();
}
default:
throw new Exception("unknown flow control " + gn.opcode.FlowControl.ToString() +
" of " + gn.opcode.ToString());
}
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
public class GraphNodeEmitLabelLeave: GraphNodeEmitLabel
{
public GraphNodeBlock unwindTo; // if unwinding, innermost finally block being unwound
// else, same as myTarget.whereAmI
// null if unwinding completely out of scope, eg, __retlbl
public GraphNodeEmitLabelLeave(ScriptCollector coll, Token errorAt, ScriptMyLabel myLabel) : base(coll, errorAt, OpCodes.Leave, myLabel)
{
}
/**
* @brief Leave instructions have exactly one unconditional next node.
* Either the given target if within the same try block
* or the beginning of the intervening finally block.
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeEmitLabelLeave gn;
private int index;
public NNEnumerator(GraphNodeEmitLabelLeave gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
if(index == 0)
{
nn = gn.unwindTo;
index++;
return nn != null;
}
nn = null;
return false;
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
public class GraphNodeEmitLabels: GraphNodeEmit
{
public ScriptMyLabel[] myLabels;
public GraphNodeEmitLabels(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels) : base(coll, errorAt, opcode)
{
this.myLabels = myLabels;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "switch":
{
coll.stackDepth.Pop(typeof(int));
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
// if a target doesn't have a depth yet, set its depth to the depth after instruction executes
// otherwise, make sure it matches all other branches to that target and what fell through to it
foreach(ScriptMyLabel myLabel in myLabels)
{
coll.stackDepth.Matches(myLabel);
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
bool first = true;
foreach(ScriptMyLabel lbl in myLabels)
{
if(!first)
sb.Append(',');
sb.Append(lbl.name);
first = false;
}
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, myLabels);
}
/**
* @brief Return list of all labels followed by the next linear instruction
* But if the target is outside our scope (eg __retlbl), omit it from the list
*/
protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
{
return new NNEnumerable(this, typeof(NNEnumerator));
}
private class NNEnumerator: NNEnumeratorBase
{
private GraphNodeEmitLabels gn;
private int index;
public NNEnumerator(GraphNodeEmitLabels gn)
{
this.gn = gn;
}
public override bool MoveNext()
{
// Return next from list of switch case labels.
while(index < gn.myLabels.Length)
{
nn = gn.myLabels[index++].whereAmI;
if(nn != null)
return true;
}
// If all ran out, the switch instruction falls through.
if(index == gn.myLabels.Length)
{
index++;
nn = gn.nextLin;
return true;
}
// Even ran out of that, say there's nothing more.
nn = null;
return false;
}
public override void Reset()
{
index = 0;
nn = null;
}
}
}
public class GraphNodeEmitIntMeth: GraphNodeEmit
{
public ScriptObjWriter method;
public GraphNodeEmitIntMeth(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptObjWriter method) : base(coll, errorAt, opcode)
{
this.method = method;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "call":
{
// calls have Varpop so pop the number of arguments
// they are all static so there is no separate 'this' parameter
coll.stackDepth.Pop(this.method.argTypes);
// calls are also Varpush so they push a return value iff non-void
if(this.method.retType != typeof(void))
coll.stackDepth.Push(this.method.retType);
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(method.methName);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, method);
}
}
public class GraphNodeEmitExtMeth: GraphNodeEmit
{
public MethodInfo method;
public GraphNodeEmitExtMeth(ScriptCollector coll, Token errorAt, OpCode opcode, MethodInfo method) : base(coll, errorAt, opcode)
{
this.method = method;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "call":
case "callvirt":
{
// calls have Varpop so pop the number of arguments
coll.stackDepth.Pop(this.method.GetParameters());
if((this.method.CallingConvention & CallingConventions.HasThis) != 0)
{
coll.stackDepth.Pop(method.DeclaringType);
}
// calls are also Varpush so they push a return value iff non-void
if(this.method.ReturnType != typeof(void))
coll.stackDepth.Push(this.method.ReturnType);
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(method.Name);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, method);
}
}
public class GraphNodeEmitCtor: GraphNodeEmit
{
public ConstructorInfo ctor;
public GraphNodeEmitCtor(ScriptCollector coll, Token errorAt, OpCode opcode, ConstructorInfo ctor) : base(coll, errorAt, opcode)
{
this.ctor = ctor;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "newobj":
{
coll.stackDepth.Pop(ctor.GetParameters());
coll.stackDepth.Push(ctor.DeclaringType);
break;
}
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(ctor.ReflectedType.Name);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, ctor);
}
}
public class GraphNodeEmitDouble: GraphNodeEmit
{
public double value;
public GraphNodeEmitDouble(ScriptCollector coll, Token errorAt, OpCode opcode, double value) : base(coll, errorAt, opcode)
{
this.value = value;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldc.r8":
coll.stackDepth.Push(typeof(double));
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(value);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, value);
}
}
public class GraphNodeEmitFloat: GraphNodeEmit
{
public float value;
public GraphNodeEmitFloat(ScriptCollector coll, Token errorAt, OpCode opcode, float value) : base(coll, errorAt, opcode)
{
this.value = value;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldc.r4":
coll.stackDepth.Push(typeof(float));
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(value);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, value);
}
}
public class GraphNodeEmitInt: GraphNodeEmit
{
public int value;
public GraphNodeEmitInt(ScriptCollector coll, Token errorAt, OpCode opcode, int value) : base(coll, errorAt, opcode)
{
this.value = value;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldarg":
case "ldarg.s":
coll.stackDepth.Push(coll.wrapped.argTypes[value]);
break;
case "ldarga":
case "ldarga.s":
coll.stackDepth.Push(coll.wrapped.argTypes[value].MakeByRefType());
break;
case "starg":
case "starg.s":
coll.stackDepth.Pop(coll.wrapped.argTypes[value]);
break;
case "ldc.i4":
case "ldc.i4.s":
coll.stackDepth.Push(typeof(int));
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append(value);
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, value);
}
}
public class GraphNodeEmitString: GraphNodeEmit
{
public string value;
public GraphNodeEmitString(ScriptCollector coll, Token errorAt, OpCode opcode, string value) : base(coll, errorAt, opcode)
{
this.value = value;
}
public override void ChainLin()
{
base.ChainLin();
switch(opcode.ToString())
{
case "ldstr":
coll.stackDepth.Push(typeof(string));
break;
default:
throw new Exception("unknown opcode " + opcode.ToString());
}
}
public override void DebString(StringBuilder sb)
{
base.DebString(sb);
sb.Append("\"");
sb.Append(value);
sb.Append("\"");
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.Emit(errorAt, opcode, value);
}
}
public class GraphNodeMarkLabel: GraphNodeBlock
{
public ScriptMyLabel myLabel;
public GraphNodeMarkLabel(ScriptCollector coll, ScriptMyLabel myLabel) : base(coll)
{
this.myLabel = myLabel;
}
public override void ChainLin()
{
base.ChainLin();
// if previous instruction can fall through to this label,
// if the label doesn't yet have a stack depth, mark it with current stack depth
// else, the label's stack depth from forward branches and current stack depth must match
// else,
// label must have had a forward branch to it so we can know stack depth
// set the current stack depth to the label's stack depth as of that forward branch
if(myLabel.whereAmI.prevLin.CanFallThrough())
{
coll.stackDepth.Matches(myLabel);
}
else
{
if(myLabel.stackDepth == null)
{
throw new Exception("stack depth unknown at " + myLabel.name);
}
coll.stackDepth.Clear();
int n = myLabel.stackDepth.Length;
for(int i = 0; i < n; i++)
{
coll.stackDepth.Push(myLabel.stackDepth[i], myLabel.stackBoxeds[i]);
}
}
}
public override void DebString(StringBuilder sb)
{
sb.Append(myLabel.name);
sb.Append(':');
if(myLabel.stackDepth != null)
{
sb.Append(" [");
sb.Append(myLabel.stackDepth.Length);
sb.Append(']');
}
}
public override void WriteOutOne(ScriptMyILGen ilGen)
{
ilGen.MarkLabel(myLabel);
}
}
/**
* @brief Generates enumerator that steps through list of nodes that can
* possibly be next in a flow-control sense.
*/
public class NNEnumerable: System.Collections.Generic.IEnumerable<GraphNode>
{
private object[] cps;
private ConstructorInfo ci;
public NNEnumerable(GraphNode gn, Type nnEnumeratorType)
{
this.cps = new object[] { gn };
this.ci = nnEnumeratorType.GetConstructor(new Type[] { gn.GetType() });
}
System.Collections.Generic.IEnumerator<GraphNode> System.Collections.Generic.IEnumerable<GraphNode>.GetEnumerator()
{
return (System.Collections.Generic.IEnumerator<GraphNode>)ci.Invoke(cps);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return (System.Collections.IEnumerator)ci.Invoke(cps);
}
}
/**
* @brief Steps through list of nodes that can possible be next in a flow-control sense.
*/
public abstract class NNEnumeratorBase: System.Collections.Generic.IEnumerator<GraphNode>
{
protected GraphNode nn;
public abstract bool MoveNext();
public abstract void Reset();
GraphNode System.Collections.Generic.IEnumerator<GraphNode>.Current
{
get
{
return this.nn;
}
}
object System.Collections.IEnumerator.Current
{
get
{
return this.nn;
}
}
void System.IDisposable.Dispose()
{
}
}
public class ScriptCollector: ScriptMyILGen
{
public static readonly bool DEBUG = false;
public ScriptObjWriter wrapped;
public GraphNode firstLin, lastLin;
private bool resolvedSomething;
private int resolveSequence;
private int excBlkSeqNos;
public StackDepth stackDepth = new StackDepth();
public GraphNodeBeginExceptionBlock curTryBlock = null; // pushed at beginning of try
// popped at BEGINNING of catch/finally
public GraphNodeBeginExceptionBlock curExcBlock = null; // pushed at beginning of try
// popped at END of catch/finally
private List<ScriptMyLocal> declaredLocals = new List<ScriptMyLocal>();
private List<ScriptMyLabel> definedLabels = new List<ScriptMyLabel>();
public string methName
{
get
{
return wrapped.methName;
}
}
/**
* @brief Wrap the optimizer around the ScriptObjWriter to collect the instruction stream.
* All stream-writing calls get saved to our graph nodes instead of being written to object file.
*/
public ScriptCollector(ScriptObjWriter wrapped)
{
this.wrapped = wrapped;
GraphNodeBegin gnb = new GraphNodeBegin(this);
this.firstLin = gnb;
this.lastLin = gnb;
}
public ScriptMyLocal DeclareLocal(Type type, string name)
{
ScriptMyLocal loc = new ScriptMyLocal();
loc.name = name;
loc.type = type;
loc.number = wrapped.localNumber++;
declaredLocals.Add(loc);
return loc;
}
public ScriptMyLabel DefineLabel(string name)
{
ScriptMyLabel lbl = new ScriptMyLabel();
lbl.name = name;
lbl.number = wrapped.labelNumber++;
definedLabels.Add(lbl);
return lbl;
}
public void BeginExceptionBlock()
{
GraphNodeBeginExceptionBlock tryBlock = new GraphNodeBeginExceptionBlock(this);
tryBlock.ChainLin();
tryBlock.excBlkSeqNo = ++this.excBlkSeqNos;
this.curExcBlock = tryBlock;
this.curTryBlock = tryBlock;
}
public void BeginCatchBlock(Type excType)
{
GraphNodeBeginCatchBlock catchBlock = new GraphNodeBeginCatchBlock(this, excType);
catchBlock.ChainLin();
if(curExcBlock.catchFinallyBlock != null)
throw new Exception("only one catch/finally allowed per try");
curExcBlock.catchFinallyBlock = catchBlock;
curTryBlock = curExcBlock.tryBlock;
}
public void BeginFinallyBlock()
{
GraphNodeBeginFinallyBlock finallyBlock = new GraphNodeBeginFinallyBlock(this);
finallyBlock.ChainLin();
if(curExcBlock.catchFinallyBlock != null)
throw new Exception("only one catch/finally allowed per try");
curExcBlock.catchFinallyBlock = finallyBlock;
curTryBlock = curExcBlock.tryBlock;
}
public void EndExceptionBlock()
{
GraphNodeEndExceptionBlock endExcBlock = new GraphNodeEndExceptionBlock(this);
endExcBlock.ChainLin();
curExcBlock.endExcBlock = endExcBlock;
curTryBlock = curExcBlock.tryBlock;
curExcBlock = curExcBlock.excBlock;
}
public void Emit(Token errorAt, OpCode opcode)
{
if(opcode == OpCodes.Endfinally)
{
new GraphNodeEmitNullEndfinally(this, errorAt).ChainLin();
}
else
{
new GraphNodeEmitNull(this, errorAt, opcode).ChainLin();
}
}
public void Emit(Token errorAt, OpCode opcode, FieldInfo field)
{
if(field == null)
throw new ArgumentNullException("field");
new GraphNodeEmitField(this, errorAt, opcode, field).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLocal myLocal)
{
new GraphNodeEmitLocal(this, errorAt, opcode, myLocal).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, Type type)
{
new GraphNodeEmitType(this, errorAt, opcode, type).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel myLabel)
{
if(opcode == OpCodes.Leave)
{
new GraphNodeEmitLabelLeave(this, errorAt, myLabel).ChainLin();
}
else
{
new GraphNodeEmitLabel(this, errorAt, opcode, myLabel).ChainLin();
}
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels)
{
new GraphNodeEmitLabels(this, errorAt, opcode, myLabels).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, ScriptObjWriter method)
{
if(method == null)
throw new ArgumentNullException("method");
new GraphNodeEmitIntMeth(this, errorAt, opcode, method).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, MethodInfo method)
{
if(method == null)
throw new ArgumentNullException("method");
new GraphNodeEmitExtMeth(this, errorAt, opcode, method).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, ConstructorInfo ctor)
{
if(ctor == null)
throw new ArgumentNullException("ctor");
new GraphNodeEmitCtor(this, errorAt, opcode, ctor).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, double value)
{
new GraphNodeEmitDouble(this, errorAt, opcode, value).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, float value)
{
new GraphNodeEmitFloat(this, errorAt, opcode, value).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, int value)
{
new GraphNodeEmitInt(this, errorAt, opcode, value).ChainLin();
}
public void Emit(Token errorAt, OpCode opcode, string value)
{
new GraphNodeEmitString(this, errorAt, opcode, value).ChainLin();
}
public void MarkLabel(ScriptMyLabel myLabel)
{
myLabel.whereAmI = new GraphNodeMarkLabel(this, myLabel);
myLabel.whereAmI.ChainLin();
}
/**
* @brief Write the whole graph out to the object file.
*/
public ScriptMyILGen WriteOutAll()
{
foreach(ScriptMyLocal loc in declaredLocals)
{
if(loc.isReferenced)
wrapped.DeclareLocal(loc);
}
foreach(ScriptMyLabel lbl in definedLabels)
{
wrapped.DefineLabel(lbl);
}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
gn.WriteOutOne(wrapped);
}
return wrapped;
}
/**
* @brief Perform optimizations.
*/
public void Optimize()
{
if(curExcBlock != null)
throw new Exception("exception block still open");
// If an instruction says it doesn't fall through, remove all instructions to
// the end of the block.
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(!gn.CanFallThrough())
{
GraphNode nn;
while(((nn = gn.nextLin) != null) && !(nn is GraphNodeBlock) &&
!(nn is GraphNodeEndExceptionBlock))
{
if((gn.nextLin = nn.nextLin) != null)
{
nn.nextLin.prevLin = gn;
}
}
}
}
// Scan for OpCodes.Leave instructions.
// For each found, its target for flow analysis purposes is the beginning of the corresponding
// finally block. And the end of the finally block gets a conditional branch target of the
// leave instruction's target. A leave instruction can unwind zero or more finally blocks.
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(gn is GraphNodeEmitLabelLeave)
{
GraphNodeEmitLabelLeave leaveInstr = (GraphNodeEmitLabelLeave)gn; // the leave instruction
GraphNodeMarkLabel leaveTarget = leaveInstr.myLabel.whereAmI; // label being targeted by leave
GraphNodeBeginExceptionBlock leaveTargetsTryBlock = // try block directly enclosing leave target
(leaveTarget == null) ? null : leaveTarget.tryBlock; // ...it must not be unwound
// Step through try { }s from the leave instruction towards its target looking for try { }s with finally { }s.
// The leave instruction unconditionally branches to the beginning of the innermost one found.
// The end of the last one found conditionally branches to the leave instruction's target.
// If none found, the leave is a simple unconditional branch to its target.
GraphNodeBeginFinallyBlock innerFinallyBlock = null;
for(GraphNodeBeginExceptionBlock tryBlock = leaveInstr.tryBlock;
tryBlock != leaveTargetsTryBlock;
tryBlock = tryBlock.tryBlock)
{
if(tryBlock == null)
throw new Exception("leave target not at or outer to leave instruction");
GraphNodeCatchFinallyBlock cfb = tryBlock.catchFinallyBlock;
if(cfb is GraphNodeBeginFinallyBlock)
{
if(innerFinallyBlock == null)
{
leaveInstr.unwindTo = cfb;
}
innerFinallyBlock = (GraphNodeBeginFinallyBlock)cfb;
}
}
// The end of the outermost finally being unwound can conditionally jump to the target of the leave instruction.
// In the case of no finallies being unwound, the leave is just a simple unconditional branch.
if(innerFinallyBlock == null)
{
leaveInstr.unwindTo = leaveTarget;
}
else if(!innerFinallyBlock.leaveTargets.Contains(leaveTarget))
{
innerFinallyBlock.leaveTargets.Add(leaveTarget);
}
}
}
// See which variables a particular block reads before writing.
// This just considers the block itself and nothing that it branches to or fallsthru to.
GraphNodeBlock currentBlock = null;
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(gn is GraphNodeBlock)
currentBlock = (GraphNodeBlock)gn;
ScriptMyLocal rdlcl = gn.ReadsLocal();
if((rdlcl != null) &&
!currentBlock.localsWrittenBeforeRead.Contains(rdlcl) &&
!currentBlock.localsReadBeforeWritten.Contains(rdlcl))
{
currentBlock.localsReadBeforeWritten.Add(rdlcl);
}
ScriptMyLocal wrlcl = gn.WritesLocal();
if((wrlcl != null) &&
!currentBlock.localsWrittenBeforeRead.Contains(wrlcl) &&
!currentBlock.localsReadBeforeWritten.Contains(wrlcl))
{
currentBlock.localsWrittenBeforeRead.Add(wrlcl);
}
}
// For every block we branch to, add that blocks readables to our list of readables,
// because we need to have those values valid on entry to our block. But if we write the
// variable before we can possibly branch to that block, then we don't need to have it valid
// on entry to our block. So basically it looks like the branch instruction is reading
// everything required by any blocks it can branch to.
do
{
this.resolvedSomething = false;
this.resolveSequence++;
this.ResolveBlock((GraphNodeBlock)firstLin);
} while(this.resolvedSomething);
// Repeat the cutting loops as long as we keep finding stuff.
bool didSomething;
do
{
didSomething = false;
// Strip out ldc.i4.1/xor/ldc.i4.1/xor
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(!(gn is GraphNodeEmit))
continue;
GraphNodeEmit xor2 = (GraphNodeEmit)gn;
if(xor2.opcode != OpCodes.Xor)
continue;
if(!(xor2.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit ld12 = (GraphNodeEmit)xor2.prevLin;
if(ld12.opcode != OpCodes.Ldc_I4_1)
continue;
if(!(ld12.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit xor1 = (GraphNodeEmit)ld12.prevLin;
if(xor1.opcode != OpCodes.Xor)
continue;
if(!(xor2.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit ld11 = (GraphNodeEmit)xor1.prevLin;
if(ld11.opcode != OpCodes.Ldc_I4_1)
continue;
ld11.prevLin.nextLin = xor2.nextLin;
xor2.nextLin.prevLin = ld11.prevLin;
didSomething = true;
}
// Replace c{cond}/ldc.i4.1/xor/br{false,true} -> c{cond}/br{true,false}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(!(gn is GraphNodeEmit))
continue;
GraphNodeEmit brft = (GraphNodeEmit)gn;
if((brft.opcode != OpCodes.Brfalse) && (brft.opcode != OpCodes.Brtrue))
continue;
if(!(brft.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit xor = (GraphNodeEmit)brft.prevLin;
if(xor.opcode != OpCodes.Xor)
continue;
if(!(xor.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit ldc = (GraphNodeEmit)xor.prevLin;
if(ldc.opcode != OpCodes.Ldc_I4_1)
continue;
if(!(ldc.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit cmp = (GraphNodeEmit)ldc.prevLin;
if(cmp.opcode.StackBehaviourPop != StackBehaviour.Pop1_pop1)
continue;
if(cmp.opcode.StackBehaviourPush != StackBehaviour.Pushi)
continue;
cmp.nextLin = brft;
brft.prevLin = cmp;
brft.opcode = (brft.opcode == OpCodes.Brfalse) ? OpCodes.Brtrue : OpCodes.Brfalse;
didSomething = true;
}
// Replace c{cond}/br{false,true} -> b{!,}{cond}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(!(gn is GraphNodeEmit))
continue;
GraphNodeEmit brft = (GraphNodeEmit)gn;
if((brft.opcode != OpCodes.Brfalse) && (brft.opcode != OpCodes.Brtrue))
continue;
if(!(brft.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit cmp = (GraphNodeEmit)brft.prevLin;
if(cmp.opcode.StackBehaviourPop != StackBehaviour.Pop1_pop1)
continue;
if(cmp.opcode.StackBehaviourPush != StackBehaviour.Pushi)
continue;
cmp.prevLin.nextLin = brft;
brft.prevLin = cmp.prevLin;
bool brtru = (brft.opcode == OpCodes.Brtrue);
if(cmp.opcode == OpCodes.Ceq)
brft.opcode = brtru ? OpCodes.Beq : OpCodes.Bne_Un;
else if(cmp.opcode == OpCodes.Cgt)
brft.opcode = brtru ? OpCodes.Bgt : OpCodes.Ble;
else if(cmp.opcode == OpCodes.Cgt_Un)
brft.opcode = brtru ? OpCodes.Bgt_Un : OpCodes.Ble_Un;
else if(cmp.opcode == OpCodes.Clt)
brft.opcode = brtru ? OpCodes.Blt : OpCodes.Bge;
else if(cmp.opcode == OpCodes.Clt_Un)
brft.opcode = brtru ? OpCodes.Blt_Un : OpCodes.Bge_Un;
else
throw new Exception();
didSomething = true;
}
// Replace ld{c.i4.0,null}/br{ne.un,eq} -> br{true,false}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if(!(gn is GraphNodeEmit))
continue;
GraphNodeEmit brcc = (GraphNodeEmit)gn;
if((brcc.opcode != OpCodes.Bne_Un) && (brcc.opcode != OpCodes.Beq))
continue;
if(!(brcc.prevLin is GraphNodeEmit))
continue;
GraphNodeEmit ldc0 = (GraphNodeEmit)brcc.prevLin;
if((ldc0.opcode != OpCodes.Ldc_I4_0) && (ldc0.opcode != OpCodes.Ldnull))
continue;
ldc0.prevLin.nextLin = brcc;
brcc.prevLin = ldc0.prevLin;
brcc.opcode = (brcc.opcode == OpCodes.Bne_Un) ? OpCodes.Brtrue : OpCodes.Brfalse;
didSomething = true;
}
// Replace:
// ldloc v1
// stloc v2
// ld<anything> except ld<anything> v2
// ldloc v2
// ...v2 unreferenced hereafter
// With:
// ld<anything> except ld<anything> v2
// ldloc v1
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
// check for 'ldloc v1' instruction
if(!(gn is GraphNodeEmitLocal))
continue;
GraphNodeEmitLocal ldlv1 = (GraphNodeEmitLocal)gn;
if(ldlv1.opcode != OpCodes.Ldloc)
continue;
// check for 'stloc v2' instruction
if(!(ldlv1.nextLin is GraphNodeEmitLocal))
continue;
GraphNodeEmitLocal stlv2 = (GraphNodeEmitLocal)ldlv1.nextLin;
if(stlv2.opcode != OpCodes.Stloc)
continue;
// check for 'ld<anything> except ld<anything> v2' instruction
if(!(stlv2.nextLin is GraphNodeEmit))
continue;
GraphNodeEmit ldany = (GraphNodeEmit)stlv2.nextLin;
if(!ldany.opcode.ToString().StartsWith("ld"))
continue;
if((ldany is GraphNodeEmitLocal) &&
((GraphNodeEmitLocal)ldany).myLocal == stlv2.myLocal)
continue;
// check for 'ldloc v2' instruction
if(!(ldany.nextLin is GraphNodeEmitLocal))
continue;
GraphNodeEmitLocal ldlv2 = (GraphNodeEmitLocal)ldany.nextLin;
if(ldlv2.opcode != OpCodes.Ldloc)
continue;
if(ldlv2.myLocal != stlv2.myLocal)
continue;
// check that v2 is not needed after this at all
if(IsLocalNeededAfterThis(ldlv2, ldlv2.myLocal))
continue;
// make 'ld<anything>...' the first instruction
ldany.prevLin = ldlv1.prevLin;
ldany.prevLin.nextLin = ldany;
// make 'ldloc v1' the second instruction
ldany.nextLin = ldlv1;
ldlv1.prevLin = ldany;
// and make 'ldloc v1' the last instruction
ldlv1.nextLin = ldlv2.nextLin;
ldlv1.nextLin.prevLin = ldlv1;
didSomething = true;
}
// Remove all the stloc/ldloc that are back-to-back without the local
// being needed afterwards. If it is needed afterwards, replace the
// stloc/ldloc with dup/stloc.
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if((gn is GraphNodeEmitLocal) &&
(gn.prevLin is GraphNodeEmitLocal))
{
GraphNodeEmitLocal stloc = (GraphNodeEmitLocal)gn.prevLin;
GraphNodeEmitLocal ldloc = (GraphNodeEmitLocal)gn;
if((stloc.opcode == OpCodes.Stloc) &&
(ldloc.opcode == OpCodes.Ldloc) &&
(stloc.myLocal == ldloc.myLocal))
{
if(IsLocalNeededAfterThis(ldloc, ldloc.myLocal))
{
GraphNodeEmitNull dup = new GraphNodeEmitNull(this, stloc.errorAt, OpCodes.Dup);
dup.nextLin = stloc;
dup.prevLin = stloc.prevLin;
stloc.nextLin = ldloc.nextLin;
stloc.prevLin = dup;
dup.prevLin.nextLin = dup;
stloc.nextLin.prevLin = stloc;
gn = stloc;
}
else
{
stloc.prevLin.nextLin = ldloc.nextLin;
ldloc.nextLin.prevLin = stloc.prevLin;
gn = stloc.prevLin;
}
didSomething = true;
}
}
}
// Remove all write-only local variables, ie, those with no ldloc[a] references.
// Replace any stloc instructions with pops.
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
ScriptMyLocal rdlcl = gn.ReadsLocal();
if(rdlcl != null)
rdlcl.isReferenced = true;
}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
ScriptMyLocal wrlcl = gn.WritesLocal();
if((wrlcl != null) && !wrlcl.isReferenced)
{
if(!(gn is GraphNodeEmitLocal) || (((GraphNodeEmitLocal)gn).opcode != OpCodes.Stloc))
{
throw new Exception("expecting stloc");
}
GraphNodeEmitNull pop = new GraphNodeEmitNull(this, ((GraphNodeEmit)gn).errorAt, OpCodes.Pop);
pop.nextLin = gn.nextLin;
pop.prevLin = gn.prevLin;
gn.nextLin.prevLin = pop;
gn.prevLin.nextLin = pop;
gn = pop;
didSomething = true;
}
}
// Remove any Ld<const>/Dup,Pop.
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
if((gn is GraphNodeEmit) &&
(gn.nextLin is GraphNodeEmit))
{
GraphNodeEmit gne = (GraphNodeEmit)gn;
GraphNodeEmit nne = (GraphNodeEmit)gn.nextLin;
if(gne.isPoppable && (nne.opcode == OpCodes.Pop))
{
gne.prevLin.nextLin = nne.nextLin;
nne.nextLin.prevLin = gne.prevLin;
gn = gne.prevLin;
didSomething = true;
}
}
}
} while(didSomething);
// Dump out the results.
if(DEBUG)
{
Console.WriteLine("");
Console.WriteLine(methName);
Console.WriteLine(" resolveSequence=" + this.resolveSequence);
Console.WriteLine(" Locals:");
foreach(ScriptMyLocal loc in declaredLocals)
{
Console.WriteLine(" " + loc.type.Name + " " + loc.name);
}
Console.WriteLine(" Labels:");
foreach(ScriptMyLabel lbl in definedLabels)
{
Console.WriteLine(" " + lbl.name);
}
Console.WriteLine(" Code:");
DumpCode();
}
}
private void DumpCode()
{
int linSeqNos = 0;
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
gn.linSeqNo = ++linSeqNos;
}
for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
{
StringBuilder sb = new StringBuilder();
gn.DebStringExt(sb);
Console.WriteLine(sb.ToString());
if(gn is GraphNodeBlock)
{
GraphNodeBlock gnb = (GraphNodeBlock)gn;
foreach(ScriptMyLocal lcl in gnb.localsReadBeforeWritten)
{
Console.WriteLine(" reads " + lcl.name);
}
}
}
}
/**
* @brief Scan the given block for branches to other blocks.
* For any locals read by those blocks, mark them as being read by this block,
* provided this block has not written them by that point. This makes it look
* as though the branch instruction is reading all the locals needed by any
* target blocks.
*/
private void ResolveBlock(GraphNodeBlock currentBlock)
{
if(currentBlock.hasBeenResolved == this.resolveSequence)
return;
// So we don't recurse forever on a backward branch.
currentBlock.hasBeenResolved = this.resolveSequence;
// Assume we haven't written any locals yet.
List<ScriptMyLocal> localsWrittenSoFar = new List<ScriptMyLocal>();
// Scan through the instructions in this block.
for(GraphNode gn = currentBlock; gn != null;)
{
// See if the instruction writes a local we don't know about yet.
ScriptMyLocal wrlcl = gn.WritesLocal();
if((wrlcl != null) && !localsWrittenSoFar.Contains(wrlcl))
{
localsWrittenSoFar.Add(wrlcl);
}
// Scan through all the possible next instructions after this.
// Note that if we are in the first part of a try/catch/finally block,
// every instruction conditionally branches to the beginning of the
// second part (the catch/finally block).
GraphNode nextFallthruNode = null;
foreach(GraphNode nn in gn.NextNodes)
{
if(nn is GraphNodeBlock)
{
// Start of a block, go through all locals needed by that block on entry.
GraphNodeBlock nextBlock = (GraphNodeBlock)nn;
ResolveBlock(nextBlock);
foreach(ScriptMyLocal readByNextBlock in nextBlock.localsReadBeforeWritten)
{
// If this block hasn't written it by now and this block doesn't already
// require it on entry, say this block requires it on entry.
if(!localsWrittenSoFar.Contains(readByNextBlock) &&
!currentBlock.localsReadBeforeWritten.Contains(readByNextBlock))
{
currentBlock.localsReadBeforeWritten.Add(readByNextBlock);
this.resolvedSomething = true;
}
}
}
else
{
// Not start of a block, should be normal fallthru instruction.
if(nextFallthruNode != null)
throw new Exception("more than one fallthru from " + gn.ToString());
nextFallthruNode = nn;
}
}
// Process next instruction if it isn't the start of a block.
if(nextFallthruNode == gn)
throw new Exception("can't fallthru to self");
gn = nextFallthruNode;
}
}
/**
* @brief Figure out whether the value in a local var is needed after the given instruction.
* True if we reach the end of the program on all branches before reading it
* True if we write the local var on all branches before reading it
* False otherwise
*/
private bool IsLocalNeededAfterThis(GraphNode node, ScriptMyLocal local)
{
do
{
GraphNode nextFallthruNode = null;
foreach(GraphNode nn in node.NextNodes)
{
if(nn is GraphNodeBlock)
{
if(((GraphNodeBlock)nn).localsReadBeforeWritten.Contains(local))
{
return true;
}
}
else
{
nextFallthruNode = nn;
}
}
node = nextFallthruNode;
if(node == null)
return false;
if(node.ReadsLocal() == local)
return true;
} while(node.WritesLocal() != local);
return false;
}
public static void PadToLength(StringBuilder sb, int len, string str)
{
int pad = len - sb.Length;
if(pad < 0)
pad = 0;
sb.Append(str.PadLeft(pad));
}
}
}