kbe
f7236eea9b
Add CallingConvention enum (Cdecl, Stdcall, Thiscall, Fastcall). Implement BuildCallStub on StubAssembler with x86 cdecl support: reverse arg push, call rel32, add esp (caller cleanup), ret. x64 stub is a placeholder (task 3.7-3.8). 3 new tests: 0-arg (call+ret), 1-arg (push+call+cleanup+ret), 2-args (reverse push+call+cleanup+ret). Known byte expectations. All passing (total: 67).
119 lines
4.0 KiB
C#
119 lines
4.0 KiB
C#
namespace WhiteMagic.Assembly;
|
|
|
|
/// <summary>
|
|
/// The default <see cref="IAssembler"/> backend. Hand-emits calling-convention
|
|
/// trampolines and injection stubs using deterministic byte emitters
|
|
/// (<see cref="EmitU8"/>, <see cref="EmitU32"/>, <see cref="EmitU64"/>). Has
|
|
/// no native or third-party dependency — no FASM, no Iced.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <see cref="Assemble"/> is not supported by this backend (it is a parse-free
|
|
/// emitter, not a text assembler). Use <see cref="IcedAssembler"/> (Phase 8) for
|
|
/// arbitrary mnemonics.
|
|
/// </remarks>
|
|
public class StubAssembler : IAssembler
|
|
{
|
|
/// <inheritdoc />
|
|
public byte[] Assemble(string assemblyText, ulong origin = 0)
|
|
{
|
|
throw new NotSupportedException(
|
|
"StubAssembler does not parse text assembly. " +
|
|
"Use IcedAssembler (Phase 8) for arbitrary mnemonics.");
|
|
}
|
|
|
|
// ── Emit primitives ────────────────────────────────────────────────────
|
|
|
|
public void EmitU8(List<byte> buffer, byte value) => buffer.Add(value);
|
|
|
|
public void EmitU32(List<byte> buffer, uint value)
|
|
{
|
|
buffer.Add((byte)value);
|
|
buffer.Add((byte)(value >> 8));
|
|
buffer.Add((byte)(value >> 16));
|
|
buffer.Add((byte)(value >> 24));
|
|
}
|
|
|
|
public void EmitU64(List<byte> buffer, ulong value)
|
|
{
|
|
EmitU32(buffer, (uint)value);
|
|
EmitU32(buffer, (uint)(value >> 32));
|
|
}
|
|
|
|
// ── Call-stub builders ─────────────────────────────────────────────────
|
|
|
|
public byte[] BuildCallStub(IntPtr stubAddress, IntPtr targetAddress,
|
|
uint[] arguments, int pointerSize, CallingConvention convention)
|
|
{
|
|
var buffer = new List<byte>(64);
|
|
|
|
if (pointerSize == 4)
|
|
BuildX86Stub(buffer, (uint)stubAddress, (uint)targetAddress, arguments, convention);
|
|
else
|
|
BuildX64Stub(buffer, (ulong)stubAddress, (ulong)targetAddress, arguments);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
private void BuildX86Stub(List<byte> buffer, uint stubAddr,
|
|
uint target, uint[] args, CallingConvention convention)
|
|
{
|
|
uint current = stubAddr;
|
|
|
|
switch (convention)
|
|
{
|
|
case CallingConvention.Thiscall when args.Length >= 1:
|
|
buffer.Add(0xB9); // mov ecx, arg0
|
|
EmitU32(buffer, args[0]);
|
|
current += 5;
|
|
args = args[1..];
|
|
break;
|
|
|
|
case CallingConvention.Fastcall:
|
|
if (args.Length >= 1)
|
|
{
|
|
buffer.Add(0xB9); // mov ecx, arg0
|
|
EmitU32(buffer, args[0]);
|
|
current += 5;
|
|
args = args[1..];
|
|
}
|
|
if (args.Length >= 1)
|
|
{
|
|
buffer.Add(0xBA); // mov edx, arg1
|
|
EmitU32(buffer, args[0]);
|
|
current += 5;
|
|
args = args[1..];
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Push remaining args in reverse order
|
|
for (int i = args.Length - 1; i >= 0; i--)
|
|
{
|
|
buffer.Add(0x68); // push imm32
|
|
EmitU32(buffer, args[i]);
|
|
current += 5;
|
|
}
|
|
|
|
// call rel32
|
|
uint rel32 = target - (current + 5);
|
|
buffer.Add(0xE8);
|
|
EmitU32(buffer, rel32);
|
|
|
|
// Caller cleanup (cdecl only)
|
|
if (convention == CallingConvention.Cdecl && args.Length > 0)
|
|
{
|
|
buffer.Add(0x83); // add esp, imm8
|
|
buffer.Add(0xC4);
|
|
buffer.Add((byte)(args.Length * 4));
|
|
}
|
|
|
|
buffer.Add(0xC3); // ret
|
|
}
|
|
|
|
private static void BuildX64Stub(List<byte> buffer, ulong stubAddr,
|
|
ulong target, uint[] args)
|
|
{
|
|
throw new NotImplementedException("x64 stubs (task 3.7-3.8)");
|
|
}
|
|
}
|