Vlákno názorů k článku Anatomie grafického formátu PNG od Jet - big endian, tj. byte s nejvyšší váhou je...

Ne, opravdu to umí použít instrukci bswap. Ale standardní funkce to není.

        x = bswap_32(x);
  400470:       0f cf                   bswap  %edi
        return x;
}
  400472:       89 f8                   mov    %edi,%eax
  400474:       c3                      retq   

Ale zdá se, že standardní ntohl funguje stejně dobře.

        x = ntohl(x);
  400468:       89 f8                   mov    %edi,%eax
  40046a:       0f c8                   bswap  %eax
        return x;
}
  40046c:       c3                      retq   

To jen kvůli tomu, že vstup už byl v EDI a návratovou hodnotu bylo potřeba dát do EAX.

0000000000400470 <main>:

int main(int argc, char *argv[])
{
        uint32_t x = argc;
        x = ntohl(x);
  400470:       0f cf                   bswap  %edi
        return x;
}
  400472:       89 f8                   mov    %edi,%eax
  400474:       c3                      retq

Jinak u mne na systému to vypadá nějak takhle:

#define bswap_32(x) __bswap_32 (x)

#   define ntohl(x)     __bswap_32 (x)

/* Swap bytes in 32 bit value.  */
#define __bswap_constant_32(x) \
     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) |                   \
      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))

#if defined __GNUC__ && __GNUC__ >= 2
# if __WORDSIZE == 64 || (defined __i486__ || defined __pentium__             \
                          || defined __pentiumpro__ || defined __pentium4__   \
                          || defined __k8__ || defined __athlon__             \
                          || defined __k6__)
/* To swap the bytes in a word the i486 processors and up provide the
   `bswap' opcode.  On i386 we have to use three instructions.  */
#  define __bswap_32(x) \
     (__extension__                                                           \
      ({ register unsigned int __v, __x = (x);                                \
         if (__builtin_constant_p (__x))                                      \
           __v = __bswap_constant_32 (__x);                                   \
         else                                                                 \
           __asm__ ("bswap %0" : "=r" (__v) : "0" (__x));                     \
         __v; }))
# else
#  define __bswap_32(x)                                                       \
     (__extension__                                                           \
      ({ register unsigned int __v, __x = (x);                                \
         if (__builtin_constant_p (__x))                                      \
           __v = __bswap_constant_32 (__x);                                   \
         else                                                                 \
           __asm__ ("rorw $8, %w0;"                                           \
                    "rorl $16, %0;"                                           \
                    "rorw $8, %w0"                                            \
                    : "=r" (__v)                                              \
                    : "0" (__x)                                               \
                    : "cc");                                                  \
         __v; }))
# endif
#else
# define __bswap_32(x) \
     (__extension__                                                           \
      ({ register unsigned int __x = (x); __bswap_constant_32 (__x); }))
#endif

Lepší příklad (a současně i ukázka jedné nevýhody takovéhoto způsobu optimalizace :-):

        x = ntohl(htonl(x));
  400470:       0f cf                   bswap  %edi
  400472:       0f cf                   bswap  %edi
        return x;
}
  400474:       89 f8                   mov    %edi,%eax
  400476:       c3                      retq