Wie kann ich das multiplizieren von zwei 64-bit-zahlen mit x86 Assembler?

Wie würde ich mich über...

Multiplikation von zwei 64-bit-zahlen
Multiplikation von zwei 16-stelligen hexadezimal-zahlen

...mit Assembler.

Ich bin mir nur erlaubt die Verwendung von Registern %eax, %ebx, %ecx, %edx, und der stack.

EDIT: Oh, ich bin mit der ATT-Syntax auf die x86

EDIT2: Nicht erlaubt, zu dekompilieren, in der Montage -...

Möchten Sie möglicherweise angeben, welche Montage Sie verwenden. Allgemeine Techniken sind cross-anwendbar ist (in der Regel), aber die mnemonics sind fast immer zwischen verschiedenen Plattformen. 🙂
Oh, ATT Syntax für die x86? Ich bin leider nicht hinzufügen, dass die info... Sieht für die Schaltfläche "Bearbeiten" auf Titel

InformationsquelleAutor Kawarazu | 2008-09-17

assembly x86

12

Verwenden, was sollte wohl werden, Ihren Kurs lehrbuch, Randall Hyde ' s "The Art of Assembly Language".

Sehen 4.2.4 - Extended-Precision-Multiplikation

Obwohl ein 8x8, 16x16 oder 32x32 multiply ist in der Regel ausreichend, es gibt Zeiten, wenn Sie wollen multiplizieren Sie größere Werte zusammen. Verwenden Sie die x86-Operanden MUL und IMUL Anweisungen für das extended-precision-Multiplikation ..

Wahrscheinlich die wichtigste Sache zu erinnern wenn Sie ein extended-precision-Multiplikation ist, dass müssen Sie auch durchführen, mehrere Präzision Ergänzung zur gleichen Zeit. Das hinzufügen von bis alle partiellen Produkte erfordert mehrere Ergänzungen, die produzieren das Ergebnis. Das folgende listing zeigt den richtigen Weg auf multiplizieren Sie zwei 64-bit-Werten auf einem 32-bit-Prozessor ..

(Siehe den link für die vollständige Liste der assembly und Illustrationen.)

InformationsquelleAutor Michael Burr

Wenn dies 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

die Frage ist, x86, nicht x86-64 und das ist offensichtlich zu leicht, da nichts besonderes getan werden muss

InformationsquelleAutor DopeDo

2

Da bist du auf x86-Sie benötigen 4 mull Anweisungen. Teilen Sie die 64-bit-Mengen, die in zwei 32bit Worte und multiplizieren Sie die niedrigen Worte zu den niedrigsten und den 2 niedrigsten word mit dem Ergebnis, dann beide Paare von low-und high-word aus verschiedenen Nummern (Sie gehen auf das 2. und 3. niedrigste Wort des Ergebnisses) und schließlich sowohl hohe Worte in den 2 höchsten Worten über das Ergebnis. Hinzufügen Sie alle zusammen, nicht zu vergessen, befassen sich mit tragen. Sie nicht geben Sie das Speicher-layout der ein-und Ausgänge, so ist es unmöglich zu schreiben Beispielcode.
- Ich denke, die hohe*hohe Teil nicht benötigte, wie es läuft, egal was
InformationsquelleAutor jjrv
2

Dieser code setzt Voraus, Sie wollen x86 (nicht x64-code), dass Sie wahrscheinlich nur eine 64-bit-Produkt, und Sie kümmern sich nicht um überlauf oder vorzeichenbehaftete zahlen. (Eine signierte version ähnlich ist).
```
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
```
Diesem nicht Ehre, die genauen register Einschränkungen der OP, aber das Ergebnis passt durchaus in das Register angeboten, die durch die x86-Architektur. (Dieser code ist ungetestet, aber ich denke, es ist richtig).

[Anmerkung: ich übertragen (meine) diese Antwort aus einer anderen Frage, die habe geschlossen, weil KEINER von den anderen "Antworten", hier direkt die Frage beantwortet].
- Griff carry-out aus der low-Hälfte add müssten Sie adc.
- Sind Sie sicher? Das "tragen" von der unteren 32 bits 32 bits in edx auf den "add ebx edx" - Anweisung.
- Ach richtig, wir sind nur 64x64 => 64 bit, und die niedrigen 32 bit des Ergebnisses ist vollständig bestimmt durch die niedrige Hälfte eines lo1 * lo2 => 64 bit, ohne Zusatz tragen kann in der oberen Hälfte Ergebnis lo1 * hi2 => 32 bit und lo2 * hi1 => 32 bits. So die letzten 2 könnte getan werden, mit 2-Operanden imul ecx, esi / imul edi, ebx statt xchg und mul, denn Sie will nur eine 64-bit-Ergebnis, und nicht 96 oder 128.
InformationsquelleAutor Ira Baxter
0

Es hängt davon ab, welche Sprache Sie verwenden. Von was ich mich erinnere, lernen MIPS assembly, es ist eine Bewegung Von Hoch-Befehl und ein Umzug Von Lo-Befehl, oder mflo und mfhi. mfhi speichert die top-64bits während mflo speichert die unteren 64 bit der Gesamtzahl.
- Der OP sagte, es ist für x86, nicht für MIPS
InformationsquelleAutor Dave
0

