division und modulo

Meep Meep

hola leute

ich hab mal folgende funktion mit dem BCB6 kompiliert.
auf geschwindigkeit optimiert.

void my_div(unsigned int x, unsigned int y, unsigned int &z, unsigned int &r)
{
   z = x / y;
   r = y % y;
}

danach hab ich die .onj datei disassembliert. da kam folgendes raus:

push	ebp
		mov	ebp, esp
		mov	ecx, [ebp+arg_4]
		mov	eax, [ebp+arg_0]
		xor	edx, edx
		div	ecx
		mov	edx, [ebp+arg_8]
		mov	[edx], eax
		mov	eax, ecx
		xor	edx, edx
		div	ecx
		mov	eax, [ebp+arg_C]
		mov	[eax], edx
		pop	ebp
		retn

waere es nicht besser wenn er aehnliches wie folgendes machen wuerde?

push	ebp
		mov	ebp, esp
		mov	ecx, [ebp+arg_4]
		mov	eax, [ebp+arg_0]
		xor	edx, edx
		div	ecx
		mov	edx, [ebp+arg_8]
		mov	eax, [ebp+arg_C]
		pop	ebp
		retn

is das eventuell beim intel oder anderen compiler anders ? koennte das mal jemand von euch
probieren ?

cermy

Meep Meep

Nobuo T

...

Bevor du dir ueber Optimierungsstrategien verscheidener Compiler zu verschiedenen CPUs den Kopf zerbrichst, wuerde ich vorschlagen, dass du dir nochmal genau ueberlegst, was deine Codes eigentlich machen, bzw. machen sollen.
So weiss ich zumindest nicht wirklich, worauf du hinaus willst. Ich kann's hoechstens erahnen.

hola

jop war absoluter bloedsinn.
wollte es eigendlich anders machen.
grundlage is eine binaerzahl als string darzustellen.

also:

void my_div(unsigned int &x, unsigned int y, unsigned int &r)
{
   r = x % y;
   x /= y;
}

bin grad schon im bett gelegen, als mir ploetzlich in den kopf schoss, welchen
bloedsinn ich da gepostet hatte.

mal morgen gucken was mein BCB daraus macht. koennt ihr trotzdem mal gucken
was euer kompiler daraus macht ?

guats naechtle

Meep Meep

Meep Meep

hola

hab jetzt die funktion von meinem letzten post kompiliert und deassembliert.

push	ebp
		mov	ebp, esp
		push	ebx
		push	esi
		mov	ebx, [ebp+arg_0]
		mov	esi, [ebp+arg_4]
		xor	edx, edx
		mov	ecx, [ebp+arg_8]
		mov	eax, [ebx]
		div	esi
		mov	[ecx], edx
		xor	edx, edx
		mov	eax, [ebx]
		div	esi
		mov	[ebx], eax
		pop	esi
		pop	ebx
		pop	ebp
		retn

macht also 2 divisionen.

heisst es jetzt eigendlich deassembliert oder disassembliert ?

Meep Meep

Nobuo T

Meep Meep schrieb:

[...]macht also 2 divisionen.

Was schliessen wir daraus?
Dein Compiler optimiert nicht immer gut.

Meep Meep schrieb:

heisst es jetzt eigendlich deassembliert oder disassembliert ?

Ziemlich eindeutiges Ergebnis wuerde ich meinen.

r = y % y da kommt immer Null raus und er muss auch zweimal dividieren wenn das div und modulo nicht bezüglich der gleichen Argumente ist