public override void CaseAVoidReturnStm(AVoidReturnStm node) { if (!neededWhile) { node.Parent().RemoveChild(node); return; } /* * return; * -> * hasMethodReturnedVar = true; * break; */ ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(hasMethodReturnedVar.GetName().Text)); data.LvalueTypes[lvalue] = hasMethodReturnedVar.GetType(); data.LocalLinks[lvalue] = hasMethodReturnedVar; PExp exp = new ABooleanConstExp(new ATrueBool()); data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null); exp = new AAssignmentExp(new TAssign("="), lvalue, exp); data.ExpTypes[exp] = hasMethodReturnedVar.GetType(); PStm stm = new AExpStm(new TSemicolon(";"), exp); AABlock block = new AABlock(); block.GetStatements().Add(stm); block.GetStatements().Add(new ABreakStm(new TBreak("break"))); node.ReplaceBy(new ABlockStm(new TLBrace("{"), block)); }
public override void CaseALocalDeclStm(ALocalDeclStm node) { AMethodDecl pMethod = Util.GetAncestor <AMethodDecl>(node); AALocalDecl decl = (AALocalDecl)node.GetLocalDecl(); if (decl.GetInit() == null) { ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text)); data.LocalLinks[lvalue] = decl; data.LvalueTypes[lvalue] = decl.GetType(); List <PStm> statements = AssignDefault(lvalue); AABlock pBlock = (AABlock)node.Parent(); foreach (PStm statement in statements) { pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node), statement); } pBlock.RemoveChild(node); } else { //Make an assignment expression before moving ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text)); data.LvalueTypes[lvalue] = decl.GetType(); AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, decl.GetInit()); AExpStm expStm = new AExpStm(new TSemicolon(";"), exp); node.ReplaceBy(expStm); data.LvalueTypes[lvalue] = decl.GetType(); data.ExpTypes[exp] = decl.GetType(); data.LocalLinks[lvalue] = decl; } AABlock block = (AABlock)pMethod.GetBlock(); block.GetStatements().Insert(0, node); }
public override void CaseAValueReturnStm(AValueReturnStm node) { /* * return <exp>; * -> * methodReturnerVar = <exp>; * hasMethodReturnedVar = true; * break; */ ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(methodReturnerVar.GetName().Text)); data.LvalueTypes[lvalue] = methodReturnerVar.GetType(); data.LocalLinks[lvalue] = methodReturnerVar; AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, node.GetExp()); data.ExpTypes[exp] = methodReturnerVar.GetType(); PStm stm = new AExpStm(new TSemicolon(";"), exp); AABlock block = new AABlock(); block.GetStatements().Add(stm); block.GetStatements().Add(new AVoidReturnStm(node.GetToken())); node.ReplaceBy(new ABlockStm(new TLBrace("{"), block)); block.Apply(this); }
public static bool Parse(ControlFlowGraph cfg, SharedData data, out bool redoLivenessAnalysis) { bool changed = false; redoLivenessAnalysis = false; Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> > Modifications = new Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> >(); foreach (ControlFlowGraph.Node node in cfg.Nodes) { if (node.Expression is AAssignmentExp) { AAssignmentExp exp = (AAssignmentExp)node.Expression; if (exp.GetLvalue() is ALocalLvalue) { AALocalDecl decl = data.LocalLinks[(ALocalLvalue)exp.GetLvalue()]; //If the variable is not live at any successors, remove this assignment bool inUse = false; foreach (ControlFlowGraph.Node successor in node.Successors) { if (successor.LiveVariables.Contains(decl)) { inUse = true; break; } } if (!inUse) { //Move method invokes out GetMethodInvokes getter = new GetMethodInvokes(); exp.GetExp().Apply(getter); //Might also have to redo because we removed a reference to a variable in the right side //if (getter.Invokes.Count > 0) redoLivenessAnalysis = true; Modifications[node] = getter.Invokes; changed = true; } } } } foreach (KeyValuePair <ControlFlowGraph.Node, List <ASimpleInvokeExp> > pair in Modifications) { ControlFlowGraph.Node node = pair.Key; foreach (ASimpleInvokeExp invoke in pair.Value) { AExpStm stm = new AExpStm(new TSemicolon(";"), invoke); AABlock pBlock = (AABlock)node.Statement.Parent(); pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node.Statement), stm); cfg.Insert(node, stm); } cfg.Remove(node); node.Statement.Parent().RemoveChild(node.Statement); } return(changed); }
public override void CaseAAssignmentExp(AAssignmentExp node) { if (!(node.Parent() is AExpStm)) { PStm parentStm = Util.GetAncestor <PStm>(node); MoveMethodDeclsOut mover = new MoveMethodDeclsOut("multipleAssignmentsVar", finalTrans.data); node.GetLvalue().Apply(mover); PLvalue lvalue = Util.MakeClone(node.GetLvalue(), finalTrans.data); ALvalueExp exp = new ALvalueExp(lvalue); finalTrans.data.ExpTypes[exp] = finalTrans.data.LvalueTypes[lvalue]; node.ReplaceBy(exp); AExpStm stm = new AExpStm(new TSemicolon(";"), node); AABlock block = (AABlock)parentStm.Parent(); //block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), localDeclStm); block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), stm); //localDeclStm.Apply(this); stm.Apply(this); if (parentStm is AWhileStm && Util.IsAncestor(exp, ((AWhileStm)parentStm).GetCondition())) { AWhileStm aStm = (AWhileStm)parentStm; //Copy assignment before continues //Before each continue in the while, and at the end. //Add continue statement, if not present block = (AABlock)((ABlockStm)aStm.GetBody()).GetBlock(); if (block.GetStatements().Count == 0 || !(block.GetStatements()[block.GetStatements().Count - 1] is AContinueStm)) { block.GetStatements().Add(new AContinueStm(new TContinue("continue"))); } //Get all continue statements in the while ContinueFinder finder = new ContinueFinder(); block.Apply(finder); foreach (AContinueStm continueStm in finder.Continues) { stm = new AExpStm(new TSemicolon(";"), Util.MakeClone(node, finalTrans.data)); block.GetStatements().Insert(block.GetStatements().IndexOf(continueStm), stm); stm.Apply(this); } } return; } base.CaseAAssignmentExp(node); }
public Node Insert(Node node, AExpStm newStm) { //Node must be a node for an AExpStm Node newNode = new Node(newStm); foreach (Node successor in node.Successors) { newNode.AddSucc(successor); } foreach (Node successor in newNode.Successors) { node.RemoveSucc(successor); } node.AddSucc(newNode); Nodes.Insert(Nodes.IndexOf(node) + 1, newNode); return(newNode); }
public override void OutAShadySAssignmentExp(AShadySAssignmentExp node) { if (node.GetLocalDeclRight().Count == 1 && ((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetName() == null) { //Assignment expression //an assignment can't be const); //An assignment must have a right side if (((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetInit() == null || ((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetAssignop() == null) { node.Parent().RemoveChild(node); return; } ASAssignmentExp exp = new ASAssignmentExp( ((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetAssignop(), node.GetLvalue(), ((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetInit()); node.ReplaceBy(exp); exp.Apply(this); } else { //Local decl AMultiLocalDecl localDecl = new AMultiLocalDecl(node.GetConst(), LvalueToType(node.GetLvalue(), node.GetPostPointers(), node.GetGenericToken(), node.GetGenericTypes()), new ArrayList()); while (node.GetLocalDeclRight().Count > 0) { localDecl.GetLocalDeclRight().Add(node.GetLocalDeclRight()[0]); } AExpStm expStm = Util.GetAncestor <AExpStm>(node); ALocalDeclStm localDeclStm = new ALocalDeclStm(expStm.GetToken(), localDecl); expStm.ReplaceBy(localDeclStm); localDeclStm.Apply(this); } }
public override void CaseAExpStm(AExpStm node) { }
public override void OutAAProgram(AAProgram node) { if (!processStructs) { if (!processFieldsOnly) { unusedMethods.RemoveAll(method => method.GetTrigger() != null); if (finalTrans.mainEntry != null) { unusedMethods.Remove(finalTrans.mainEntry); } if (finalTrans.data.DeobfuscateMethod != null) { unusedMethods.Remove(finalTrans.data.DeobfuscateMethod); } foreach (AMethodDecl unusedMethod in unusedMethods) { if (firstMethodRun && finalTrans.data.UserMethods.Contains(unusedMethod)) { children.Add(new ErrorCollection.Error(unusedMethod.GetName(), Util.GetAncestor <AASourceFile>(unusedMethod), LocRM.GetString("ErrorText219") + unusedMethod.GetName().Text, true)); } if (Options.Compiler.RemoveUnusedMethods) { unusedMethod.Parent().RemoveChild(unusedMethod); } } firstMethodRun = false; if (Options.Compiler.RemoveUnusedMethods) { finalTrans.data.Methods.RemoveAll(declItem => unusedMethods.Contains(declItem.Decl)); if (unusedMethods.Count > 0) { //We removed a method. this may cause other methods to be unused processMethodsOnly = true; unusedMethods.Clear(); unusedMethods.AddRange(finalTrans.data.Methods.Select((declItem) => declItem.Decl)); base.CaseAAProgram(node); return; } } unusedMethods.Clear(); processMethodsOnly = false; } if (!processFieldsOnly) { fieldsWithMethodCalls.Clear(); usedFields.Clear(); processFieldsOnly = true; base.CaseAAProgram(node); return; } usedFields.AddRange(finalTrans.data.ObfuscationFields); List <SharedData.DeclItem <AFieldDecl> > removedFields = new List <SharedData.DeclItem <AFieldDecl> >(); foreach (SharedData.DeclItem <AFieldDecl> declItem in finalTrans.data.Fields) { AFieldDecl fieldDecl = declItem.Decl; if (fieldDecl.GetConst() == null && !usedFields.Contains(fieldDecl)) { if (!reportedFields.Contains(declItem.Decl)) { if (firstFieldRun && finalTrans.data.UserFields.Contains(fieldDecl)) { children.Add(new ErrorCollection.Error(fieldDecl.GetName(), Util.GetAncestor <AASourceFile>(fieldDecl), LocRM.GetString("ErrorText65") + fieldDecl.GetName().Text, true)); } reportedFields.Add(declItem.Decl); } if (Options.Compiler.RemoveUnusedFields || (fieldDecl.GetType() is AArrayTempType && ((AArrayTempType)fieldDecl.GetType()).GetIntDim().Text == "0")) { //We cannot remove it if there is a method call in it if (fieldsWithMethodCalls.Contains(fieldDecl)) { continue; } //Remove assignments to the field foreach (AAssignmentExp assignmentExp in assignedToFields[fieldDecl]) { if (assignmentExp.Parent() is AExpStm) { AExpStm stm = (AExpStm)assignmentExp.Parent(); RemoveVariableStatement(stm, assignmentExp.GetExp(), stm.GetToken().Line, stm.GetToken().Pos); continue; } PExp exp = assignmentExp.GetExp(); assignmentExp.ReplaceBy(exp); } removedFields.Add(declItem); fieldDecl.Parent().RemoveChild(fieldDecl); } } } firstFieldRun = false; foreach (var removedField in removedFields) { finalTrans.data.Fields.Remove(removedField); } /* if (Options.Compiler.RemoveUnusedFields) * finalTrans.data.Fields.RemoveAll( * declItem => * (!usedFields.Contains(declItem.Decl)) && (!fieldsWithMethodCalls.Contains(declItem.Decl)));*/ if (removedFields.Count > 0) { //Other fields may have become unused fieldsWithMethodCalls.Clear(); usedFields.Clear(); processFieldsOnly = true; base.CaseAAProgram(node); return; } //Remove empty arrays from struct fields foreach (var pair in finalTrans.data.StructFields) { for (int i = 0; i < pair.Value.Count; i++) { AALocalDecl field = pair.Value[i]; if (field.GetType() is AArrayTempType && ((AArrayTempType)field.GetType()).GetIntDim().Text == "0") { field.Parent().RemoveChild(field); pair.Value.RemoveAt(i); --i; } } } } //Remove unused structs processFieldsOnly = false; if (!processStructs) { processStructs = true; base.CaseAAProgram(node); return; } foreach (SharedData.DeclItem <AStructDecl> declItem in finalTrans.data.Structs) { if (!usedStructs.Contains(declItem.Decl)) { if (firstStructRun) { children.Add(new ErrorCollection.Error(declItem.Decl.GetName(), Util.GetAncestor <AASourceFile>(declItem.Decl), LocRM.GetString("ErrorText64") + declItem.Decl.GetName().Text, true)); } if (Options.Compiler.RemoveUnusedStructs) { if (declItem.Decl != null && declItem.Decl.Parent() != null) { declItem.Decl.Parent().RemoveChild(declItem.Decl); } } } } if (Options.Compiler.RemoveUnusedStructs) { finalTrans.data.Structs.RemoveAll(declItem => !usedStructs.Contains(declItem.Decl)); } if (children.Count > 0) { finalTrans.errors.Add(new ErrorCollection.Error(children[0], LocRM.GetString("ErrorText66"), children.ToArray())); } }
public override void CaseAMethodDecl(AMethodDecl node) { if (processStructs || processFieldsOnly || processMethodsOnly) { base.CaseAMethodDecl(node); return; } bool removed = true; List <AALocalDecl> couldntRemove = new List <AALocalDecl>(); while (removed) { removed = false; definedLocals.Clear(); usedLocals.Clear(); assignedToLocals.Clear(); base.CaseAMethodDecl(node); usedLocals.AddRange(finalTrans.data.GeneratedVariables); foreach (AALocalDecl definedLocal in definedLocals) { if (!usedLocals.Contains(definedLocal) && !couldntRemove.Contains(definedLocal)) { if ((Util.GetAncestor <AABlock>(definedLocal) != null || node.GetTrigger() == null) && finalTrans.data.UserLocals.Contains(definedLocal)) { children.Add(new ErrorCollection.Error(definedLocal.GetName(), Util.GetAncestor <AASourceFile>(node), LocRM.GetString("ErrorText67") + definedLocal.GetName().Text, true)); } removed = true; //Remove decl); if (definedLocal.Parent() is ALocalDeclStm) { ALocalDeclStm localDeclStm = (ALocalDeclStm)definedLocal.Parent(); RemoveVariableStatement(localDeclStm, definedLocal.GetInit(), localDeclStm.GetToken().Line, localDeclStm.GetToken().Pos); } //Dont remove parameters else { couldntRemove.Add(definedLocal); } //Remove assignments); foreach (AAssignmentExp assignmentExp in assignedToLocals[definedLocal]) { if (assignmentExp.Parent() is AExpStm) { AExpStm stm = (AExpStm)assignmentExp.Parent(); RemoveVariableStatement(stm, assignmentExp.GetExp(), stm.GetToken().Line, stm.GetToken().Pos); continue; } PExp exp = assignmentExp.GetExp(); assignmentExp.ReplaceBy(exp); } } } } }
public override void CaseAExpStm(AExpStm node) { //Create node GetNode(node); }
public override void CaseAExpStm(AExpStm node) { node.GetExp().Apply(this); Write(";\n"); }