4. Was tut dieser Assembly Code? (Anfängerfrage)

Was tut dieser Assembly Code? (Anfängerfrage)


  • Also ich weiss nicht, x86 ist für mich nach 68k so ziemlich der einfachste Assembler.

    0
  • ?

    Ich fand es damals ziemlich krass, von den 16 Registern auf die wenige vom x86 umzuschwenken. Das war aber alles noch zu 486 Zeiten und mit Code Segment etc. Ich habe das auch nur zwei Wochen probiert und nicht mehr wie so ein Echtzeit Apfelmännchen mit gemacht, dann hatte ich keine Lust mehr auf x86. Bzw dann kam eine kurze Zeit TurboPascal mit Assemblerstücken und irgendwann mal kurz der portable Assembler C. Alles aber nie so intensiv wie damals auf dem Amiga.

    Für mein jetziges Projekt werde ich später auch versuchen einige Teile selbst in Assembler zu optimieren, einfach um mal real zu erleben wer besser ist. Ich oder der Compiler, aber wahrscheinlich wird der Compiler gewinnen.

    0
  • E
    Gesperrt

    Ok, hier nu mein Versuch, zumindest getx umzuschreiben:

    	.globl	getx
	.type	getx, @function
getx:
.LFB0:
	push		%ecx
	push		%edx
# main.c:7: 	float w2 = w * (M_PI / 180.0);
# main.c:8: 	x = (int) (r * cos(w2));
# main.c:9: 	return x;
	divss		%ecx, $0x4048f5c3, $0x43340000
	mulss		%edx, %ecx, %ebx
	movs		%edx, %xmm0
	call		cos@PLT
	movs		%xmm0, %edx
	mulss		%eax, %eax, %edx
	cvttss2si	%eax, %eax
	leave
	ret

    Und gleich auch 1000 Fehlermeldungen bezüglich der 32-bit Register:

    main.c: Assembler messages:
main.c:42: Error: operand type mismatch for `push'
main.c:43: Error: operand type mismatch for `push'
main.c:47: Error: number of operands mismatch for `divss'
main.c:48: Error: number of operands mismatch for `mulss'
main.c:49: Error: operand type mismatch for `movs'
main.c:51: Error: operand type mismatch for `movs'
main.c:52: Error: number of operands mismatch for `mulss'
main.c:53: Error: operand type mismatch for `cvttss2si'

    push gibt es anscheinend für 32-bit nicht und divss und mulss nehmen keine 3 Operanden bei 64-bit. Blöd alles.

    0

  • Du musst sowieso das ganze 64 Bit Register pushen, da im 64 Bit Mode die 32 Bit Befehle die oberen 32 Bit des Ziel-Registers auf 0 setzen. Daher macht push %eax im 64 Bit Mode wenig bis gar keinen Sinn.

    Oder anders gesagt: push einfach das ganze Register.

    0
  • E
    Gesperrt

    Ok, also alles für den 64 Bit Mode umschreiben.

    0
  • ?

    Mal ne Frage am Rande: Muss man diese Prozentzeichen nutzen? Hier in einem Beispiel für InlineAssembler unter VisualStudio sieht das schon sehr viel lesbarer aus.

    // Power2_inline_asm.c
// compile with: /EHsc
// processor: x86

#include <stdio.h>

int power2( int num, int power );

