x86 असेंबली भाषा का उपयोग करके मैं दो 64-बिट संख्याओं को कैसे गुणा कर सकता हूं?

Question

मैं के बारे में कैसे जाना होगा ...

• दो 64-बिट संख्या

• गुणा दो 16 अंकों हेक्साडेसिमल संख्याओं

... का उपयोग कर विधानसभा भाषा गुणा।

मुझे केवल रजिस्ट्रार% eax,% ebx,% ecx,% edx, और स्टैक का उपयोग करने की अनुमति है।

संपादित करें: ओह, मैं ATT सिंटेक्स उपयोग कर रहा हूँ 86
EDIT2 पर: विधानसभा में डिकंपाइल करने के लिए अनुमति नहीं ...

Answer 1

संभवतः अपनी पाठ्यक्रम पाठ्यपुस्तक, रैंडल हाइड की "असेंबली भाषा की कला" का उपयोग करना चाहिए।

4.2.4 - Extended Precision Multiplication

हालांकि एक 8x8, 16x16, 32x32 या गुणा आमतौर पर पर्याप्त है देखें, बार जब आप बड़े मान एक साथ गुणा कर सकते हैं कर रहे हैं। आप .. बढ़ाया परिशुद्धता गुणन के लिए 86 एकल संकार्य एमयूएल और IMUL निर्देश का उपयोग करेगा

शायद याद करने के लिए सबसे महत्वपूर्ण बात यह है जब प्रदर्शन कर एक विस्तारित परिशुद्धता गुणा है कि आप भी एक ही समय पर एक से अधिक परिशुद्धता इसके अलावा प्रदर्शन करना है । सभी आंशिक उत्पादों को जोड़ने के लिए कई जोड़ों की आवश्यकता होती है जो परिणाम उत्पन्न करेंगे। निम्नलिखित सूची एक 32 बिट प्रोसेसर पर दो 64 बिट मूल्यों गुणा करने के लिए उचित तरीके से ..

(पूर्ण विधानसभा सूची और चित्रों के लिए लिंक देखें।)

Answer 2

आप क्या विधानसभा आप उपयोग कर रहे निर्दिष्ट करने के लिए कर सकते हैं। सामान्य तकनीकें पार-लागू होती हैं (आमतौर पर), लेकिन प्लेटफार्मों के बीच निमोनिक्स लगभग हमेशा अलग होते हैं। :-)

Answer 3

यह निर्भर करता है कि आप किस भाषा का उपयोग कर रहे हैं। एमआईपीएस असेंबली सीखने से मुझे जो याद है, उससे हाई कमांड से एक मूव और लो कमांड, या एमएफएलओ और एमएफआई से एक मूव है। एमएफआई शीर्ष 64 बिट्स स्टोर करता है जबकि एमएफएलओ कुल संख्या के 64 बिट्स को स्टोर करता है।

Answer 4

आह विधानसभा को दर्शाता है, थोड़ा समय हो गया जब से i ' मैंने इसका इस्तेमाल किया इसलिए मुझे लगता है कि असली समस्या यह है कि माइक्रोकंट्रोलर (जो भी मैं असेंबली में कोड लिखता था) आप काम कर रहे हैं 64 बिट रजिस्ट्रार नहीं है? यदि ऐसा है, तो आप उन संख्याओं को तोड़ने जा रहे हैं जिनके साथ आप अलग-अलग काम कर रहे हैं और टुकड़ों के साथ कई गुणा प्रदर्शन करते हैं।

इस लगता है जिस तरह से आप यह शब्दों में किया है से एक होमवर्क असाइनमेंट है जैसे, तो मैं यह बहुत आगे नहीं जादू बाहर जा रहा हूँ: पी

Answer 5

जब से तुम 86 पर हैं तो आप 4 मुल निर्देश की जरूरत है। 64 बिट मात्राओं को दो 32 बिट शब्दों में विभाजित करें और निम्न शब्दों को निम्नतम और परिणाम के दूसरे सबसे कम शब्द में गुणा करें, फिर विभिन्न संख्याओं से निम्न और उच्च शब्द दोनों जोड़े (वे परिणाम के दूसरे और तीसरे सबसे कम शब्द पर जाते हैं) और अंत में परिणाम के 2 उच्चतम शब्दों में उच्च शब्द दोनों। उन्हें सभी को एक साथ जोड़ना न भूलें। आपने इनपुट और आउटपुट के मेमोरी लेआउट को निर्दिष्ट नहीं किया है, इसलिए नमूना कोड लिखना असंभव है।

