MUL(Assembler) in C

In Assembler kann ich auch mit dem MUL Befehl aus und erhalten Sie eine 64-bit-Ergebnis EAX:EDX,
wie kann ich das gleiche in C ? http://siyobik.info/index.php?module=x86&id=210

Mein Ansatz ein uint64_t und Schiebe das Ergebnis nicht arbeiten^^

Danke für Eure Hilfe (=

Mir

Bitte posten Sie den C-code, den Sie verwendet, und die Ergebnisse, die Sie erwartet hatten, und wir können von dort aus zu gehen...
Ich bin mir ziemlich sicher, dass dein problem ist, dass du versuchst zu werfen, um uint64_t nach Multiplikation anstatt vor. Besetzung eines der Argumente, bevor die Multiplikation.

InformationsquelleAutor binary | 2010-11-04

c multiplication

3

Jeder anständige compiler tun Sie es einfach, wenn Sie gefragt.

Z.B. mit VC++ 2010, den folgenden code:
```
unsigned long long result ;
unsigned long a = 0x12345678 ;
unsigned long b = 0x87654321 ;

result = (unsigned long long)a * b ;
```
generiert die folgende assembler:
```
mov         eax,dword ptr [b] 
mov         ecx,dword ptr [a] 
mul         eax,ecx 
mov         dword ptr [result],eax 
mov         dword ptr [a],edx 
```
- Warum ist deine Montage zu zerstören a nach der Vermehrung? Es erscheint die Speicherung der höhere Anteil des Ergebnisses in a. Ihre C-Quelle nicht irgend etwas tun, wie.
- Es ist nicht meine Baugruppe, es ist der compiler! Ich wunderte mich darüber, dass auch und als zu entfernen es von der post, war aber der code-der debugger verbunden mit dieser Zeile. Im Gegensatz zu @binären ich habe gelernt, dass es meist nicht Wert, sich Gedanken über das, was der compiler generiert, so lange, wie es richtig ist.
- Naja, das problem ist, dass auf den ersten Blick der code ist natürlich nicht richtig, aber ohne mehr Kontext ist es schwer zu sagen, ob dies ist ein weird-Optimierung. Ich meine, es könnte sein, dass der compiler beschlossen, überlappen sich die Speicher belegt durch a und durch result, was vielleicht OK ist a ist nie benutzt danach.
- Wahrscheinlicher ist, dass die Linie des Assemblers verbunden war mit dem, was folgte (das war die Rückkehr aus main()), aber die debug-Informationen hatte keine bestimmte Linie zu zuordnen. Aber ich glaube nicht, dass es besonders relevant; der Punkt steht, dass der compiler generiert code, der die mul-Anweisung. Soll ich einfach die Zeile entfernen und behaupten, dass ich noch nie gesehen!? Es scheint, um von der Hauptsache ablenken.
- Ich bin kein x86 assembler-Experte; das ist, was der compiler für. Ich biete keine Erklärung, und kümmern sich nicht genug um Sie kümmern.
InformationsquelleAutor Clifford
1

Post code. Dies funktioniert für mich:
```
#include <inttypes.h>
#include <stdio.h>

int main(void) {
  uint32_t x, y;
  uint64_t z;
  x = 0x10203040;
  y = 0x3000;
  z = (uint64_t)x * y;
  printf("%016" PRIX64 "\n", z);
  return 0;
}
```
- Ich habe es jetzt wie uint64_t a = b * c; a = a >> 32; 😉
- Meinst du diese nutzt die MUL Anleitung? Haben Sie überprüft?
- grep mul 4099867.s gibt ` imulq %rdx, %rax. Apparently my compiler doesn't use MUL` bei der Montage, dass der code ohne optimizimations. Mit voller Optimierungen, die grep gibt nichts zurück
- Es würde Sie nur mul wenn die Operanden und das Ergebnis waren nicht signiert.
- Um zu vermeiden, Kraft-Reduktion im test, besser Ihre Operanden von der Befehl Linie Argumente.
- Mit Register mit dem Namen %rdx, die Sie kompilieren in 64 bit.
- Ich bitte um Entschuldigung, ich habe falsch gelesen die Urheberschaft der Kommentar, und gar nicht bemerkt, dass es war in Bezug auf Ihr - code. Interessanterweise, wenn ich codiert es in VC++ mit vorzeichenbehafteten Typen, die er erzeugt ein imul, und mit unsignierten eine mul - daher mein Kommentar.
InformationsquelleAutor pmg
0

Sehen, wenn Sie den Gegenwert von __emul oder __emulu für den compiler(oder benutzen Sie dies einfach, wenn Sie haben eine MS-compiler). obwohl 64-bit-multiplizieren sollte automatisch funktionieren, es sei denn Ihr sitzt hinter bestimmten Einschränkungen oder andere lustige problem(wie _aulmul)
- Hmm, nun ist die Multiplikation nur gearbeitet, trotzdem danke an Euch beide =)
InformationsquelleAutor Necrolis
0

Du meinst multiplizieren zwei 32-bit-Mengen, erhalten Sie eine 64-bit-Ergebnis?

Dies ist nicht vorgesehen in C von selbst, entweder Sie haben tow 32 bit in wie uint32_t und dann ist das Ergebnis die gleiche Breite. Oder Sie werfen vor, um uint64_t aber dann verlieren Sie den Vorteil, dass spezielle (und schnell) zu vermehren.

