Update Disarm

Author: js6pak

Cpp2IL.InstructionSets.ArmV8/ArmV8InstructionSet.cs

@@ -28,18 +28,17 @@ public override Memory<byte> GetRawBytesForMethod(MethodAnalysisContext context,
                 return LibCpp2IlMain.Binary!.GetRawBinaryContent().AsMemory(ptrAsInt, count);
         }
 
-        var result = ArmV8Utils.GetArm64MethodBodyAtVirtualAddress(context.UnderlyingPointer);
-        var endVa = result.EndVirtualAddress;
+        ArmV8Utils.GetArm64MethodBodyAtVirtualAddress(context.UnderlyingPointer, out var endVirtualAddress);
 
         var start = (int) context.AppContext.Binary.MapVirtualAddressToRaw(context.UnderlyingPointer);
-        var end = (int) context.AppContext.Binary.MapVirtualAddressToRaw(endVa);
-        
+        var end = (int) context.AppContext.Binary.MapVirtualAddressToRaw(endVirtualAddress);
+
         return context.AppContext.Binary.GetRawBinaryContent().AsMemory(start, end - start);
     }
 
     public override List<InstructionSetIndependentInstruction> GetIsilFromMethod(MethodAnalysisContext context)
     {
-        var result = ArmV8Utils.GetArm64MethodBodyAtVirtualAddress(context.UnderlyingPointer);
+        var instructions = ArmV8Utils.GetArm64MethodBodyAtVirtualAddress(context.UnderlyingPointer, out var endVirtualAddress);
 
         throw new NotImplementedException();
     }
@@ -49,5 +48,5 @@ public override BaseKeyFunctionAddresses CreateKeyFunctionAddressesInstance()
         return new ArmV8KeyFunctionAddresses();
     }
 
-    public override string PrintAssembly(MethodAnalysisContext context) => string.Join("\n", Disassembler.Disassemble(context.RawBytes.Span, context.UnderlyingPointer).Instructions);
+    public override string PrintAssembly(MethodAnalysisContext context) => string.Join("\n", Disassembler.Disassemble(context.RawBytes, context.UnderlyingPointer));
 }

Cpp2IL.InstructionSets.ArmV8/ArmV8KeyFunctionAddresses.cs