Answer 6

बस सामान्य लंबी गुणा करें, जैसे कि आप 2 अंकों की संख्या की एक जोड़ी गुणा कर रहे थे, सिवाय इसके कि प्रत्येक "अंक" वास्तव में 32-बिट पूर्णांक है। आप पते एक्स और वाई में दो नंबर गुणा और जेड में परिणाम भंडारण कर रहे हैं तो क्या आप (स्यूडोकोड में) क्या करना चाहते है:

Z[0..3] = X[0..3] * Y[0..3] 
Z[4..7] = X[0..3] * Y[4..7] + X[4..7] * Y[0..3]

ध्यान दें कि हम के ऊपरी 64 बिट्स को त्यागकर रहे हैं नतीजा (64-बिट संख्या 64-बिट संख्या 128-बिट संख्या के बाद से)। यह भी ध्यान रखें कि यह थोड़ा-अंतराल मान रहा है। साथ ही, एक हस्ताक्षरित गुणा के हस्ताक्षर किए गए हस्ताक्षर के बारे में सावधान रहें।

Answer 7

एक सी संकलक ढूंढें जो 64 बिट (जीसीसी आईआईआरसी करता है) का समर्थन करता है जो एक प्रोग्राम को संकलित करता है जो बस करता है, फिर डिस्सेप्लर प्राप्त करें। जीसीसी इसे अपने आप थूक सकता है और आप इसे सही टूल के साथ ऑब्जेक्ट फ़ाइल से बाहर निकाल सकते हैं।

OTOH उनके एक 32bX32b = 64b 86 पर सेशन

a:b * c:d = e:f 
// goes to 
e:f = b*d; 
x:y = a*d; e += x; 
x:y = b*c; e += x; 

सब कुछ किसी और overflows

(untested)

संपादित अहस्ताक्षरित केवल

Answer 8

मैं तुम्हें दांव लगा रहा हूँ 'है एक छात्र फिर से देखें, तो देखें कि क्या आप यह काम कर सकते हैं: इसे शब्द से शब्द करें, और बिट बदलावों का उपयोग करें। सबसे कुशल समाधान सोचो। साइन बिट से सावधान रहें।

Answer 9

यदि यह 64x86 था,

function(x, y, *lower, *higher) 
movq %rx,%rax  #Store x into %rax 
mulq %y   #multiplies %y to %rax 
#mulq stores high and low values into rax and rdx. 
movq %rax,(%r8) #Move low into &lower 
movq %rdx,(%r9) #Move high answer into &higher 

Answer 10

इस कोड को समझती है कि आप 86 चाहते हैं (नहीं 64 कोड), कि आप शायद ही एक 64 बिट उत्पाद चाहते हैं, और आप अतिप्रवाह या हस्ताक्षर किए संख्या के बारे में परवाह नहीं है कि । (एक हस्ताक्षरित संस्करण समान है)।

MUL64_MEMORY: 
    mov edi, val1high 
    mov esi, val1low 
    mov ecx, val2high 
    mov ebx, val2low 
MUL64_EDIESI_ECXEBX: 
    mov eax, edi 
    mul ebx 
    xch eax, ebx ; partial product top 32 bits 
    mul esi 
    xch esi, eax ; partial product lower 32 bits 
    add ebx, edx 
    mul ecx 
    add ebx, eax ; final upper 32 bits 
; answer here in EBX:ESI 

इस ओपी की सटीक रजिस्टर बाधाओं का सम्मान नहीं करता है, लेकिन परिणाम 86 द्वारा की पेशकश की रजिस्टरों में पूरी तरह से फिट बैठता है। (यह कोड अवांछित है, लेकिन मुझे लगता है कि यह सही है)।

[नोट: मैंने इस उत्तर को दूसरे प्रश्न से स्थानांतरित कर दिया है, क्योंकि बंद हो गया है, क्योंकि अन्य "उत्तरों" में से कोई भी सीधे प्रश्न का उत्तर नहीं देता है]।

Answer 11

आप 128 मोड इस कोशिश चाहते हैं ...

