public DataType VisitPointer(PointerType_v1 pointer) { return(new Pointer(pointer.DataType.Accept(this), ptrBitSize) { Qualifier = pointer.Qualifier }); }
public DataType VisitPointer(PointerType_v1 pointer) { DataType dt; if (pointer.DataType == null) { dt = new UnknownType(); } else { try { //$TODO: remove the try-catch when done. dt = pointer.DataType.Accept(this); #if FUTURE //$HACK: this is a dangerous assumption, not all // pointers to char are pointing to strings -- // but most (90% or more) do. With const char // this rises to 99% if (dt is PrimitiveType pt && pt.Domain == Domain.Character) { dt = StringType.NullTerminated(dt); } #endif } catch { Debug.Print("** Dropping exception on floor ***********"); dt = new UnknownType(platform.PointerType.Size); } } return(new Pointer(dt, platform.PointerType.BitSize)); }
public void StCreate() { SerializedType st = new PrimitiveType_v1(Domain.SignedInt, 4); Assert.AreEqual("prim(SignedInt,4)", st.ToString()); st = new PointerType_v1(new PrimitiveType_v1(Domain.UnsignedInt, 4)); Assert.AreEqual("ptr(prim(UnsignedInt,4))", st.ToString()); }
public void X86_64Psig_MixedIntsFloats() { var pser = Given_ProcedureSerializer(); var ssig = new SerializedSignature { ReturnValue = new Argument_v1 { Type = PrimitiveType_v1.Int32() }, Arguments = new Argument_v1[] { new Argument_v1 { Type = PrimitiveType_v1.Int32(), Name = "a" }, new Argument_v1 { Type = PrimitiveType_v1.Real64(), Name = "b" }, new Argument_v1 { Type = PointerType_v1.Create(PrimitiveType_v1.Char8(), 8), Name = "c" }, new Argument_v1 { Type = PrimitiveType_v1.Real64(), Name = "d" }, new Argument_v1 { Type = PrimitiveType_v1.Real32(), Name = "e" }, } }; var sig = pser.Deserialize(ssig, frame); Assert.AreEqual("rax", sig.ReturnValue.Storage.ToString()); ExpectArgs(sig, "rcx", "xmm1", "r8", "xmm3", "Stack +0008"); }
public void StWritePrimitive() { SerializedType st = new PointerType_v1(new PrimitiveType_v1(Domain.SignedInt, 4)); StringWriter writer = new StringWriter(); XmlSerializer ser = SerializedLibrary.CreateSerializer_v1(st.GetType()); ser.Serialize(writer, st); string s = writer.ToString(); int b = s.IndexOf("<prim"); int e = s.IndexOf("/>"); Assert.AreEqual("<prim domain=\"SignedInt\" size=\"4\" xmlns=\"http://schemata.jklnet.org/Decompiler\" ", s.Substring(b, e-b)); }
public void StWritePrimitive() { SerializedType st = new PointerType_v1(new PrimitiveType_v1(Domain.SignedInt, 4)); StringWriter writer = new StringWriter(); XmlSerializer ser = SerializedLibrary.CreateSerializer_v1(st.GetType()); ser.Serialize(writer, st); string s = writer.ToString(); int b = s.IndexOf("<prim"); int e = s.IndexOf("/>"); Assert.AreEqual("<prim domain=\"SignedInt\" size=\"4\" xmlns=\"http://schemata.jklnet.org/Decompiler\" ", s.Substring(b, e - b)); }
public DataType VisitPointer(PointerType_v1 pointer) { DataType dt; if (pointer.DataType == null) { dt = new UnknownType(); } else { dt = pointer.DataType.Accept(this); } return(new Pointer(dt, platform.PointerType.Size)); }
public StringBuilder VisitPointer(PointerType_v1 pointer) { var n = name; name = null; pointer.DataType.Accept(this); sb.AppendFormat(" *"); name = n; if (name != null) { sb.AppendFormat(" {0}", name); } return(sb); }
public SerializedType ParsePointer(List <Argument_v1> compoundArgs, Qualifier q) { int size = 4; //$TODO: should follow platform pointer size, really. SerializedType type; if (PeekAndDiscard('E')) // 64-bit pointer { size = 8; } switch (str[i++]) { case 'A': type = ParseDataTypeCode(new List <Argument_v1>()); break; //$BUG: assumes 32-bitness case 'B': type = Qualify(ParseDataTypeCode(new List <Argument_v1>()), Qualifier.Const); break; // const ptr case 'C': type = Qualify(ParseDataTypeCode(new List <Argument_v1>()), Qualifier.Volatile); break; // volatile ptr case 'D': type = Qualify(ParseDataTypeCode(new List <Argument_v1>()), Qualifier.Const | Qualifier.Volatile); break; // const volatile ptr case '6': type = ParseFunctionTypeCode(); break; // fn ptr case '8': return(ParseMemberFunctionPointerCode(size, compoundArgs)); default: Error("Unsupported pointer code 'P{0}'.", str[i - 1]); return(null); } SerializedType pType = new PointerType_v1 { DataType = type, PointerSize = size, }; if (q != Qualifier.None) { pType = new QualifiedType_v1 { DataType = pType, Qualifier = q, }; } compoundArgs.Add(new Argument_v1 { Type = pType }); return(pType); }
public DataType VisitPointer(PointerType_v1 pointer) { DataType dt; if (pointer.DataType == null) { dt = new UnknownType(); } else { try { //$TODO: remove the try-catch when done. dt = pointer.DataType.Accept(this); } catch { dt = new UnknownType(); } } return(new Pointer(dt, platform.PointerType.Size)); }
public SerializedSignature ParseFunctionTypeCode() { string convention = ParseCallingConvention(); SerializedType retType; if (PeekAndDiscard('@')) { // C++ ctors have no explicit return type! if (isConstuctor) { // C++ constructor implicitly returns pointer to // initialised object retType = new PointerType_v1 { DataType = CreateEnclosingType(Scope), PointerSize = pointerSize, }; } else { retType = null; } } else { retType = ParseDataTypeCode(new List <Argument_v1>()); } Argument_v1[] args = ParseArgumentList(); return(new SerializedSignature { Convention = convention, Arguments = args, EnclosingType = CreateEnclosingType(Scope), IsInstanceMethod = this.isInstanceMethod, ReturnValue = new Argument_v1 { Type = retType ?? new VoidType_v1() } }); }
public DataType VisitPointer(PointerType_v1 pointer) { DataType dt; if (pointer.DataType == null) { dt = new UnknownType(); } else { try { //$TODO: remove the try-catch when done. dt = pointer.DataType.Accept(this); } catch { Debug.Print("** Dropping exception on floor ***********"); dt = new UnknownType(platform.PointerType.Size); } } return(new Pointer(dt, platform.PointerType.BitSize)); }
public SerializedType ParsePointer(List<Argument_v1> compoundArgs) { int size = 4; //$TODO: should follow platform pointer size, really. SerializedType type; if (PeekAndDiscard('E')) // 64-bit pointer { size = 8; } switch (str[i++]) { case 'A': type = ParseDataTypeCode(new List<Argument_v1>()); break; //$BUG: assumes 32-bitness case 'B': type = ParseDataTypeCode(new List<Argument_v1>()); break; // const ptr case 'C': type = ParseDataTypeCode(new List<Argument_v1>()); break; // volatile ptr case 'D': type = ParseDataTypeCode(new List<Argument_v1>()); break; // const volatile ptr case '6': type = ParseFunctionTypeCode(); break; // fn ptr case '8': return ParseMemberFunctionPointerCode(size, compoundArgs); default: Error("Unsupported pointer code 'P{0}'.", str[i - 1]); return null; } var pType = new PointerType_v1 { DataType = type, PointerSize = size, }; compoundArgs.Add(new Argument_v1 { Type = pType }); return pType; }
private SerializedType Type() { var qual = CvQualifier(); switch (str[i++]) { case 'v': return(new VoidType_v1()); case 'b': return(Qualify(PrimitiveType_v1.Bool(), qual)); case 'c': return(Qualify(PrimitiveType_v1.Char8(), qual)); case 'h': return(Qualify(PrimitiveType_v1.UChar8(), qual)); case 's': return(Qualify(PrimitiveType_v1.Int16(), qual)); case 't': return(Qualify(PrimitiveType_v1.UInt16(), qual)); case 'i': return(Qualify(PrimitiveType_v1.Int32(), qual)); case 'j': return(Qualify(PrimitiveType_v1.UInt32(), qual)); case 'l': return(Qualify(PrimitiveType_v1.Int64(), qual)); case 'm': return(Qualify(PrimitiveType_v1.UInt64(), qual)); case 'w': return(Qualify(PrimitiveType_v1.WChar16(), qual)); case 'f': return(Qualify(PrimitiveType_v1.Real32(), qual)); case 'd': return(Qualify(PrimitiveType_v1.Real64(), qual)); case 'F': --i; return(FunctionType()); case 'N': --i; return(CreateTypeReference(NestedName())); case 'P': var ptr = new PointerType_v1 { DataType = Type(), PointerSize = ptrSize }; AddSubstitution(ptr); return(Qualify(ptr, qual)); case 'R': qual = CvQualifier(); var r = new ReferenceType_v1 { Referent = Type(), Size = ptrSize }; return(Qualify(r, qual)); case 'S': switch (str[i++]) { case 't': return(Qualify(new TypeReference_v1 { Scope = new[] { "std" }, TypeName = Type().ToString(), }, qual)); case 's': return(Qualify(new TypeReference_v1 { Scope = new[] { "std" }, TypeName = "string" }, qual)); default: int iStart = --i; while (str[i] != '_') { ++i; } ++i; var sub = str.Substring(iStart, i - iStart); Debug.Print(sub); return(Qualify((SerializedType)substitutions[sub], qual)); } throw new NotImplementedException(); default: --i; if (char.IsDigit(str[i])) { var tref = new TypeReference_v1 { TypeName = UnqualifiedName() }; AddSubstitution(tref); return(Qualify(tref, qual)); } throw new NotImplementedException(string.Format("Unknown GCC type code '{0}' ({1}).", str[i], str.Substring(i))); } }
private static SerializedType FarPtr(SerializedType type) { return(PointerType_v1.Create(type, 4)); }
public DataType VisitPointer(PointerType_v1 pointer) { throw new NotImplementedException(); }
private bool LoadParameter(SerializedSignature ssig, List <Argument_v1> args) { if (PeekAndDiscard(TokenType.NUMBER)) { return(true); } Token tok = Peek(); if (tok.Type != TokenType.ID) { return(false); } Get(); SerializedType type = null; switch (tok.Value) { case "word": case "s_word": type = new PrimitiveType_v1(PrimitiveType.Word16.Domain, 2); break; case "long": type = new PrimitiveType_v1(PrimitiveType.Word32.Domain, 4); break; //$TODO: need SegmentedPointerType case "segptr": case "segstr": type = new PrimitiveType_v1(Domain.SegPointer, 4); break; case "ptr": type = new PrimitiveType_v1(Domain.Pointer, 4); break; case "str": type = PointerType_v1.Create(PrimitiveType_v1.Char8(), 4); break; case "wstr": type = PointerType_v1.Create(PrimitiveType_v1.WChar16(), 4); break; case "uint16": type = PrimitiveType_v1.UInt16(); break; case "uint32": type = PrimitiveType_v1.UInt32(); break; case "uint64": type = PrimitiveType_v1.UInt64(); break; case "int16": type = PrimitiveType_v1.Int16(); break; case "int32": type = PrimitiveType_v1.Int32(); break; case "int64": type = PrimitiveType_v1.Int64(); break; default: throw new Exception("Unknown: " + tok.Value); } args.Add(new Argument_v1 { Type = type }); return(true); }
public DataType VisitPointer(PointerType_v1 pointer) { return(new Pointer(pointer.DataType.Accept(this), 4)); }
public int VisitPointer(PointerType_v1 pointer) { return(platform.PointerType.Size); }
public int VisitPointer(PointerType_v1 pointer) { return(4); //$BUGBUG: architecture dependent }
private SerializedType Type() { switch (str[i++]) { case 'v': return(new VoidType_v1()); case 'b': return(PrimitiveType_v1.Bool()); case 'c': return(PrimitiveType_v1.Char8()); case 'h': return(PrimitiveType_v1.UChar8()); case 's': return(PrimitiveType_v1.Int16()); case 't': return(PrimitiveType_v1.UInt16()); case 'i': return(PrimitiveType_v1.Int32()); case 'j': return(PrimitiveType_v1.UInt32()); case 'l': return(PrimitiveType_v1.Int64()); case 'm': return(PrimitiveType_v1.UInt64()); case 'w': return(PrimitiveType_v1.WChar16()); case 'f': return(PrimitiveType_v1.Real32()); case 'd': return(PrimitiveType_v1.Real64()); case 'F': --i; return(FunctionType()); case 'N': --i; return(CreateTypeReference(NestedName())); case 'P': var ptr = new PointerType_v1 { DataType = Type(), PointerSize = ptrSize }; AddSubstitution(ptr); return(ptr); case 'R': //$TODO: Reko doesn't have a concept of 'const' or 'volatile'. // Needs to be implemented for completeness, but should not affect // quality of decompilation. var qual = CvQualifier(); return(new ReferenceType_v1 { Referent = Type(), Size = ptrSize }); case 'S': switch (str[i++]) { case 't': return(new TypeReference_v1 { Scope = new[] { "std" }, TypeName = Type().ToString(), }); case 's': return(new TypeReference_v1 { Scope = new[] { "std" }, TypeName = "string" }); default: int iStart = --i; while (str[i] != '_') { ++i; } ++i; var sub = str.Substring(iStart, i - iStart); Debug.Print(sub); return((SerializedType)substitutions[sub]); } throw new NotImplementedException(); default: --i; if (char.IsDigit(str[i])) { var tref = new TypeReference_v1 { TypeName = UnqualifiedName() }; AddSubstitution(tref); return(tref); } throw new NotImplementedException(string.Format("Unknown GCC type code '{0}' ({1}).", str[i], str.Substring(i))); } }
public bool VisitPointer(PointerType_v1 pX) { y = ((PointerType_v1)y !).DataType !; return(pX.DataType !.Accept(this)); }