Fonctions d'appel de l'assembly x86_64

Question

Je suis en train de créer mon propre JIT et j'ai réussi à exécuter un code d'assemblage très simple (en code machine), mais j'ai du mal à comprendre comment appeler les fonctions de cette manière. Dans Visual Studio, je peux voir les fonctions dans la fenêtre de désassemblage.

Une autre question connexe est comment puis-je appeler Win32 MessageBox() en code machine?

La question suivante est comment puis-je appeler des fonctions DLL/LIB externes de cette manière?

Y a-t-il aussi des livres ou des tutoriels qui pourraient m'apprendre davantage sur ce sujet? J'ai essayé de le rechercher mais obtenir des résultats comme .NET, JVM et LLVM qui je pense n'est pas vraiment ce que je cherche.

Voici une version simplifiée du code que je travaille sur:

#include <iostream> 
#include <Windows.h> 

int main(int argc, char* argv[]) 
{ 
    // b8 03 00 00 00 83 c0 02 c3 
    unsigned char code[] = { 
     0xb8,     // mov eax, 3 
     0x03, 0x00, 0x00, 0x00, // 3 (32 bit) 
     0x83,     // add eax, 2 // 0x83 = add, 
     0xc0,     // ModR/M with immediate 8 bit value 
     0x02,     // 2 (8 bit) 
     0xc3     // ret 
    }; 

    void* mem = VirtualAlloc(0, sizeof(code), MEM_COMMIT, PAGE_EXECUTE_READWRITE); 

    memcpy(mem, code, sizeof(code)); 

    DWORD old; 
    VirtualProtect(mem, sizeof(mem), PAGE_EXECUTE_READ, &old); 

    int(*func)() = reinterpret_cast<int(*)()>(mem); 

    printf("Number is %d\n", func()); 

    VirtualFree(mem, 0, MEM_RELEASE); 

    return 0; 
} 

Est-il possible d'avoir le code assembleur JIT pour appeler une fonction C++?

Avant ce projet j'ai fait un interpréteur de code octet en C++, mais je n'étais pas vraiment content de la vitesse en le comparant à un programme de test équivalent en C#. C# était environ 25 fois plus rapide. Donc je suis tombé sur quelque chose appelé JIT pour le rendre plus rapide. Donc j'espère que vous pouvez tous voir où je prends ce projet JIT. Et peut-être si possible, faites-le gérer l'interface graphique.

Answer 1

Vous pouvez probablement trouver quelques tutoriels sur l'écriture d'un compilateur/éditeur de liens. Cela peut aider à implémenter/appeler des bibliothèques dynamiques.

Je ne suis pas sûr de ce que vous voulez dire exactement en appelant des fonctions C++. Quoi qu'il en soit, j'ai écrit le programme de démonstration suivant que vous pouvez jeter un coup d'oeil et voir si cela aide du tout.

#include <Windows.h> 
#include <iostream> 


using namespace std; 

__int64 sub(__int64 a, __int64 b) 
{ 
    return a - b; 
} 

int main(int argc, char **argv) 
{ 
    char code[] = 
    { 
     0x48, 0x89, 0xC8,   // mov rax, rcx 
     0xC3,      // ret 

     0x48, 0x83, 0xEC, 0x20,  // sub rsp, 0x20 
     0xFF, 0xD0,     // call rax 
     0x48, 0x83, 0xC4, 0x20,  // add rsp, 0x20 
     0xC3      // ret 
    }; 


    char *mem = static_cast<char *>(VirtualAlloc(0, sizeof(code), MEM_COMMIT, PAGE_EXECUTE_READWRITE)); 

    MoveMemory(mem, code, sizeof(code)); 

    auto setFunc = reinterpret_cast<void *(*)(void *)>(mem); 
    auto callFunc = reinterpret_cast<__int64 (*)(__int64, __int64)>(mem + 4); 

    setFunc(sub); 
    __int64 r = callFunc(0, 1); 
    cout << "r = " << r << endl; 

    VirtualFree(mem, 0, MEM_RELEASE); 


    cin.ignore(); 
    return 0; 
}