__uint128_t AES::XMULTX(__uint128_t TA,__uint128_t TB) 
{ 
    union 
    { 
     __uint128_t WHOLE; 
     struct 
     { 
      unsigned long long int LWORDS[2]; 
     } SPLIT; 
    } KEY; 
    register unsigned long long int __XRBX,__XRCX,__XRSI,__XRDI; 
    __uint128_t RESULT; 

    KEY.WHOLE=TA; 
    __XRSI=KEY.SPLIT.LWORDS[0]; 
    __XRDI=KEY.SPLIT.LWORDS[1]; 
    KEY.WHOLE=TB; 
    __XRBX=KEY.SPLIT.LWORDS[0]; 
    __XRCX=KEY.SPLIT.LWORDS[1]; 
    __asm__ __volatile__(
       "movq   %0,    %%rsi   \n\t"  
       "movq   %1,    %%rdi   \n\t" 
       "movq   %2,    %%rbx   \n\t" 
       "movq   %3,    %%rcx   \n\t" 
       "movq   %%rdi,   %%rax   \n\t" 
       "mulq   %%rbx       \n\t" 
       "xchgq   %%rbx,   %%rax   \n\t" 
       "mulq   %%rsi       \n\t" 
       "xchgq   %%rax,   %%rsi   \n\t" 
       "addq   %%rdx,   %%rbx   \n\t" 
       "mulq   %%rcx       \n\t" 
       "addq   %%rax,   %%rbx   \n\t" 
       "movq   %%rsi,   %0    \n\t" 
       "movq   %%rbx,   %1    \n\t" 
       : "=m" (__XRSI), "=m" (__XRBX) 
       : "m" (__XRSI), "m" (__XRDI), "m" (__XRBX), "m" (__XRCX) 
       : "rax","rbx","rcx","rdx","rsi","rdi" 
       ); 
    KEY.SPLIT.LWORDS[0]=__XRSI; 
    KEY.SPLIT.LWORDS[1]=__XRBX; 
    RESULT=KEY.WHOLE; 
    return RESULT; 
} 

Answer 12

आप 128 बिट गुणा चाहते हैं तो इस काम करना चाहिए इस पर & टी प्रारूप में है।

__uint128_t FASTMUL128(const __uint128_t TA,const __uint128_t TB) 
{ 
    union 
    { 
     __uint128_t WHOLE; 
     struct 
     { 
      unsigned long long int LWORDS[2]; 
     } SPLIT; 
    } KEY; 
    register unsigned long long int __RAX,__RDX,__RSI,__RDI; 
    __uint128_t RESULT; 

KEY.WHOLE=TA; 
__RAX=KEY.SPLIT.LWORDS[0]; 
__RDX=KEY.SPLIT.LWORDS[1]; 
KEY.WHOLE=TB; 
__RSI=KEY.SPLIT.LWORDS[0]; 
__RDI=KEY.SPLIT.LWORDS[1]; 
__asm__ __volatile__(
    "movq   %0,        %%rax     \n\t" 
    "movq   %1,        %%rdx     \n\t" 
    "movq   %2,        %%rsi     \n\t" 
    "movq   %3,        %%rdi     \n\t" 
    "movq   %%rsi,       %%rbx     \n\t" 
    "movq   %%rdi,       %%rcx     \n\t" 
    "movq   %%rax,       %%rsi     \n\t" 
    "movq   %%rdx,       %%rdi     \n\t" 
    "xorq   %%rax,       %%rax     \n\t" 
    "xorq   %%rdx,       %%rdx     \n\t" 
    "movq   %%rdi,       %%rax     \n\t" 
    "mulq   %%rbx             \n\t" 
    "xchgq   %%rbx,       %%rax     \n\t" 
    "mulq   %%rsi             \n\t" 
    "xchgq   %%rax,       %%rsi     \n\t" 
    "addq   %%rdx,       %%rbx     \n\t" 
    "mulq   %%rcx             \n\t" 
    "addq   %%rax,       %%rbx     \n\t" 
    "movq   %%rsi,       %%rax     \n\t" 
    "movq   %%rbx,       %%rdx     \n\t" 
    "movq   %%rax,       %0      \n\t" 
    "movq   %%rdx,       %1      \n\t" 
    "movq   %%rsi,       %2      \n\t" 
    "movq   %%rdi,       %3      \n\t" 
    : "=m"(__RAX),"=m"(__RDX),"=m"(__RSI),"=m"(__RDI) 
    : "m"(__RAX), "m"(__RDX), "m"(__RSI), "m"(__RDI) 
    : "rax","rbx","ecx","rdx","rsi","rdi" 
); 
KEY.SPLIT.LWORDS[0]=__RAX; 
KEY.SPLIT.LWORDS[1]=__RDX; 
RESULT=KEY.WHOLE; 
return RESULT; 
}