Was tut dieser Assembly Code? (Anfängerfrage)

DirkB

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

Ne, ich muss für eine Prüfung den (Inline) Assemblercode eines bestimmten Mikrocontrollers verstehen und anwenden können.

Warum lernst du nicht gleich für den Controller.
Es gibt einfachere Syntax als x64 Assembler.

EinNutzer0

Ok, Danke für alle Antworten bisher. Noch eine Frage... Wenn ich zum Beispiel diesen C Code habe:

#include <stdio.h>
#include <math.h>

int getx(int r, int w)
{
	int x;
	float w2 = w * (M_PI / 180.0);
	x = (int) (r * cos(w2));
	return x;
}

int gety(int r, int w)
{
	int x;
	float w2 = w * (M_PI / 180.0);
	x = (int) (r * sin(w2));
	return x;
}

void get_kreis(int to)
{
	int i = 0, x, y, x2, y2;
	while (i <= to) {
		x = getx(25, i);
		y = gety(25, i);
		if (x != x2 || y != y2) {
			printf("i=%03d x=%03d y=%03d\n", i, x, y);
		}
		x2 = x;
		y2 = y;
		i++;
	}
	printf("ready.\n");
}

int main ()
{
	get_kreis(720);
}

wie komme ich dann zu dem nächsten Schritt, dieses Programm manuell in Assembler zu schreiben?

Der Aufruf gcc -O0 -S -fverbose-asm -o main.S main.c -lm ergibt Folgendes:

	.file	"main.c"
# GNU C17 (Debian 8.3.0-6) version 8.3.0 (x86_64-linux-gnu)
#	compiled by GNU C version 8.3.0, GMP version 6.1.2, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.20-GMP

# GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
# options passed:  -imultiarch x86_64-linux-gnu main.c -mtune=generic
# -march=x86-64 -auxbase-strip main.S -O0 -fverbose-asm
# options enabled:  -fPIC -fPIE -faggressive-loop-optimizations
# -fasynchronous-unwind-tables -fauto-inc-dec -fchkp-check-incomplete-type
# -fchkp-check-read -fchkp-check-write -fchkp-instrument-calls
# -fchkp-narrow-bounds -fchkp-optimize -fchkp-store-bounds
# -fchkp-use-static-bounds -fchkp-use-static-const-bounds
# -fchkp-use-wrappers -fcommon -fdelete-null-pointer-checks
# -fdwarf2-cfi-asm -fearly-inlining -feliminate-unused-debug-types
# -ffp-int-builtin-inexact -ffunction-cse -fgcse-lm -fgnu-runtime
# -fgnu-unique -fident -finline-atomics -fira-hoist-pressure
# -fira-share-save-slots -fira-share-spill-slots -fivopts
# -fkeep-static-consts -fleading-underscore -flifetime-dse
# -flto-odr-type-merging -fmath-errno -fmerge-debug-strings -fpeephole
# -fplt -fprefetch-loop-arrays -freg-struct-return
# -fsched-critical-path-heuristic -fsched-dep-count-heuristic
# -fsched-group-heuristic -fsched-interblock -fsched-last-insn-heuristic
# -fsched-rank-heuristic -fsched-spec -fsched-spec-insn-heuristic
# -fsched-stalled-insns-dep -fschedule-fusion -fsemantic-interposition
# -fshow-column -fshrink-wrap-separate -fsigned-zeros
# -fsplit-ivs-in-unroller -fssa-backprop -fstdarg-opt
# -fstrict-volatile-bitfields -fsync-libcalls -ftrapping-math -ftree-cselim
# -ftree-forwprop -ftree-loop-if-convert -ftree-loop-im -ftree-loop-ivcanon
# -ftree-loop-optimize -ftree-parallelize-loops= -ftree-phiprop
# -ftree-reassoc -ftree-scev-cprop -funit-at-a-time -funwind-tables
# -fverbose-asm -fzero-initialized-in-bss -m128bit-long-double -m64 -m80387
# -malign-stringops -mavx256-split-unaligned-load
# -mavx256-split-unaligned-store -mfancy-math-387 -mfp-ret-in-387 -mfxsr
# -mglibc -mieee-fp -mlong-double-80 -mmmx -mno-sse4 -mpush-args -mred-zone
# -msse -msse2 -mstv -mtls-direct-seg-refs -mvzeroupper

	.text
	.globl	getx
	.type	getx, @function
