Converti codice assembly inline in C++

Question

Sto lavorando su un progetto cpp. Il progetto deve essere migrato a 64 bit. Contiene un codice assembly Inline che non può essere compilato su x64. Questa è la funzione che contengono il codice assembly:

void ExternalFunctionCall::callFunction(ArgType resultType, void* resultBuffer) 
{ 
#if defined(_NT_) || defined(__OS2__) 

    // I386 

    // just copy the args buffer to the stack (it's already layed out correctly) 
    int* begin = m_argsBegin; 
    int* ptr = m_argsEnd; 
    int arr[1000], i=0; 
    while (ptr > begin) { 
     int val = *(--ptr); 

     __asm push val 
    } 

    void* functionAddress = m_functionAddress; 

    // call the function & handle the return value. use __stdcall calling convention 
    switch (resultType) { 
    case voidType: 
     __asm { 
      call functionAddress 
     } 
     break; 
    case pointerType: 
    case int32Type: 
     __asm { 
      call functionAddress 
      mov ebx, resultBuffer 
      mov dword ptr [ebx],eax 
     } 
     break; 
    case floatType: 
     __asm { 
      call functionAddress 
      mov ebx, resultBuffer 
      fstp dword ptr [ebx] 
     } 
     break; 
    case doubleType: 
     __asm { 
      call functionAddress 
      mov ebx, resultBuffer 
      fstp qword ptr [ebx] 
     } 
     break; 
    } 

ho usato pila, matrice di migrare questa "asm spinta val", ma non ha funzionato. Sebbene, non genera alcun errore di compilazione ma la logica non ha funzionato.

Quindi, voglio chiedere, Cosa posso usare in C++ invece di "__asm ​​push val". Qualsiasi aiuto sarà apprezzato.

Answer 1

Ci sono diverse cose che è necessario risolvere. (Ho cercato il tuo codice su un'altra domanda). Come ho capito questo codice è un wrapper per chiamare la funzione piuttosto astratta situata all'indirizzo specificato che si aspetta una certa quantità di dati nello stack e può restituire cose diverse basate su ArgType.

Se si desidera eseguire il wrapping tramite C semplice, è necessario definire diversi prototipi di funzioni (in base al valore restituito) da utilizzare sullo switch, ma è necessario risolvere un altro problema, che è più complesso.

Il problema con il porting di tali elementi in C è che non si conosce in anticipo una quantità di argomenti (dimensione dati) da inserire nello stack, quindi si avranno problemi a definire il prototipo.

Diciamo che func (char c) inserirà definitivamente 1 byte di stack (ma anche non sempre corretto a causa dell'allineamento dei dati) .. nel tuo caso devi pensare a una soluzione che avrà un set di parametri con una dimensione uguale alla dimensione dei dati devi essere in pila. Che a prima vista non è qualcosa che puoi fare subito.

UPD. puoi farlo con func (char [] param); ma ha anche problemi che sono stati spiegati nella risposta sopra.

Answer 2

Il problema non è risolvibile in generale; questo perché il commento,

// call the function & handle the return value. use __stdcall calling convention 

indica dipendenza convenzioni a 32 bit chiamata.

In 32bit x86, stdcall significa che tutti argomenti sono passati sullo stack, in ordine inverso (cioè l'ultimo arg viene spinto prima. Cioè, se arg[0] è a addr allora arg[1], non importa suo tipo, è a addr + sizeof(arg[0])). Questo è il motivo per cui il seguente codice nel tuo esempio:

// just copy the args buffer to the stack (it's already layed out correctly) 
int* begin = m_argsBegin; 
int* ptr = m_argsEnd; 
int arr[1000], i=0; 
while (ptr > begin) { 
    int val = *(--ptr); 

    __asm push val 
} 

in realtà in grado di lavorare - perché semplicemente non importa che cosa è esattamente lì, che tipo sono gli argomenti; tutto ciò che è rilevante è che ognuno di loro si trova in una posizione di memoria conosciuta e in una memoria consecutiva. Se sai che l'argomento N è a addr, allora puoi sapere l'argomento N+1 è a addr + sizeof(arg[N]).

Questo è ciò che il commento dice: "è già spiegate correttamente" - purtroppo, questo è non vero in modalità a 64 bit. Quindi il codice non può essere "portato"; non esiste un equivalente a port to.

Chiamare convenzioni basate almeno parzialmente sul registro - come su Win64 su x64 (64 bit x86) si comportano in modo diverso.Per quelli, dipende da quali tipi di argomenti prendono le funzioni chiamate (è possibile, in Windows, passare quattro argomenti di tipo intero nei registri generici più alcuni argomenti di tipo float nei registri XMM). È quindi necessario conoscere più sulla firma (prototipo) della funzione chiamata piuttosto che "ci vogliono gli argomenti N" per poter eseguire correttamente il marshalling degli argomenti da un wrapper di tipo "anycall" come sopra. In modalità 64 bit, per ogni funzione che desideri chiamare tramite il tuo wrapper, devi sapere non solo quanti argomenti ci sono in totale, ma anche quanti sono in reg generici, quanti nei registri XMM e come molti in pila.

Il comando "chiama una funzione tramite un puntatore e copia il valore di ritorno in una posizione nota" è portatile e può essere espresso in semplice C/C++. Ma la parte che ottiene i argomenti per questo, come sopra, non non porta in alcun modo diretto tra i 32bit stdcall e qualsiasi convenzione a 64 bit x86 chiamando che conosco (né Win64/x64 né l'ONU * X x86_64 convenzioni consentono per predire sia le posizioni che l'utilizzo totale della memoria dello stack di tutti gli argomenti per una funzione dato solo il numero e il tipo degli argomenti ma non il loro ordine).

Che cosa esattamente dovete fare dipende molto di più sui chiamanti/utenti di cui sopra class ExternalFunctionCall che sul piccolo piccolo campione di assembly inline hai mostrato. È particolarmente necessario sapere come vengono inizializzati i membri m_argsBegin e m_argsEnd e dove. Puoi fornire qualche dettaglio in più su come si presenta la classe (tutte le variabili/funzioni membro), nonché esempi sul suo uso effettivo?

Answer 3

Mi rendo conto che questa è una domanda un po 'vecchia, ma mi sono imbattuto in: xbyak.

Forse quello che stai cercando?