इनलाइन असेंबली कोड को C++

Question

पर कनवर्ट करें मैं एक सीपीपी प्रोजेक्ट पर काम कर रहा हूं। परियोजना को 64 बिट में माइग्रेट करने की आवश्यकता है। इसमें कुछ इनलाइन असेंबली कोड शामिल हैं जो x64 पर संकलित नहीं हो सकते हैं।

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; 
    } 

मैं इस "ASM धक्का वैल" विस्थापित करने के लिए ढेर, सारणी का प्रयोग किया है, लेकिन काम नहीं किया: इस समारोह जो विधानसभा कोड होता है। हालांकि, यह किसी संकलन त्रुटि को फेंक नहीं देता है लेकिन तर्क काम नहीं करता है।

तो, मैं पूछना चाहता हूं, मैं "__asm ​​पुश वैल" के बजाय सी ++ में क्या उपयोग कर सकता हूं। किसी भी तरह की सहायता को आभार समझेंगे।

Answer 1

ऐसी कई चीजें हैं जिन्हें आपको हल करने की आवश्यकता है। (मैंने आपके कोड को दूसरे प्रश्न पर देखा)। जैसा कि मैंने समझा है कि यह कोड निर्दिष्ट पते पर स्थित सुंदर अमूर्त फ़ंक्शन को कॉल करने के लिए एक रैपर है, जो स्टैक में कुछ मात्रा में डेटा की अपेक्षा करता है और ArgType में आधारित विभिन्न चीज़ों को वापस कर सकता है।

यदि आप इसे सादे सी के माध्यम से लपेटना चाहते हैं तो आपको अपने स्विच पर उपयोग करने के लिए कई फ़ंक्शन प्रोटोटाइप (वापसी मूल्य के आधार पर) को परिभाषित करना होगा, लेकिन फिर आपको एक और समस्या हल करना होगा, जो अधिक कठिन है।

सी में ऐसी चीजों को पोर्ट करने में समस्या यह है कि आपको स्टैक में धक्का देने के लिए पर्याप्त मात्रा में तर्क (डेटा आकार) नहीं पता है, इसलिए आपको प्रोटोटाइप को परिभाषित करने में परेशानी होगी।

मान लें कि func (char c) निश्चित रूप से स्टैक 1 बाइट (लेकिन डेटा संरेखण के कारण हमेशा सही नहीं) में धक्का देगा .. आपके मामले में आपको समाधान के बारे में सोचना होगा जो बराबर आकार वाले पैरामीटर सेट करेगा डेटा के आकार के लिए आपको ढेर पर होना चाहिए। जो पहली नज़र में कुछ नहीं है जो आप सीधे कर सकते हैं।

यूपीडी। आप इसे func (char [] param) के साथ कर सकते हैं; लेकिन इसमें ऐसे मुद्दे भी हैं जो ऊपर दिए गए उत्तर में समझाए गए थे।

Answer 2

समस्या सामान्य रूप से हल नहीं होती है; ऐसा इसलिए है क्योंकि टिप्पणी,

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

32 बिट बुला सम्मेलनों पर निर्भरता को इंगित करता है है।

32 बिट 86 में, stdcall, इसका मतलब है कि सभी तर्क ढेर पर पारित कर रहे हैं, उलटे क्रम में (यानी पिछले आर्ग पहले धकेल दिया जाता है। यही कारण है कि है, अगर arg[0]addr पर तो arg[1], कोई फर्क नहीं पड़ता यह प्रकार है है addr + sizeof(arg[0]) पर)। यही कारण है कि क्यों अपने नमूना में निम्न कोड:

// 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 
} 

वास्तव में काम कर सकते हैं - क्योंकि यह बस फर्क नहीं पड़ता वास्तव में क्या है, किस प्रकार का तर्क हैं; यह सब प्रासंगिक है कि उनमें से प्रत्येक एक ज्ञात स्मृति स्थान में है, और लगातार-लगातार-स्मृति में जाना जाता है। यदि आप जानते हैं कि Naddr पर है, तो आप N+1 पर addr + sizeof(arg[N]) पर तर्क कर सकते हैं।

है यही कारण है कि टिप्पणी कहते हैं, "यह पहले से ही बाहर सही ढंग से रखी है" - दुर्भाग्य से, यह 64 बिट मोड में सच नहीं है। इसलिए कोड "पोर्ट" नहीं किया जा सकता है; बंदरगाह के बराबर नहीं है।

कॉलिंग सम्मेलन जो कम से कम आंशिक रूप से पंजीकृत हैं - जैसा कि x64 (64 बिट x86) पर Win64 अलग-अलग व्यवहार करता है।उन लोगों के लिए, यह इस बात पर निर्भर करता है कि किस प्रकार के तर्क बुलाए गए कार्यों को लेते हैं (आप विंडोज़ में, सामान्य प्रयोजन रजिस्टरों में चार पूर्णांक-प्रकार के तर्कों को पास कर सकते हैं और कुछ फ्लोट-टाइप तर्क XMM रजिस्टरों में) कर सकते हैं। इसलिए आपको और को "फ़ंक्शन N तर्क" से हस्ताक्षर किए गए फ़ंक्शन के हस्ताक्षर (प्रोटोटाइप) के बारे में जानने की आवश्यकता है ताकि उपरोक्त की तरह "anycall" प्रकार रैपर से सही ढंग से मार्शल तर्कों को सक्षम किया जा सके। 64 बिट मोड में, प्रत्येक फ़ंक्शन के लिए आप अपने रैपर के माध्यम से कॉल करना चाहते हैं, आपको यह जानने की जरूरत है कि कुल में कितने तर्क हैं, लेकिन सामान्य प्रयोजन के नियमों में कितने भी हैं, XMM regs में कितने हैं, और कैसे ढेर पर कई।

"एक पॉइंटर के माध्यम से एक func कॉल करें और वापसी मूल्य को एक ज्ञात स्थान पर कॉपी करें" भाग पोर्टेबल है और इसे सादे सी/सी ++ में व्यक्त किया जा सकता है। लेकिन बात यह है कि, इस के लिए तर्क हो जाता है इसके बाद के संस्करण के अनुसार, 32 बिट stdcall और किसी भी 64 बिट x86 बुला सम्मेलन मैं की (न Win64/64 है और न ही संयुक्त राष्ट्र * एक्स x86_64 सम्मेलनों की अनुमति देने के पता के बीच किसी भी सरल तरीके से नहीं बंदरगाह करता है एक समारोह के लिए सभी तर्कों के सभी स्थानों और कुल ढेर स्मृति उपयोग दोनों की भविष्यवाणी करने के लिए केवल तर्कों की संख्या और प्रकार दिए गए हैं, लेकिन उनके आदेश नहीं)।

वास्तव में क्या आपको बस इतना करना ऊपर class ExternalFunctionCall इनलाइन विधानसभा के छोटे छोटे नमूना आप दिखाया है पर से की कॉल/उन पर बहुत अधिकनिर्भर करता है। यह जानना विशेष रूप से जरूरी है कि सदस्य m_argsBegin और m_argsEnd कैसे प्रारंभ किए गए हैं और कहां हैं। क्या आप इस बारे में कुछ और विवरण प्रदान कर सकते हैं कि वर्ग कैसा दिखता है (सभी सदस्य चर/कार्य), साथ ही इसके वास्तविक उपयोग के उदाहरण भी?

Answer 3

मुझे एहसास है कि यह कुछ हद तक पुराना सवाल है, लेकिन मैं बस इस पर ठोकर खाई: xbyak।

शायद आप क्या देख रहे हैं?