
x86/x86-64 명령어 인코딩을 위한 헤더 전용 C++2x 컴파일 타임 어셈블러
컴파일 타임 x86/x86-64 명령어 인코딩을 위한 헤더 온리 C++20 라이브러리입니다.
이 프로젝트는 Boost Software License 1.0과 MIT License에 따라 이중 라이선스가 적용됩니다. 둘 중 하나를 선택할 수 있습니다.
#include "static_asm.hpp"
using namespace static_asm;
using namespace static_asm::x86;
using namespace static_asm::x86::registers;
using namespace static_asm::x86::instructions;
// Build machine code at compile time
constexpr auto code = core::assemble(
mov(rax, 0x12345678), // mov rax, imm32
add(rax, rcx), // add rax, rcx
xor_(r8, r8), // xor r8, r8
call(rax), // call rax
ret() // ret
);
// code is std::array<uint8_t, N> - fully constexpr!
명명된 분기와 임베디드 데이터에 대해서는 레이블 및 분기 완화를 참조하십시오.
// Register to register
add(rax, rbx); // 48 01 D8
sub(ecx, edx); // 29 D1
and_(r8, r9); // 4D 21 C8
or_(rsi, rdi); // 48 09 FE
xor_(eax, eax); // 31 C0 (common idiom to zero a register)
cmp(rax, rcx); // 48 39 C8
// Register with immediate
add(rax, 0x10); // 48 83 C0 10 (sign-extended imm8)
add(rax, 0x10000); // 48 05 00 00 01 00 (imm32)
sub(ecx, 100); // 83 E9 64
and_(rdx, 0xFF); // 48 83 E2 FF
// With memory operands
add(eax, dword_ptr(rbx)); // 03 03
add(rax, qword_ptr(rcx + disp<0x10>)); // 48 03 41 10
sub(dword_ptr(rsp + disp<0x20>), eax); // 29 44 24 20
가장 짧은 변위에는
disp<value>를 사용하십시오. 이는 0에 대해 합법적인 경우 변위를 선택하지 않고, -128부터 127까지는 부호 있는disp8을, 그 외에는disp32를 선택합니다. RIP 상대 주소는 항상disp32가 필요하며, 0인 RBP/R13도 여전히 0disp8이 필요합니다. 부호 있는 32비트 범위를 벗어나는 값은 컴파일 실패합니다.rcx + 0x10과 같은 일반 정수는 여전히disp32를 사용합니다. C++는int인자의 값에 따라 서로 다른 정확한 크기의 명령어 배열 타입을 선택할 수 없기 때문입니다. 일반 베이스를 사용하는[base + disp]는 정규 ModR/M 전용 형식(SIB 바이트 없음)을 사용하며, RSP/R12 베이스는 하드웨어가 요구하기 때문에 SIB 바이트를 생성합니다.
// Register to register
mov(rax, rbx); // 48 89 D8
mov(eax, ecx); // 89 C8
mov(r8, r9); // 4D 89 C8
// Immediate to register
mov(rax, 0x12345678); // 48 C7 C0 78 56 34 12
mov(eax, 0xDEADBEEF); // B8 EF BE AD DE
// Memory operations
mov(rax, qword_ptr(rbx)); // 48 8B 03
mov(eax, dword_ptr(rcx + disp<0x10>)); // 8B 41 10
mov(rax, qword_ptr(rbp - disp<0x20>)); // 48 8B 45 E0 (canonical, no SIB)
mov(qword_ptr(rsp + disp<0x8>), rax); // 48 89 44 24 08 (RSP base needs SIB)
// Zero/sign extension
movzx(eax, bl); // 0F B6 C3 (zero-extend byte to dword)
movzx(rax, bx); // 48 0F B7 C3 (zero-extend word to qword)
movsx(eax, cl); // 0F BE C1 (sign-extend byte to dword)
movsx(rax, dx); // 48 0F BF C2 (sign-extend word to qword)
movsxd(rax, ecx); // 48 63 C1 (sign-extend dword to qword)
// Load effective address
lea(rax, qword_ptr(rbx + rcx * s4)); // 48 8D 04 8B
lea(rax, qword_ptr(rbx + rcx * s8 + disp<0x10>)); // 48 8D 44 CB 10
// Exchange (register or memory; XCHG is symmetric)
xchg(rax, rbx); // 48 87 D8
xchg(qword_ptr(rcx), rax); // 48 87 01
xchg(rbx, qword_ptr(rcx + disp<0x10>)); // 48 87 59 10
// Store an immediate to a displaced / SIB / RIP memory destination
mov(dword_ptr(rbp - disp<0x20>), 0x100); // C7 45 E0 00 01 00 00
mov(qword_ptr(rcx + disp<0x10>), 1); // 48 C7 41 10 01 00 00 00
add(qword_ptr(rbx + disp<0x8>), 0x10); // 48 81 43 08 10 00 00 00
qword 메모리 목적지는 부호 확장된 32비트 즉시값 인코딩만을 가집니다.
정수의 64비트 비트 패턴은 해당 인코딩과 일치해야 합니다. 예를 들어 0x7FFFFFFF와
-0x80000000LL은 적합하지만, 양수 0x80000000ULL은 적합하지 않습니다. 유효하지 않은
값은 상수 평가에 실패하거나 런타임에 std::out_of_range를 발생시킵니다.
예외가 비활성화된 경우, 유효하지 않은 런타임 값은 프로그램을 종료시킵니다. 명시적인
imm32 피연산자는 원시 4바이트 즉시값을 제공합니다.
rip + disp(및 rip - disp)는 64비트 RIP 상대 형식(ModR/M
mod=00 r/m=101, 필수 disp32, 절대 SIB 바이트 없음)을 인코딩합니다:
mov(rax, qword_ptr(rip + 0x10)); // 48 8B 05 10 00 00 00
lea(rax, qword_ptr(rip + 0x100)); // 48 8D 05 00 01 00 00
add(qword_ptr(rip + 0x20), rbx); // 48 01 1D 20 00 00 00
inc(qword_ptr(rip + 0x40)); // 48 FF 05 40 00 00 00
test(rax, qword_ptr(rip + 0x10)); // 48 85 05 10 00 00 00
test(qword_ptr(rip + 0), 0x10); // 48 F7 05 00 00 00 00 10 00 00 00
// [base + index*scale]
mov(eax, dword_ptr(rbx + rcx * s1)); // 8B 04 0B
mov(eax, dword_ptr(rbx + rcx * s2)); // 8B 04 4B
mov(eax, dword_ptr(rbx + rcx * s4)); // 8B 04 8B
mov(eax, dword_ptr(rbx + rcx * s8)); // 8B 04 CB
// [base + index*scale + displacement]
mov(rax, qword_ptr(rbx + rcx * s4 + disp<0x10>)); // 48 8B 44 8B 10
mov(rax, qword_ptr(r12 + r13 * s8 + 0x1000)); // 4B 8B 84 EC 00 10 00 00
// Store to SIB address
mov(dword_ptr(rax + rdx * s4), ecx); // 89 0C 90
mov(qword_ptr(rbx + rsi * s8 + disp<0x20>), rax); // 48 89 44 F3 20
// LEA with SIB (useful for address calculations)
lea(rax, qword_ptr(rbx + rcx * s4)); // 48 8D 04 8B
lea(rax, qword_ptr(rdi + rsi * s8 + 0x100)); // 48 8D 84 F7 00 01 00 00
// Shift by 1
shl(eax, 1); // D1 E0
shr(rax, 1); // 48 D1 E8
sar(ecx, 1); // D1 F9
// Shift by immediate
shl(eax, 4); // C1 E0 04
shr(rax, 8); // 48 C1 E8 08
sar(rdx, 16); // 48 C1 FA 10
// Shift by CL register
shl(eax, cl); // D3 E0
shr(rax, cl); // 48 D3 E8
// Rotate
rol(eax, 1); // D1 C0
ror(rax, 8); // 48 C1 C8 08
rcl(ecx, cl); // D3 D1
rcr(rdx, 1); // 48 D1 DA
// Single operand (result in rdx:rax)
mul(rbx); // 48 F7 E3 (unsigned: rdx:rax = rax * rbx)
imul(rcx); // 48 F7 E9 (signed: rdx:rax = rax * rcx)
div(rbx); // 48 F7 F3 (unsigned: rax = rdx:rax / rbx, rdx = remainder)
idiv(rcx); // 48 F7 F9 (signed division)
// Two-operand IMUL (dest = dest * src)
imul(rax, rbx); // 48 0F AF C3
imul(ecx, edx); // 0F AF CA
// Three-operand IMUL (dest = src * imm)
imul(rax, rbx, 10); // 48 6B C3 0A
imul(ecx, edx, 1000); // 69 CA E8 03 00 00
// Single-operand form with a memory operand
mul(qword_ptr(rcx)); // 48 F7 21
imul(qword_ptr(rcx + disp<0x20>)); // 48 F7 69 20
div(dword_ptr(rax + disp<0x10>)); // F7 70 10
idiv(qword_ptr(rbx)); // 48 F7 3B
// Register operands
inc(rax); // 48 FF C0
dec(ecx); // FF C9
neg(rbx); // 48 F7 DB
not_(rdx); // 48 F7 D2
// Memory operands (canonical ModR/M-only addressing)
inc(qword_ptr(rcx)); // 48 FF 01
inc(qword_ptr(rcx + disp<0x20>)); // 48 FF 41 20
dec(dword_ptr(rax + disp<0x10>)); // FF 48 10
neg(qword_ptr(rbx)); // 48 F7 1B
not_(qword_ptr(rbx - disp<0x4>)); // 48 F7 53 FC
lock_는 인코딩된 모든 명령어 앞에 LOCK 접두사(0xF0)를 붙여 메모리에 대한 읽기-수정-쓰기를 원자적으로 만듭니다:
lock_(inc(qword_ptr(rcx + disp<0x20>))); // F0 48 FF 41 20
lock_(add(dword_ptr(rax), ecx)); // F0 01 08
바이트 수준의 얇은 래퍼이며, 래핑된 명령어가 CPU에서 LOCK을 허용하는 명령어인지 검증하지 않습니다.