// Soo, since I cannot be 100% sure where the start of a instance might be
// ( could be an expresion, complex var, etc)
// Its put somewhere in a block
public bool PushEnviromentFix(IList <ILNode> body, ILBasicBlock head, int pos)
{
ILExpression expr;
ILLabel next;
ILLabel pushLabel;
ILLabel pushLabelNext;
if (head.MatchLastAndBr(GMCode.Push, out expr, out next) &&
// labelGlobalRefCount[next] == 1 && // don't check this
body.Contains(labelToBasicBlock[next]) &&
labelToBasicBlock[next].MatchSingleAndBr(GMCode.Pushenv, out pushLabel, out pushLabelNext)
)
{
ILBasicBlock pushBlock = labelToBasicBlock[next];
head.Body.RemoveAt(head.Body.Count - 2);// hackery, but sure, block should be removed in a flatten
if (expr.Code == GMCode.Constant)
{
ILValue value = expr.Operand as ILValue;
if (value.Value is int)
{
value.ValueText = context.InstanceToString((int)value.Value);
}
}
(pushBlock.Body[pushBlock.Body.Count - 2] as ILExpression).Arguments.Add(expr);
return(true);
}
return(false);
}
public static bool MatchCaseBlock(this ILBasicBlock bb, out ILExpression caseCondition, out ILLabel caseLabel, out ILLabel nextCase)
{
int dupType = 0;
ILExpression pushSeq;
ILExpression btExpresion;
if (bb.Body.Count == 6 &&
bb.Body[0] is ILLabel &&
bb.Body[1].Match(GMCode.Dup, out dupType) &&
dupType == 0 &&
bb.Body[2].Match(GMCode.Push, out caseCondition) &&
bb.Body[3].Match(GMCode.Seq) &&
bb.MatchLastAndBr(GMCode.Bt, out caseLabel, out btExpresion, out nextCase)
)
{
return(true);
}
caseCondition = default(ILExpression);
caseLabel = nextCase = default(ILLabel);
return(false);
}
List <ILNode> FindConditions(HashSet <ControlFlowNode> scope, ControlFlowNode entryNode)
{
List <ILNode> result = new List <ILNode>();
// Do not modify entry data
scope = new HashSet <ControlFlowNode>(scope);
Stack <ControlFlowNode> agenda = new Stack <ControlFlowNode>();
agenda.Push(entryNode);
while (agenda.Count > 0)
{
ControlFlowNode node = agenda.Pop();
// Find a block that represents a simple condition
if (scope.Contains(node))
{
ILBasicBlock block = (ILBasicBlock)node.UserData;
{
// Switch
IList <ILExpression> cases;
ILLabel[] caseLabels;
ILExpression switchCondition;
ILLabel fallLabel;
// IList<ILExpression> cases; out IList<ILExpression> arg, out ILLabel fallLabel)
// matches a switch statment, not sure how the hell I am going to do this
if (block.MatchLastAndBr(GMCode.Switch, out caseLabels, out cases, out fallLabel))
{
// Debug.Assert(fallLabel == endBlock); // this should be true
switchCondition = cases[0]; // thats the switch arg
cases.RemoveAt(0); // remove the switch condition
// Replace the switch code with ILSwitch
ILSwitch ilSwitch = new ILSwitch()
{
Condition = switchCondition
};
block.Body.RemoveTail(GMCode.Switch, GMCode.B);
block.Body.Add(ilSwitch);
block.Body.Add(new ILExpression(GMCode.B, fallLabel));
result.Add(block);
// Remove the item so that it is not picked up as content
scope.RemoveOrThrow(node);
// Pull in code of cases
ControlFlowNode fallTarget = null;
labelToCfNode.TryGetValue(fallLabel, out fallTarget);
HashSet <ControlFlowNode> frontiers = new HashSet <ControlFlowNode>();
if (fallTarget != null)
{
frontiers.UnionWith(fallTarget.DominanceFrontier.Except(new[] { fallTarget }));
}
foreach (ILLabel condLabel in caseLabels)
{
ControlFlowNode condTarget = null;
labelToCfNode.TryGetValue(condLabel, out condTarget);
if (condTarget != null)
{
frontiers.UnionWith(condTarget.DominanceFrontier.Except(new[] { condTarget }));
}
}
for (int i = 0; i < caseLabels.Length; i++)
{
ILLabel condLabel = caseLabels[i];
// Find or create new case block
ILSwitch.CaseBlock caseBlock = ilSwitch.CaseBlocks.FirstOrDefault(b => b.EntryGoto.Operand == condLabel);
if (caseBlock == null)
{
caseBlock = new ILSwitch.CaseBlock()
{
Values = new List <ILExpression>(),
EntryGoto = new ILExpression(GMCode.B, condLabel)
};
ilSwitch.CaseBlocks.Add(caseBlock);
ControlFlowNode condTarget = null;
labelToCfNode.TryGetValue(condLabel, out condTarget);
if (condTarget != null && !frontiers.Contains(condTarget))
{
HashSet <ControlFlowNode> content = FindDominatedNodes(scope, condTarget);
scope.ExceptWith(content);
foreach (var con in FindConditions(content, condTarget))
{
caseBlock.Body.Add(con);
}
// caseBlock.Body.AddRange(FindConditions(content, condTarget));
// Add explicit break which should not be used by default, but the goto removal might decide to use it
caseBlock.Body.Add(new ILBasicBlock()
{
Body =
{
new ILLabel()
{
Name = "SwitchBreak_" + (nextLabelIndex++)
},
new ILExpression(GMCode.LoopOrSwitchBreak, null)
}
});
}
}
if (cases[i].Code != GMCode.DefaultCase)
{
caseBlock.Values.Add(cases[i].Arguments[0]);
}
else
{
caseBlock.Values.Add(new ILExpression(GMCode.DefaultCase, null));
}
}
// Heuristis to determine if we want to use fallthough as default case
if (fallTarget != null && !frontiers.Contains(fallTarget))
{
HashSet <ControlFlowNode> content = FindDominatedNodes(scope, fallTarget);
if (content.Any())
{
var caseBlock = new ILSwitch.CaseBlock()
{
EntryGoto = new ILExpression(GMCode.B, fallLabel)
};
ilSwitch.CaseBlocks.Add(caseBlock);
block.Body.RemoveTail(GMCode.B);
scope.ExceptWith(content);
foreach (var con in FindConditions(content, fallTarget))
{
caseBlock.Body.Add(con);
}
// Add explicit break which should not be used by default, but the goto removal might decide to use it
caseBlock.Body.Add(new ILBasicBlock()
{
Body =
{
new ILLabel()
{
Name = "SwitchBreak_" + (nextLabelIndex++)
},
new ILExpression(GMCode.LoopOrSwitchBreak, null)
}
});
}
}
}
// Debug.Assert((block.Body.First() as ILLabel).Name != "L1938");
// Two-way branch
ILLabel trueLabel;
ILLabel falseLabel;
IList <ILExpression> condExprs;
if (block.MatchLastAndBr(GMCode.Bf, out falseLabel, out condExprs, out trueLabel) &&
condExprs[0].Code != GMCode.Pop) // its resolved
{
ILExpression condExpr = condExprs[0];
IList <ILNode> body = block.Body;
// this is a simple condition, skip anything short curiket for now
// Match a condition patern
// Convert the brtrue to ILCondition
ILCondition ilCond = new ILCondition()
{
Condition = condExpr,
TrueBlock = new ILBlock()
{
EntryGoto = new ILExpression(GMCode.B, trueLabel)
},
FalseBlock = new ILBlock()
{
EntryGoto = new ILExpression(GMCode.B, falseLabel)
}
};
block.Body.RemoveTail(GMCode.Bf, GMCode.B);
block.Body.Add(ilCond);
result.Add(block);
// Remove the item immediately so that it is not picked up as content
scope.RemoveOrThrow(node);
ControlFlowNode trueTarget = null;
labelToCfNode.TryGetValue(trueLabel, out trueTarget);
ControlFlowNode falseTarget = null;
labelToCfNode.TryGetValue(falseLabel, out falseTarget);
// Pull in the conditional code
if (trueTarget != null && HasSingleEdgeEnteringBlock(trueTarget))
{
HashSet <ControlFlowNode> content = FindDominatedNodes(scope, trueTarget);
scope.ExceptWith(content);
foreach (var con in FindConditions(content, trueTarget))
{
ilCond.TrueBlock.Body.Add(con);
}
}
if (falseTarget != null && HasSingleEdgeEnteringBlock(falseTarget))
{
HashSet <ControlFlowNode> content = FindDominatedNodes(scope, falseTarget);
scope.ExceptWith(content);
foreach (var con in FindConditions(content, falseTarget))
{
ilCond.FalseBlock.Body.Add(con);
}
}
}
}
// Add the node now so that we have good ordering
if (scope.Contains(node))
{
result.Add((ILNode)node.UserData);
scope.Remove(node);
}
}
// depth-first traversal of dominator tree
for (int i = node.DominatorTreeChildren.Count - 1; i >= 0; i--)
{
agenda.Push(node.DominatorTreeChildren[i]);
}
}
// Add whatever is left
foreach (var node in scope)
{
result.Add((ILNode)node.UserData);
}
return(result);
}
// This is before the expression is processed, so ILValue's and constants havn't been assigned
public bool SimplifyTernaryOperator(List <ILNode> body, ILBasicBlock head, int pos)
{
Debug.Assert(body.Contains(head));
// Debug.Assert((head.Body[0] as ILLabel).Name != "Block_54");
// Debug.Assert((head.Body[0] as ILLabel).Name != "L1257");
ILExpression condExpr;
ILLabel trueLabel;
ILLabel falseLabel;
ILExpression trueExpr;
ILLabel trueFall;
ILExpression falseExpr;
ILLabel falseFall;
ILExpression finalFall;
ILLabel finalFalseFall;
ILLabel finalTrueFall;
if ((head.MatchLastAndBr(GMCode.Bt, out trueLabel, out condExpr, out falseLabel) ||
head.MatchLastAndBr(GMCode.Bf, out falseLabel, out condExpr, out trueLabel)) &&
labelGlobalRefCount[trueLabel] == 1 &&
labelGlobalRefCount[falseLabel] == 1 &&
labelToBasicBlock[trueLabel].MatchSingleAndBr(GMCode.Push, out trueExpr, out trueFall) &&
labelToBasicBlock[falseLabel].MatchSingleAndBr(GMCode.Push, out falseExpr, out falseFall) &&
trueFall == falseFall &&
body.Contains(labelToBasicBlock[trueLabel]) &&
labelToBasicBlock[trueFall].MatchLastAndBr(GMCode.Bf, out finalFalseFall, out finalFall, out finalTrueFall) &&
finalFall.Code == GMCode.Pop
) // (finalFall == null || finalFall.Code == GMCode.Pop)
{
Debug.Assert(finalFall.Arguments.Count != 2);
ILValue falseLocVar = falseExpr.Code == GMCode.Constant ? falseExpr.Operand as ILValue : null;
ILValue trueLocVar = trueExpr.Code == GMCode.Constant ? trueExpr.Operand as ILValue : null;
Debug.Assert(falseLocVar != null || trueLocVar != null);
ILExpression newExpr = null;
// a ? true : b is equivalent to a || b
// a ? b : true is equivalent to !a || b
// a ? b : false is equivalent to a && b
// a ? false : b is equivalent to !a && b
if (trueLocVar != null && trueLocVar.Type == GM_Type.Short && (trueLocVar == 0 || trueLocVar == 1))
{
// It can be expressed as logical expression
if (trueLocVar != 0)
{
newExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicOr, condExpr, falseExpr);
}
else
{
newExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicAnd, new ILExpression(GMCode.Not, null, condExpr), falseExpr);
}
}
else if (falseLocVar != null && falseLocVar.Type == GM_Type.Short && (falseLocVar == 0 || falseLocVar == 1))
{
// It can be expressed as logical expression
if (falseLocVar != 0)
{
newExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicOr, new ILExpression(GMCode.Not, null, condExpr), trueExpr);
}
else
{
newExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicAnd, condExpr, trueExpr);
}
}
Debug.Assert(newExpr != null);
// head.Body.RemoveTail(ILCode.Brtrue, ILCode.Br);
head.Body.RemoveRange(head.Body.Count - 2, 2);
head.Body.Add(new ILExpression(GMCode.Bf, finalFalseFall, newExpr));
head.Body.Add(new ILExpression(GMCode.B, finalTrueFall));
// Remove the inlined branch from scope
// body.RemoveOrThrow(nextBasicBlock);
// Remove the old basic blocks
body.RemoveOrThrow(labelToBasicBlock[trueLabel]);
body.RemoveOrThrow(labelToBasicBlock[falseLabel]);
body.RemoveOrThrow(labelToBasicBlock[trueFall]);
return(true);
}
return(false);
}
public bool SimplifyShortCircuit(IList <ILNode> body, ILBasicBlock head, int pos)
{
Debug.Assert(body.Contains(head));
// Debug.Assert((head.Body[0] as ILLabel).Name != "Block_54");
ILExpression condExpr;
ILLabel trueLabel;
ILLabel falseLabel;
// Ok, since we have not changed out all the Bf's to Bt like in ILSpy, we have to do them seperately
// as I am getting bugs in my wahhoo about it
if ((head.MatchLastAndBr(GMCode.Bf, out falseLabel, out condExpr, out trueLabel) ||
head.MatchLastAndBr(GMCode.Bt, out trueLabel, out condExpr, out falseLabel)) &&
condExpr.Code != GMCode.Pop // its a terrtery so ignore it?
) // I saw this too
{
GMCode code = (head.Body[head.Body.Count - 2] as ILExpression).Code;
for (int pass = 0; pass < 2; pass++)
{
// On the second pass, swap labels and negate expression of the first branch
// It is slightly ugly, but much better then copy-pasting this whole block
ILLabel nextLabel = (pass == 0) ? trueLabel : falseLabel;
ILLabel otherLablel = (pass == 0) ? falseLabel : trueLabel;
bool negate = (pass == 1);
negate = GMCode.Bt == code ? !negate : negate;
ILBasicBlock nextBasicBlock = labelToBasicBlock[nextLabel];
ILExpression nextCondExpr;
ILLabel nextTrueLablel;
ILLabel nextFalseLabel;
if (body.Contains(nextBasicBlock) &&
nextBasicBlock != head &&
labelGlobalRefCount[(ILLabel)nextBasicBlock.Body.First()] == 1 &&
(nextBasicBlock.MatchSingleAndBr(GMCode.Bf, out nextFalseLabel, out nextCondExpr, out nextTrueLablel) ||
nextBasicBlock.MatchSingleAndBr(GMCode.Bt, out nextTrueLablel, out nextCondExpr, out nextFalseLabel)) &&
nextCondExpr.Code != GMCode.Pop && // ugh
(otherLablel == nextFalseLabel || otherLablel == nextTrueLablel))
{
// Debug.Assert(nextCondExpr.Arguments.Count != 2);
// Create short cicuit branch
ILExpression logicExpr;
if (otherLablel == nextFalseLabel)
{
logicExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicAnd, negate ? new ILExpression(GMCode.Not, null, condExpr) : condExpr, nextCondExpr);
}
else
{
logicExpr = MakeLeftAssociativeShortCircuit(GMCode.LogicOr, negate ? condExpr : new ILExpression(GMCode.Not, null, condExpr), nextCondExpr);
}
// head.Body.RemoveTail(GMCode.Bf, GMCode.B);
head.Body.RemoveRange(head.Body.Count - 2, 2);
head.Body.Add(new ILExpression(GMCode.Bf, nextFalseLabel, logicExpr));
head.Body.Add(new ILExpression(GMCode.B, nextTrueLablel));
// Remove the inlined branch from scope
body.RemoveOrThrow(nextBasicBlock);
return(true);
}
}
}
return(false);
}
void TestAndFixWierdLoop(List <ILNode> body, ILBasicBlock head, int pos)
{
object uvalue1;
ILValue value2;
ILLabel endLoop;
ILLabel startLoop;
ILExpression filler;
//Debug.Assert((head.Body[0] as ILLabel).Name != "L36");
// Wierd one here. I ran accross this a few times and I think this is generated code
// for events. Basicly, it pushes a constant on the stack and uses a repeat loop
// however since I am not doing ANY kind of real stack/temporary analysis. I would have
// to rewrite and add a bunch of code to get that to work and right now its only a few functions
// Its easyer to build a while loop out of it and let the decompiler handle it rather than
// build a more robust stack anilizer
// ugh have to make a new block for it too, meh
int headLen = head.Body.Count;
if (head.MatchAt(headLen - 6, GMCode.Push, out uvalue1) &&
head.MatchAt(headLen - 5, GMCode.Dup) &&
head.MatchAt(headLen - 4, GMCode.Push, out value2) &&
head.MatchAt(headLen - 3, GMCode.Sle) &&
head.MatchLastAndBr(GMCode.Bt, out endLoop, out filler, out startLoop))
{
// ok, lets rewrite the head so it makes sence
ILLabel newLoopStart = NewJunkLoop();
ILVariable genVar = NewGeneratedVar();
List <ILNode> newHead = new List <ILNode>();
for (int ii = 0; ii <= headLen - 7; ii++)
{
newHead.Add(head.Body[ii]); // add the front of it including the sub part
}
newHead.Add(new ILExpression(GMCode.Push, uvalue1));
newHead.Add(new ILExpression(GMCode.Pop, genVar));
newHead.Add(new ILExpression(GMCode.B, newLoopStart));
ILBasicBlock newLoopBlock = new ILBasicBlock();
newLoopBlock.Body.Add(newLoopStart);
newLoopBlock.Body.Add(new ILExpression(GMCode.Push, genVar));
newLoopBlock.Body.Add(new ILExpression(GMCode.Push, new ILValue(0)));
newLoopBlock.Body.Add(new ILExpression(GMCode.Sgt, null));
newLoopBlock.Body.Add(new ILExpression(GMCode.Bf, endLoop, new ILExpression(GMCode.Pop, null)));
newLoopBlock.Body.Add(new ILExpression(GMCode.B, startLoop));
head.Body = newHead;
body.Add(newLoopBlock);
// Now the hard part, we have to find the end bit
for (int j = pos; j < body.Count; j++)
{
ILBasicBlock bj = body[j] as ILBasicBlock;
ILLabel testEnd, testStart;
ILValue subPart;
int len = bj.Body.Count;
// Debug.Assert((bj.Body[0] as ILLabel).Name != "L114");
if (bj.MatchLastAndBr(GMCode.Bt, out testStart, out filler, out testEnd) &&
testEnd == endLoop && testStart == startLoop &&
bj.MatchAt(len - 3, GMCode.Dup) &&
bj.MatchAt(len - 4, GMCode.Sub) &&
bj.MatchAt(len - 5, GMCode.Push, out subPart)
)
{
List <ILNode> list2 = new List <ILNode>();
for (int ii = 0; ii <= len - 6; ii++)
{
list2.Add(bj.Body[ii]); // add the front of it including the sub part
}
list2.Add(new ILExpression(GMCode.Push, genVar));
list2.Add(bj.Body[len - 5]); // add the sub part
list2.Add(bj.Body[len - 4]); // add the sub part
list2.Add(new ILExpression(GMCode.Pop, genVar)); // assign it
list2.Add(new ILExpression(GMCode.B, newLoopStart)); // branch back to the start
bj.Body = list2; // replace
break; // all done, let it continue
}
}
// Debug.Assert(false); // coudln't find the end block
}
}
void CreateSwitchExpresion(ILNode condition, List <ILNode> list, List <ILNode> body, ILBasicBlock head, int pos)
{
// we are in a case block, check if its the first block
List <ILBasicBlock> caseBlocks = new List <ILBasicBlock>();
List <ILLabel> caseLabels = new List <ILLabel>();
ILExpression switchExpression = new ILExpression(GMCode.Switch, null);
switchExpression.Arguments.Add(NodeToExpresion(condition)); // pop the switch condition
ILBasicBlock current = head;
ILLabel nextCase;
ILLabel caseTrue;
ILExpression fakeArgument;
while (current.MatchLastAndBr(GMCode.Bt, out caseTrue, out fakeArgument, out nextCase))
{
ILNode operand;
if (!current.MatchAt(current.Body.Count - 4, GMCode.Push, out operand))
{
throw new Exception("fix");
}
if (!(operand is ILValue))
{
throw new Exception("Can only handle constants right now");
}
switchExpression.Arguments.Add(new ILExpression(GMCode.Case, caseTrue, NodeToExpresion(operand)));
caseLabels.Add(caseTrue);
body.Remove(current);
current = labelToBasicBlock[nextCase];
}
body.Insert(pos, head);
var lastBlock = current;
ILLabel fallLabel;
if (!lastBlock.MatchSingle(GMCode.B, out fallLabel))
{
throw new Exception("fix");
}
current = labelToBasicBlock[fallLabel];
if (!current.MatchAt(1, GMCode.Popz))
{ // has a default case
// Side note, the LoopAndConditions figures out if we have a default case by checking
// if the ending branch is linked to all the other case branches
// so we don't need to do anything here
// All this code is JUST for finding that popz that pops the condition out of the switch
// if you don't care about it, you could just search though all the expresions and remove any and all
// popz's I am beggining to think this is the right way to do it as I don't see any other uses
// of popz's
// Debug.Assert(false);
BuildNextBlockData(); // build block chain, we need this for default and mabye case lookups
// ok, this is why we DON'T want to remove redundent code as there is this empty
// useless goto RIGHt after this that has the link to the finale case
ILLabel nextBlockLabel = lastBlock.Body.First() as ILLabel;
var uselessBlock = this.labelToNextBlock[nextBlockLabel];
ILLabel newFallLabel;
if (!uselessBlock.MatchSingle(GMCode.B, out newFallLabel))
{
throw new Exception("fix");
}
current = labelToBasicBlock[newFallLabel];
if (!current.MatchAt(1, GMCode.Popz))
{
throw new Exception("I have no idea where the popz is for this switch");
}
}
current.Body.RemoveAt(1);
ILLabel lastBlockLabel = lastBlock.Body.First() as ILLabel;
if (this.labelGlobalRefCount[lastBlockLabel] == 1)
{
body.Remove(lastBlockLabel);
}
switchExpression.Operand = caseLabels.ToArray();
list.Add(switchExpression);
list.Add(new ILExpression(GMCode.B, fallLabel));
}