Merge pull request #1000 from icsharpcode/floating-point-arithmetic

Floating point arithmetic

ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs

@@ -65,6 +65,12 @@ namespace ICSharpCode.Decompiler.Tests
 			RunCS(options: options);
 		}
 
+		[Test]
+		public void FloatingPointArithmetic([ValueSource("defaultOptions")] CompilerOptions options)
+		{
+			RunCS(options: options);
+		}
+
 		[Test]
 		public void HelloWorld([ValueSource("defaultOptions")] CompilerOptions options)
 		{

ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -60,6 +60,7 @@
     <Compile Include="TestCases\Correctness\ExpressionTrees.cs" />
     <Compile Include="TestCases\Correctness\LINQRaytracer.cs" />
     <Compile Include="TestCases\Correctness\MiniJSON.cs" />
+    <Compile Include="TestCases\Correctness\FloatingPointArithmetic.cs" />
     <Compile Include="TestCases\ILPretty\Issue982.cs" />
     <Compile Include="TestCases\Pretty\ExpressionTrees.cs" />
     <Compile Include="TestCases\Pretty\VariableNaming.cs" />

ICSharpCode.Decompiler.Tests/TestCases/Correctness/FloatingPointArithmetic.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness
+{
+	class FloatingPointArithmetic
+	{
+		public static int Main(string[] args)
+		{
+			Issue999();
+			return 0;
+		}
+
+		static void Issue999()
+		{
+			for (float i = -10f; i <= 10f; i += 0.01f) 
+				Console.WriteLine("{1:R}: {0:R}", M(i), i);
+		}
+
+		static float M(float v)
+		{
+			return 0.99f * v + 0.01f;
+		}
+	}
+}

ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@@ -307,7 +307,14 @@ namespace ICSharpCode.Decompiler.CSharp
 			return false;
 		}
 
-		protected internal override TranslatedExpression VisitLdcF(LdcF inst, TranslationContext context)
+		protected internal override TranslatedExpression VisitLdcF4(LdcF4 inst, TranslationContext context)
+		{
+			return new PrimitiveExpression(inst.Value)
+				.WithILInstruction(inst)
+				.WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Single), inst.Value));
+		}
+
+		protected internal override TranslatedExpression VisitLdcF8(LdcF8 inst, TranslationContext context)
 		{
 			return new PrimitiveExpression(inst.Value)
 				.WithILInstruction(inst)

ICSharpCode.Decompiler/IL/ILReader.cs

@@ -262,6 +262,10 @@ namespace ICSharpCode.Decompiler.IL
 				return true;
 			if (stackType1 == StackType.I4 && stackType2 == StackType.I)
 				return true;
+			if (stackType1 == StackType.F4 && stackType2 == StackType.F8)
+				return true;
+			if (stackType1 == StackType.F8 && stackType2 == StackType.F4)
+				return true;
 			// allow merging unknown type with any other type
 			return stackType1 == StackType.Unknown || stackType2 == StackType.Unknown;
 		}
@@ -457,8 +461,10 @@ namespace ICSharpCode.Decompiler.IL
 					return Push(new BinaryNumericInstruction(BinaryNumericOperator.Sub, new Conv(new LdcI4(0), PrimitiveType.I, false, Sign.None), Pop(), checkForOverflow: false, sign: Sign.None));
 				case StackType.I8:
 					return Push(new BinaryNumericInstruction(BinaryNumericOperator.Sub, new LdcI8(0), Pop(), checkForOverflow: false, sign: Sign.None));
-				case StackType.F:
+				case StackType.F4:
-					return Push(new BinaryNumericInstruction(BinaryNumericOperator.Sub, new LdcF(0), Pop(), checkForOverflow: false, sign: Sign.None));
+					return Push(new BinaryNumericInstruction(BinaryNumericOperator.Sub, new LdcF4(0), Pop(), checkForOverflow: false, sign: Sign.None));
+				case StackType.F8:
+					return Push(new BinaryNumericInstruction(BinaryNumericOperator.Sub, new LdcF8(0), Pop(), checkForOverflow: false, sign: Sign.None));
 				default:
 					Warn("Unsupported input type for neg.");
 					goto case StackType.I4;
