public CallIndirect(LIRMethod parent, ISource targetMethod, IEnumerable<ISource> sources = null, IDestination returnValueDest = null) : base(parent, LIROpCode.CallIndirect)
{
this.TargetMethod = targetMethod;
if (sources != null)
Sources.AddRange(sources);
this.ReturnValueDestination = returnValueDest;
}
public Unary(LIRMethod parent, ISource src, IDestination dest, UnaryOperation op, LIRType argType) : base(parent, LIROpCode.Unary)
{
Source = src;
Destination = dest;
Operation = op;
ArgumentType = argType;
}
public Convert(LIRMethod parent, ISource source, LIRType sourceType, IDestination dest, LIRType destType) : base(parent, LIROpCode.Convert)
{
Source = source;
SourceType = sourceType;
Destination = dest;
DestinationType = destType;
}
public Math(LIRMethod parent, ISource srcA, ISource srcB, IDestination dest, MathOperation op, LIRType argType) : base(parent, LIROpCode.Math)
{
SourceA = srcA;
SourceB = srcB;
Destination = dest;
Operation = op;
ArgumentType = argType;
}
public Compare(LIRMethod parent, ISource sourceA, ISource sourceB, IDestination destination, LIRType type, CompareCondition condition) : base(parent, LIROpCode.Compare)
{
this.SourceA = sourceA;
this.SourceB = sourceB;
this.Destination = destination;
this.Type = type;
this.Condition = condition;
}
public override void Run(LIRMethod method)
{
for (int i = 0; i < method.mInstructions.Count; i++)
{
var curInstr = method.mInstructions[i];
if (curInstr.OpCode == LIROpCode.Label && ((Label)curInstr).References == 0)
method.mInstructions[i] = new Instructions.Dead(i);
}
}
public override void Run(LIRMethod method)
{
List<LIRInstruction> instrs = new List<LIRInstruction>(method.mInstructions.Count);
foreach (var i in method.mInstructions)
{
if (i.OpCode == LIROpCode.Dead)
continue;
i.Index = instrs.Count;
instrs.Add(i);
}
instrs.TrimExcess();
method.mInstructions = instrs;
}
public override void Run(LIRMethod method)
{
for (int i = 0; i < method.mInstructions.Count; i++)
{
var curInstr = method.mInstructions[i];
switch (curInstr.OpCode)
{
case LIROpCode.Math:
{
var curMath = (Instructions.Math)curInstr;
switch (curMath.Operation)
{
case Instructions.MathOperation.Add:
case Instructions.MathOperation.Subtract:
if (curMath.SourceA.SourceType == SourceType.Literal && ((LIRImm)curMath.SourceA).IsZero)
{
method.mInstructions[i] = new Instructions.Move(i, curMath.SourceB, curMath.Destination, curMath.ArgumentType);
}
else if (curMath.SourceB.SourceType == SourceType.Literal && ((LIRImm)curMath.SourceB).IsZero)
{
method.mInstructions[i] = new Instructions.Move(i, curMath.SourceA, curMath.Destination, curMath.ArgumentType);
}
break;
case Instructions.MathOperation.Multiply:
break;
case Instructions.MathOperation.Divide:
break;
case Instructions.MathOperation.And:
break;
case Instructions.MathOperation.Or:
break;
case Instructions.MathOperation.Xor:
break;
case Instructions.MathOperation.ShiftLeft:
break;
case Instructions.MathOperation.ShiftRight:
break;
case Instructions.MathOperation.ShiftRightSignExtended:
break;
default:
throw new Exception("Unknown MathOperation!");
}
break;
}
default:
break;
}
}
}
public BranchTrue(LIRMethod parent, ISource source, Label target) : base(parent, LIROpCode.BranchTrue)
{
this.Source = source;
this.Target = target;
target.References++;
}
public override void Run(LIRMethod method)
{
for (int i = 0; i < method.mInstructions.Count; i++)
{
var curInstr = method.mInstructions[i];
switch(curInstr.OpCode)
{
case LIROpCode.Move:
{
var curMove = (Instructions.Move)curInstr;
if (curMove.Source.SourceType == SourceType.Local)
{
var loc = (LIRLocal)curMove.Source;
if (loc.Dynamic && loc.AssignedValue != null &&
(
loc.AssignedValue.SourceType == SourceType.Local ||
loc.AssignedValue.SourceType == SourceType.Literal ||
loc.AssignedValue.SourceType == SourceType.Parameter
)
)
{
curMove.Source = loc.AssignedValue;
method.mInstructions[loc.AssignedAt] = new Instructions.Dead(loc.AssignedAt);
}
}
if (curMove.Destination.DestinationType == DestinationType.Local)
{
var loc = (LIRLocal)curMove.Destination;
if (loc.Dynamic)
{
loc.AssignedAt = i;
loc.AssignedValue = curMove.Source;
}
}
break;
}
case LIROpCode.Math:
{
// Need to do dest
var curMath = (Instructions.Math)curInstr;
curMath.SourceA = ProcessSource(curMath.SourceA, method);
curMath.SourceB = ProcessSource(curMath.SourceB, method);
break;
}
case LIROpCode.Compare:
{
// Need to do dest
var curCompare = (Instructions.Compare)curInstr;
curCompare.SourceA = ProcessSource(curCompare.SourceA, method);
curCompare.SourceB = ProcessSource(curCompare.SourceB, method);
break;
}
case LIROpCode.BranchIndirect:
{
var curBranch = (Instructions.BranchIndirect)curInstr;
curBranch.Source = ProcessSource(curBranch.Source, method);
break;
}
case LIROpCode.BranchTrue:
{
var curBranch = (Instructions.BranchTrue)curInstr;
curBranch.Source = ProcessSource(curBranch.Source, method);
break;
}
case LIROpCode.Unary:
{
// Need to do dest
var curUnary = (Instructions.Unary)curInstr;
curUnary.Source = ProcessSource(curUnary.Source, method);
break;
}
case LIROpCode.Convert:
{
// Need to do dest
var curConvert = (Instructions.Convert)curInstr;
curConvert.Source = ProcessSource(curConvert.Source, method);
break;
}
case LIROpCode.Return:
{
var curReturn = (Instructions.Return)curInstr;
if (curReturn.Source != null)
curReturn.Source = ProcessSource(curReturn.Source, method);
break;
}
case LIROpCode.Call:
{
// Need to do dest
var curCall = (Instructions.Call)curInstr;
for (int i2 = 0; i2 < curCall.Sources.Count; i2++)
{
curCall.Sources[i2] = ProcessSource(curCall.Sources[i2], method);
}
break;
}
case LIROpCode.CallIndirect:
{
// Need to do dest
var curCallIndirect = (Instructions.CallIndirect)curInstr;
for (int i2 = 0; i2 < curCallIndirect.Sources.Count; i2++)
{
curCallIndirect.Sources[i2] = ProcessSource(curCallIndirect.Sources[i2], method);
}
break;
}
case LIROpCode.Comment:
case LIROpCode.Dead:
case LIROpCode.Label:
case LIROpCode.Nop:
case LIROpCode.Branch:
break;
default:
throw new Exception("Unknown LIROpCode!");
}
if (curInstr.MayHaveSideEffects)
method.Locals.ForEach(l => { l.AssignedAt = -1; l.AssignedValue = null; });
}
}
private static ISource ProcessSource(ISource src, LIRMethod method)
{
if (src.SourceType == SourceType.Local)
{
var loc = (LIRLocal)src;
if (loc.Dynamic && loc.AssignedValue != null && loc.AssignedValue.SourceType == SourceType.Local)
{
method.mInstructions[loc.AssignedAt] = new Instructions.Dead(loc.AssignedAt);
return loc.AssignedValue;
}
}
return src;
}
public Branch(LIRMethod parent)
: base(parent, LIROpCode.Branch)
{
}
public Branch(LIRMethod parent, Label target) : base(parent, LIROpCode.Branch)
{
this.Target = target;
target.References++;
}
public Move(LIRMethod parent, ISource src, IDestination dest, LIRType argType) : base(parent, LIROpCode.Move)
{
Source = src;
Destination = dest;
ArgumentType = argType;
}
public Return(LIRMethod parent, ISource source = null, LIRType sourceType = null) : base(parent, LIROpCode.Return)
{
this.Source = source;
this.SourceType = sourceType;
}
public abstract void Run(LIRMethod method);
public BranchTrue(LIRMethod parent, ISource source) : base(parent, LIROpCode.BranchTrue)
{
this.Source = source;
}
public BranchIndirect(LIRMethod parent, ISource source) : base(parent, LIROpCode.BranchIndirect)
{
this.Source = source;
}
public Comment(LIRMethod parent, string text) : base(parent, LIROpCode.Comment)
{
this.Text = text;
}
public Nop(LIRMethod parent) : base(parent, LIROpCode.Nop)
{
}
