#3465: Fix bugs in comp.o handling.

Author: dgrunwald

ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue3465.cs

@@ -16,8 +16,7 @@ private static Program GetProgram()
 		private static bool Test3465()
 		{
 			Program program = GetProgram();
-			Program program2 = programNull;
-			return System.Runtime.CompilerServices.Unsafe.As<Program, UIntPtr>(ref program) > System.Runtime.CompilerServices.Unsafe.As<Program, UIntPtr>(ref program2);
+			return System.Runtime.CompilerServices.Unsafe.As<Program, UIntPtr>(ref program) > System.Runtime.CompilerServices.Unsafe.As<Program, UIntPtr>(ref programNull);
 		}
 	}
 }

ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@@ -1112,15 +1112,15 @@ TranslatedExpression TranslateComp(Comp inst)
 			{
 				// Unsafe.As<object, UIntPtr>(ref left) op Unsafe.As<object, UIntPtr>(ref right)
 				// TTo Unsafe.As<TFrom, TTo>(ref TFrom source)
-				var uintptr = compilation.FindType(KnownTypeCode.UIntPtr);
+				var integerType = compilation.FindType(inst.Sign == Sign.Signed ? KnownTypeCode.IntPtr : KnownTypeCode.UIntPtr);
 				left = WrapInUnsafeAs(left, inst.Left);
 				right = WrapInUnsafeAs(right, inst.Right);
 
 				TranslatedExpression WrapInUnsafeAs(TranslatedExpression expr, ILInstruction inst)
 				{
 					var type = expr.Type;
 					expr = WrapInRef(expr, new ByReferenceType(type));
-					return CallUnsafeIntrinsic("As", [expr], uintptr, typeArguments: [type, uintptr]);
+					return CallUnsafeIntrinsic("As", [expr], integerType, typeArguments: [type, integerType]);
 				}
 			}
 			return new BinaryOperatorExpression(left.Expression, op, right.Expression)

ICSharpCode.Decompiler/IL/ILReader.cs

@@ -1248,11 +1248,14 @@ DecodedInstruction DecodeInstruction()
 			}
 		}
 
-		StackType PeekStackType(int i = 0)
+		StackType PeekStackType()
 		{
-			if (expressionStack.Count > i)
-				return expressionStack[^(i + 1)].ResultType;
-			return currentStack.Skip(i).FirstOrDefault()?.StackType ?? StackType.Unknown;
+			if (expressionStack.Count > 0)
+				return expressionStack.Last().ResultType;
+			if (currentStack.IsEmpty)
+				return StackType.Unknown;
+			else
+				return currentStack.Peek().StackType;
 		}
 
 		sealed class CollectStackVariablesVisitor : ILVisitor<ILInstruction>
@@ -1842,8 +1845,7 @@ DecodedInstruction DecodeCallIndirect()
 
 		ILInstruction Comparison(ComparisonKind kind, bool un = false)
 		{
-			var stackType = PeekStackType();
-			if (!kind.IsEqualityOrInequality() && stackType == StackType.O && stackType == PeekStackType(1))
+			if (!kind.IsEqualityOrInequality() && PeekStackType() == StackType.O)
 			{
 				FlushExpressionStack();
 			}

ICSharpCode.Decompiler/IL/Instructions/Comp.cs

@@ -235,7 +235,23 @@ internal override bool CanInlineIntoSlot(int childIndex, ILInstruction expressio
 			// ExpressionBuilder translates comp.o(a op b) for op not in (==, !=) into
 			// Unsafe.As(ref a) op Unsafe.As(ref b), which requires that a and b are variables
 			// and not expressions. Returning false in those cases prevents inlining.
-			return kind.IsEqualityOrInequality() || this.InputType != StackType.O;
+			// However if one of the arguments is LdNull, then we don't need the Unsafe.As trickery, and can always inline.
+			if (kind.IsEqualityOrInequality() || this.InputType != StackType.O)
+			{
+				// OK, won't need Unsafe.As.
+				return true;
+			}
+			if (expressionBeingMoved is LdLoc || expressionBeingMoved.MatchLdsFld(out _))
+			{
+				// OK, can use variable/field name with Unsafe.As(ref x)
+				return true;
+			}
+			if (Sign != Sign.Signed && (expressionBeingMoved is LdNull || Left is LdNull || Right is LdNull))
+			{
+				// OK, this is the "compare with null" special case that doesn't need Unsafe.As()
+				return true;
+			}
+			return false;
 		}
 	}
 }