Verständnisproblem C und inline Assembler

[Fer T. (fer_t)]

Ich habe ein paar einfach Funktionen die die Fakultät einer Zahl 
berechnen und wollte spaßeshalber mal es mit inline Assembler probieren.
Ich bekomme aber immer komisch Fehler Meldungen.
Daher hab ich mal was auskommentiert und schwupps geht es???
Kann mir jemand verraten was die "Magie" dahinter ist?

MfG

Im Anhang die der gesamte Quellcode, der gibt Compiler-Warnungen (gcc 
-std=gnu99).
Der Ausschnitt der nicht geht:

int fakultaet_pro(int a){
  int i;
  asm(
      "mov cx, %1\n\t"
      "mov ax, 1\n\t"
      "mov bx, 1\n\t"
      "wh: mul bx\n\t"
      "inc bx\n\t"
      "loop wh\n\t"
      "mov ah, 4Ch\n\t"
      "int 21h\n\t"
      "mov %0, ax"
      : "+r" (i)
      : "g" (a));
  return i;
}

Und hier die Änderung, die das richtige Ergebnis ausspuckt:

int fakultaet_pro(int a){
  int i;
  asm(
      "nop"
      /*"mov cx, %1\n\t"
      "mov ax, 1\n\t"
      "mov bx, 1\n\t"
      "wh: mul bx\n\t"
      "inc bx\n\t"
      "loop wh\n\t"
      "mov ah, 4Ch\n\t"
      "int 21h\n\t"
      "mov %0, ax"*/
      : "+r" (i)
      : "g" (a));
  return i;
}

[Rolf Magnus (Gast)]

Ruf mal in deinem Programm fakultaet_pro() als erstes auf, vor den 
anderen Varianten. Tut's dann immer noch?

[Johann L. (gjlayde)]

Wenn ich's recht sehe, dann veränderst du

- ax
- bx
- cx
- ah

ohne dem COmpiler mitzuteilen, das sich da was ändert --> ja nach 
Aufrufsituation zeschießt das andere Werte.

Label "wh" ist schlecht, da bei Mehrfachverwendung (Inlining, 
Loop-Unroll, ...) das zu einem Fehler des Assembler führt --> Entweder 
lokale label wie 0, 1, 2, ... oder sowas wie .L_loop_%=

[Fer T. (fer_t)]

Eigentlich war es ja nur aus Spaß aber mittlerweile will ich es endlich 
mal hinbekommen:

So sieht es jetzt bei mir aus:

int fakultaet_pro(int a){
  int i = 1;
  asm(
      "mov %%eax, %0\n\t"
      "mov %%bx, %1\n\t"
      "0: mul %%bx\n\t"
      "dec %%bx\n\t"
      "cmp %%bx,0\n\t"
      "ja 0\n\t"
      "mov %0, %%eax"
      : "+r" (i)
      : "g" (a)
      : "%eax", "%bx");
  return i;
}

Kompilieren tut es, aber es gibt immer Speicherzugriffsfehler...
Jemand einen Plan?
Danke :)

[Daniel A. (daniel-a)]

Fer T. schrieb:
> Jemand einen Plan?

Nein, aber inline-assembler gefällt mir nicht, zu kompilerabhängig. Ich 
würde c und assembler trennen, mit gcc aus c code .o files machen, mit 
nasm aus asm code .o files machen, und dann alles zusammenlinken.

[Decius (Gast)]

Damit dein C-Code nach dem Aufruf fakultaet_pro() korrekt abgearbeitet 
wird. Solltest du die im ASM-Code benutzten Register am Anfang der 
ASM-Anweisung auf den Stack mit PUSH sichern und am Ende mit POP 
wiederherstellen.

Ansonsten zerschiesst du Daten in den Registern die der C-Code eventuell 
noch braucht.

[Rolf Magnus (Gast)]

Decius schrieb:
> Damit dein C-Code nach dem Aufruf fakultaet_pro() korrekt abgearbeitet
> wird. Solltest du die im ASM-Code benutzten Register am Anfang der
> ASM-Anweisung auf den Stack mit PUSH sichern und am Ende mit POP
> wiederherstellen.

Aber dafür stehen die doch in der Clobber-Liste.
http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html#ss5.3