SWAP in GCC

[ein verzweifelter (Gast)]

Gibt es in GCC auch den SWAP Befehl analog zu Assembler
der das untere mit dem oberen Nibbel bei einem Byte vertauscht?

Danke schonmal

[dins (Gast)]

Geht mit inline Assembler:
http://www.roboternetz.de/wissen/index.php/Inline-Assembler_in_avr-gcc#swap_Nibbles

[Andreas Paulin (Gast)]

Wenns nicht DERMASSEN(!!) schnell gehen muss..... warum nicht einfach in 
C mit einer Hilfsvariablen:

tmpbyte = swapbyte;
swapbyte = <<=4;
tmpbyte >>=4;
swapbyte |= tmpbyte;

Setzt der Compiler normal 1:1 um.

Grüßle

[Jörg X. (Gast)]

hättest du gesucht, hättest du das gefunden

uint8_t swapbyte
swapbyte = (swapbyte << 4) && (swapbyte >> 4);

vorher ggf. nach unsigned casten

[Jörg X. (Gast)]

oups!
natürlich:

swapbyte = (swapbyte << 4) & (swapbyte >> 4);

sorry

[Rolf Magnus (Gast)]

> Geht mit inline Assembler:

Der Code, den man dort sieht:

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

kann übrigens noch einen Tick verbessert werden. Inline-Assembler 
verhindert leider ein "constant folding", weshalb diese Berechnung auch 
in den Fällen zur Laufzeit durchgeführt wird, in denen es eigentlich 
nicht nötig wäre. Es gibt bei gcc einen Trick, um auch diese 
Optimierungen zu ermöglichen. Der geht so:

static inline unsigned char swap (unsigned char x)
{
    if (__builtin_constant_p(x))
        x = (x << 4) | (x >> 4);
    else
        asm volatile ("swap %0" : "=r" (x) : "0" (x));

    return x;
}

__builtin_constant_p wird zur Compileeit ausgewertet, wodurch das if() 
auch zur Compilezeit aufgelöst wird. Wenn swap() inline expandiert wird, 
wird ein zur Compilezeit bekannter übergebener Wert als solche erkannt 
und die C-Implementation verwendet, die dann ebenfalls zur Compilezeit 
durchgeführt wird.

[Walter (Gast)]

@Jörg

"oups!
natürlich:

swapbyte = (swapbyte << 4) & (swapbyte >> 4);

sorry"

Sollte da nicht ein | anstatt des & stehen?!

[Rolf Magnus (Gast)]

Doch, sollte es.

[Jörg X. (Gast)]

@ Walter (Gast):
autsch,
ja natürlich!

[ein nicht mehr verzweifelter (Gast)]

Vielen Dankfür die schnelle Hilfe.

Habe wieder was gelernt. Klasse Forum.

Bis dann 73 & 55

[Malte _. (malte)]

Bei mir optimiert der Compiler leider
  a = (a<<4) | (a>>4);
überhaupt nicht zu einem SWAP Befehl.
Aus

typedef uint8_t u08;
static void rs232_receiveconfig(void) {
u08 k;
u08 a, b;
u08 * addr = (u08 *)eep_config;
for (k = 0; k < sizeof(eep_config); k++) {
  a = hextobyte(rs232_get_nextbyte());
  //swap the byte (the lower 4 bits will be zero afterwards)
  a = (a<<4) | (a>>4);
  b = hextobyte(rs232_get_nextbyte());
  eeprom_write_byte(addr+k, a | b);
  rs232_put_byte('A');
}
}

wird ein völlig umständliches

  rcall rs232_get_nextbyte
  rcall hextobyte
  mov r17,r24
  .stabn 68,0,64,.LM25-rs232_thread
.LM25:
  clr r25
  ldi r18,4
1:  lsl r24
  rol r25
  dec r18
  brne 1b
  swap r17
  andi r17,0x0f
  or r17,r24
  .stabn 68,0,65,.LM26-rs232_thread
.LM26:
  rcall rs232_get_nextbyte
  rcall hextobyte

mit einem Typecast

a = ((u08)(a<<4)) | ((u08)(a>>4));

sieht es nur geringfügig besser aus:

  rcall rs232_get_nextbyte
  rcall hextobyte
  mov r17,r24
  .stabn 68,0,64,.LM25-rs232_thread
.LM25:
  swap r24
  andi r24,0xf0
  swap r17
  andi r17,0x0f
  or r17,r24
  .stabn 68,0,65,.LM26-rs232_thread
.LM26:
  rcall rs232_get_nextbyte
  rcall hextobyte

Der GCC Compiler ist: 3.4.3

[Jörg W. (dl8dtl) (Moderator)]

Besser als das zweite wird's wohl im Moment nicht.  Es müsste jemand,
der hinreichend viel RTL versteht, sich mal hinsetzen und gucken,
wie man es erreicht, dass er die überflüssigen 4 Befehle einfach
weglässt.