Написание машинных инструкций MIPS и их выполнение из C

Написанный код OP компилируется без ошибок с помощью Codesourcery mips-linux-gnu-gcc.

Как упоминалось выше, самомодифицирующийся код на MIPS требует, чтобы кеш инструкций был синхронизирован с кешем данных после записи кода. Версия MIPS32R2 архитектуры MIPS добавил SYNCI инструкция, которая является инструкцией пользовательского режима, которая делает то, что вам здесь нужно. Все современные процессоры MIPS реализуют MIPS32R2, включая SYNCI.

Защита памяти является опцией для MIPS, но большинство процессоров MIPS не построены с выбранной функцией, поэтому использование системного вызова mprotect, вероятно, не требуется на большинстве реальных аппаратных средств MIPS.

Обратите внимание, что если вы используете любую оптимизацию, кроме -O0, компилятор может и действительно оптимизирует хранилища до *addone и вызова функции, что нарушает ваш код. Использование ключевого слова volatile предотвращает это от компилятора.

Следующий код генерирует правильную сборку MIPS, но у меня нет удобного оборудования MIPS, чтобы протестировать его:

int inc() {
    volatile int i = 41;
    // malloc 8 x sizeof(int) to allocate 32 bytes ie one cache line,
    // also ensuring that the address of function addone is aligned to
    // a cache line.
    volatile int *addone = malloc(sizeof(*addone) * 8);
    *(addone)     = 0x20820001; // this is addi $v0 $a0 1
    *(addone + 1) = 0x23e00000; //this is jr $ra
    // use a SYNCI instruction to flush the data written above from
    // the D cache and to flush any stale data from the I cache
    asm volatile("synci 0(%0)": : "r" (addone));
    volatile int (*f)(int x) = addone; //our function pointer
    int j = (*f)(i);
    return j;
}

int main(){
    int k = 0;
    k = inc();
    printf("%d",k);    
    exit(0);
}

Вы неправильно используете указатели. Или, если быть более точным, вы не используете указатели там, где должны быть.

Попробуйте это для размера:

uint32_t *addone = malloc(sizeof(*addone) * 2);
addone[0] = 0x20820001; // addi $v0, $a0, 1
addone[1] = 0x23e00000; // jr $ra

int (*f)(int x) = addone; //our function pointer
i = (*f)(i);
printf("%d\n",i);

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

mprotect(addone, sizeof(int) * 2, PROT_READ | PROT_EXEC);

Чтобы это работало, вам может дополнительно потребоваться выделить значительно больший блок памяти (4 КБ или около того), чтобы адрес был выровнен по страницам.

Вы также должны убедиться, что рассматриваемая память является исполняемой, и убедиться, что она правильно сбрасывается из dcache после ее записи и загружается в icache перед ее выполнением. Как это сделать, зависит от ОС, работающей на вашем mips-компьютере.

В Linux вы должны использовать системный вызов mprotect, чтобы сделать память исполняемой, и системный вызов cacheflush, чтобы выполнить очистку кеша.

изменить

Пример:

#include <unistd.h>
#include <sys/mman.h>
#include <asm/cachecontrol.h>

#define PALIGN(P)  ((char *)((uintptr_t)(P) & (pagesize-1)))
uintptr_t  pagesize;

void inc(){
    int i = 41;
    uint32_t *addone = malloc(sizeof(*addone) * 2); //we malloc space for our asm function
    *(addone) = 0x20820001; // this is addi $v0 $a0 1, which adds one to our arg (gcc calling con)
    *(addone + 1) = 0x23e00000; //this is jr $ra

    pagesize = sysconf(_SC_PAGESIZE);  // only needs to be done once
    mprotect(PALIGN(addone), PALIGN(addone+1)-PALIGN(addone)+pagesize,
             PROT_READ | PROT_WRITE | PROT_EXEC);
    cacheflush(addone, 2*sizeof(*addone), ICACHE|DCACHE);

    int (*f)(int x) = addone; //our function pointer
    i = (*f)(i);
    printf("%d",i);    
}

Обратите внимание, что мы делаем все страницы, содержащие код, доступными как для записи, так и для выполнения. Это связано с тем, что защита памяти работает для каждой страницы, и мы хотим, чтобы malloc мог продолжать использовать остальные страницы для других целей. Вместо этого вы можете использовать valloc или memalign для выделения целых страниц, и в этом случае вы можете безопасно сделать исполняемый код доступным только для чтения.

Вызов функции намного сложнее, чем просто переход к инструкции.

• Как передаются аргументы? Сохраняются ли они в регистрах или помещаются в стек вызовов?

• Как возвращается значение?

• Где размещается обратный адрес для обратного перехода? Если у вас есть рекурсивная функция, $ra ее не обрезает.

• Ответственен ли вызывающий или вызываемый объект за извлечение фрейма стека после завершения вызываемой функции?

Различные соглашения о вызовах дают разные ответы на эти вопросы. Хотя я никогда не пробовал ничего подобного тому, что вы делаете, я предполагаю, что вам придется написать свой машинный код в соответствии с соглашением, а затем сообщить компилятору, что ваш указатель на функцию использует это соглашение (у разных компиляторов есть разные способы выполнения это - gcc делает это с атрибутами функции).