ah-Versammlung, schon eine Weile her, ich habe es verwendet. also ich gehe davon aus, dass das eigentliche problem hier ist, dass der mikrocontroller (was ich zu dem schreiben von code in Assembler sowieso) Sie arbeiten nicht in 64 bit-Register? wenn das der Fall ist, sind Sie gehen zu müssen, die brechen die zahlen mit dem Sie arbeiten, auseinander und führen Sie mehrere Multiplikationen mit den Stücken.

das klingt wie es ist eine Hausaufgabe aus dem Weg, du hast formuliert, so dass ich werde nicht buchstabieren Sie es aus, viel weiter 😛

InformationsquelleAutor
0

Nur normale lange Multiplikation, wie wenn du die Multiplikation von zwei 2-stelligen zahlen, außer jede "Ziffer" ist wirklich eine 32-bit-Ganzzahl. Wenn Sie die Multiplikation von zwei zahlen in die Adressen X und Y, und speichern das Ergebnis in Z, dann, was Sie tun wollen (in pseudocode) ist:
```
Z[0..3] = X[0..3] * Y[0..3] 
Z[4..7] = X[0..3] * Y[4..7] + X[4..7] * Y[0..3]
```
Beachten Sie, dass wir verwerfen die oberen 64 bits des Ergebnisses (da ein 64-bit-Zahl mal eine 64-bit-Nummer ist mit einer 128-bit-Zahl). Beachten Sie auch, dass dies wird vorausgesetzt, little-endian. Auch, vorsichtig sein, über ein signiertes oder ein unsigniertes multiplizieren.
- Fehlt die high-bits aus dem ersten Teil
- Warten Sie, Sie haben verwirrt mich-- Sie haben gesagt, nach vorne zu gehen und loszuwerden, die oberen 64 bits des Ergebnisses? Warum wäre das... naja, rational...?
InformationsquelleAutor Adam Rosenfield
0

Finden Sie einen C-compiler, unterstützt 64-bit (GCC hat IIRC) kompilieren Sie ein Programm, das genau das tut, dann Holen Sie sich die Demontage. GCC spucken kann er sich auf seine eigene, und Sie können es out-of-object-Datei mit den richtigen tools.

OTOH ist eine 32bX32b = 64b-op auf x86
```
a:b * c:d = e:f
//goes to
e:f = b*d;
x:y = a*d;  e += x;
x:y = b*c;  e += x;
```
alles andere überläuft

(ungetestet)

Bearbeiten Unsigned nur

InformationsquelleAutor BCS
-1

Ich Wette, du bist ein student, so sehen Sie, ob Sie diese Arbeit machen: Tun Sie es Wort für Wort, und verwenden Sie bit-Verschiebungen. Denke, die effizienteste Lösung. Hüten Sie sich vor der das Vorzeichen-bit.
- Am Ende, bit-Verschiebungen wird nicht effizienter sein, als die Vermehrung-Anleitung - zumindest nicht auf der x86 und nicht mit 32-bit-Werte. Um die Grundlagen zu lernen, was der Prozessor muss zum durchführen einer Multiplikation, es ist eine gute übung, aber.
InformationsquelleAutor Kevin Conner

-3

Wenn Sie möchten, 128-Modus versuchen, diese...

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

Warum würden Sie benötigen die Eingänge und Ausgänge im Speicher, anstatt nur lassen gcc-laden Sie Sie, wenn nötig? Sie würden sich besser von asm nur mit __uint128_t und Vermietung gcc zu tun. Auch dies ziemlich genau kopiert Ira Baxter ' s Antwort. Wenn es war gute inline-asm, könnte es eine sinnvolle Ergänzung sein, ist es aber nicht. Mit einer Menge von festen Registern, ohne memory-Operanden ist bei weitem nicht optimal. Sollten Sie nur lassen Sie gcc alles im Griff, außer die 64x64 -> 128 mul Anweisungen, mit zwei getrennten asm Aussagen mit 2 Eingänge und 2 Ausgänge. Und das sollte nicht sein volatile
Denn ich bin die Anbindung von C in Assembler und ich nicht den source-code für die libs GCC verwenden und ich weiß nicht verwenden möchten, Vertreibungen, denn das würde die Schraube die Antwort, die ich suchte, und ich wollte auch zu beschleunigen, ist ein Stück code, das wirft n^p mod n, "OK".
Sie sollten mit code wie asm ("mulq %[src]" : "=a"(lo64_result), "=d"(hi64_result) : "a"(KEY.SPLIT.LWORDS[1]), [src] "rm" (KEY.SPLIT.LWORDS[0])); Und dann eine zweite ähnliche asm-Anweisung für die zweite multiplizieren. gcc wird alles tun, den mov Anweisungen. Sie einfach sagen, es, wo die Dinge sein müssen, und wo die Ergebnisse angezeigt werden. Quelle für die gcc-Bibliothek code hat nichts damit zu tun, und weder memory-Verschiebungen. Siehe die x86 - Tags, wiki-links zu schreiben wie man inline-asm, das ist nicht so schlimm. Das kompiliert: goo.gl/izSfMi
Ich habe tatsächlich extrahiert, das von Borland Turbo C++ also ich bin nicht mit kopieren debug86.exe

InformationsquelleAutor user80998

-3

Wenn Sie möchten, dass die 128-bit-Multiplikation, dann sollte diese Arbeit ist dies in AT&T-format.

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

Dies ist ein repost des gleichen Benutzers ineffizient und schwerfällig Antwort auf diese Frage. Siehe meine Kommentare dort. Tun Sie das nicht. Bearbeiten Sie Ihre ersten, wenn Sie haben änderungen.

InformationsquelleAutor user80998

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.