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 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 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));
}