getx:
.LFB0:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
	subq	$32, %rsp	#,
	movl	%edi, -20(%rbp)	# r, r
	movl	%esi, -24(%rbp)	# w, w
# main.c:7: 	float w2 = w * (M_PI / 180.0);
	cvtsi2sd	-24(%rbp), %xmm1	# w, _1
	movsd	.LC0(%rip), %xmm0	#, tmp95
	mulsd	%xmm1, %xmm0	# _1, _2
# main.c:7: 	float w2 = w * (M_PI / 180.0);
	cvtsd2ss	%xmm0, %xmm2	# _2, tmp98
	movss	%xmm2, -4(%rbp)	# tmp98, w2
# main.c:8: 	x = (int) (r * cos(w2));
	cvtsi2sd	-20(%rbp), %xmm3	# r, _3
	movsd	%xmm3, -32(%rbp)	# _3, %sfp
# main.c:8: 	x = (int) (r * cos(w2));
	cvtss2sd	-4(%rbp), %xmm0	# w2, _4
	call	cos@PLT	#
# main.c:8: 	x = (int) (r * cos(w2));
	mulsd	-32(%rbp), %xmm0	# %sfp, _6
# main.c:8: 	x = (int) (r * cos(w2));
	cvttsd2si	%xmm0, %eax	# _6, tmp96
	movl	%eax, -8(%rbp)	# tmp96, x
# main.c:9: 	return x;
	movl	-8(%rbp), %eax	# x, _11
# main.c:10: }
	leave	
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc
.LFE0:
	.size	getx, .-getx
	.globl	gety
	.type	gety, @function
gety:
.LFB1:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
	subq	$32, %rsp	#,
	movl	%edi, -20(%rbp)	# r, r
	movl	%esi, -24(%rbp)	# w, w
# main.c:15: 	float w2 = w * (M_PI / 180.0);
	cvtsi2sd	-24(%rbp), %xmm1	# w, _1
	movsd	.LC0(%rip), %xmm0	#, tmp95
	mulsd	%xmm1, %xmm0	# _1, _2
# main.c:15: 	float w2 = w * (M_PI / 180.0);
	cvtsd2ss	%xmm0, %xmm2	# _2, tmp98
	movss	%xmm2, -4(%rbp)	# tmp98, w2
# main.c:16: 	x = (int) (r * sin(w2));
	cvtsi2sd	-20(%rbp), %xmm3	# r, _3
	movsd	%xmm3, -32(%rbp)	# _3, %sfp
# main.c:16: 	x = (int) (r * sin(w2));
	cvtss2sd	-4(%rbp), %xmm0	# w2, _4
	call	sin@PLT	#
# main.c:16: 	x = (int) (r * sin(w2));
	mulsd	-32(%rbp), %xmm0	# %sfp, _6
# main.c:16: 	x = (int) (r * sin(w2));
	cvttsd2si	%xmm0, %eax	# _6, tmp96
	movl	%eax, -8(%rbp)	# tmp96, x
# main.c:17: 	return x;
	movl	-8(%rbp), %eax	# x, _11
# main.c:18: }
	leave	
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc
.LFE1:
	.size	gety, .-gety
	.section	.rodata
.LC1:
	.string	"i=%03d x=%03d y=%03d\n"
.LC2:
	.string	"ready."
	.text
	.globl	get_kreis
	.type	get_kreis, @function
get_kreis:
.LFB2:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
	subq	$48, %rsp	#,
	movl	%edi, -36(%rbp)	# to, to