@@ -665,9 +671,9 @@ namespace ICSharpCode.Decompiler.IL
 				case Cil.Code.Ldc_I8:
 					return Push(new LdcI8((long)cecilInst.Operand));
 				case Cil.Code.Ldc_R4:
-					return Push(new LdcF((float)cecilInst.Operand));
+					return Push(new LdcF4((float)cecilInst.Operand));
 				case Cil.Code.Ldc_R8:
-					return Push(new LdcF((double)cecilInst.Operand));
+					return Push(new LdcF8((double)cecilInst.Operand));
 				case Cil.Code.Ldc_I4_M1:
 					return Push(new LdcI4(-1));
 				case Cil.Code.Ldc_I4_0:
@@ -781,9 +787,9 @@ namespace ICSharpCode.Decompiler.IL
 				case Cil.Code.Stind_I8:
 					return new StObj(value: Pop(StackType.I8), target: PopPointer(), type: compilation.FindType(KnownTypeCode.Int64));
 				case Cil.Code.Stind_R4:
-					return new StObj(value: Pop(StackType.F), target: PopPointer(), type: compilation.FindType(KnownTypeCode.Single));
+					return new StObj(value: Pop(StackType.F4), target: PopPointer(), type: compilation.FindType(KnownTypeCode.Single));
 				case Cil.Code.Stind_R8:
-					return new StObj(value: Pop(StackType.F), target: PopPointer(), type: compilation.FindType(KnownTypeCode.Double));
+					return new StObj(value: Pop(StackType.F8), target: PopPointer(), type: compilation.FindType(KnownTypeCode.Double));
 				case Cil.Code.Stind_I:
 					return new StObj(value: Pop(StackType.I), target: PopPointer(), type: compilation.FindType(KnownTypeCode.IntPtr));
 				case Cil.Code.Stind_Ref:
@@ -1043,6 +1049,12 @@ namespace ICSharpCode.Decompiler.IL
 						Warn($"Expected {expectedType}, but got {inst.ResultType}");
 					}
 					inst = new Conv(inst, PrimitiveType.Ref, false, Sign.None);
+				} else if (expectedType == StackType.F8 && inst.ResultType == StackType.F4) {
+					// IL allows implicit F4->F8 conversions, because in IL F4 and F8 are the same.
+					inst = new Conv(inst, PrimitiveType.R8, false, Sign.Signed);
+				} else if (expectedType == StackType.F4 && inst.ResultType == StackType.F8) {
+					// IL allows implicit F8->F4 conversions, because in IL F4 and F8 are the same.
+					inst = new Conv(inst, PrimitiveType.R4, false, Sign.Signed);
 				} else {
 					Warn($"Expected {expectedType}, but got {inst.ResultType}");
 					inst = new Conv(inst, expectedType.ToKnownTypeCode().ToPrimitiveType(), false, Sign.None);
@@ -1287,7 +1299,15 @@ namespace ICSharpCode.Decompiler.IL
 			}
 			
 			// Based on Table 4: Binary Comparison or Branch Operation