int main( void )
{
    printf_s( "3 times 2 to the power of 5 is %d\n", \
              power2( 3, 5) );
}
int power2( int num, int power )
{
   __asm
   {
      mov eax, num    ; Get first argument
      mov ecx, power  ; Get second argument
      shl eax, cl     ; EAX = EAX * ( 2 to the power of CL )
   }
   // Return with result in EAX
}

    Quelle:Link Text

    0
    W
     1 Antwort
  • W

    @chris4cpp sagte in Was tut dieser Assembly Code? (Anfängerfrage):

    Mal ne Frage am Rande: Muss man diese Prozentzeichen nutzen?

    Lies meinen Text oben.

    Intel Syntax: ohne % für Register und ohne $ für Immediates und ohne Längenangabe, dabei bedeutet mov eax, 0 dasselbe wie eax = 0;
    AT&T Syntax: mit % und $. Derselbe Befehl ist movl $0, %eax - also auch noch mit verdrehten Operanden.

    Offensichtlich verwendest du in VS Intel Syntax.

    (PS: und ja, ich weiß, dass man xor nehmen würde, um ein Register auf 0 zu setzen)

    0
  • ?

    Danke noch mal, ja sorry nicht gelesen.

    PS: Na ich vermute mal, solche Kniffe wie mit xor brauch man heute nicht mehr. Und Speicher soll wohl auch ein ziemlicher Flaschenhals geworden sein, da dessen Geschwindigkeit nicht so schnell gewachsen ist wie bei den CPUs, also wird es heute wohl weniger LUTs geben als früher, wenn die Berechnung weniger kostet als ein Speicherzugriff. Aber in der Materie bin ich nicht mehr drin.

    0

  • Der Opcode für xor eax, eax ist kürzer als der für mov eax, 0, daher verwendet man es immer noch. Ich würde sogar sagen dass es so üblich ist, dass es den einen oder anderen geübten Assembler-Leser ein klein bisschen verwirren könnte mov eax, 0 zu lesen.

    BTW: xor eax, eax ist auch kürzer als xor rax, rax, weswegen man xor eax, eax auch findet wenn das ganze rax auf 0 gesetzt werden soll. Was sich wieder die Tatsache zu nutze macht dass bei 32 Bit Befehlen im 64 Bit Mode die oberen 32 Bit des Ziel-Registers auf 0 gesetzt werden.

    Und Speicher soll wohl auch ein ziemlicher Flaschenhals geworden sein, da dessen Geschwindigkeit nicht so schnell gewachsen ist wie bei den CPUs, also wird es heute wohl weniger LUTs geben als früher, wenn die Berechnung weniger kostet als ein Speicherzugriff.

    Was günstiger ist kommt auf viele Faktoren an. Wenn man viele Werte in Folge aus der LUT braucht, die LUT klein genug ist und die Befehle um den Wert direkt zu berechnen teuer genug, dann zahlt sich das schon noch aus. Für eine Multiplikation macht man es aber eher nicht mehr. Für eine Division meist auch nicht, aber für viele in Folge... vielleicht doch.

    0
  • E
    Gesperrt

    Hier kommt immer eine Gleitkomma-Ausnahme und ich weiß auch nicht, wieso ich rax nur relativ adressieren kann:

    	.text
	.globl	getx
	.type	getx, @function
getx:
.LFB0:
	push		%rax
	push		%rbx
	push		%rcx
	push		%rdx
#	mov			%r8, %rax
#	mov			%r9, %rbx
# main.c:7: 	float w2 = w * (M_PI / 180.0);
# main.c:8: 	x = (int) (r * cos(w2));
# main.c:9: 	return x;
	mov			$0x4048f5c3, %rax
	mov			$0x43340000, %rbx
	div			%rbx
	mul			%r8
	movsd		0(%rax), %xmm0
	call		cos@PLT
	movsd		%xmm0, 0(%rax)
	mul			%r9
	mov			0(%rax), %eax
#	pop			%rax
#	pop			%rbx
#	pop			%rcx
#	pop			%rdx
	leave
	ret

    Aufruf:

    # main.c:24: 		x = getx(25, i);
	mov		%rbp, %r8	# i, tmp87
	mov		$25, %r9	#,
	call	getx	#
	movl	%eax, -16(%rbp)	# tmp88, x
    0

  • Die Ausnahme kommt vermutlich gerade weil du rax "relativ addressierst" - das heisst ja du lädst den Wert für xmm0 aus dem Speicher, und zwar von der Adresse die in rax steht. Und da an der Adresse - wenig überraschend - nix gemappt ist, gibt's aua.

    Und warum es nicht "direkt" geht: rax ist ein 64 Bit Skalar-Register, xmm0 ist ein 128 Bit Vektorregister. Wie soll das also gehen? Angenommen es gibt einen Register<->Register mov Befehl der das kann (keinen Ahnung ob es den gibt), dann müsstest du zumindest irgendwo mit angeben was genau er jetzt mit den 64 Bit machen soll. Also wie er die 64 Bit aus rax auf xmm0 "aufteilen" soll.

    Bei "indirekt" dagegen nimmt der Compiler an dass xmm0 in seinem normalen Format (also 128 Bit) im Speicher liegt. Und das geht natürlich immer, dabei ist ja keine Konvertierung/Abbildung von Bits nötig.

    0
  • E
    Gesperrt

    Auch damit geht es nicht (gleiche Fehlermeldung)

    getx:
