New Invalid ISIL Instruction

Cpp2IL.Core/ISIL/InstructionSetIndependentInstruction.cs

@@ -20,4 +20,15 @@ public InstructionSetIndependentInstruction(InstructionSetIndependentOpCode opCo
     }
 
     public override string ToString() => $"{InstructionIndex:000} {OpCode} {string.Join(", ", (IEnumerable<InstructionSetIndependentOperand>) Operands)}";
-}
+
+    /// <summary>
+    /// Marks the instruction as <see cref="IsilMnemonic.Invalid"/>.
+    /// </summary>
+    /// <param name="reason">The reason that this instruction is being invalidated.</param>
+    public void Invalidate(string reason)
+    {
+        OpCode = InstructionSetIndependentOpCode.Invalid;
+        Operands = [InstructionSetIndependentOperand.MakeImmediate(reason)];
+        FlowControl = IsilFlowControl.Continue;
+    }
+}

Cpp2IL.Core/ISIL/InstructionSetIndependentOpCode.cs

@@ -45,6 +45,8 @@ public class InstructionSetIndependentOpCode
 
     public static readonly InstructionSetIndependentOpCode NotImplemented = new(IsilMnemonic.NotImplemented, 1, InstructionSetIndependentOperand.OperandType.Immediate);
 
+    public static readonly InstructionSetIndependentOpCode Invalid = new(IsilMnemonic.Invalid, 1, InstructionSetIndependentOperand.OperandType.Immediate);
+
 
     public readonly IsilMnemonic Mnemonic;
     public readonly InstructionSetIndependentOperand.OperandType[] PermittedOperandTypes;
@@ -76,15 +78,21 @@ public void Validate(InstructionSetIndependentInstruction instruction)
         var operands = instruction.Operands;
 
         if (operands.Length > MaxOperands)
-            throw new($"Too many operands! We have {operands.Length} but we only allow {MaxOperands}");
+        {
+            instruction.Invalidate($"Too many operands! We have {operands.Length} but we only allow {MaxOperands}");
+            return;
+        }
 
         if (PermittedOperandTypes.Length == 0)
             return;
 
         for (var i = 0; i < operands.Length; i++)
         {
             if ((operands[i].Type & PermittedOperandTypes[i]) == 0)
-                throw new($"Instruction {instruction}: Operand {operands[i]} at index {i} (0-based) is of type {operands[i].Type}, which is not permitted for this index of a {Mnemonic} instruction");
+            {
+                instruction.Invalidate($"Operand {operands[i]} at index {i} (0-based) is of type {operands[i].Type}, which is not permitted for this index of a {Mnemonic} instruction");
+                return;
+            }
         }
     }
 

Cpp2IL.Core/ISIL/IsilBuilder.cs

@@ -30,15 +30,13 @@ public IsilBuilder(List<InstructionSetIndependentInstruction> backingStatementLi
 
     private void AddInstruction(InstructionSetIndependentInstruction instruction)
     {
-        if (InstructionAddressMap.ContainsKey(instruction.ActualAddress))
+        if (InstructionAddressMap.TryGetValue(instruction.ActualAddress, out var list))
         {
-            InstructionAddressMap[instruction.ActualAddress].Add(instruction);
+            list.Add(instruction);
         }
         else
         {
-            var newList = new List<InstructionSetIndependentInstruction>();
-            newList.Add(instruction);
-            InstructionAddressMap[instruction.ActualAddress] = newList;
+            InstructionAddressMap[instruction.ActualAddress] = [ instruction ];
         }
         BackingStatementList.Add(instruction);
         instruction.InstructionIndex = (uint)BackingStatementList.Count;
@@ -51,17 +49,15 @@ public void FixJumps()
             if (InstructionAddressMap.TryGetValue(tuple.Item2, out var list))
             {
                 var target = list.First();
-                if (target is null)
-                    throw new IsilConversionException("This can't ever happen");
 
                 if (target.Equals(tuple.Item1))
-                    throw new IsilConversionException("Invalid jump target for instruction: Instruction can't jump to itself");
-
-                tuple.Item1.Operands = new[] { InstructionSetIndependentOperand.MakeInstruction(target) };
+                    tuple.Item1.Invalidate("Invalid jump target for instruction: Instruction can't jump to itself");
+                else
+                    tuple.Item1.Operands = [InstructionSetIndependentOperand.MakeInstruction(target)];
             }
             else
             {
-                throw new IsilConversionException("Jump target not found in method. Ruh roh");
+                tuple.Item1.Invalidate("Jump target not found in method.");
             }
         }
     }
@@ -124,6 +120,8 @@ private void CreateJump(ulong instructionAddress, ulong target, InstructionSetIn
 
     public void NotImplemented(ulong instructionAddress, string text) => AddInstruction(new(InstructionSetIndependentOpCode.NotImplemented, instructionAddress, IsilFlowControl.Continue, InstructionSetIndependentOperand.MakeImmediate(text)));
 
+    public void Invalid(ulong instructionAddress, string text) => AddInstruction(new(InstructionSetIndependentOpCode.Invalid, instructionAddress, IsilFlowControl.Continue, InstructionSetIndependentOperand.MakeImmediate(text)));
+
     public void Interrupt(ulong instructionAddress) => AddInstruction(new(InstructionSetIndependentOpCode.Interrupt, instructionAddress, IsilFlowControl.Interrupt));
 
     private InstructionSetIndependentOperand[] PrepareCallOperands(ulong dest, InstructionSetIndependentOperand[] args)

Cpp2IL.Core/ISIL/IsilMnemonic.cs

@@ -31,5 +31,6 @@ public enum IsilMnemonic
     JumpIfLessOrEqual,
     SignExtend,
     Interrupt,
-    NotImplemented
+    NotImplemented,
+    Invalid,
 }