-			if (left.ResultType == StackType.F && right.ResultType == StackType.F) {
+			if (left.ResultType.IsFloatType() && right.ResultType.IsFloatType()) {
+				if (left.ResultType != right.ResultType) {
+					// make the implicit F4->F8 conversion explicit:
+					if (left.ResultType == StackType.F4) {
+						left = new Conv(left, PrimitiveType.R8, false, Sign.Signed);
+					} else if (right.ResultType == StackType.F4) {
+						right = new Conv(right, PrimitiveType.R8, false, Sign.Signed);
+					}
+				}
 				if (un) {
 					// for floats, 'un' means 'unordered'
 					return Comp.LogicNot(new Comp(kind.Negate(), Sign.None, left, right));

ICSharpCode.Decompiler/IL/ILTypeExtensions.cs

@@ -44,8 +44,9 @@ namespace ICSharpCode.Decompiler.IL
 				case MetadataType.FunctionPointer:
 					return StackType.I;
 				case MetadataType.Single:
+					return StackType.F4;
 				case MetadataType.Double:
-					return StackType.F;
+					return StackType.F8;
 				case MetadataType.ByReference:
 					return StackType.Ref;
 				case MetadataType.Void:

ICSharpCode.Decompiler/IL/Instructions.cs

@@ -108,8 +108,10 @@ namespace ICSharpCode.Decompiler.IL
 		LdcI4,
 		/// <summary>Loads a constant 64-bit integer.</summary>
 		LdcI8,
-		/// <summary>Loads a constant floating-point number.</summary>
+		/// <summary>Loads a constant 32-bit floating-point number.</summary>
-		LdcF,
+		LdcF4,
+		/// <summary>Loads a constant 64-bit floating-point number.</summary>
+		LdcF8,
 		/// <summary>Loads a constant decimal.</summary>
 		LdcDecimal,
 		/// <summary>Loads the null reference.</summary>
@@ -2614,15 +2616,52 @@ namespace ICSharpCode.Decompiler.IL
 }
 namespace ICSharpCode.Decompiler.IL
 {
-	/// <summary>Loads a constant floating-point number.</summary>
+	/// <summary>Loads a constant 32-bit floating-point number.</summary>
-	public sealed partial class LdcF : SimpleInstruction
+	public sealed partial class LdcF4 : SimpleInstruction
 	{
-		public LdcF(double value) : base(OpCode.LdcF)
+		public LdcF4(float value) : base(OpCode.LdcF4)
+		{
+			this.Value = value;
+		}
+		public readonly float Value;
+		public override StackType ResultType { get { return StackType.F4; } }
+		public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
+		{
+			ILRange.WriteTo(output, options);
+			output.Write(OpCode);
+			output.Write(' ');
+			Disassembler.DisassemblerHelpers.WriteOperand(output, Value);
+		}
+		public override void AcceptVisitor(ILVisitor visitor)
+		{
+			visitor.VisitLdcF4(this);
+		}
+		public override T AcceptVisitor<T>(ILVisitor<T> visitor)
+		{
+			return visitor.VisitLdcF4(this);
+		}
+		public override T AcceptVisitor<C, T>(ILVisitor<C, T> visitor, C context)
+		{
+			return visitor.VisitLdcF4(this, context);
+		}
+		protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match)
+		{
+			var o = other as LdcF4;
+			return o != null && this.Value == o.Value;
+		}
+	}
+}
+namespace ICSharpCode.Decompiler.IL
+{
+	/// <summary>Loads a constant 64-bit floating-point number.</summary>
+	public sealed partial class LdcF8 : SimpleInstruction
+	{
+		public LdcF8(double value) : base(OpCode.LdcF8)
 		{
 			this.Value = value;
 		}
 		public readonly double Value;
-		public override StackType ResultType { get { return StackType.F; } }
+		public override StackType ResultType { get { return StackType.F8; } }
 		public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
 		{
 			ILRange.WriteTo(output, options);
@@ -2632,19 +2671,19 @@ namespace ICSharpCode.Decompiler.IL
 		}
 		public override void AcceptVisitor(ILVisitor visitor)
 		{
-			visitor.VisitLdcF(this);
+			visitor.VisitLdcF8(this);
 		}
 		public override T AcceptVisitor<T>(ILVisitor<T> visitor)
 		{
-			return visitor.VisitLdcF(this);
+			return visitor.VisitLdcF8(this);
 		}
 		public override T AcceptVisitor<C, T>(ILVisitor<C, T> visitor, C context)
 		{
-			return visitor.VisitLdcF(this, context);
+			return visitor.VisitLdcF8(this, context);
 		}
 		protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match)
 		{
-			var o = other as LdcF;
+			var o = other as LdcF8;
 			return o != null && this.Value == o.Value;
 		}
 	}
@@ -5058,7 +5097,11 @@ namespace ICSharpCode.Decompiler.IL
 		{
 			Default(inst);
 		}
-		protected internal virtual void VisitLdcF(LdcF inst)
+		protected internal virtual void VisitLdcF4(LdcF4 inst)
+		{
+			Default(inst);
+		}
+		protected internal virtual void VisitLdcF8(LdcF8 inst)
 		{
 			Default(inst);
 		}
@@ -5364,7 +5407,11 @@ namespace ICSharpCode.Decompiler.IL
 		{
 			return Default(inst);
 		}
-		protected internal virtual T VisitLdcF(LdcF inst)
+		protected internal virtual T VisitLdcF4(LdcF4 inst)
+		{
+			return Default(inst);
+		}
+		protected internal virtual T VisitLdcF8(LdcF8 inst)
 		{
 			return Default(inst);
 		}
@@ -5670,7 +5717,11 @@ namespace ICSharpCode.Decompiler.IL
 		{
 			return Default(inst, context);
 		}
-		protected internal virtual T VisitLdcF(LdcF inst, C context)
+		protected internal virtual T VisitLdcF4(LdcF4 inst, C context)
+		{
+			return Default(inst, context);
+		}
+		protected internal virtual T VisitLdcF8(LdcF8 inst, C context)
 		{
 			return Default(inst, context);
 		}
@@ -5854,7 +5905,8 @@ namespace ICSharpCode.Decompiler.IL
 			"ldstr",
 			"ldc.i4",
 			"ldc.i8",
-			"ldc.f",
+			"ldc.f4",
+			"ldc.f8",
 			"ldc.decimal",
 			"ldnull",
 			"ldftn",
@@ -6095,9 +6147,19 @@ namespace ICSharpCode.Decompiler.IL
 			value = default(long);
 			return false;
 		}