Die einzige Möglichkeit die ich sehe ist die Verwendung von inline-assembler-Erweiterungen. gcc ist ziemlich gut in diesem können Sie produzieren ganz optimalen code. Aber das ist nicht portabel zwischen verschiedenen Versionen von Compilern. (Viele public-domain-Compiler verabschieden, gcc, obwohl, glaube ich)

InformationsquelleAutor Jens Gustedt
0

#include
```
/* The name says it all.  Multiply two 32 bit unsigned ints and get
 * one 64 bit unsigned int.
 */
uint64_t mul_U32xU32_u64(uint32_t a, uint32_t x) {
  return a * (uint64_t)b; /* Note about the cast below. */
}
```
Diese produziert:
```
mul_U32xU32_u64:
    movl    8(%esp), %eax
    mull    4(%esp)
    popl    %ebp
    ret
```
Beim kompilieren mit:
```
 gcc -m32 -O3 -fomit-frame-pointer -S mul.c
```
Verwendet mul Anweisung (genannt mull hier für multiplizieren lange, wie man den gnu assembler für x86-mag es) in der Weise, dass Sie wollen.

In diesem Fall wird einer der Parameter war, zog direkt aus dem Stapel, anstatt platziert in einem register (der 4(%esp) was bedeutet, dass 4 bytes oberhalb des stack-Zeigers, und die 4 bytes werden übersprungen, sind die Rückkehr-Adresse), weil die zahlen an die Funktion übergeben wurden und hätte auf dem Stapel abgelegt (wie pro die x86-ABI (application binary interface) ).

Wenn Sie inlined, die Funktion oder habe gerade die Mathe in der es in deinem code würde es höchstwahrscheinlich mit der mul Unterricht in vielen Fällen, wenn die Optimierung der Compiler ersetzen auch einige Multiplikationen mit einfacher code, wenn Sie sagen, dass es funktionieren würde (zum Beispiel könnte daraus eine Verschiebung oder gar eine Konstante, wenn die eine oder mehrere der Argumente bekannt waren).

In den C-code mindestens eines der Argumente mussten gegossen werden, um eine 64-bit-Wert, so dass der compiler erzeugen würde eine 64 bit-Ergebnis. Selbst wenn der compiler war die Verwendung der code, der produziert einen 64-bit-Ergebnis, wenn die Multiplikation von 32-bit-Werten, kann es nicht als die Obere Hälfte der es wichtig zu sein, weil nach den Regeln der C-Operationen führen meist zu einem Wert vom gleichen Typ wie der Wert mit der größten Auswahl aus seinen Komponenten (außer manchmal kann man argumentieren, dass ist nicht wirklich genau was Sie tut).

InformationsquelleAutor nategoose
0

Können Sie nicht tun, genau das auch in C, d.h. Sie können nicht multiplizieren von zwei N-bit-Werte, und der Erwerb eines 2N-bit-Wert als Ergebnis. Semantik von C Multiplikation unterscheidet sich von der Maschine eine Multiplikation. In C die Multiplikation operator bezieht sich immer auf die Werte des gleichen Typs T (so genannte üblichen arithmetischen Umwandlungen kümmern) und erzeugt das Ergebnis des gleichen Typs T.

Wenn du overflow bei Multiplikation, haben Sie einen größeren Typ der Operanden. Wenn es keine größere geben, sind Sie aus Glück (d.h., Sie haben keine andere Wahl, sondern auf library-Ebene die Umsetzung der großen Multiplikation).

Beispielsweise, wenn der größte integer-Typ Ihrer Plattform ist eine 64-bit-Typ, dann auf der assembly-Ebene auf Ihrem Computer haben Zugriff auf mul Betrieb produzieren die richtigen 128-bit-Ergebnis. Auf sprachlicher Ebene haben Sie keinen Zugriff auf eine solche Multiplikation.
- Trotz der downvote troll, die Antwort ist absolut korrekt.
- Ich denke mal, dass da zwar richtige, keine Erwähnung von der einfachen Lösung in der Umwandlung eines Operanden gemacht wurde. Sehr Fett für die Geltendmachung Ihrer eigenen Richtigkeit doch 😉 +1 zum Ausgleich der Ungerechtigkeit.
- Gut, in Ordnung zu kommen, die Lösung muss man zuerst das problem zu verstehen. Da es keine Beschreibung einer spezifischen situation die Frage, interpretierte ich die OP ' s problem sich buchstäblich eine Frage über "Erweiterung" Multiplikation in C (Nbit * Nbit -> 2Nbit). Und wie ich schon sagte in meiner Antwort, leider gibt es keine solche Multiplikation in C. Es gibt keine Lösung. In der C-Multiplikation ist immer Nbit * Nbit -> Nbit.
- Also, wenn Sie Sie brauchen, die 2N-bit-Ergebnis, die "Lösung" wäre zu wechseln 2Nbit * 2Nbit -> 2Nbit Vermehrung (wenn möglich), das ist das, was Sie vorgeschlagen. Aber das ist nicht das, was angefordert wurde, der nach meiner interpretation der Frage. Es gibt ein Beispiel in meiner Antwort, dass zeigt den Unterschied: in C hat man keinen Zutritt zu der Maschine 64-bit * 64-bit -> 128-bit Multiplikation ist die größte integer-Typ ist 64-bit. Maschine es tun kann. C kann es nicht. Genauer gesagt, die C bietet keine Möglichkeit für Sie, die Aufgabe die Maschine zu tun. Das ist mein Punkt.
- Nun können Sie die Frage beantworten, die gestellt wurde, oder die Frage, sollte gefragt worden 😉
InformationsquelleAutor AnT

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.