Cpp2IL.Core/ProcessingLayers/CallAnalysisProcessingLayer.cs

@@ -30,7 +30,8 @@ private static void InjectAttribute(ApplicationAnalysisContext appContext)
         const string Namespace = "Cpp2ILInjected.CallAnalysis";
 
         var deduplicatedMethodAttributes = AttributeInjectionUtils.InjectZeroParameterAttribute(appContext, Namespace, "DeduplicatedMethodAttribute", AttributeTargets.Method, false);
-        var analysisFailedAttributes = AttributeInjectionUtils.InjectZeroParameterAttribute(appContext, Namespace, "CallAnalysisFailedAttribute", AttributeTargets.Method, false);
+        var invalidInstructionsAttributes = AttributeInjectionUtils.InjectZeroParameterAttribute(appContext, Namespace, "ContainsInvalidInstructionsAttribute", AttributeTargets.Method, false);
+        var unimplementedInstructionsAttributes = AttributeInjectionUtils.InjectZeroParameterAttribute(appContext, Namespace, "ContainsUnimplementedInstructionsAttribute", AttributeTargets.Method, false);
         var analysisNotSupportedAttributes = AttributeInjectionUtils.InjectZeroParameterAttribute(appContext, Namespace, "CallAnalysisNotSupportedAttribute", AttributeTargets.Method, false);
 
         var callsDeduplicatedMethodsAttributes = AttributeInjectionUtils.InjectOneParameterAttribute(appContext, Namespace, "CallsDeduplicatedMethodsAttribute", AttributeTargets.Method, false, appContext.SystemTypes.SystemInt32Type, "Count");
@@ -50,7 +51,8 @@ private static void InjectAttribute(ApplicationAnalysisContext appContext)
 
         foreach (var assemblyAnalysisContext in appContext.Assemblies)
         {
-            var analysisFailedConstructor = analysisFailedAttributes[assemblyAnalysisContext];
+            var invalidInstructionsConstructor = invalidInstructionsAttributes[assemblyAnalysisContext];
+            var unimplementedInstructionsConstructor = unimplementedInstructionsAttributes[assemblyAnalysisContext];
             var analysisNotSupportedConstructor = analysisNotSupportedAttributes[assemblyAnalysisContext];
             var deduplicatedMethodConstructor = deduplicatedMethodAttributes[assemblyAnalysisContext];
 
@@ -65,16 +67,7 @@ private static void InjectAttribute(ApplicationAnalysisContext appContext)
                     AttributeInjectionUtils.AddZeroParameterAttribute(m, deduplicatedMethodConstructor);
                 }
 
-                try
-                {
-                    m.Analyze();
-                }
-                catch
-                {
-                    m.ConvertedIsil = null;
-                    AttributeInjectionUtils.AddZeroParameterAttribute(m, analysisFailedConstructor);
-                    continue;
-                }
+                m.Analyze();
 
                 if (m.ConvertedIsil is { Count: 0 })
                 {
@@ -85,6 +78,16 @@ private static void InjectAttribute(ApplicationAnalysisContext appContext)
                     continue;
                 }
 
+                if (m.ConvertedIsil.Any(i => i.OpCode == InstructionSetIndependentOpCode.Invalid))
+                {
+                    AttributeInjectionUtils.AddZeroParameterAttribute(m, invalidInstructionsConstructor);
+                }
+
+                if (m.ConvertedIsil.Any(i => i.OpCode == InstructionSetIndependentOpCode.NotImplemented))
+                {
+                    AttributeInjectionUtils.AddZeroParameterAttribute(m, unimplementedInstructionsConstructor);
+                }
+
                 foreach (var instruction in m.ConvertedIsil)
                 {
                     if (instruction.OpCode != InstructionSetIndependentOpCode.Call && instruction.OpCode != InstructionSetIndependentOpCode.CallNoReturn)

Cpp2IL.Core/ProcessingLayers/NativeMethodDetectionProcessingLayer.cs

@@ -48,20 +48,7 @@ private static void AnalyzeMethod(ApplicationAnalysisContext appContext, MethodA
         if (m.UnderlyingPointer == 0)
             return;
 
-        try
-        {
-            m.Analyze();
-        }
-        catch (Exception ex)
-        {
-#if DEBUG
-            if (ex.Message is not "Failed to convert to ISIL. Reason: Jump target not found in method. Ruh roh" && !ex.Message.StartsWith("Instruction "))
-            {
-            }
-#endif
-            m.ConvertedIsil = null;
-            return;
-        }
+        m.Analyze();
 
         if (m.ConvertedIsil is { Count: 0 })
         {