Parität in Assembler

[Woyzeck]

Hallo zusammen,

ich bin absoluter Frischling in Assembler. Meine Aufgabe ist es eine 4-Bit-Zahl um den dazugehörigen Paritätsbit zu erweitern.

Wie ich ihn anhängen kann, denke ich zu wissen:

shll $1, %eax
or p,%eax , wobei in p entweder eine 0 oder eine 1 drinsteht.

Bei der Berechnung des Paritätsbits hapert es aber doch gewaltig, da ich weder Sprung-, noch Konditionalbefehle benutzen darf.

Könnt ihr mir weiterhelfen?

Mit freundlichen Grüßen

Woyzeck

[implementation]

Also die Berechnung sollte doch eigentlich kein Problem sein :gruebel:

1234 mod 2 = 0 => gerade
2345 mod 2 = 1 => ungerade

... und da hast du schon deine 0/1.

[Bummi]

meine letzten Assemblerroutinen habe ich vor 16 Jahren geschrieben, aber nach dem SHL müsste IMHO in das erste BIT der Inhalt des 2. Bit eingetragen werden.

[Woyzeck]

Zitat:

Zitat von implementation (Beitrag 1060105)

Also die Berechnung sollte doch eigentlich kein Problem sein :gruebel:

1234 mod 2 = 0 => gerade
2345 mod 2 = 1 => ungerade

... und da hast du schon deine 0/1.

Das ist nicht der Paritätsbit. Ein Paritätsbit gibt nicht an, ob eine Zahl gerade oder ungerade ist, sondern ob die Anzahl der Einsen in binärer Darstellung gerade oder ungerade ist... Aus einer 2 = 0b0010 soll also 0b00101 = 5 werden.

Zitat:

Zitat von Bummi (Beitrag 1060106)

meine letzten Assemblerroutinen habe ich vor 16 Jahren geschrieben, aber nach dem SHL müsste IMHO in das erste BIT der Inhalt des 2. Bit eingetragen werden.

Auch das würde als Parität einfach nur angeben, ob Zahl gerade oder ungerade, was aber nicht die Definition der Parität ist.


Ich hab mittlerweile eine Lösung entwickelt, die nicht sonderlich elegant, aber funktionsfähig ist.

Code:

movl $15,%eax # wertübergabe
movl %eax,%edx # mit edx rechne ich
movl $0,%ecx # ecx speichert die anzahl der 1er

and $1,%edx # edx= letzte Stelle von eax
addl %edx,%ecx # summieren der quersumme

movl %eax,%edx

shrl %edx
and $1,%edx
addl %edx,%ecx

movl %eax,%edx

shrl $2,%edx
and $1,%edx
addl %edx,%ecx

movl %eax,%edx

shrl $3,%edx
and $1,%edx
addl %edx,%ecx

and $1,%ecx

shll %eax
or %ecx,%eax

Ich teste das jetzt nochmal schnell durch, aber eigentlich sollte das tun.

[sx2008]

Zitat:

Zitat von Woyzeck (Beitrag 1060103)

Bei der Berechnung des Paritätsbits hapert es aber doch gewaltig, da ich weder Sprung-, noch Konditionalbefehle benutzen darf

Dein Lehrer möchte Dich ärgern?
Dann würde ich ihm eine Lösung präsentieren, die er vielleicht nicht erwartet hat.
Man nehme vorberechnete 16 Bytes in denen der Wert der Parität steht.

Code:

Zahl |  Parität
0000 => 0
0001 => 1
0010 => 1
0011 => 0
...
1111 => 0

In Assembler wird das mit Define Byte abgelegt:

Code:

.data
LU_TABLE:
DB 0,1,1,0,....,0

.text
LEA %ebx, LU_TABLE
# jetzt die Zahl in Register %eax dazuaddieren und man hat die Adresse
# an der die Parität steht
ADD %ebx, %eax
# Inhalt des Bytes auslesen
MOVB %cx, [%ebx]

Also ich stehe ja mit X86-Assembler auf Kriegsfuss, daher sind bestimmt noch Fehler in obigem Code.
Aber das Prinzip der Nachschlagetabelle sollte klar geworden sein.

[schöni]

Wenn ich mich richtig erinnere, gibt es ein Parity Flag im Flagregister. Müsste daher ausreichen, dieses Flag abzufragen. Es sollte auch Assemblerbefehhle geben, die das Flagregister laden können. Auf jeden Fall PUSHF, welcher das Flagregister auf den Stack schreibt. Von da aus in ein CPU Register POPen sollte kein Problem sein. Dann das Flag per Bitmaske auswerten.

Bei Sprungbefehlen in Abhängigkeit vom Parity Flag bin ich mit nicht sicher. Aber auf den Stack pushen und in ein Register poppen, um dann das Parity Flag abzufragen sollte klappen.

[BUG]

Code:

JNP [Ziel] -> Sprung wenn Parity-Flag Null
JP [Ziel] -> Sprung wenn Parity-Flag Eins

Aber darf er ja nicht benutzen :wink:

EDIT:
Die engl. Wikipedia rückt ein paar interessante Informationen raus.

[Amateurprofi]

Wie wär es hiermit ?

Delphi-Quellcode:

FUNCTION AddParity(value:byte):byte;
asm
      test  al,al    // Setzt u.a. das Parity-Flag
      lahf           // Flags in AH (Bit 2 = Parity Flag)
      shr   ah,2     // Parity-Flag in Carry-Flag schieben
      rcl   al,1     // AL um 1 Bit nach oben und Carry-Flag in Bit 0
end;

Achtung :
Das Parity-Flag ist dann = 1, wenn die Anzahl der 1er-Bits gerade ist.

Wenn 32-Bit Werte benutzt werden sollen, wird es etwas länger

Delphi-Quellcode:

FUNCTION AddParity(value:integer):integer;
asm
      mov   edx,eax
      test  eax,eax
      lahf
      shr   ah,2
      rcl   edx,1
      mov   eax,edx
end;