.LFB0:
	push		%rax
	push		%rbx
	push		%rcx
	push		%rdx
#	mov			%r8, %rax
#	mov			%r9, %rbx
# main.c:7: 	float w2 = w * (M_PI / 180.0);
# main.c:8: 	x = (int) (r * cos(w2));
# main.c:9: 	return x;
	mov			$0x4048f5c3, %rax
	mov			$0x43340000, %rbx
	div			%rbx
	mul			%r8
	movd		%rax, %xmm0
	call		cos@PLT
	movd		%xmm0, %rax
	mul			%r9
	movd		%rax, %xmm0
	cvttsd2si	%xmm0, %eax
#	pop			%rax
#	pop			%rbx
#	pop			%rcx
#	pop			%rdx
	leave
	ret
    0

  • Sorry, ich hab vollkommen übersehen dass da ja nicht mov sondern movd stand. Peinlich.

    Fangen wir mal so an: Was willst du denn überhaupt machen?

    Und: Ich mag mich jetzt täuschen, aber mir wäre nicht bekannt dass man bei AMD64 die "normalen" Register (rax, rbx, ..., r8 ... r15) für Floating-Point Berechnungen verwenden könnte.
    Und z.B.

    	mul			%r9

    ist ziemlich sicher ne 64 Bit Integer Multiplikation (rax = rax * r9). Da würde ich jetzt mittlere Geldbeträge drauf verwetten.

    Wenn du Float-Zeugs machen willst musst du die SSE* Register verwenden (oder den guten alten x87 Registerstack).

    0
  • E
    Gesperrt

    Also was ich machen möchte das steht in den Kommentaren in Zeile 9, 10 und 11.

    Sowas blödes... Dann hab ich die ganze Zeit die falschen Register verwendet!

    Aber nochmal ganz kurz umrissen, was ich machen möchte:
    Es werden zwei int Werte übergeben, sagen wir jetzt einfach mal i und j.
    Dann möchte ich einmal dividieren und zweimal multiplizieren (und einmal cos aufrufen):
    (cos((3.14 / 180.0) * i) * j)
    Das Ergebnis möchte ich dann wieder in einen int Wert konvertieren und nach %eax schieben.

    0
    D
    W
     2 Antworten
  • D

    @EinNutzer0 (3.14 / 180.0) ist ein Konstanter Wert, den du schon vorher ausrechnen kannst (spart die Division).

    0
  • E
    Gesperrt

    @DirkB : richtig, das wäre $0x3c8efa35. 🙂

    0
  • W

    @EinNutzer0 sagte in Was tut dieser Assembly Code? (Anfängerfrage):

    Dann möchte ich einmal dividieren und zweimal multiplizieren (und einmal cos aufrufen):
    (cos((3.14 / 180.0) * i) * j)

    Du willst aber eine floating-Point-Division durchführen! div mit rax ist aber Integer-Division. Floating point Division ist fdiv (wie im Pentium-Bug) (das wäre @hustbaer s "guter alter" Weg). Mit SSE kannst du z.B. mit cvtsi2sd xmm0, eax den Wert aus eax von int nach double konvertieren. Dann weiter mit divsd oder so.

    Schau dir doch einfach mal den gewünschten Code an im Compiler Explorer an. Nur für dich als Beispiel: https://godbolt.org/z/7cxXFW

    0

  • @EinNutzer0 ich weiß immer noch nicht was du mit x86-64 asm willst wenn du lernen sollst einen bestimmten (welchen?) µController zu programmieren. Geht nicht in mein Hirn.

    0
  • E
    Gesperrt

    @wob : super, ich weiß nur noch nicht, wie man selber zu solch einer Lösung gelangen kann.

    0
  • E
    Gesperrt

    @wob sagte in Was tut dieser Assembly Code? (Anfängerfrage):

    dann hast du doch bestimmt irgendwas bekommen haben, womit du lernen sollst?!

    Wir haben ein Skript. Das gute Stück umfasst 500 Folien und mehr... Aber das Problem: es ist zwar Assembler Code vorhanden, jedoch wird dieser in keinster Weise erklärt.

    0 1 Antwort
Anmelden zum Antworten