/// <summary>
/// Gets the type of stelem code to use for the given element type.
/// </summary>
public static AstCode GetStElemCode(this XTypeReference elementType)
{
if (elementType.IsByte() || elementType.IsSByte() || elementType.IsBoolean())
{
return(AstCode.Stelem_I1);
}
if (elementType.IsChar() || elementType.IsInt16() || elementType.IsUInt16())
{
return(AstCode.Stelem_I2);
}
if (elementType.IsInt32() || elementType.IsUInt32())
{
return(AstCode.Stelem_I4);
}
if (elementType.IsInt64() || elementType.IsUInt64())
{
return(AstCode.Stelem_I8);
}
if (elementType.IsFloat())
{
return(AstCode.Stelem_R4);
}
if (elementType.IsDouble())
{
return(AstCode.Stelem_R8);
}
return(AstCode.Stelem_Ref);
}
/// <summary>
/// Convert the given argument if it does not match the target type.
/// </summary>
private static void ConvertForRetIfNeeded(AstExpression arg, XTypeReference targetType)
{
var argType = arg.GetResultType();
if (!targetType.IsSame(argType))
{
if (targetType.IsChar())
{
if (argType.IsUInt16() || argType.IsByte() || argType.IsInt16())
{
Convert(arg, AstCode.Conv_U2, targetType);
}
}
else if (targetType.IsUInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Int_to_ushort, targetType);
}
}
else if (targetType.IsInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Conv_I2, targetType);
}
}
}
}
/// <summary>
/// Generate converter for the value of an Const instruction.
/// </summary>
internal static Func <object, object> ConstValueConverter(this XTypeReference elementType, bool keepUnsigned)
{
if (elementType.IsBoolean())
{
return(x => Convert.ToBoolean(x) ? 1 : 0);
}
if (elementType.IsByte())
{
if (keepUnsigned)
{
return(x => (int)Convert.ToByte(x));
}
return(x => (int)((sbyte)unchecked (Convert.ToByte(x))));
}
if (elementType.IsSByte())
{
return(x => (int)(Convert.ToSByte(x)));
}
if (elementType.IsChar())
{
return(x => (int)(Convert.ToChar(x)));
}
if (elementType.IsUInt16())
{
return(x => (int)(Convert.ToUInt16(x)));
}
if (elementType.IsInt16())
{
return(x => (int)(Convert.ToInt16(x)));
}
if (elementType.IsInt32())
{
return(x => XConvert.ToInt(x));
}
if (elementType.IsUInt32())
{
return(x => XConvert.ToInt(x)); // unchecked((int)Convert.ToUInt32(Convert.ToInt64(x) & 0xFFFFFFFF));
}
if (elementType.IsFloat())
{
return(x => Convert.ToSingle(x));
}
if (elementType.IsInt64())
{
return(x => XConvert.ToLong(x));
}
if (elementType.IsUInt64())
{
return(x => XConvert.ToLong(x)); // unchecked((long)Convert.ToInt64(x));
}
if (elementType.IsDouble())
{
return(x => Convert.ToDouble(x));
}
if (elementType.IsDexObject() && !elementType.IsVoid())
{
return(x => x);
}
throw new NotSupportedException("Unknown type for constValueConverter " + elementType);
}
/// <summary>
/// Generate an Add opcode.
/// </summary>
private static RCode OpcodeForType(XTypeReference type, RCode[] opcodes)
{
if (type.IsInt32() || type.IsUInt32() || type.IsInt16() || type.IsUInt16() || type.IsChar() || type.IsByte() || type.IsSByte() || type.IsBoolean())
{
return(opcodes[0]);
}
if (type.IsInt64() || type.IsUInt64())
{
return(opcodes[1]);
}
if (type.IsFloat())
{
return(opcodes[2]);
}
if (type.IsDouble())
{
return(opcodes[3]);
}
XTypeDefinition typeDef;
if (type.TryResolve(out typeDef))
{
if (typeDef.IsEnum)
{
return(OpcodeForType(typeDef.GetEnumUnderlyingType(), opcodes));
}
}
throw new ArgumentException("Unsupported type " + type);
}
/// <summary>
/// Returns the method name when converting an array to an IEnumerableT in compiler helper.
///
/// (not sure if this is the best place for this method...)
/// </summary>
public static string GetAsEnumerableTMethodName(XTypeReference sourceArrayElementType)
{
var convertMethodName = "AsObjectEnumerable";
if (sourceArrayElementType.IsPrimitive)
{
if (sourceArrayElementType.IsBoolean())
{
convertMethodName = "AsBoolEnumerable";
}
else if (sourceArrayElementType.IsByte())
{
convertMethodName = "AsByteEnumerable";
}
else if (sourceArrayElementType.IsSByte())
{
convertMethodName = "AsSByteEnumerable";
}
else if (sourceArrayElementType.IsChar())
{
convertMethodName = "AsCharEnumerable";
}
else if (sourceArrayElementType.IsInt16())
{
convertMethodName = "AsInt16Enumerable";
}
else if (sourceArrayElementType.IsUInt16())
{
convertMethodName = "AsUInt16Enumerable";
}
else if (sourceArrayElementType.IsInt32())
{
convertMethodName = "AsInt32Enumerable";
}
else if (sourceArrayElementType.IsUInt32())
{
convertMethodName = "AsUInt32Enumerable";
}
else if (sourceArrayElementType.IsInt64())
{
convertMethodName = "AsInt64Enumerable";
}
else if (sourceArrayElementType.IsFloat())
{
convertMethodName = "AsFloatEnumerable";
}
else if (sourceArrayElementType.IsDouble())
{
convertMethodName = "AsDoubleEnumerable";
}
else
{
throw new ArgumentOutOfRangeException("Unknown primitive array element type " + sourceArrayElementType);
}
}
return(convertMethodName);
}
/// <summary>
/// Convert the result of the given node to uint8/uint16 if needed.
/// </summary>
private static void ConvertIfNeeded(AstExpression node, XTypeReference valueType, AstExpression parent)
{
AstCode convCode;
if (valueType.IsByte())
{
// Convert from int to uint8
convCode = AstCode.Int_to_ubyte;
}
else if (valueType.IsUInt16())
{
// Convert from int to uint16
convCode = AstCode.Int_to_ushort;
}
else if (valueType.IsChar())
{
// Convert from int to uint16
convCode = AstCode.Conv_U2;
}
else
{
// Do not convert
return;
}
// Avoid recursion
if ((parent != null) && (parent.Code == convCode))
{
return;
}
// Copy load expression
var clone = new AstExpression(node);
// Convert node
node.Code = convCode;
node.Arguments.Clear();
node.Arguments.Add(clone);
node.Operand = null;
node.InferredType = valueType;
// keep the expected type!
node.ExpectedType = clone.ExpectedType;
clone.ExpectedType = valueType;
}
private static bool CanPullComparisonUp(AstCode code, XTypeReference arg1, XTypeReference arg2, PullTarget target)
{
if (arg1 == null || arg2 == null)
{
return(false);
}
bool isReference = arg1.IsDexObject() && arg1.IsDexObject();
if (!isReference && !arg1.IsSame(arg2))
{
return(false);
}
if (target == PullTarget.Comparison)
{
return(true);
}
if (arg1.Is(XTypeReferenceKind.Float))
{
return(false);
}
if (arg1.IsDexWide())
{
return(false);
}
bool isEq = IsEqualsBranchOrComparison(code);
if (isEq)
{
return(true);
}
bool isUnsigned = arg1.IsUInt16() || arg1.IsUInt32(); // TODO: check if we really have to exclude unsigned.
if (isReference || isUnsigned)
{
return(false);
}
return(true);
}
/// <summary>
/// Create code to box the given source value into the given type.
/// </summary>
public static RLRange Box(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec source, XTypeReference type, DexTargetPackage targetPackage, IRegisterAllocator frame)
{
if (type.IsPrimitive)
{
if (type.IsByte())
{
builder.Add(sequencePoint, RCode.Int_to_byte, source.Register, source.Register);
}
else if (type.IsUInt16())
{
builder.Add(sequencePoint, RCode.Int_to_short, source.Register, source.Register);
}
// Call appropriate valueOf method
var boxedType = type.Module.TypeSystem.Object;
var r = frame.AllocateTemp(boxedType.GetReference(targetPackage));
var call = builder.Add(sequencePoint, RCode.Invoke_static, type.GetBoxValueOfMethod(), source.Registers);
var last = builder.Add(sequencePoint, RCode.Move_result_object, r);
return(new RLRange(call, last, r));
}
if (type.IsGenericParameter)
{
var nop = builder.Add(sequencePoint, RCode.Nop);
return(new RLRange(nop, source));
}
XTypeDefinition typeDef;
if (type.TryResolve(out typeDef) && (typeDef.IsEnum))
{
// Call appropriate valueOf method
/*var boxedType = type.Module.TypeSystem.Object;
* var r = frame.AllocateTemp(boxedType.GetReference(target, nsConverter));
* var call = builder.Add(sequencePoint, RCode.Invoke_static, typeDef.GetEnumUnderlyingType().GetBoxValueOfMethod(), source.Registers);
* var last = builder.Add(sequencePoint, RCode.Move_result_object, r);
* return new RLRange(call, last, r);*/
}
// Just cast
var checkCast = builder.Add(sequencePoint, RCode.Check_cast, type.GetReference(targetPackage), source);
return(new RLRange(checkCast, source));
}
/// <summary>
/// Emit code (if needed) to convert a value from source type to destination type.
/// This method is used in "store" opcodes such stloc, stfld, stsfld, call
/// </summary>
internal static RLRange ConvertTypeBeforeStore(this IRLBuilder builder, ISourceLocation sequencePoint, XTypeReference sourceType, XTypeReference destinationType, RegisterSpec source, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler, out bool converted)
{
converted = false;
if (sourceType.IsSame(destinationType))
{
// Unsigned conversions
if (sourceType.IsByte())
{
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
var ins = builder.Add(sequencePoint, RCode.Int_to_byte, tmp.Result, tmp.Result);
converted = true;
return(new RLRange(tmp, ins, tmp.Result));
}
else if (sourceType.IsUInt16())
{
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
var ins = builder.Add(sequencePoint, RCode.Int_to_short, tmp.Result, tmp.Result);
converted = true;
return(new RLRange(tmp, ins, tmp.Result));
}
return(new RLRange(source));
}
if (sourceType.IsArray)
{
var compilerHelper = compiler.GetDot42InternalType(InternalConstants.CompilerHelperName).Resolve();
var arrayType = targetPackage.DexFile.GetClass(targetPackage.NameConverter.GetConvertedFullName(compilerHelper));
var sourceArrayElementType = ((XArrayType)sourceType).ElementType;
if (destinationType.ExtendsIList())
{
// Use ArrayHelper.AsList to convert
var convertMethodName = "AsList";
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
if (destinationType.ExtendsICollection())
{
// Use ArrayHelper.AsCollection to convert
var convertMethodName = "AsCollection";
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
if (destinationType.ExtendsIEnumerable())
{
// Use ArrayHelper.As...Enumerable to convert
var convertMethodName = FrameworkReferences.GetAsEnumerableTMethodName(sourceArrayElementType);
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
}
if (sourceType.IsGenericParameter && !destinationType.IsSystemObject())
{
var gp = (XGenericParameter)sourceType;
if (gp.Constraints.Length > 0)
{
// we could find the best matching constraint here, and check if we actually
// need to cast. This would probably allow us to skip some unneccesary casts.
// We would need some sort of IsAssignableFrom though, and I'm not sure we have
// this logic with XTypeDefinition implemented yet.
// Therefore, we just assume that the original compiler has done its job well,
// and always cast to the destination type.
// Apparently dex seems not to need a cast when destinationType is an interface.
// Since i'm not to sure about this, we nevertheless insert the cast here.
// [TODO: check if this is needed]
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
var cast = builder.Add(sequencePoint, RCode.Check_cast, destinationType.GetReference(targetPackage), tmp.Result);
converted = true;
return(new RLRange(tmp, cast, tmp.Result));
}
}
// Do not convert
return(new RLRange(source));
}
/// <summary>
/// Emit code (if needed) to convert a value from source type to destination type.
/// This method is used in "store" opcodes such stloc, stfld, stsfld, call
/// </summary>
internal static RLRange ConvertTypeBeforeStore(this IRLBuilder builder, ISourceLocation sequencePoint, XTypeReference sourceType, XTypeReference destinationType, RegisterSpec source, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler, out bool converted)
{
converted = false;
if (sourceType.IsSame(destinationType))
{
// Unsigned conversions
if (sourceType.IsByte())
{
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
var ins = builder.Add(sequencePoint, RCode.Int_to_byte, tmp.Result, tmp.Result);
converted = true;
return(new RLRange(tmp, ins, tmp.Result));
}
else if (sourceType.IsUInt16())
{
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
var ins = builder.Add(sequencePoint, RCode.Int_to_short, tmp.Result, tmp.Result);
converted = true;
return(new RLRange(tmp, ins, tmp.Result));
}
return(new RLRange(source));
}
if (sourceType.IsArray)
{
var compilerHelper = compiler.GetDot42InternalType(InternalConstants.CompilerHelperName).Resolve();
var arrayType = targetPackage.DexFile.GetClass(targetPackage.NameConverter.GetConvertedFullName(compilerHelper));
var sourceArrayElementType = ((XArrayType)sourceType).ElementType;
if (destinationType.ExtendsIList())
{
// Use ArrayHelper.AsList to convert
var convertMethodName = "AsList";
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
if (destinationType.ExtendsICollection())
{
// Use ArrayHelper.AsCollection to convert
var convertMethodName = "AsCollection";
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
if (destinationType.ExtendsIEnumerable())
{
// Use ArrayHelper.As...Enumerable to convert
var convertMethodName = "AsObjectEnumerable";
if (sourceArrayElementType.IsPrimitive)
{
if (sourceArrayElementType.IsBoolean())
{
convertMethodName = "AsBoolEnumerable";
}
else if (sourceArrayElementType.IsByte())
{
convertMethodName = "AsByteEnumerable";
}
else if (sourceArrayElementType.IsSByte())
{
convertMethodName = "AsSByteEnumerable";
}
else if (sourceArrayElementType.IsChar())
{
convertMethodName = "AsCharEnumerable";
}
else if (sourceArrayElementType.IsInt16())
{
convertMethodName = "AsInt16Enumerable";
}
else if (sourceArrayElementType.IsUInt16())
{
convertMethodName = "AsUInt16Enumerable";
}
else if (sourceArrayElementType.IsInt32())
{
convertMethodName = "AsInt32Enumerable";
}
else if (sourceArrayElementType.IsUInt32())
{
convertMethodName = "AsUInt32Enumerable";
}
else if (sourceArrayElementType.IsInt64())
{
convertMethodName = "AsInt64Enumerable";
}
else if (sourceArrayElementType.IsFloat())
{
convertMethodName = "AsFloatEnumerable";
}
else if (sourceArrayElementType.IsDouble())
{
convertMethodName = "AsDoubleEnumerable";
}
else
{
throw new ArgumentOutOfRangeException("Unknown primitive array element type " + sourceArrayElementType);
}
}
var convertMethod = arrayType.GetMethod(convertMethodName);
// Add code
var tmp = builder.EnsureTemp(sequencePoint, source, frame);
builder.Add(sequencePoint, RCode.Invoke_static, convertMethod, tmp.Result.Register);
var last = builder.Add(sequencePoint, RCode.Move_result_object, tmp.Result.Register);
converted = true;
return(new RLRange(tmp, last, tmp.Result));
}
}
// Do not convert
return(new RLRange(source));
}
