// Mutators /////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(Address address, DataType dataType)
{
var size = GetDataSize(address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
{
this.ImageMap.AddItemWithSize(address, item);
}
else
{
this.ImageMap.AddItem(address, item);
}
this.User.Globals.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return(item);
}
public void Accept(TSqlFragmentVisitor visitor)
{
visitor.ExplicitVisit(this);
VariableName?.Accept(visitor);
DataType?.Accept(visitor);
Value?.Accept(visitor);
}
public void WriteGlobalVariable(Address address, DataType dataType, string name, Formatter formatter)
{
this.formatter = formatter;
this.codeFormatter = new CodeFormatter(formatter);
this.tw = new TypeReferenceFormatter(formatter);
this.globals = new StructureType();
this.queue = new Queue <StructureField>(globals.Fields);
try
{
tw.WriteDeclaration(dataType, name);
if (program.SegmentMap.IsValidAddress(address))
{
formatter.Write(" = ");
this.rdr = program.CreateImageReader(program.Architecture, address);
dataType.Accept(this);
}
}
catch (Exception ex)
{
var dc = services.RequireService <DecompilerEventListener>();
dc.Error(
dc.CreateAddressNavigator(program, address),
ex,
"Failed to write global variable {0}.",
name);
}
formatter.Terminate(";");
}
public override void Accept(TSqlFragmentVisitor visitor)
{
visitor.ExplicitVisit(this);
DataType?.Accept(visitor);
Parameter?.Accept(visitor);
}
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(IProcessorArchitecture arch, Address address, DataType dataType)
{
//$TODO: if user enters a segmented address, we need to
// place the item in the respective globals struct.
var size = GetDataSize(arch, address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
{
this.ImageMap.AddItemWithSize(address, item);
}
else
{
this.ImageMap.AddItem(address, item);
}
this.User.Globals.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return(item);
}
public bool Find(DataType dt)
{
if (dt == dtCandidate)
{
return(true);
}
return(dt.Accept(this));
}
/// <summary>
/// Rewrites a machine word constant depending on its data type.
/// </summary>
/// <param name="c"></param>
/// <param name="dereferenced"></param>
/// <returns></returns>
public Expression Rewrite(Constant c, bool dereferenced)
{
this.c = c;
DataType dtInferred = c.TypeVariable.DataType.ResolveAs <DataType>();
this.pOrig = c.TypeVariable.OriginalDataType as PrimitiveType;
this.dereferenced = dereferenced;
return(dtInferred.Accept(this));
}
private Argument_v1 SerializeArgument(string name, Storage stg, DataType dt)
{
return(new Argument_v1
{
Name = name,
// Kind = arg.Storage.Serialize(),
OutParameter = stg is OutArgumentStorage,
Type = dt.Accept(this)
});
}
private Expression RewritePointer(DataType ptr, DataType dtPointee, DataType dtOrigPointee)
{
if (++depth > 20)
{
Debug.Print("*** Quitting; determine cause of recursion"); //$DEBUG
return(expComplex);
}
enclosingPtr = ptr;
this.dtComplex = dtPointee;
this.dtComplexOrig = dtOrigPointee;
return(dtComplex.Accept(this));
}
public Expression VisitArray(ArrayType array)
{
int i = (int)(offset / array.ElementType.Size);
int r = (int)(offset % array.ElementType.Size);
dt = array.ElementType;
dtOriginal = array.ElementType;
complexExp.DataType = array;
complexExp = CreateArrayAccess(dt, array, i, indexExp, dereferenced);
dereferenced = true;
offset = r;
return(dt.Accept(this));
}
public Expression VisitArray(ArrayType at)
{
int i = (int)(offset / at.ElementType.Size);
int r = (int)(offset % at.ElementType.Size);
index = ScaleDownIndex(index, at.ElementType.Size);
dtComplex = at.ElementType;
dtComplexOrig = at.ElementType;
this.expComplex.DataType = at;
expComplex = CreateArrayAccess(at.ElementType, at, i, index);
index = null; // we've consumed the index.
offset = r;
return(dtComplex.Accept(this));
}
public Expression VisitStructure(StructureType str)
{
StructureField field = str.Fields.LowerBound(this.offset);
if (field == null)
{
throw new TypeInferenceException("Expected structure type {0} to have a field at offset {1} ({1:X}).", str.Name, offset);
}
dt = field.DataType;
dtOriginal = field.DataType;
complexExp = CreateFieldAccess(str, field.DataType, complexExp, field.Name);
offset -= field.Offset;
return(dt.Accept(this));
}
public Expression VisitStructure(StructureType str)
{
if (++depth > 20)
{
Debug.Print("*** recursion too deep, quitting. Determine error then remove this"); //$DEBUG
return(expComplex);
}
if (enclosingPtr != null)
{
int strSize = str.GetInferredSize();
if (str.Size > 0 && // We know the size of the struct, for sure.
(offset >= strSize && offset % strSize == 0 && index == null))
{
var exp = CreateArrayAccess(str, enclosingPtr, offset / strSize, index);
index = null;
--depth;
return(exp);
}
else if (index != null && offset == 0)
{
var idx = this.ScaleDownIndex(index, strSize);
index = null;
var exp = CreateArrayAccess(str, enclosingPtr, 0, idx);
--depth;
return(exp);
}
}
StructureField field = str.Fields.LowerBound(this.offset);
if (field == null)
{
throw new TypeInferenceException("Expected structure type {0} to have a field at offset {1} ({1:X}).", str.Name, offset);
}
dtComplex = field.DataType;
dtComplexOrig = field.DataType.ResolveAs <DataType>();
this.expComplex = CreateFieldAccess(str, field.DataType, expComplex, field);
offset -= field.Offset;
var e = dtComplex.Accept(this);
--depth;
return(e);
}
public Formatter VisitFunctionType(FunctionType ft)
{
string?oldName = name;
name = null;
if (ft.ParametersValid)
{
ft.ReturnValue !.DataType.Accept(this);
}
if (mode == Mode.Writing)
{
writer.Write(" (");
}
name = oldName;
WriteName(false);
if (mode == Mode.Writing)
{
writer.Write(")(");
}
if (ft.ParametersValid && ft.Parameters != null && ft.Parameters.Length > 0)
{
name = ft.Parameters[0].Name;
ft.Parameters[0].DataType.Accept(this);
for (int i = 1; i < ft.Parameters.Length; ++i)
{
if (mode == Mode.Writing)
{
writer.Write(", ");
}
name = ft.Parameters[i].Name;
ft.Parameters[i].DataType.Accept(this);
}
name = oldName;
}
if (mode == Mode.Writing)
{
writer.Write(")");
}
return(writer);
}
public void WriteGlobalVariable(Address address, DataType dataType, string name)
{
this.globals = new StructureType();
this.queue = new Queue <StructureField>(globals.Fields);
var oneLineDeclaration = IsOneLineDeclaration(dataType);
try
{
tw.WriteDeclaration(dataType, name);
if (program.SegmentMap.IsValidAddress(address))
{
formatter.Write(" = ");
if (!oneLineDeclaration && showAddressInComment)
{
formatter.Write("// {0}", address);
}
this.rdr = program.CreateImageReader(program.Architecture, address);
dataType.Accept(this);
}
}
catch (Exception ex)
{
var dc = services.RequireService <DecompilerEventListener>();
dc.Error(
dc.CreateAddressNavigator(program, address),
ex,
"Failed to write global variable {0}.",
name);
formatter.Terminate(";");
return;
}
if (oneLineDeclaration && showAddressInComment)
{
formatter.Write("; // {0}", address);
formatter.Terminate();
}
else
{
formatter.Terminate(";");
}
}
public Expression VisitUnion(UnionType ut)
{
UnionAlternative alt = ut.FindAlternative(dtOriginal);
if (alt == null)
{
throw new TypeInferenceException("Unable to find {0} in {1} (offset {2}).", dtOriginal, ut, offset);
}
dt = alt.DataType;
dtOriginal = alt.DataType;
if (ut.PreferredType != null)
{
complexExp = new Cast(ut.PreferredType, complexExp);
}
else
{
complexExp = new FieldAccess(alt.DataType, complexExp, alt.Name);
}
return(dt.Accept(this));
}
public Expression VisitUnion(UnionType ut)
{
UnionAlternative alt = ut.FindAlternative(dtComplexOrig);
if (alt == null)
{
Debug.Print("Unable to find {0} in {1} (offset {2}).", dtComplexOrig, ut, offset); //$diagnostic service
return(expComplex);
}
dtComplex = alt.DataType;
dtComplexOrig = alt.DataType;
if (ut.PreferredType != null)
{
expComplex = new Cast(ut.PreferredType, expComplex);
}
else
{
expComplex = CreateFieldAccess(ut, alt.DataType, expComplex, alt);
}
return(dtComplex.Accept(this));
}
public override Key Parse(DataType item) => new Key.BulkString(
item.Accept(BulkStringExpectation.Singleton)
);
public override void Process()
{
dt.Accept(this);
}
public Expression BuildComplex()
{
var exp = dt.Accept(this);
return(exp);
}
public static bool IsInCycle(TypeStore store, DataType dtCandidate)
{
var finder = new TypeStoreCycleFinder(store, dtCandidate);
return(dtCandidate.Accept(finder));
}
/// <summary>
/// Resolves the specified type into its type reference.
/// </summary>
/// <param name="dataType">The data type.</param>
/// <returns>CodeTypeReference that should be used in code to refer to the type.</returns>
public CodeTypeReference Resolve(DataType dataType)
{
return(dataType.Accept(this));
}
public Expression VisitEquivalenceClass(EquivalenceClass eq)
{
dt = eq.DataType;
dtOriginal = eq.DataType;
return(dt.Accept(this));
}
// Mutators /////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(Address address, DataType dataType)
{
//$TODO: if user enters a segmented address, we need to
// place the item in the respective globals struct.
var size = GetDataSize(address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
this.User.Globals.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return item;
}
private void WriteEntry(TypeVariable tv, DataType dt, Formatter writer)
{
writer.Write("{0}: ", tv);
if (dt != null)
{
dt.Accept(new TypeGraphWriter(writer));
WriteExpressionOf(tv, writer);
}
writer.WriteLine();
}
/// <summary>
/// Converts data type from Taupo term into Edm term
/// </summary>
/// <param name="taupoDataType">The DataType (Taupo term)</param>
/// <returns>The TypeReference (Edm term)</returns>
public IEdmTypeReference ConvertToEdmTypeReference(DataType taupoDataType)
{
return(taupoDataType.Accept(this));
}
// Mutators /////////////////////////////////////////////////////////////////
/// <summary>
/// This method is called when the user has created a global item.
/// </summary>
/// <param name="address"></param>
/// <param name="dataType"></param>
/// <returns></returns>
public ImageMapItem AddUserGlobalItem(Address address, DataType dataType)
{
var size = GetDataSize(address, dataType);
var item = new ImageMapItem
{
Address = address,
Size = size,
DataType = dataType,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
this.UserGlobalData.Add(address, new Serialization.GlobalDataItem_v2
{
Address = address.ToString(),
DataType = dataType.Accept(new Serialization.DataTypeSerializer()),
});
return item;
}
/// <summary>
/// Gets the short qualified Edm name of a data type
/// </summary>
/// <param name="dataType">The data type</param>
/// <returns>The short qualified edm name</returns>
public string GetEdmShortQualifiedName(DataType dataType)
{
return(dataType.Accept(this));
}
public DataType Replace(DataType dt)
{
return dt != null
? dt.Accept(this)
: null;
}
public void Write(DataType dt, string name)
{
this.name = name;
dt.Accept(this);
}
public DataType Replace(DataType dt)
{
return(dt != null
? dt.Accept(this)
: null);
}
private Expression RewritePointer(DataType dtPtr, DataType dtPointee, DataType dtPointeeOriginal)
{
if (seenPtr)
{
return(complexExp);
}
seenPtr = true;
Expression result;
if (dtPointee is PrimitiveType || dtPointee is Pointer || dtPointee is MemberPointer ||
dtPointee is CodeType ||
comp.Compare(dtPtr, dtResult) == 0)
{
if (dtPointee.Size == 0)
{
Debug.Print("WARNING: {0} has size 0, which should be impossible", dtPointee);
}
if (offset == 0 || dtPointee is ArrayType || dtPointee.Size > 0 && offset % dtPointee.Size == 0)
{
int idx = (offset == 0 || dtPointee is ArrayType)
? 0
: offset / dtPointee.Size;
if (idx == 0 && this.indexExp == null)
{
if (Dereferenced)
{
result = CreateDereference(dtPointee, complexExp);
}
else
{
result = CreateUnreferenced(dtPointee, complexExp);
}
}
else
{
result = CreateArrayAccess(dtPointee, dtPtr, idx, indexExp, Dereferenced);
}
}
else
{
result = new PointerAddition(dtPtr, complexExp, offset);
}
}
else
{
// Drill down.
dtOriginal = dtPointeeOriginal;
complexExp = CreateDereference(dtPointee, complexExp);
bool deref = Dereferenced; //$REVIEW: causes problems with arrayType
Dereferenced = true; //$REVUEW: causes problems with arrayType
basePointer = null;
result = dtPointee.Accept(this);
if (!deref)
{
result = new UnaryExpression(UnaryOperator.AddrOf, dtPtr, result);
}
Dereferenced = deref; //$REVIEW: causes problems with arrayType
}
seenPtr = false;
return(result);
}
public DataType?Replace(DataType?dt)
{
return(dt?.Accept(this));
}
public virtual string ShortPrefix(DataType dt)
{
return(dt.Accept(prefixPolicy));
}