Register umkehren

[Alex X. (behindi)]

Hallo

ich hab da ne frage und es wäre super wenn mir jemand weiterhelfen 
könnte.

wie kehrt man ein Register um? (LSB 1 wid MSB 2 und MSB 1 wird LSB 2)

z.B       1101 0010
          0100 1011

(ich meine nicht invertieren!!!!)



Danke für jede Hilfe

mgf

[Hmm (Gast)]

Das wird hier immer wieder mal gefragt.

Suche mal hier im Forum "Bit reihenfolge umdrehen"

[Uwe Bonnes (Gast)]

Cortex M kann das mit eingebauten Befehl.

[Klaus 2. (klaus2m5)]

Bitweise nach links schieben und über Carry nach rechts in das 
Zielregister schieben.

[Speedy (Gast)]

Soll es zügig gehen und stehen 256 Byte Festspeicher dafür zur 
Verfügung, bietet sich ein Table-Lookup in eine Tabelle mit "rückwärts 
bestückten" Bits an.

[Johann L. (gjlayde)]

In avr-gcc gibt's dafür ein Built-in, siehe am Ende der Seite:

http://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/AVR-Built_002din-Functions.html
 

char rev (char bits)
{
    return __builtin_avr_insert_bits (0x01234567, bits, 0);
}

 
Wird compiliert zu:
 

rev:
  lsl r24
  adc r24,__zero_reg__
  mov __tmp_reg__,r24
  bst r0,1
  bld r24,7
  bst r0,2
  bld r24,6
  bst r0,3
  bld r24,5
  bst r0,5
  bld r24,3
  bst r0,6
  bld r24,2
  bst r0,7
  bld r24,1
  ret

[Reinhard Kern (Gast)]

Hallo,

da es bei fast allen Prozessoren keinen Befehl dafür gibt, braucht man 3 
Register , 2 zum Schieben und 1 zum Zählen. Die Schleife erfordert dann 
16 Schiebe- und 8 Zähl/Sprungbefehle, kürzer gehts nicht. Man kann 
natürlich die 16 Schiebebefehle hintereinanderschreiben und spart damit 
die Sprünge, nur wird dadurch das Programm länger.

Gruss Reinhard

[Spess53 (Gast)]

Hi

>da es bei fast allen Prozessoren keinen Befehl dafür gibt, braucht man 3
>Register , 2 zum Schieben und 1 zum Zählen.

Nö. Ein zusätzliches Register reicht. Das Prinzip stammt hier aus dem 
Forum. Allerdings weiß ich nicht mehr genau von wem (PeDa,KHB oder ....)

;****************************************************************************************
;*
;* mirror_fast        26 Takte (mit call/ret) / 36 Byte
;*
;* Spiegeln r16
;*
;****************************************************************************************

                      .if use_mirror_fast

mirror_fast:          push r17
                      swap r16
                      mov r17,r16

                      lsr r16
                      lsr r16
                      lsl r17
                      lsl r17
                      andi r16,$33
                      andi r17,$CC

                      or r16,r17
                      mov r17,r16

                      lsr r16
                      lsl r17
                      andi r16,$55
                      andi r17,$AA
                      or r16,r17
                      pop r17
                      ret

                      .endif

MfG Spess

[(prx) A. K. (prx)]

Dieses Prinzip gibts auch in breit. Aufwand log(#Bits):
http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious
Prozessoren mit Barrelshifter tun sich da leichter.

Die formal (in C) kürzeste 8-Bit Variante ist wohl:
b = (b * 0x0202020202ULL & 0x010884422010ULL) % 1023;
Geht zwar auch auf AVR (bei GCC), aber...

[Jobst M. (jobstens-de)]

Klaus 2m5 schrieb:
> Bitweise nach links schieben und über Carry nach rechts in das
> Zielregister schieben.

So sieht das aus! Und zwar gegenseitig. Dann ist kein weiteres Register 
notwendig.



Also so:

 ,---------v
[<<<<<<<<][>>>>>>>>]
        ^---------'

[01234567][89ABCDEF]
[1234567F][089ABCDE]
[234567FE][1089ABCD]
[34567FED][21089ABC]
[4567FEDC][321089AB]
[567FEDCB][4321089A]
[67FEDCBA][54321089]
[7FEDCBA9][65432108]
[FEDCBA98][76543210]


Gruß

Jobst