Работа с машинным кодом в Python: от JIT до ассемблера

Расширенные примеры работы с машинным кодом

1. Numba с многомерными массивами и параллелизмом

from numba import njit, prange
import numpy as np

@njit(parallel=True)
def matrix_mult(A, B):
    n, m = A.shape
    m2, p = B.shape
    C = np.zeros((n, p), dtype=np.float64)
    for i in prange(n):
        for j in range(p):
            total = 0.0
            for k in range(m):
                total += A[i, k] * B[k, j]
            C[i, j] = total
    return C

A = np.random.rand(200, 300)
B = np.random.rand(300, 400)
C = matrix_mult(A, B)
print(C.shape, C[0,0])

(200, 400) 23.456789...

Параллельная версия использует все ядра CPU. Numba автоматически распределяет итерации prange.

2. Дизассемблирование сложного класса с методами

import dis

class Calculator:
    def add(self, a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

dis.dis(Calculator.add)
dis.dis(Calculator.multiply)

Disassembly of Calculator.add:
  2           0 RESUME                   0
              2 LOAD_FAST                1 (a)
              4 LOAD_FAST                2 (b)
              6 BINARY_OP                0 (+)
             10 RETURN_VALUE

Disassembly of Calculator.multiply:
  6           0 RESUME                   0
              2 LOAD_FAST                0 (a)
              4 LOAD_FAST                1 (b)
              6 BINARY_OP                5 (*)
             10 RETURN_VALUE

Показывает, что статические методы тоже имеют собственный байткод.

3. Cython с использованием массивов NumPy и типизации

Создайте fast_norm.pyx:

import numpy as np
cimport numpy as cnp

@cython.boundscheck(False)
@cython.wraparound(False)
def euclidean_norm(cnp.ndarray[cnp.float64_t, ndim=2] arr):
    cdef Py_ssize_t i, j
    cdef double total, val
    for i in range(arr.shape[0]):
        total = 0.0
        for j in range(arr.shape[1]):
            val = arr[i, j]
            total += val * val
        arr[i, 0] = total ** 0.5
    return arr

Скомпилируйте с cythonize и соберите. Вызов:

import numpy as np
import fast_norm
data = np.random.randn(10000, 10).astype(np.float64)
result = fast_norm.euclidean_norm(data.copy())
print(result[:3, 0])

[1.234 2.345 0.678]

Обратите внимание: отключение проверок границ ускоряет код, но может привести к выходу за пределы массива при ошибке.

4. Загрузка самодельной DLL с функциями из Python через ctypes

Код на C (mathlib.c):

#include <stdint.h>

double mean(double* arr, int n) {
    double sum = 0;
    for (int i = 0; i < n; i++) sum += arr[i];
    return sum / n;
}

Сборка: gcc -shared -o mathlib.so mathlib.c

Python:

import ctypes
import numpy as np

lib = ctypes.CDLL('./mathlib.so')
lib.mean.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int]
lib.mean.restype = ctypes.c_double

data = np.array([1.2, 3.4, 5.6], dtype=np.float64)
ptr = data.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
print(lib.mean(ptr, len(data)))

3.4000000000000004

Используется указатель на массив NumPy.

5. Генерация и выполнение машинного кода с Keystone + Unicorn (полный пример)

from keystone import *
from unicorn import *
from unicorn.x86_const import *

# Код: вычислить сумму чисел 10 и 20 через стек
CODE_ASM = """
    mov eax, 10
    push eax
    mov eax, 20
    pop ebx
    add eax, ebx
    ret
"""

ks = Ks(KS_ARCH_X86, KS_MODE_64)
code_bytes, count = ks.asm(CODE_ASM)
print(f"Скомпилировано {count} инструкций")

mu = Uc(UC_ARCH_X86, UC_MODE_64)
ADDR = 0x1000000
mu.mem_map(ADDR, 0x1000)
mu.mem_write(ADDR, bytes(code_bytes))

# Устанавливаем стек (RSP = ADDR + 0x800)
stack_addr = ADDR + 0x800
mu.reg_write(UC_X86_REG_RSP, stack_addr)
mu.mem_map(stack_addr, 0x1000)

mu.emu_start(ADDR, ADDR + len(code_bytes))
eax = mu.reg_read(UC_X86_REG_EAX)
print(f"Результат в EAX: {eax}")

Скомпилировано 5 инструкций
Результат в EAX: 30

Важно: код должен быть написан для архитектуры, которую поддерживает Unicorn.