-		public bool MatchLdcF(out double value)
+		public bool MatchLdcF4(out float value)
+		{
+			var inst = this as LdcF4;
+			if (inst != null) {
+				value = inst.Value;
+				return true;
+			}
+			value = default(float);
+			return false;
+		}
+		public bool MatchLdcF8(out double value)
 		{
-			var inst = this as LdcF;
+			var inst = this as LdcF8;
 			if (inst != null) {
 				value = inst.Value;
 				return true;

ICSharpCode.Decompiler/IL/Instructions.tt

@@ -167,8 +167,10 @@
 			LoadConstant("int"), ResultType("I4")),
 		new OpCode("ldc.i8", "Loads a constant 64-bit integer.",
 			LoadConstant("long"), ResultType("I8")),
-		new OpCode("ldc.f", "Loads a constant floating-point number.",
+		new OpCode("ldc.f4", "Loads a constant 32-bit floating-point number.",
-			LoadConstant("double"), ResultType("F")),
+			LoadConstant("float"), ResultType("F4")),
+		new OpCode("ldc.f8", "Loads a constant 64-bit floating-point number.",
+			LoadConstant("double"), ResultType("F8")),
 		new OpCode("ldc.decimal", "Loads a constant decimal.",
 			LoadConstant("decimal"), ResultType("O")),
 		new OpCode("ldnull", "Loads the null reference.",

ICSharpCode.Decompiler/IL/Instructions/Conv.cs

@@ -188,7 +188,8 @@ namespace ICSharpCode.Decompiler.IL
 						case StackType.I8:
 						case StackType.I:
 							return ConversionKind.Truncate;
-						case StackType.F:
+						case StackType.F4:
+						case StackType.F8:
 							return ConversionKind.FloatToInt;
 						default:
 							return ConversionKind.Invalid;
@@ -201,7 +202,8 @@ namespace ICSharpCode.Decompiler.IL
 						case StackType.I:
 						case StackType.I8:
 							return ConversionKind.Truncate;
-						case StackType.F:
+						case StackType.F4:
+						case StackType.F8:
 							return ConversionKind.FloatToInt;
 						default:
 							return ConversionKind.Invalid;
@@ -217,7 +219,8 @@ namespace ICSharpCode.Decompiler.IL
 								return inputSign == Sign.Signed ? ConversionKind.SignExtend : ConversionKind.ZeroExtend;
 						case StackType.I8:
 							return ConversionKind.Nop;
-						case StackType.F:
+						case StackType.F4:
+						case StackType.F8:
 							return ConversionKind.FloatToInt;
 						case StackType.Ref:
 						case StackType.O:
@@ -237,7 +240,8 @@ namespace ICSharpCode.Decompiler.IL
 							return ConversionKind.Nop;
 						case StackType.I8:
 							return ConversionKind.Truncate;
-						case StackType.F:
+						case StackType.F4:
+						case StackType.F8:
 							return ConversionKind.FloatToInt;
 						case StackType.Ref:
 						case StackType.O:
@@ -246,14 +250,28 @@ namespace ICSharpCode.Decompiler.IL
 							return ConversionKind.Invalid;
 					}
 				case PrimitiveType.R4:
+					switch (inputType) {
+						case StackType.I4:
+						case StackType.I:
+						case StackType.I8:
+							return ConversionKind.IntToFloat;
+						case StackType.F4:
+							return ConversionKind.Nop;
+						case StackType.F8:
+							return ConversionKind.FloatPrecisionChange;
+						default:
+							return ConversionKind.Invalid;
+					}
 				case PrimitiveType.R8:
 					switch (inputType) {
 						case StackType.I4:
 						case StackType.I:
 						case StackType.I8:
 							return ConversionKind.IntToFloat;
-						case StackType.F:
+						case StackType.F4:
 							return ConversionKind.FloatPrecisionChange;
+						case StackType.F8:
+							return ConversionKind.Nop;
 						default:
 							return ConversionKind.Invalid;
 					}

ICSharpCode.Decompiler/IL/Instructions/PatternMatching.cs

@@ -27,9 +27,14 @@ namespace ICSharpCode.Decompiler.IL
 			return OpCode == OpCode.LdcI4 && ((LdcI4)this).Value == val;
 		}
 
