public static string DecompileCode(GMFileContent content, RefData rdata, CodeInfo code, bool absolute = false) { if (code.Instructions.Length == 0) { return(String.Empty); } var sb = new StringBuilder(); var stack = new Stack <Expression>(); var dupts = new List <Expression>(); var firstI = (long)code.Instructions[0]; var graph = BuildCFGraph(content, code); //TODO: CFG kind recognition stuff (if, if/else, for, while, etc) var i = 0; foreach (var g in graph) { var stmts = ParseStatements(content, rdata, code, g.Instructions, stack, absolute: absolute); sb.Append(SR.HEX_PRE) .Append(((long)g.Instructions[0] - firstI).ToString(SR.HEX_FM6)) .AppendLine(SR.COLON); foreach (var s in stmts) { sb.Append(SR.INDENT4).AppendLine(s.ToString()); } i++; } sb.Append(SR.HEX_PRE).Append(code.Size.ToString(SR.HEX_FM6)).AppendLine(SR.COLON); sb.Append(SR.INDENT4).AppendLine(FinalRet.ToString()); return(sb.ToString()); }
public static string DisplayInstructions(GMFileContent content, RefData rdata, CodeInfo code, AnyInstruction *[] instructions = null, bool absolute = false) { var bcv = content.General->BytecodeVersion; var instrs = instructions ?? code.Instructions; if (instrs.Length == 0) { return(String.Empty); } var sb = new StringBuilder(); var firstI = code.Instructions[0]; for (int i = 0; i < instrs.Length; i++) { var iptr = instrs[i]; var relInstr = (long)iptr - (absolute ? (long)content.RawData.BPtr : (long)firstI); sb.Append(HEX_PRE).Append(relInstr.ToString(HEX_FM6)) .Append(COLON_S).Append(iptr->OpCode.ToPrettyString(bcv)).Append(' '); switch (iptr->Kind(content.General->BytecodeVersion)) { case InstructionKind.SingleType: var st = iptr->SingleType; sb.Append(st.Type.ToPrettyString()); if (bcv > 0xE && st.OpCode.VersionF == FOpCode.Dup) { sb.Append(' ').Append(st.DupExtra); } break; case InstructionKind.DoubleType: var dt = iptr->DoubleType; if (bcv > 0xE && iptr->OpCode.VersionF == FOpCode.Cmp) { sb.Append(dt.ComparisonType.ToPrettyString()).Append(' '); } sb.Append(dt.Types); break; case InstructionKind.Goto: var g = iptr->Goto; var a = g.Offset.UValue * 4; if ((a & 0xFF000000) != 0) { a &= 0x00FFFFFF; a -= 0x01000000; } sb.Append(HEX_PRE).Append(Utils.ToHexSignString(relInstr + unchecked ((int)a), HEX_FM6)); break; #region set case InstructionKind.Set: var s = iptr->Set; sb.Append(s.Types).Append(' '); if (s.IsMagic) { sb.Append(MAGIC); break; } if (s.Instance <= InstanceType.StackTopOrGlobal) { sb.Append(s.Instance.ToPrettyString()); } else { var o = SectionReader.GetObjectInfo(content, (uint)s.Instance); sb.Append('[').Append(o.Name).Append(']'); } sb.Append(':'); sb.Append(rdata.Variables[rdata.VarAccessors[(IntPtr)iptr]].Name); sb.Append(s.DestVar.Type.ToPrettyString()); break; #endregion #region push case InstructionKind.Push: var pp = (PushInstruction *)iptr; var p = iptr->Push; sb.Append(p.Type.ToPrettyString()).Append(' '); var r = p.ValueRest; switch (p.Type) { case DataType.Int16: sb.Append(p.Value.ToString(CultureInfo.InvariantCulture)); break; case DataType.Variable: var rv = *(Reference *)&r; var inst = (InstanceType)p.Value; if (inst <= InstanceType.StackTopOrGlobal) { sb.Append(inst.ToPrettyString()); } else { var o = SectionReader.GetObjectInfo(content, (uint)inst); sb.Append('[').Append(o.Name).Append(']'); } sb.Append(':'); sb.Append(rdata.Variables[rdata.VarAccessors[(IntPtr)iptr]].Name); sb.Append(rv.Type.ToPrettyString()); break; case DataType.Boolean: sb.Append(((DwordBool *)&r)->ToPrettyString()); break; case DataType.Double: sb.Append(((double *)&r)->ToString(CultureInfo.InvariantCulture)); break; case DataType.Single: sb.Append(((float *)&r)->ToString(CultureInfo.InvariantCulture)); break; case DataType.Int32: sb.Append(unchecked ((int)r).ToString(CultureInfo.InvariantCulture)); break; case DataType.Int64: sb.Append(((long *)&pp->ValueRest)->ToString(CultureInfo.InvariantCulture)); break; case DataType.String: sb.Append(SectionReader.GetStringInfo(content, p.ValueRest).Escape()); break; } break; #endregion #region call case InstructionKind.Call: var c = iptr->Call; sb.Append(c.ReturnType.ToPrettyString()).Append(':') .Append(c.Arguments).Append(' '); sb.Append(rdata.Functions[rdata.FuncAccessors[(IntPtr)iptr]].Name); sb.Append(c.Function.Type.ToPrettyString()); break; #endregion case InstructionKind.Break: var b = iptr->Break; sb.Append(b.Type.ToPrettyString()).Append(' ').Append(b.Signal); break; } sb.AppendLine(); } return(sb.ToString()); }
public static Statement[] ParseStatements(GMFileContent content, RefData rdata, CodeInfo code, AnyInstruction *[] instr = null, Stack <Expression> stack = null, List <Expression> dupTars = null, bool absolute = false) { var bcv = content.General->BytecodeVersion; //! here be dragons stack = stack ?? new Stack <Expression>(); dupTars = dupTars ?? new List <Expression>(); instr = instr ?? code.Instructions; if (instr.Length == 0) { return(EmptyStmtArray); } var stmts = new List <Statement>(); var firstI = code.Instructions[0]; var baseOff = absolute ? (long)content.RawData.BPtr : (long)firstI; //TODO: use locals Func <Expression> Pop = () => stack.Count == 0 ? PopExpr : stack.Pop(); //Func<Expression> Peek = () => stack.Count == 0 ? PopExpr : stack.Peek(); Func <int, IEnumerable <Expression> > PopMany = i => { var ret = new List <Expression>(); for (int j = 0; j < i; j++) { ret.Add(Pop()); } return(ret); }; Action FlushStack = () => { var readd = new Stack <Expression>(); //? not sure if this is a good idea (random 'push'es in the wild) (see TODO) stmts.AddRange(stack.PopAll().Where(e => { if (dupTars.Contains(e)) { readd.Push(e); return(false); } return(!(e is PopExpression)); // 'push pop' is obviously stupid to emit }).Reverse().Select(e => e is UnaryOperatorExpression && ((UnaryOperatorExpression)e).Operator == UnaryOperator.Duplicate ? (Statement) new DupStatement() : new PushStatement { Expr = e })); stack.PushRange(readd); }; Action <Statement> AddStmt = s => { FlushStack(); stmts.Add(s); }; Func <VariableType, Expression[]> TryGetIndices = vt => { Expression index = null; var dimentions = 0; if (vt == VariableType.Array) { index = Pop(); var arrInd = Pop(); if ((arrInd is LiteralExpression) && ((LiteralExpression)arrInd).Value is short) { var s = (short)((LiteralExpression)arrInd).Value; switch (s) { case -1: dimentions = 2; break; case -5: dimentions = 1; break; } } if (dimentions == 0) { stack.Push(arrInd); stack.Push(index); index = null; } } if (index == null) { return(null); } // analyse index for specified dimention switch (dimentions) { case 2: if (index is BinaryOperatorExpression && ((BinaryOperatorExpression)index).Operator == BinaryOperator.Addition) { var boe = (BinaryOperatorExpression)index; var a = boe.Arg1; var b = boe.Arg2; if (a is BinaryOperatorExpression && ((BinaryOperatorExpression)a).Operator == BinaryOperator.Multiplication) { var a_ = (BinaryOperatorExpression)a; var c = a_.Arg2; if (c is LiteralExpression && ((LiteralExpression)c).ReturnType == DataType.Int32 && (int /* should be */)((LiteralExpression)c).Value == 32000) { return new[] { a_.Arg1, b } } ; } } break; } return(new[] { index }); }; for (int i = 0; i < instr.Length; i++) { var ins = instr[i]; #region stuff var pst = (SingleTypeInstruction *)ins; var pdt = (DoubleTypeInstruction *)ins; var pcl = (CallInstruction *)ins; var pps = (PushInstruction *)ins; var pse = (SetInstruction *)ins; var pbr = (BranchInstruction *)ins; var pbk = (BreakInstruction *)ins; var st = ins->SingleType; var dt = ins->DoubleType; var cl = ins->Call; var ps = ins->Push; var se = ins->Set; var t1 = ins->Kind(bcv) == InstructionKind.SingleType ? st.Type : (ins->Kind(bcv) == InstructionKind.DoubleType ? dt.Types.Type1 : 0); var t2 = ins->Kind(bcv) == InstructionKind.DoubleType ? dt.Types.Type2 : (ins->Kind(bcv) == InstructionKind.SingleType ? st.Type : 0); #endregion GeneralOpCode opc; switch (opc = ins->OpCode.General(bcv)) { #region dup, pop case GeneralOpCode.Dup: var normal = true; if (i < instr.Length - 1 && instr[i + 1]->OpCode.General(bcv) == GeneralOpCode.Push) { var n = &instr[i + 1]->Push; var t = ((Reference *)&n->ValueRest)->Type; if (t == VariableType.Array && stack.Count > 1) { normal = false; stack.Push(stack.Skip(1).First()); // second item stack.Push(stack.Skip(1).First()); // first item (original stack top) } } if (!normal) { break; } if (!dupTars.Contains(stack.Peek())) { dupTars.Add(stack.Peek()); } //var stackArr = stack.ToArray(); //for (i = 0; i <= ins->SingleType.DupExtra; i++) //{ // if (i >= stackArr.Length) // { // // .__. // break; // } var elem = stack.Peek(); //stackArr[stackArr.Length - i - 1]; if (elem.WalkExprTree(e => e is CallExpression).Any(Utils.Identity)) { stack.Push(new UnaryOperatorExpression { Input = elem, Operator = UnaryOperator.Duplicate, OriginalType = elem.ReturnType, ReturnType = st.Type }); } else { stack.Push(elem); } //} break; case GeneralOpCode.Pop: if (stack.Count > 0 && stack.Peek() is CallExpression) { AddStmt(new CallStatement { Call = (CallExpression)stack.Pop() }); } else { AddStmt(new PopStatement()); } break; #endregion #region br etc //TODO: use actual '(with obj ...)' syntax //! it might mess with the CFG structure case GeneralOpCode.PushEnv: case GeneralOpCode.PopEnv: case GeneralOpCode.Brt: case GeneralOpCode.Brf: case GeneralOpCode.Br: { var a = pbr->Offset.UValue * 4; if ((a & 0xFF000000) != 0) { a &= 0x00FFFFFF; a -= 0x01000000; } var tar = (AnyInstruction *)((long)ins + unchecked ((int)a)); var off = (long)ins - baseOff + unchecked ((int)a); switch (opc) { case GeneralOpCode.PushEnv: AddStmt(new PushEnvStatement { Target = tar, TargetOffset = off, Parent = stack.Pop() }); break; case GeneralOpCode.PopEnv: AddStmt(new PopEnvStatement { Target = tar, TargetOffset = off }); break; case GeneralOpCode.Brt: case GeneralOpCode.Brf: case GeneralOpCode.Br: AddStmt(new BranchStatement { Type = pbr->Type(bcv), Conditional = pbr->Type(bcv) == BranchType.Unconditional ? null : Pop(), Target = tar, TargetOffset = off }); break; } } break; #endregion #region break, ret, exit case GeneralOpCode.Break: stack.Push(new AssertExpression { ControlValue = pbk->Signal, ReturnType = pbk->Type, Expr = Pop() }); break; case GeneralOpCode.Ret: AddStmt(new ReturnStatement { ReturnType = pst->Type, RetValue = Pop() }); break; case GeneralOpCode.Exit: AddStmt(new ExitStatement()); break; #endregion #region set case GeneralOpCode.Set: if (se.IsMagic) { AddStmt(new MagicSetStatement { OriginalType = se.Types.Type1, ReturnType = se.Types.Type2 }); break; } var ind = TryGetIndices(se.DestVar.Type); // call before Value's pop AddStmt(new SetStatement { OriginalType = se.Types.Type1, ReturnType = se.Types.Type2, Type = se.DestVar.Type, OwnerType = se.Instance, OwnerName = se.Instance > InstanceType.StackTopOrGlobal ? SectionReader.GetObjectInfo(content, (uint)se.Instance, true).Name : null, Target = rdata.Variables[rdata.VarAccessors[(IntPtr)ins]], Value = Pop(), ArrayIndices = ind ?? TryGetIndices(se.DestVar.Type) }); break; #endregion default: switch (ins->ExprType(bcv)) { #region variable case ExpressionType.Variable: var vt = ((Reference *)&pps->ValueRest)->Type; stack.Push(/*vt == VariableType.StackTop &&*/ (InstanceType)ps.Value == InstanceType.StackTopOrGlobal ? new MemberExpression { Owner = Pop(), ReturnType = ps.Type, Type = vt, OwnerType = (InstanceType)ps.Value, OwnerName = se.Instance > InstanceType.StackTopOrGlobal ? SectionReader.GetObjectInfo(content, (uint)se.Instance, true).Name : null, Variable = rdata.Variables[rdata.VarAccessors[(IntPtr)ins]], ArrayIndices = TryGetIndices(vt) } : new VariableExpression { ReturnType = ps.Type, Type = vt, OwnerType = (InstanceType)ps.Value, Variable = rdata.Variables[rdata.VarAccessors[(IntPtr)ins]], ArrayIndices = TryGetIndices(vt) }); break; #endregion #region literal case ExpressionType.Literal: object v = null; var rest = &pps->ValueRest; #region get value switch (ps.Type) { case DataType.Int16: v = ps.Value; break; case DataType.Boolean: v = ((DwordBool *)rest)->IsTrue(); break; case DataType.Double: v = *(double *)rest; break; case DataType.Single: v = *(float *)rest; break; case DataType.Int32: v = *(int *)rest; break; case DataType.Int64: v = *(long *)rest; break; case DataType.String: v = SectionReader.GetStringInfo(content, (uint)ps.ValueRest); break; } #endregion stack.Push(new LiteralExpression { ReturnType = ps.Type, Value = v }); break; #endregion #region call case ExpressionType.Call: stack.Push(new CallExpression { ReturnType = cl.ReturnType, Type = cl.Function.Type, Function = rdata.Functions[rdata.FuncAccessors[(IntPtr)ins]], Arguments = PopMany(cl.Arguments).Reverse().ToArray() }); break; #endregion #region binaryop case ExpressionType.BinaryOp: var a1 = Pop(); var a2 = Pop(); stack.Push(new BinaryOperatorExpression { OriginalType = t1, ReturnType = t2, Arg1 = a2, Arg2 = a1, Operator = ins->BinaryOp(bcv) }); break; #endregion #region unaryop case ExpressionType.UnaryOp: stack.Push(new UnaryOperatorExpression { OriginalType = t1, ReturnType = t2, Input = Pop(), Operator = ins->UnaryOp(bcv) }); break; #endregion } break; } } FlushStack(); return(stmts.ToArray()); }