Swap Befehl für Byte bei Atmega 32

[Bernd H. (bernd79)]

AVR Studio, Atmega32

Hallo,

Gibt es einen Swap-Befehl, um eingelesene high und low Bits zutauschen 
und wie sieht der aus ?

Also mache

0101 1100  (0x5C)

zu

1100 0101 (0xC5)

[Εrnst B. (ernst)]

mit __builtin_avr_insert_bits könnte das (und noch viel mehr) gehen, 
aber ob's schneller ist als per Hand maskieren und schieben?

oder meintest du in ASM?

[Bernd H. (bernd79)]

Εrnst B✶ schrieb:
> mit __builtin_avr_insert_bits könnte das (und noch viel mehr) gehen,
> aber ob's schneller ist als per Hand maskieren und schieben?
>
> oder meintest du in ASM?

__builtin_avr_insert_bits  sagt mir nichts!

Per Hand wäre es möglich. Dachte aber es gibt einen Befehl dafür in C

[Clemens M. (panko)]

http://www.rn-wissen.de/index.php/Inline-Assembler_in_avr-gcc#swap_Nibbles

static inline unsigned char swap (unsigned char x)
{
    asm volatile ("swap %0" : "=r" (x) : "0" (x));
    return x;
}

Meinst du so? Einziger Nachteil (vielleicht): Hilfsfunktion musst du 
u.U. auf anderen Prozessor anpassen. Falls das kein low level Code ist - 
wobei ja dann eher swappen unwichtiger würde.

[Stefan N. (stefan_n)]

was spricht gegen:

x = (x << 4) | (x >> 4)

Ein halbwegs vernünftiger compiler sollte dann ein swp draus machen.

[Peter II (Gast)]

Stefan Noack schrieb:
> Ein halbwegs vernünftiger compiler sollte dann ein swp draus machen.

daruf würde ich nicht wetten.

schon ein
x >> 4

ist auf einem atmel langsam, weil es in 4 schritten gemacht werden muss.

[test (Gast)]

Clemens M. schrieb:
> http://www.rn-wissen.de/index.php/Inline-Assembler...
>
> static inline unsigned char swap (unsigned char x)
> {
>     asm volatile ("swap %0" : "=r" (x) : "0" (x));
>     return x;
> }
>
>
> Meinst du so? Einziger Nachteil (vielleicht): Hilfsfunktion musst du
> u.U. auf anderen Prozessor anpassen. Falls das kein low level Code ist -
> wobei ja dann eher swappen unwichtiger würde.

Das gibts schon als intrinsic function im Header: avr/builtin.h

extern unsigned char __builtin_avr_swap(unsigned char __b);

Ist aber natürlich auch nicht portabel.

[eProfi (Gast)]

schon ein
x >> 4

ist auf einem atmel langsam, weil es in 4 schritten gemacht werden muss.


und was spricht dagegen (zumindest bei unsigned), das mit swap und and 
(0f) zu machen?

[Stefan N. (stefan_n)]

Peter II schrieb:
> Stefan Noack schrieb:
>> Ein halbwegs vernünftiger compiler sollte dann ein swp draus machen.
>
> daruf würde ich nicht wetten.
>
> schon ein
> x >> 4
>
> ist auf einem atmel langsam, weil es in 4 schritten gemacht werden muss.

http://sdcc.svn.sourceforge.net/viewvc/sdcc/trunk/sdcc/src/avr/gen.c?revision=8097&view=markup 
in Zeile 3116:

                if (shCount >= 4) {
                          if (AOP_ISHIGHREG(AOP(result),0)) {
                                  emitcode ("swap", "%s", aopGet (AOP (result), 0));
                                  emitcode ("andi", "%s,0xf0");
                          } else {
                                  emitcode ("ldi","r24,0xf0");
                                  emitcode ("swap", "%s", aopGet (AOP (result), 0));
                                  emitcode ("and", "%s,r24");
                          }
                          shCount -= 4;
                  }

Ich wette stark darauf, zumindest für diesen compiler, beim avr-gcc kann 
man ja auch mal gucken ;-)

[Stefan N. (stefan_n)]

eProfi schrieb:
> und was spricht dagegen (zumindest bei unsigned), das mit swap und and
> (0f) zu machen?

dass der compiler einem die arbeit normalerweise abnimmt, das so zu 
schreiben? (siehe oben) ansonsten kann man gleich in assembler schreiben 
(was ich übrigens durchaus befürworte)...

[Oliver J. (skriptkiddy)]

Peter II schrieb:
> schon ein
> x >> 4
>
> ist auf einem atmel langsam, weil es in 4 schritten gemacht werden muss.

Der avr-gcc erledigt das aber mit swap und andi und nicht über 
Schiebebefehle oder add. Also braucht das nur 2 Zyklen.
(Betrachtung ohne Speicherzugriffe)


Mit -Os erledigt der avr-gcc die swap-Geschichte in C zuverlässig:

uint8_t c;

void main(void)
{
  c = (c<<4) | (c>>4);
  7c:  80 91 60 00   lds  r24, 0x0060
  80:  82 95         swap  r24
  82:  80 93 60 00   sts  0x0060, r24
}
  86:  08 95         ret

Gruß Oliver

[Stefan N. (stefan_n)]

Oliver J. schrieb:

> Mit -Os erledigt der avr-gcc die swap-Geschichte in C zuverlässig:
>

> uint8_t c;
> 
> void main(void)
> {
>   c = (c<<4) | (c>>4);
>   7c:  80 91 60 00   lds  r24, 0x0060
>   80:  82 95         swap  r24
>   82:  80 93 60 00   sts  0x0060, r24
> }
>   86:  08 95         ret
> 
>

>
> Gruß Oliver

Sehr schön, damit hätten wir das eindeutig geklärt (und die Wette hätte 
ich gewonnen ^^)...