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