@@ -6,17 +6,17 @@ namespace Cpp2IL.InstructionSets.ArmV8;
 
 public class ArmV8KeyFunctionAddresses : BaseKeyFunctionAddresses
 {
-    private Arm64DisassemblyResult? _cachedDisassembledBytes;
+    private List<Arm64Instruction>? _cachedDisassembledBytes;
 
-    private Arm64DisassemblyResult DisassembleTextSection()
+    private List<Arm64Instruction> DisassembleTextSection()
     {
         if (_cachedDisassembledBytes == null)
         {
             var toDisasm = LibCpp2IlMain.Binary!.GetEntirePrimaryExecutableSection();
-            _cachedDisassembledBytes = Disassembler.Disassemble(toDisasm, LibCpp2IlMain.Binary.GetVirtualAddressOfPrimaryExecutableSection());
+            _cachedDisassembledBytes = Disassembler.Disassemble(toDisasm, LibCpp2IlMain.Binary.GetVirtualAddressOfPrimaryExecutableSection()).ToList();
         }
 
-        return _cachedDisassembledBytes.Value;
+        return _cachedDisassembledBytes;
     }
 
     protected override IEnumerable<ulong> FindAllThunkFunctions(ulong addr, uint maxBytesBack = 0, params ulong[] addressesToIgnore)
@@ -25,7 +25,7 @@ protected override IEnumerable<ulong> FindAllThunkFunctions(ulong addr, uint max
         var disassembly = DisassembleTextSection();
 
         //Find all jumps to the target address
-        var matchingJmps = disassembly.Instructions.Where(i => i.Mnemonic is Arm64Mnemonic.B or Arm64Mnemonic.BL && i.BranchTarget == addr).ToList();
+        var matchingJmps = disassembly.Where(i => i.Mnemonic is Arm64Mnemonic.B or Arm64Mnemonic.BL && i.BranchTarget == addr).ToList();
 
         foreach (var matchingJmp in matchingJmps)
         {
@@ -81,6 +81,6 @@ protected override int GetCallerCount(ulong toWhere)
         var disassembly = DisassembleTextSection();
 
         //Find all jumps to the target address
-        return disassembly.Instructions.Count(i => i.Mnemonic is Arm64Mnemonic.B or Arm64Mnemonic.BL && i.BranchTarget == toWhere);
+        return disassembly.Count(i => i.Mnemonic is Arm64Mnemonic.B or Arm64Mnemonic.BL && i.BranchTarget == toWhere);
     }
 }

Cpp2IL.InstructionSets.ArmV8/ArmV8Utils.cs

@@ -6,49 +6,51 @@ namespace Cpp2IL.InstructionSets.ArmV8;
 
 internal static class ArmV8Utils
 {
-    public static Arm64DisassemblyResult GetArm64MethodBodyAtVirtualAddress(ulong virtAddress, bool managed = true, int count = -1)
+    public static IEnumerable<Arm64Instruction> GetArm64MethodBodyAtVirtualAddress(ulong virtualAddress, out ulong endVirtualAddress, bool managed = true, int count = -1)
     {
         if (managed)
         {
-            var startOfNext = MiscUtils.GetAddressOfNextFunctionStart(virtAddress);
+            var startOfNext = MiscUtils.GetAddressOfNextFunctionStart(virtualAddress);
 
             //We have to fall through to default behavior for the last method because we cannot accurately pinpoint its end
             if (startOfNext > 0)
             {
                 var rawStartOfNextMethod = LibCpp2IlMain.Binary!.MapVirtualAddressToRaw(startOfNext);
 
-                var rawStart = LibCpp2IlMain.Binary.MapVirtualAddressToRaw(virtAddress);
+                var rawStart = LibCpp2IlMain.Binary.MapVirtualAddressToRaw(virtualAddress);
                 if (rawStartOfNextMethod < rawStart)
                     rawStartOfNextMethod = LibCpp2IlMain.Binary.RawLength;
 
-                var bytes = LibCpp2IlMain.Binary.GetRawBinaryContent().AsSpan((int)rawStart, (int)(rawStartOfNextMethod - rawStart));
+                var bytes = LibCpp2IlMain.Binary.GetRawBinaryContent().AsMemory((int)rawStart, (int)(rawStartOfNextMethod - rawStart));
 
-                return Disassemble(bytes, virtAddress);
+                return Disassemble(bytes, virtualAddress, out endVirtualAddress);
             }
         }
 
         //Unmanaged function, look for first b
-        var pos = (int)LibCpp2IlMain.Binary!.MapVirtualAddressToRaw(virtAddress);
+        var pos = (int)LibCpp2IlMain.Binary!.MapVirtualAddressToRaw(virtualAddress);
         var allBytes = LibCpp2IlMain.Binary.GetRawBinaryContent();
-        var span = allBytes.AsSpan(pos, 4);
-        Arm64DisassemblyResult ret = new();
+        
+        var instructions = new List<Arm64Instruction>();
 
-        while ((count == -1 || ret.Instructions.Count < count) && !ret.Instructions.Any(i => i.Mnemonic is Arm64Mnemonic.B))
+        endVirtualAddress = virtualAddress;
+        foreach (var instruction in Disassembler.Disassemble(allBytes.AsSpan(pos), virtualAddress, Disassembler.Options.IgnoreErrors))
         {
-            ret = Disassemble(span, virtAddress);
-
-            //All arm64 instructions are 4 bytes
-            span = allBytes.AsSpan(pos, span.Length + 4);
+            instructions.Add(instruction);
+            endVirtualAddress = instruction.Address;
+            if (instruction.Mnemonic == Arm64Mnemonic.B) break;
+            if (count != -1 && instructions.Count >= count) break;
         }
 
-        return ret;
+        return instructions;
     }
 
-    private static Arm64DisassemblyResult Disassemble(Span<byte> bytes, ulong virtAddress)
+    private static IEnumerable<Arm64Instruction> Disassemble(ReadOnlyMemory<byte> bytes, ulong virtualAddress, out ulong endVirtualAddress)
     {
         try
         {
-            return Disassembler.Disassemble(bytes, virtAddress);
+            endVirtualAddress = virtualAddress + (ulong)bytes.Length;
+            return Disassembler.Disassemble(bytes, virtualAddress, Disassembler.Options.IgnoreErrors);
         }
         catch (Exception e)
         {

Cpp2IL.InstructionSets.ArmV8/Cpp2IL.InstructionSets.ArmV8.csproj

@@ -6,6 +6,6 @@
 
     <ItemGroup>
         <ProjectReference Include="..\Cpp2IL.Core\Cpp2IL.Core.csproj" />
-        <PackageReference Include="Disarm" Version="2022.1.0-master.26" />
+        <PackageReference Include="Disarm" Version="2022.1.0-master.34" />
     </ItemGroup>
 </Project>