Assembler: Reihenfolge eines Bitfelds umdrehen

[theomega]

Hallo Leute,
ich such einen einfachen Assembler-Befehl der die Reihenfolge der Bits in einem Byte umdreht:
Es soll also aus
12345678
das werden:
87654321
mit den Ziffern meine ich natürlich die Stellen nicht den Wert (Der kann ja nur 0 oder 1 sein).

Wer kann mir helfen?

Danke
TO

[Olli]

BSWAP ist dein Freund.

[theomega]

Hy,
danke für die schnelle Antwort, leider bringt mich der Tip nicht weiter, denn der Befehl wird von meinem Microkontroller nicht unterstzütz. Es handelt sich hierbei um einen AVR von Atmel, also um einen 8bit-Controller.
Sonst noch jemand eine Idee?
Danke auf jeden Fall
TO

[Olli]

Zitat von theomega:

danke für die schnelle Antwort, leider bringt mich der Tip nicht weiter, denn der Befehl wird von meinem Microkontroller nicht unterstzütz. Es handelt sich hierbei um einen AVR von Atmel, also um einen 8bit-Controller.

LOL, irgendwie vermisse ich diesen Hinweis in der Ausgangsfrage

Du kannst es "manuell" machen. Hast du Rotate- und Shift-Befehle zur Verfügung in deinem ASM? Am besten gib mal einen Link zur Prozessordoku.

[theomega]

Hy,
ja, ich gebe zu, ich hätte die Info reinschreiben müßen, sorry.

Hier ist eine Befehlsliste für den MC:
http://www.avr-asm-tutorial.net/avr_.../commands.html

Wäre super wenn du mir helfen könntest

Gruß und Danke
TO

[Nothine]

Zitat von theomega:

Hy,
danke für die schnelle Antwort, leider bringt mich der Tip nicht weiter, denn der Befehl wird von meinem Microkontroller nicht unterstzütz. Es handelt sich hierbei um einen AVR von Atmel, also um einen 8bit-Controller.
Sonst noch jemand eine Idee?
Danke auf jeden Fall
TO

naja, es gibt (laut der dokumentation in deinem letzten post) durchaus einen äquivalenten befehl mit namen SWAP, aber da du (soweit ich das ersehen kann) nicht vorhast nur die nibbles zu vertauschen, bringt es dich im endeffekt auch nicht weiter. ich hab mir das mal durchgelesen und möchte dich vor allem auf ROR und ROL hinweisen, die durchaus die gewünschte funktionalität bieten, du kannst es allerdings nicht mit nur einem befehl realisieren (verbessere mich wer wenn ich falsch liege).

[SirThornberry]

so gehts

Delphi-Quellcode:

function RotateLeft(Value: Longint;Rotate: Byte): Longint; assembler;
asm
   mov     cl, dl
   rol     eax, cl
end;

function RotateRight(Value: Longint; Rotate: Byte): Longint; assembler;
asm
   mov     cl, dl
   ror     eax, cl
end;

sollte also mit einer anweisung getan sein da die zweite hier wohl dazu dient das ganze auf result zu schieben (kenn mich da nicht so aus mit asm)

[Nothine]

Zitat von SirThornberry:

sollte also mit einer anweisung getan sein da die zweite hier wohl dazu dient das ganze auf result zu schieben (kenn mich da nicht so aus mit asm)

das problem in diesem fall besteht in der tatsache das ROL und ROR die reihenfolge der bits durchaus beibehalten, z.B.:

Code:

Bit#: 76543210
Bits: 10101100
--------------
rol 2
--------------
Bit#: 76543210
Bits: 10110010

er will aber (natürlich nur sofern ich das richtig verstanden habe) die bitreihenfolge komplett umdrehen, und das ist nicht so ohne weiteres möglich, dafür brauchts schon ein wenig (aber wirklich nur ein wenig ) mehr

(und es geht net um standard inline-assembler, wie aus der ersten antwort von theomega deutlich wird)

[negaH]

Delphi-Quellcode:

{reverse the bit order from a integer}
function SwapBits(Value, Bits: LongWord): LongWord; register;
asm
       BSWAP  EAX
       MOV    ECX,EAX
       AND    EAX,0AAAAAAAAh
       AND    ECX,055555555h
       SHR    EAX,1
       SHL    ECX,1
       OR     EAX,ECX
       MOV    ECX,EAX
       AND    EAX,0CCCCCCCCh
       AND    ECX,033333333h
       SHR    EAX,2
       SHL    ECX,2
       OR     EAX,ECX
       MOV    ECX,EAX
       AND    EAX,0F0F0F0F0h
       AND    ECX,00F0F0F0Fh
       SHR    EAX,4
       SHL    ECX,4
       OR     EAX,ECX
       AND    EDX,01Fh
       JZ     @@1
       MOV    ECX,32
       SUB    ECX,EDX
       SHR    EAX,CL
@@1:
end;

aus meinem DEC,

gruß Hagen

[Flocke]

[offtopic]

@Hagen: wo ich deinen Assembler-Code gerade so sehe: kann man da an zwei Stellen nicht noch etwas (zugegeben: minimal) optimieren, indem man Zuweisung + links Schieben durch LEA mit Faktor ersetzt? Die beiden Operanden für OR haben ja keine gemeinsamen Bits, also kann man statt dessen auch einfach addieren.

(das Semikolon soll einen Kommentar einleiten. Ich weiß jetzt aus dem Kopf nicht mehr, ob der Delphi-Assembler das unterstützt)

Code:

{reverse the bit order from a integer}
function SwapBits(Value, Bits: LongWord): LongWord; register;
asm
       BSWAP  EAX

       LEA    ECX,[2*EAX]    ; <-- x2 schon drin
      ;MOV    ECX,EAX
       AND    EAX,0AAAAAAAAh
       AND    ECX,0AAAAAAAAh ; <--
       SHR    EAX,1
      ;SHL    ECX,1          ; <--
       OR     EAX,ECX

       LEA    ECX,[4*EAX]    ; <-- x4 schon drin
      ;MOV    ECX,EAX
       AND    EAX,0CCCCCCCCh
       AND    ECX,0CCCCCCCCh ; <--
       SHR    EAX,2
      ;SHL    ECX,2          ; <--
       OR     EAX,ECX

       MOV    ECX,EAX
       AND    EAX,0F0F0F0F0h
       AND    ECX,00F0F0F0Fh
       SHR    EAX,4
       SHL    ECX,4
       OR     EAX,ECX
       AND    EDX,01Fh
       JZ     @@1
       MOV    ECX,32
       SUB    ECX,EDX
       SHR    EAX,CL
@@1:
end;

oder (2. Variante)

Code:

{reverse the bit order from a integer}
function SwapBits(Value, Bits: LongWord): LongWord; register;
asm
       BSWAP  EAX

       MOV    ECX,EAX
       AND    EAX,0AAAAAAAAh
       AND    ECX,055555555h
       SHR    EAX,1
       LEA    EAX,[EAX+2*ECX]  ;<-- Keine gemeinsamen Bits
      ;SHL    ECX,1
      ;OR     EAX,ECX

       MOV    ECX,EAX
       AND    EAX,0CCCCCCCCh
       AND    ECX,033333333h
       SHR    EAX,2
       LEA    EAX,[EAX+4*ECX]  ;<-- Keine gemeinsamen Bits
      ;SHL    ECX,2
      ;OR     EAX,ECX

      ;MOV    ECX,EAX
       LEA    ECX,[4*EAX]      ;<-- Erstes x4
       AND    EAX,0F0F0F0F0h
       AND    ECX,03C3C3C3Ch   ;<--
       SHR    EAX,4
       LEA    EAX,[EAX+4*ECX]  ;<-- Zweites x4
      ;SHL    ECX,4
      ;OR     EAX,ECX

       AND    EDX,01Fh
       JZ     @@1
       MOV    ECX,32
       SUB    ECX,EDX
       SHR    EAX,CL
@@1:
end;

Ich weiß natürlich nicht, ob das irgendwelche negativen Einflüsse auf den Instruction-Cache hat und die ganze Sache ggf. vielleicht doch langsamer macht.

[/offtopic]