244 lines
8.5 KiB
C#
244 lines
8.5 KiB
C#
// Copyright (C) 2026 SharpEmu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
using SharpEmu.Core.Cpu.Emulation;
|
|
using Xunit;
|
|
|
|
namespace SharpEmu.Libs.Tests.Cpu;
|
|
|
|
// These exercise the pure BMI1/BMI2/ABM semantics used by the illegal-instruction software
|
|
// fallback. The expected values were computed by hand from the Intel/AMD definitions so a
|
|
// regression in the bit math or the flag handling fails here without needing a live guest.
|
|
public sealed class BmiInstructionEmulatorTests
|
|
{
|
|
private const uint Carry = 1u << 0;
|
|
private const uint Zero = 1u << 6;
|
|
private const uint Sign = 1u << 7;
|
|
private const uint Overflow = 1u << 11;
|
|
private const uint DirectionFlag = 1u << 10; // Unrelated flag; must be preserved.
|
|
|
|
[Fact]
|
|
public void Andn_ClearsSourceBitsAndFlags()
|
|
{
|
|
uint flags = Overflow | Carry | DirectionFlag;
|
|
var result = BmiInstructionEmulator.Andn(0x0000_00F0, 0x0000_00FF, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x0000_000FUL, result);
|
|
Assert.Equal(0u, flags & Carry);
|
|
Assert.Equal(0u, flags & Overflow);
|
|
Assert.Equal(0u, flags & Zero);
|
|
Assert.Equal(0u, flags & Sign);
|
|
Assert.Equal(DirectionFlag, flags & DirectionFlag);
|
|
}
|
|
|
|
[Fact]
|
|
public void Andn_SetsZeroFlagWhenResultIsZero()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Andn(0xFF, 0xFF, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0UL, result);
|
|
Assert.Equal(Zero, flags & Zero);
|
|
}
|
|
|
|
[Fact]
|
|
public void Andn_SetsSignFlagOnHighBit32()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Andn(0, 0x8000_0000, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x8000_0000UL, result);
|
|
Assert.Equal(Sign, flags & Sign);
|
|
}
|
|
|
|
[Fact]
|
|
public void Andn_MasksTo64Bits()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Andn(0xFFFF_FFFF_FFFF_FF00, 0xFF, GprOperandSize.Bits64, ref flags);
|
|
|
|
Assert.Equal(0xFFUL, result);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x0000_000CUL, 0x0000_0004UL, false)] // isolate lowest set bit
|
|
[InlineData(0x0000_0000UL, 0x0000_0000UL, true)] // src == 0 -> CF clear, ZF set
|
|
public void Blsi_IsolatesLowestBit(ulong src, ulong expected, bool zero)
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Blsi(src, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(expected, result);
|
|
Assert.Equal(src != 0 ? Carry : 0u, flags & Carry);
|
|
Assert.Equal(zero ? Zero : 0u, flags & Zero);
|
|
}
|
|
|
|
[Fact]
|
|
public void Blsmsk_MasksThroughLowestBit()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Blsmsk(0x0000_000C, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x0000_0007UL, result);
|
|
Assert.Equal(0u, flags & Carry);
|
|
}
|
|
|
|
[Fact]
|
|
public void Blsmsk_SetsCarryWhenSourceZero32()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Blsmsk(0, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0xFFFF_FFFFUL, result);
|
|
Assert.Equal(Carry, flags & Carry);
|
|
Assert.Equal(Sign, flags & Sign);
|
|
}
|
|
|
|
[Fact]
|
|
public void Blsr_ResetsLowestBit()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Blsr(0x0000_000C, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x0000_0008UL, result);
|
|
Assert.Equal(0u, flags & Carry);
|
|
}
|
|
|
|
[Fact]
|
|
public void Blsr_SetsCarryAndZeroWhenSourceZero()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Blsr(0, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0UL, result);
|
|
Assert.Equal(Carry, flags & Carry);
|
|
Assert.Equal(Zero, flags & Zero);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bextr_ExtractsBitField()
|
|
{
|
|
uint flags = 0;
|
|
// start = 4, len = 8 -> bits [11:4] of 0x12345678 == 0x67
|
|
var control = (8UL << 8) | 4UL;
|
|
var result = BmiInstructionEmulator.Bextr(0x1234_5678, control, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x0000_0067UL, result);
|
|
Assert.Equal(0u, flags & Zero);
|
|
Assert.Equal(0u, flags & Carry);
|
|
Assert.Equal(0u, flags & Overflow);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bextr_StartBeyondWidthYieldsZero()
|
|
{
|
|
uint flags = 0;
|
|
var control = (8UL << 8) | 40UL; // start = 40 >= 32
|
|
var result = BmiInstructionEmulator.Bextr(0xFFFF_FFFF, control, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0UL, result);
|
|
Assert.Equal(Zero, flags & Zero);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bzhi_ZeroesHighBits()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Bzhi(0xFFFF_FFFF, 8, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0x0000_00FFUL, result);
|
|
Assert.Equal(0u, flags & Carry);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bzhi_SetsCarryWhenIndexAtOrBeyondWidth()
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Bzhi(0xFFFF_FFFF, 32, GprOperandSize.Bits32, ref flags);
|
|
|
|
Assert.Equal(0xFFFF_FFFFUL, result);
|
|
Assert.Equal(Carry, flags & Carry);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x0000_0008UL, GprOperandSize.Bits32, 3UL, false)]
|
|
[InlineData(0x0000_0001UL, GprOperandSize.Bits32, 0UL, false)]
|
|
[InlineData(0x0000_0000UL, GprOperandSize.Bits32, 32UL, true)]
|
|
[InlineData(0x1_0000_0000UL, GprOperandSize.Bits64, 32UL, false)]
|
|
public void Tzcnt_CountsTrailingZeros(ulong src, GprOperandSize size, ulong expected, bool carry)
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Tzcnt(src, size, ref flags);
|
|
|
|
Assert.Equal(expected, result);
|
|
Assert.Equal(carry ? Carry : 0u, flags & Carry);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x0000_0001UL, GprOperandSize.Bits32, 31UL, false)]
|
|
[InlineData(0x8000_0000UL, GprOperandSize.Bits32, 0UL, false)]
|
|
[InlineData(0x0000_0000UL, GprOperandSize.Bits32, 32UL, true)]
|
|
[InlineData(0x0000_0001UL, GprOperandSize.Bits64, 63UL, false)]
|
|
[InlineData(0x0000_0000UL, GprOperandSize.Bits64, 64UL, true)]
|
|
public void Lzcnt_CountsLeadingZeros(ulong src, GprOperandSize size, ulong expected, bool carry)
|
|
{
|
|
uint flags = 0;
|
|
var result = BmiInstructionEmulator.Lzcnt(src, size, ref flags);
|
|
|
|
Assert.Equal(expected, result);
|
|
Assert.Equal(carry ? Carry : 0u, flags & Carry);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x1234_5678UL, 8, GprOperandSize.Bits32, 0x7812_3456UL)]
|
|
[InlineData(0x1234_5678UL, 0, GprOperandSize.Bits32, 0x1234_5678UL)]
|
|
[InlineData(0x0123_4567_89AB_CDEFUL, 4, GprOperandSize.Bits64, 0xF012_3456_789A_BCDEUL)]
|
|
public void Rorx_RotatesRight(ulong src, int count, GprOperandSize size, ulong expected)
|
|
{
|
|
Assert.Equal(expected, BmiInstructionEmulator.Rorx(src, count, size));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x8000_0000UL, 4, GprOperandSize.Bits32, 0xF800_0000UL)]
|
|
[InlineData(0x8000_0000UL, 36, GprOperandSize.Bits32, 0xF800_0000UL)] // count masked to 4
|
|
[InlineData(0x8000_0000_0000_0000UL, 4, GprOperandSize.Bits64, 0xF800_0000_0000_0000UL)]
|
|
public void Sarx_ArithmeticShiftRight(ulong src, int count, GprOperandSize size, ulong expected)
|
|
{
|
|
Assert.Equal(expected, BmiInstructionEmulator.Sarx(src, count, size));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x0000_0001UL, 4, GprOperandSize.Bits32, 0x0000_0010UL)]
|
|
[InlineData(0x0000_0001UL, 33, GprOperandSize.Bits32, 0x0000_0002UL)] // count masked to 1
|
|
public void Shlx_LogicalShiftLeft(ulong src, int count, GprOperandSize size, ulong expected)
|
|
{
|
|
Assert.Equal(expected, BmiInstructionEmulator.Shlx(src, count, size));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x8000_0000UL, 4, GprOperandSize.Bits32, 0x0800_0000UL)]
|
|
[InlineData(0x8000_0000_0000_0000UL, 4, GprOperandSize.Bits64, 0x0800_0000_0000_0000UL)]
|
|
public void Shrx_LogicalShiftRight(ulong src, int count, GprOperandSize size, ulong expected)
|
|
{
|
|
Assert.Equal(expected, BmiInstructionEmulator.Shrx(src, count, size));
|
|
}
|
|
|
|
[Fact]
|
|
public void PdepAndPext_AreInverseForContiguousSource()
|
|
{
|
|
var deposited = BmiInstructionEmulator.Pdep(0x0000_000F, 0x0000_00AA, GprOperandSize.Bits32);
|
|
Assert.Equal(0x0000_00AAUL, deposited);
|
|
|
|
var extracted = BmiInstructionEmulator.Pext(0x0000_00AA, 0x0000_00AA, GprOperandSize.Bits32);
|
|
Assert.Equal(0x0000_000FUL, extracted);
|
|
}
|
|
|
|
[Fact]
|
|
public void Pext_GathersSelectedBits()
|
|
{
|
|
// mask selects bit positions 1,3,5,7; source has 1s only at 5 and 7 -> packed 0b1100
|
|
var extracted = BmiInstructionEmulator.Pext(0xF0, 0xAA, GprOperandSize.Bits32);
|
|
Assert.Equal(0x0000_000CUL, extracted);
|
|
}
|
|
}
|