Fix/disasm: more inline evaluators (LDS, LES, LEA, CALL FAR) (#2094)

* fix: Handle LEA: show effective address, not memory value

ExpressionEvaluationService now computes and displays the effective address for LEA instructions instead of reading memory contents. Added AddAddressValue and address expression builders for LEA. Introduced UI tests to verify correct LEA operand evaluation and prevent memory value display. Refactored RegisterToExpression for clarity.

* fix:  Show memory values for LDS and CALL FAR PTR

* refactor: compileValue returns uint not long

* fix: address PR review comments - remove unused param, fix null operators, replace non-ASCII chars

Agent-Logs-Url: https://github.com/OpenRakis/Spice86/sessions/39c41621-5b19-46ce-999c-061701146122

Co-authored-by: maximilien-noal <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: maximilien-noal <[email protected]>

Author: maximilien-noal

src/Spice86/ViewModels/Services/ExpressionEvaluationService.cs

@@ -40,20 +40,32 @@ public ExpressionEvaluationService(State state, IMemory memory) {
                 Register reg = instruction.GetOpRegister(i);
                 string? expr = RegisterToExpression(reg);
                 if (expr != null) {
-                    long value = _compiler.CompileValue(expr)();
+                    uint value = _compiler.CompileValue(expr)();
                     if (segments.Count > 0) {
                         AddSeparator(segments);
                     }
                     AddRegisterValue(segments, expr.ToUpperInvariant(), value, GetRegisterBitWidth(reg));
                 }
             } else if (kind == OpKind.Memory) {
-                string? expr = BuildMemoryExpression(instruction);
-                if (expr != null) {
-                    long value = _compiler.CompileValue(expr)();
-                    if (segments.Count > 0) {
-                        AddSeparator(segments);
+                bool isLea = instruction.Mnemonic == Mnemonic.Lea;
+                if (isLea) {
+                    string? addressExpr = BuildAddressExpression(instruction);
+                    if (addressExpr != null) {
+                        uint value = _compiler.CompileValue(addressExpr)();
+                        if (segments.Count > 0) {
+                            AddSeparator(segments);
+                        }
+                        AddAddressValue(segments, value, GetRegisterBitWidth(instruction.GetOpRegister(0)));
+                    }
+                } else {
+                    string? expr = BuildMemoryExpression(instruction);
+                    if (expr != null) {
+                        uint value = _compiler.CompileValue(expr)();
+                        if (segments.Count > 0) {
+                            AddSeparator(segments);
+                        }
+                        AddMemoryValue(segments, instruction, value, GetMemorySizeBitWidth(instruction.MemorySize));
                     }
-                    AddMemoryValue(segments, instruction, value, GetMemorySizeBitWidth(instruction.MemorySize));
                 }
             }
             // Immediate and branch operands are skipped (already visible in disassembly text)
@@ -72,6 +84,12 @@ private static void AddRegisterValue(List<FormattedTextToken> segments, string n
         segments.Add(new FormattedTextToken { Text = FormatHex(value, bitWidth), Kind = FormatterTextKind.Number });
     }
 
+    private static void AddAddressValue(List<FormattedTextToken> segments, long value, int bitWidth) {
+        segments.Add(new FormattedTextToken { Text = "addr", Kind = FormatterTextKind.Keyword });
+        segments.Add(new FormattedTextToken { Text = "=", Kind = FormatterTextKind.Punctuation });
+        segments.Add(new FormattedTextToken { Text = FormatHex(value, bitWidth), Kind = FormatterTextKind.Number });
+    }
+
     private static void AddMemoryValue(List<FormattedTextToken> segments, Instruction instruction, long value, int bitWidth) {
         segments.Add(new FormattedTextToken { Text = "[", Kind = FormatterTextKind.Punctuation });
 
@@ -112,14 +130,36 @@ private static void AddMemoryValue(List<FormattedTextToken> segments, Instructio
 
     private static string? RegisterToExpression(Register register) {
         return register switch {
-            Register.AL => "al", Register.CL => "cl", Register.DL => "dl", Register.BL => "bl",
-            Register.AH => "ah", Register.CH => "ch", Register.DH => "dh", Register.BH => "bh",
-            Register.AX => "ax", Register.CX => "cx", Register.DX => "dx", Register.BX => "bx",
-            Register.SP => "sp", Register.BP => "bp", Register.SI => "si", Register.DI => "di",
-            Register.EAX => "eax", Register.ECX => "ecx", Register.EDX => "edx", Register.EBX => "ebx",
-            Register.ESP => "esp", Register.EBP => "ebp", Register.ESI => "esi", Register.EDI => "edi",
-            Register.ES => "es", Register.CS => "cs", Register.SS => "ss", Register.DS => "ds",
-            Register.FS => "fs", Register.GS => "gs",
+            Register.AL => "al",
+            Register.CL => "cl",
+            Register.DL => "dl",
+            Register.BL => "bl",
+            Register.AH => "ah",
+            Register.CH => "ch",
+            Register.DH => "dh",
+            Register.BH => "bh",
+            Register.AX => "ax",
+            Register.CX => "cx",
+            Register.DX => "dx",
+            Register.BX => "bx",
+            Register.SP => "sp",
+            Register.BP => "bp",
+            Register.SI => "si",
+            Register.DI => "di",
+            Register.EAX => "eax",
+            Register.ECX => "ecx",
+            Register.EDX => "edx",
+            Register.EBX => "ebx",
+            Register.ESP => "esp",
+            Register.EBP => "ebp",
+            Register.ESI => "esi",
+            Register.EDI => "edi",
+            Register.ES => "es",
+            Register.CS => "cs",
+            Register.SS => "ss",
+            Register.DS => "ds",
+            Register.FS => "fs",
+            Register.GS => "gs",
             _ => null
         };
     }
@@ -138,7 +178,7 @@ private static int GetRegisterBitWidth(Register register) {
         return size switch {
             MemorySize.UInt8 or MemorySize.Int8 => "byte",
             MemorySize.UInt16 or MemorySize.Int16 => "word",
-            MemorySize.UInt32 or MemorySize.Int32 => "dword",
+            MemorySize.UInt32 or MemorySize.Int32 or MemorySize.SegPtr16 => "dword",
             _ => null
         };
     }
@@ -147,7 +187,7 @@ private static int GetMemorySizeBitWidth(MemorySize size) {
         return size switch {
             MemorySize.UInt8 or MemorySize.Int8 => 8,
             MemorySize.UInt16 or MemorySize.Int16 => 16,
-            MemorySize.UInt32 or MemorySize.Int32 => 32,
+            MemorySize.UInt32 or MemorySize.Int32 or MemorySize.SegPtr16 => 32,
             _ => 16
         };
     }
@@ -158,7 +198,23 @@ private static int GetMemorySizeBitWidth(MemorySize size) {
             return null;
         }
 
+        string addressExpr = BuildAddressExpressionCore(instruction);
+
         string? segment = RegisterToExpression(instruction.MemorySegment);
+        return segment != null
+            ? $"{sizePrefix} ptr {segment}:[{addressExpr}]"
+            : $"{sizePrefix} ptr [{addressExpr}]";
+    }
+
+    /// <summary>
+    /// Builds an arithmetic expression for the effective address (offset only, no memory dereference).
+    /// Used by LEA to compute the address without reading memory.
+    /// </summary>
+    private static string? BuildAddressExpression(Instruction instruction) {
+        return BuildAddressExpressionCore(instruction);
+    }
+
+    private static string BuildAddressExpressionCore(Instruction instruction) {
 
         List<string> addressParts = new();
 
@@ -179,9 +235,7 @@ private static int GetMemorySizeBitWidth(MemorySize size) {
 
         string addressExpr = string.Join(" + ", addressParts);
 
-        return segment != null
-            ? $"{sizePrefix} ptr {segment}:[{addressExpr}]"
-            : $"{sizePrefix} ptr [{addressExpr}]";
+        return addressExpr;
     }
 
     private static string FormatHex(long value, int bitWidth) {

tests/Spice86.Tests/UI/ExpressionEvaluatorUITests.cs

@@ -68,7 +68,7 @@ public void EvaluateOperands_MovAxBx_ShowsBothRegisterValues() {
         state.AX = 0x1234;
         state.BX = 0x5678;
 
-        // x86 16-bit encoding: mov ax, bx → 89 D8
+        // x86 16-bit encoding: mov ax, bx -> 89 D8
         byte[] machineCode = [0x89, 0xD8];
         SegmentedAddress address = new(0x1000, 0x0100);
         DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
@@ -80,7 +80,8 @@ public void EvaluateOperands_MovAxBx_ShowsBothRegisterValues() {
 
         // Assert
         evaluated.Should().NotBeNullOrEmpty();
-        string text = SegmentsToText(evaluated!);
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
         text.Should().Contain("AX=0x1234");
         text.Should().Contain("BX=0x5678");
 
@@ -107,7 +108,7 @@ public void EvaluateOperands_MovAxMemBx_ShowsMemoryValue() {
         // Write 0xABCD at physical address DS*16 + BX = 0x20000 + 0x50 = 0x20050
         memory.UInt16[0x20050] = 0xABCD;
 
-        // x86 16-bit encoding: mov ax, word ptr [bx] → 8B 07
+        // x86 16-bit encoding: mov ax, word ptr [bx] -> 8B 07
         byte[] machineCode = [0x8B, 0x07];
         SegmentedAddress address = new(0x1000, 0x0100);
         DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
@@ -119,7 +120,8 @@ public void EvaluateOperands_MovAxMemBx_ShowsMemoryValue() {
 
         // Assert
         evaluated.Should().NotBeNullOrEmpty();
-        string text = SegmentsToText(evaluated!);
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
         text.Should().Contain("AX=0x0000");
         text.Should().Contain("0xABCD");
 
@@ -130,7 +132,7 @@ public void EvaluateOperands_MovAxMemBx_ShowsMemoryValue() {
 
     /// <summary>
     /// Verifies that immediates are NOT evaluated (they are already visible in disassembly text).
-    /// ASM: mov ax, 0x1234 (opcode B8 34 12) — only AX should appear in evaluation.
+    /// ASM: mov ax, 0x1234 (opcode B8 34 12) - only AX should appear in evaluation.
     /// </summary>
     [AvaloniaFact]
     public void EvaluateOperands_MovAxImm_OnlyShowsDestRegister() {
@@ -140,7 +142,7 @@ public void EvaluateOperands_MovAxImm_OnlyShowsDestRegister() {
 
         state.AX = 0x5555;
 
-        // x86 16-bit encoding: mov ax, 0x1234 → B8 34 12
+        // x86 16-bit encoding: mov ax, 0x1234 -> B8 34 12
         byte[] machineCode = [0xB8, 0x34, 0x12];
         SegmentedAddress address = new(0x1000, 0x0100);
         DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
@@ -152,7 +154,8 @@ public void EvaluateOperands_MovAxImm_OnlyShowsDestRegister() {
 
         // Assert
         evaluated.Should().NotBeNullOrEmpty();
-        string text = SegmentsToText(evaluated!);
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
         text.Should().Contain("AX=0x5555");
         // The immediate value 0x1234 should NOT appear in evaluation
         text.Should().NotContain("=0x1234");
@@ -175,7 +178,7 @@ public void EvaluateOperands_MovAxMemBxDisp_ShowsMemoryValue() {
         // Write 0xBEEF at physical address DS*16 + BX + 0x10 = 0x20000 + 0x50 + 0x10 = 0x20060
         memory.UInt16[0x20060] = 0xBEEF;
 
-        // x86 16-bit encoding: mov ax, word ptr [bx+0x10] → 8B 47 10
+        // x86 16-bit encoding: mov ax, word ptr [bx+0x10] -> 8B 47 10
         byte[] machineCode = [0x8B, 0x47, 0x10];
         SegmentedAddress address = new(0x1000, 0x0100);
         DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
@@ -187,11 +190,162 @@ public void EvaluateOperands_MovAxMemBxDisp_ShowsMemoryValue() {
 
         // Assert
         evaluated.Should().NotBeNullOrEmpty();
-        string text = SegmentsToText(evaluated!);
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
         text.Should().Contain("AX=0x0000");
         text.Should().Contain("0xBEEF");
 
         // Verify displacement operator is syntax-colored
         evaluated.Should().Contain(s => s.Text == "+" && s.Kind == FormatterTextKind.Operator);
     }
+
+    /// <summary>
+    /// Verifies that LEA computes the effective address instead of reading memory.
+    /// ASM: lea ax, [bp-8] (opcode 8D 46 F8) - should show computed address, not memory contents.
+    /// </summary>
+    [AvaloniaFact]
+    public void EvaluateOperands_LeaAxBpMinus8_ShowsEffectiveAddress() {
+        // Arrange
+        State state = CreateState();
+        (Memory memory, _, _) = CreateMemory();
+
+        state.AX = 0x1111;
+        state.BP = 0x0100;
+        state.SS = 0x2000;
+
+        // Write decoy data at effective address - LEA must NOT read this
+        uint physicalAddress = (uint)(state.SS * 16 + state.BP - 8);
+        memory.UInt16[physicalAddress] = 0xDEAD;
+
+        // x86 16-bit encoding: lea ax, [bp-8] -> 8D 46 F8
+        byte[] machineCode = [0x8D, 0x46, 0xF8];
+        SegmentedAddress address = new(0x1000, 0x0100);
+        DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
+
+        ExpressionEvaluationService service = new(state, memory);
+
+        // Act
+        List<FormattedTextToken>? evaluated = service.FormatOperandValues(line.InstructionInfo);
+
+        // Assert
+        evaluated.Should().NotBeNullOrEmpty();
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
+
+        // LEA should show effective address = BP - 8 = 0x0100 - 8 = 0x00F8
+        text.Should().Contain("0x00F8");
+        // LEA must NOT show the memory contents 0xDEAD
+        text.Should().NotContain("DEAD");
+        // AX register value should still be shown
+        text.Should().Contain("AX=0x1111");
+    }
+
+    /// <summary>
+    /// Verifies LEA with base+index computes the effective address.
+    /// ASM: lea ax, [bx+si] (opcode 8D 00)
+    /// </summary>
+    [AvaloniaFact]
+    public void EvaluateOperands_LeaAxBxSi_ShowsEffectiveAddress() {
+        // Arrange
+        State state = CreateState();
+        (Memory memory, _, _) = CreateMemory();
+
+        state.AX = 0x0000;
+        state.BX = 0x0030;
+        state.SI = 0x0010;
+        state.DS = 0x2000;
+
+        // x86 16-bit encoding: lea ax, [bx+si] -> 8D 00
+        byte[] machineCode = [0x8D, 0x00];
+        SegmentedAddress address = new(0x1000, 0x0100);
+        DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
+
+        ExpressionEvaluationService service = new(state, memory);
+
+        // Act
+        List<FormattedTextToken>? evaluated = service.FormatOperandValues(line.InstructionInfo);
+
+        // Assert
+        evaluated.Should().NotBeNullOrEmpty();
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
+        // Effective address = BX + SI = 0x0030 + 0x0010 = 0x0040
+        text.Should().Contain("0x0040");
+    }
+
+    /// <summary>
+    /// Verifies that LDS evaluates the far pointer memory operand (dword containing offset:segment).
+    /// ASM: lds si, ss:[bp+0x10] (opcode C5 76 10) - should show the dword value at memory.
+    /// </summary>
+    [AvaloniaFact]
+    public void EvaluateOperands_LdsSiBpPlus10_ShowsFarPointerValue() {
+        // Arrange
+        State state = CreateState();
+        (Memory memory, _, _) = CreateMemory();
+
+        state.SI = 0x0000;
+        state.BP = 0x0984;
+        state.SS = 0x2F23;
+        state.DS = 0x261F;
+
+        // Write a far pointer (offset:segment) at SS:BP+0x10
+        uint physicalAddress = (uint)(state.SS * 16 + state.BP + 0x10);
+        memory.UInt16[physicalAddress] = 0x1234;       // offset
+        memory.UInt16[physicalAddress + 2] = 0x5678;   // segment
+
+        // x86 16-bit encoding: lds si, [bp+0x10] -> C5 76 10
+        byte[] machineCode = [0xC5, 0x76, 0x10];
+        SegmentedAddress address = new(0x1000, 0x0100);
+        DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
+
+        ExpressionEvaluationService service = new(state, memory);
+
+        // Act
+        List<FormattedTextToken>? evaluated = service.FormatOperandValues(line.InstructionInfo);
+
+        // Assert
+        evaluated.Should().NotBeNullOrEmpty();
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
+        // Should show the dword value read from memory (segment:offset packed as dword)
+        text.Should().Contain("0x56781234");
+        // SI register value should also be shown
+        text.Should().Contain("SI=0x0000");
+    }
+
+    /// <summary>
+    /// Verifies that CALL dword ptr [mem] evaluates the far pointer memory operand.
+    /// ASM: call dword ptr ss:[bp-4] (opcode FF 5E FC) - should show the target address.
+    /// </summary>
+    [AvaloniaFact]
+    public void EvaluateOperands_CallFarPtrBpMinus4_ShowsFarPointerValue() {
+        // Arrange
+        State state = CreateState();
+        (Memory memory, _, _) = CreateMemory();
+
+        state.BP = 0x0984;
+        state.SS = 0x2F23;
+
+        // Write a far pointer (offset:segment) at SS:BP-4
+        uint physicalAddress = (uint)(state.SS * 16 + state.BP - 4);
+        memory.UInt16[physicalAddress] = 0xABCD;       // offset
+        memory.UInt16[physicalAddress + 2] = 0x1234;   // segment
+
+        // x86 16-bit encoding: call dword ptr [bp-4] -> FF 5E FC
+        byte[] machineCode = [0xFF, 0x5E, 0xFC];
+        SegmentedAddress address = new(0x1000, 0x0100);
+        DebuggerLineViewModel line = CreateDebuggerLine(machineCode, address);
+
+        ExpressionEvaluationService service = new(state, memory);
+
+        // Act
+        List<FormattedTextToken>? evaluated = service.FormatOperandValues(line.InstructionInfo);
+
+        // Assert
+        evaluated.Should().NotBeNullOrEmpty();
+        List<FormattedTextToken> evaluatedTokens = evaluated ?? [];
+        string text = SegmentsToText(evaluatedTokens);
+        // Should show the dword value read from memory
+        text.Should().Contain("0x1234ABCD");
+    }
 }