-		public bool MatchLdcF(double value)
+		public bool MatchLdcF4(float value)
 		{
-			return MatchLdcF(out var v) && v == value;
+			return MatchLdcF4(out var v) && v == value;
+		}
+
+		public bool MatchLdcF8(double value)
+		{
+			return MatchLdcF8(out var v) && v == value;
 		}
 
 		/// <summary>

ICSharpCode.Decompiler/IL/StackType.cs

@@ -54,11 +54,16 @@ namespace ICSharpCode.Decompiler.IL
 		/// and any enums with one of the above as underlying type.
 		/// </remarks>
 		I8,
-		/// <summary>Floating point number</summary>
+		/// <summary>32-bit floating point number</summary>
 		/// <remarks>
-		/// Used for C# <c>float</c> and <c>double</c>.
+		/// Used for C# <c>float</c>.
 		/// </remarks>
-		F,
+		F4,
+		/// <summary>64-bit floating point number</summary>
+		/// <remarks>
+		/// Used for C# <c>double</c>.
+		/// </remarks>
+		F8,
 		/// <summary>Another stack type. Includes objects, value types, ...</summary>
 		O,
 		/// <summary>A managed pointer</summary>

ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs

@@ -184,7 +184,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		{
 			ILInstruction lhs, rhs;
 			if (arg is Comp comp) {
-				if ((comp.InputType != StackType.F && !comp.IsLifted) || comp.Kind.IsEqualityOrInequality()) {
+				if ((!comp.InputType.IsFloatType() && !comp.IsLifted) || comp.Kind.IsEqualityOrInequality()) {
 					context.Step("push negation into comparison", inst);
 					comp.Kind = comp.Kind.Negate();
 					comp.AddILRange(inst.ILRange);

ICSharpCode.Decompiler/IL/Transforms/SwitchOnStringTransform.cs

@@ -327,7 +327,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			values = null;
 			// stloc dictVar(newobj Dictionary..ctor(ldc.i4 valuesLength))
 			// -or-
-			// stloc dictVar(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f loadFactor))
+			// stloc dictVar(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f4 loadFactor))
 			if (!(block.Instructions[0].MatchStLoc(out var dictVar, out var newObjDict) && newObjDict is NewObj newObj))
 				return false;
 			if (!newObj.Method.DeclaringType.Equals(dictionaryType))
@@ -336,7 +336,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			if (newObj.Arguments.Count == 2) {
 				if (!newObj.Arguments[0].MatchLdcI4(out valuesLength))
 					return false;
-				if (!newObj.Arguments[1].MatchLdcF(0.5))
+				if (!newObj.Arguments[1].MatchLdcF4(0.5f))
 					return false;
 			} else if (newObj.Arguments.Count == 1) {
 				if (!newObj.Arguments[0].MatchLdcI4(out valuesLength))

ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs

@@ -146,8 +146,9 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				case KnownTypeCode.UInt64:
 					return new LdcI8(0);
 				case KnownTypeCode.Single:
+					return new LdcF4(0);
 				case KnownTypeCode.Double:
-					return new LdcF(0);
+					return new LdcF8(0);
 				case KnownTypeCode.Decimal:
 					return new LdcDecimal(0);
 				case KnownTypeCode.Void:
@@ -384,9 +385,9 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				case TypeCode.UInt64:
 					return DecodeArrayInitializer(initialValue, array, arrayLength, output, typeCode, type, (d, i) => new LdcI8(BitConverter.ToInt64(d, i)));
 				case TypeCode.Single:
-					return DecodeArrayInitializer(initialValue, array, arrayLength, output, typeCode, type, (d, i) => new LdcF(BitConverter.ToSingle(d, i)));
+					return DecodeArrayInitializer(initialValue, array, arrayLength, output, typeCode, type, (d, i) => new LdcF4(BitConverter.ToSingle(d, i)));
 				case TypeCode.Double:
-					return DecodeArrayInitializer(initialValue, array, arrayLength, output, typeCode, type, (d, i) => new LdcF(BitConverter.ToDouble(d, i)));
+					return DecodeArrayInitializer(initialValue, array, arrayLength, output, typeCode, type, (d, i) => new LdcF8(BitConverter.ToDouble(d, i)));
 				case TypeCode.Object:
 				case TypeCode.Empty:
 					var typeDef = type.GetDefinition();

ICSharpCode.Decompiler/IL/Transforms/TransformExpressionTrees.cs

@@ -972,8 +972,11 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 						case StackType.I:
 							left = new Conv(new LdcI4(0), PrimitiveType.I, false, Sign.None);
 							break;
-						case StackType.F:
+						case StackType.F4:
-							left = new LdcF(0);
+							left = new LdcF4(0);
+							break;
+						case StackType.F8:
+							left = new LdcF8(0);
 							break;
 						default:
 							return (null, SpecialType.UnknownType);

ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs

@@ -166,6 +166,21 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			}
 		}
 
+		/// <summary>
+		/// Gets whether the type is an IL floating point type.
+		/// Returns true for F4 or F8.
+		/// </summary>
+		public static bool IsFloatType(this StackType type)
+		{
+			switch (type) {
+				case StackType.F4:
+				case StackType.F8:
+					return true;
+				default:
+					return false;
+			}
+		}
+
 		/// <summary>
 		/// Gets whether reading/writing an element of accessType from the pointer
 		/// is equivalent to reading/writing an element of the pointer's element type.
@@ -223,8 +238,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 				case KnownTypeCode.UInt64:
 					return StackType.I8;
 				case KnownTypeCode.Single:
+					return StackType.F4;
 				case KnownTypeCode.Double:
-					return StackType.F;
+					return StackType.F8;
 				case KnownTypeCode.Void:
 					return StackType.Void;
 				case KnownTypeCode.IntPtr:
@@ -373,7 +389,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 					return sign == Sign.Unsigned ? KnownTypeCode.UInt64 : KnownTypeCode.Int64;
 				case StackType.I:
 					return sign == Sign.Unsigned ? KnownTypeCode.UIntPtr : KnownTypeCode.IntPtr;
-				case StackType.F:
+				case StackType.F4:
+					return KnownTypeCode.Single;
+				case StackType.F8:
 					return KnownTypeCode.Double;
 				case StackType.O:
 					return KnownTypeCode.Object;