Eu gosto de exemplos, então eu escrevi um pouco de código de auto-modificação em c ...

#include <stdio.h>
#include <sys/mman.h> // linux

int main(void) {
    unsigned char *c = mmap(NULL, 7, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|
                            MAP_ANONYMOUS, -1, 0); // get executable memory
    c[0] = 0b11000111; // mov (x86_64), immediate mode, full-sized (32 bits)
    c[1] = 0b11000000; // to register rax (000) which holds the return value
                       // according to linux x86_64 calling convention 
    c[6] = 0b11000011; // return
    for (c[2] = 0; c[2] < 30; c[2]++) { // incr immediate data after every run
        // rest of immediate data (c[3:6]) are already set to 0 by MAP_ANONYMOUS
        printf("%d ", ((int (*)(void)) c)()); // cast c to func ptr, call ptr
    }
    putchar('\n');
    return 0;
}

... o que funciona, aparentemente:

>>> gcc -Wall -Wextra -std=c11 -D_GNU_SOURCE -o test test.c; ./test
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Mas honestamente, eu não fizEspero para trabalhar em tudo. Eu esperava que a instrução contendoc[2] = 0 para ser armazenado em cache na primeira chamada parac, após o qual todas as chamadas consecutivas parac iria ignorar as mudanças repetidas feitas parac (a menos que eu de algum modo explicitamente invalidasse o cache). Felizmente, minha CPU parece ser mais inteligente do que isso.

Eu acho que o cpu compara RAM (assumindoc mesmo reside na RAM) com o cache de instruções sempre que o ponteiro de instrução faz um salto grande-ish (como com a chamada para a memória mmap acima), e invalida o cache quando ele não corresponde (tudo isso?), mas eu Estou esperando obter informações mais precisas sobre isso. Em particular, eu gostaria de saber se esse comportamento pode ser considerado previsível (salvo quaisquer diferenças de hardware e sistema operacional) e confiado em?

(Eu provavelmente devo me referir ao manual da Intel, mas isso tem milhares de páginas e eu tento me perder nele ...)