# main.c:22: 	int i = 0, x, y, x2, y2;
	movl	$0, -4(%rbp)	#, i
# main.c:23: 	while (i <= to) {
	jmp	.L6	#
.L9:
# main.c:24: 		x = getx(25, i);
	movl	-4(%rbp), %eax	# i, tmp87
	movl	%eax, %esi	# tmp87,
	movl	$25, %edi	#,
	call	getx	#
	movl	%eax, -16(%rbp)	# tmp88, x
# main.c:25: 		y = gety(25, i);
	movl	-4(%rbp), %eax	# i, tmp89
	movl	%eax, %esi	# tmp89,
	movl	$25, %edi	#,
	call	gety	#
	movl	%eax, -20(%rbp)	# tmp90, y
# main.c:26: 		if (x != x2 || y != y2) {
	movl	-16(%rbp), %eax	# x, tmp91
	cmpl	-8(%rbp), %eax	# x2, tmp91
	jne	.L7	#,
# main.c:26: 		if (x != x2 || y != y2) {
	movl	-20(%rbp), %eax	# y, tmp92
	cmpl	-12(%rbp), %eax	# y2, tmp92
	je	.L8	#,
.L7:
# main.c:27: 			printf("i=%03d x=%03d y=%03d\n", i, x, y);
	movl	-20(%rbp), %ecx	# y, tmp93
	movl	-16(%rbp), %edx	# x, tmp94
	movl	-4(%rbp), %eax	# i, tmp95
	movl	%eax, %esi	# tmp95,
	leaq	.LC1(%rip), %rdi	#,
	movl	$0, %eax	#,
	call	printf@PLT	#
.L8:
# main.c:29: 		x2 = x;
	movl	-16(%rbp), %eax	# x, tmp96
	movl	%eax, -8(%rbp)	# tmp96, x2
# main.c:30: 		y2 = y;
	movl	-20(%rbp), %eax	# y, tmp97
	movl	%eax, -12(%rbp)	# tmp97, y2
# main.c:31: 		i++;
	addl	$1, -4(%rbp)	#, i
.L6:
# main.c:23: 	while (i <= to) {
	movl	-4(%rbp), %eax	# i, tmp98
	cmpl	-36(%rbp), %eax	# to, tmp98
	jle	.L9	#,
# main.c:33: 	printf("ready.\n");
	leaq	.LC2(%rip), %rdi	#,
	call	puts@PLT	#
# main.c:34: }
	nop	
	leave	
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc
.LFE2:
	.size	get_kreis, .-get_kreis
	.globl	main
	.type	main, @function
main:
.LFB3:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
# main.c:38: 	get_kreis(720);
	movl	$720, %edi	#,
	call	get_kreis	#
	movl	$0, %eax	#, _3
# main.c:39: }
	popq	%rbp	#
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc
.LFE3:
	.size	main, .-main
	.section	.rodata
	.align 8
.LC0:
	.long	2723323193
	.long	1066524486
	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
	.section	.note.GNU-stack,"",@progbits

Jetzt wird quasi schon beschrieben, was jede Zeile tut. Ich möchte jedoch / muss jedoch auch so ein Programm selber, ohne Hilfe des Compilers in der Prüfung hinbekommen. Kann man das überhaupt lernen?

DirkB

Automatisch generierter Code ist übel zu lesen.

Da sind viele Register-indirekte Zugriffe drin, die du so eigentlich nicht schreiben wirst.
Du wirst auch keine fertige Funktion sin oder zur Konvertierung haben.

Aber ja, man kann das in Assembler schreiben.
Der sieht dann aber ganz anders aus.

EinNutzer0

Ich versuche mal, das selber hinzubekommen. ... sin und cos (-lm) sind natürlich berechtigte Einwände. Selber werde ich diese Funktionen nicht hin bekommmen...

wob

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

Ich möchte jedoch / muss jedoch auch so ein Programm selber, ohne Hilfe des Compilers in der Prüfung hinbekommen. Kann man das überhaupt lernen?

Und was für Lehrmaterialien hast du bekommen? Wenn das prüfungsrelevant ist, dann hast du doch bestimmt irgendwas bekommen haben, womit du lernen sollst?! Ein korrektes Assemberprogramm in einer Prüfungssituation zu schreiben, halte ich für relativ schwierig, wenn es über "einfache" Dinge mit "normalen" Register hinausgeht - also z.B. wenn du jetzt auch noch die SSE-Befehle (die xmm-Register) kennen sollst (die Leute scheitern bei Bewerbungsgesprächen schon regelmäßig an einfachen Schleifen - in Hochsprachen!).

Zu sin und cos: sehr häufig kann man, wenn man den Wertebereich, für den sin/cos aufgerufen werden, kennt, die Funktionen durch eine Taylorexpansion annähern. Wenn zum Beispiel nahe 0, dann $\sin x \approx x$

Swordfish

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

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

Ne, ich muss für eine Prüfung den (Inline) Assemblercode eines bestimmten Mikrocontrollers verstehen und anwenden können.

Warum lernst du nicht gleich für den Controller.
Es gibt einfachere Syntax als x64 Assembler.

Das da!!!!!111elf

@EinNutzer0 Bei deinem Code würde ich erstmal getx und gety zusammen führen, denn der einzige Unterschied ist dass einmal sin und einmal cos genutzt wird, da ist er einzige Unterschied dass du bei einem 90Grad dazurechnen musst um den richtigen Wert zu erhalten. Ich habe früher nur mit FixedPoint Arithmetik gearbeitet und brauchte daher keine Fließkommazahlen. Für Sin/Cos hatte ich eine Look Up Tabelle, musste den Wert also nicht jedes mal neu berechnen, sondern der Winkel war direkt ein Index in einem Array.

Wie man das heute macht, weiß ich nicht. Ich kann nur berichten wie ich das damals auf dem Amiga in Assembler gemacht hatte.

Am besten fängst du einfach mit irgendeinen Assemblerkurs für deinen Microcontroller an. Die Befehle sind simple und Assembler ist viel logischer als C oder C++, denn da hängt es davon ab wie bestimmte Sachen im Standard geregelt sind.

Tja, wie fängt man dann? Wenn man die Assemblerbefehle kennt, dann versucht man wie die CPU zu denken. Ich brauche einen Wert mit dem ich gleich rechnen will? Dann packe ich das in ein CPU Register. Ich brauche einen Wert für später, dann schreibe ich den direkt in eine Speicherstelle wenn nicht mehr genug Register vorhanden sind. Ich will eine Schleife machen? Ich zähle einen Wert im Register auf null runter und springe dann zu einem Label, ist der Wert noch nicht Null, so springe ich dahin wo mein Wert um eins runtergezählt wird und Teste erneut.

Dieses Springen ist wohl leider vielen Programmierern von heute fremd. Früher gab es in Basic Goto und Gosub was man dann in Assembler in der Art auch wieder findet.

Ich hatte große Probleme früher nicht mit Goto und Gosub programmieren zu können, da ich das Konzept von Funktionen nicht kannte. Eine noch größere Hürde war dann die Objekt Orientierte Programmierung, das wollte überhaupt nicht in mein Kopf und auch heute setze ich das nur sehr marginal ein, da ich oft keinen Sinn darin sehe OOP einzusetzen. Ich finde es schrecklich mich durch fremden OOP Code zu wurschteln. Um so mehr abstrahiert wird, umso komplizierter wird es durch zublicken und gute aktuelle Dokumentation habe ich im Arbeitsleben nie erlebt.

hustbaer

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

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.

EinNutzer0

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.

hustbaer

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.

EinNutzer0

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

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

wob

@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)

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.

hustbaer

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.

EinNutzer0

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

hustbaer

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.

EinNutzer0

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

hustbaer

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).