C++ __builtin_bswap64函數代碼示例

static inline void bswap128(uint128_t *dst, const uint128_t *src)
{
	uint64_t tmp;

	tmp = __builtin_bswap64(src->ll[1]);
	dst->ll[1] = __builtin_bswap64(src->ll[0]);
	dst->ll[0] = tmp;
}

int main(int argc, const char * argv[])
{

    // Dumps a pbzx to stdout. Can work as a filter if no argument is specified

    char buffer[1024];
    int fd = 0;

    if (argc < 2) { fd  = 0 ;}
    else { fd = open (argv[1], O_RDONLY);
           if (fd < 0) { perror (argv[1]); exit(5); }
         }


    read (fd, buffer, 4);
    if (strncmp(buffer, "pbzx", 4)) { fprintf(stderr, "Can't find pbzx magic\n"); exit(0);}

    // Now, if it IS a pbzx

    uint64_t length = 0, flags = 0;

    read (fd, &flags, sizeof (uint64_t));
    flags = __builtin_bswap64(flags);

    fprintf(stderr,"Flags: 0x%llx\n", flags);

    int i = 0;
    int off = 0;

    while (flags &   0x01000000) { // have more chunks
    i++;
    read (fd, &flags, sizeof (uint64_t));
    flags = __builtin_bswap64(flags);
    read (fd, &length, sizeof (uint64_t));
    length = __builtin_bswap64(length);

    fprintf(stderr,"Chunk #%d (flags: %llx, length: %lld bytes)\n",i, flags,length);
     
    // Let's ignore the fact I'm allocating based on user input, etc..
    char *buf = malloc (length);
    read (fd, buf, length);

   // We want the XZ header/footer if it's the payload, but prepare_payload doesn't have that, 
    // so just warn.
    

    if (strncmp(buf, "\xfd""7zXZ\0", 6))  { fprintf (stderr, "Warning: Can't find XZ header. This is likely not XZ data.\n"); }
    else // if we have the header, we had better have a footer, too
    if (strncmp(buf + length -2, "YZ", 2)) { fprintf (stderr, "Warning: Can't find XZ footer. This is bad.\n"); }

    write (1, buf, length);

    }

    return 0;
} 

static inline void
vfoo64 (unsigned long long* a)
{
  int i = 0;
  for (i = 0; i < N; ++i)
    a[i] = __builtin_bswap64 (a[i]);
}

static int GDB_ParseCommonThreadInfo(char *out, GDBContext *ctx, int sig)
{
    u32 threadId = ctx->currentThreadId;
    ThreadContext regs;
    s64 dummy;
    u32 core;
    Result r = svcGetDebugThreadContext(&regs, ctx->debug, threadId, THREADCONTEXT_CONTROL_ALL);
    int n = sprintf(out, "T%02xthread:%x;", sig, threadId);

    if(R_FAILED(r))
        return n;

    r = svcGetDebugThreadParam(&dummy, &core, ctx->debug, ctx->currentThreadId, DBGTHREAD_PARAMETER_CPU_CREATOR); // Creator = "first ran, and running the thread"

    if(R_SUCCEEDED(r))
        n += sprintf(out + n, "core:%x;", core);

    for(u32 i = 0; i <= 12; i++)
        n += sprintf(out + n, "%x:%08x;", i, __builtin_bswap32(regs.cpu_registers.r[i]));

    n += sprintf(out + n, "d:%08x;e:%08x;f:%08x;19:%08x;",
        __builtin_bswap32(regs.cpu_registers.sp), __builtin_bswap32(regs.cpu_registers.lr), __builtin_bswap32(regs.cpu_registers.pc),
        __builtin_bswap32(regs.cpu_registers.cpsr));

    for(u32 i = 0; i < 16; i++)
    {
        u64 val;
        memcpy(&val, &regs.fpu_registers.d[i], 8);
        n += sprintf(out + n, "%x:%016llx;", 26 + i, __builtin_bswap64(val));
    }

    n += sprintf(out + n, "2a:%08x;2b:%08x;", __builtin_bswap32(regs.fpu_registers.fpscr), __builtin_bswap32(regs.fpu_registers.fpexc));

    return n;
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
  if (Size < 14) return 0;
  uint64_t x = 0;
  uint32_t y = 0;
  uint32_t z = 0;
  memcpy(&x, Data, sizeof(x));
  memcpy(&y, Data + Size / 2, sizeof(y));
  memcpy(&z, Data + Size - sizeof(z), sizeof(z));

  x = __builtin_bswap64(x);
  y = __builtin_bswap32(y);
  z = __builtin_bswap32(z);
  const bool k32bit = sizeof(void*) == 4;

  if ((k32bit || x == 0x46555A5A5A5A5546ULL) &&
      z == 0x4F4B &&
      y == 0x66757A7A &&
      true
      ) {
    if (Data[Size - 5] == 'z') {
      fprintf(stderr, "BINGO; Found the target\n");
      exit(1);
    }
  }
  return 0;
}

 size_t data_length() const noexcept {
   if (is_ext2())
       return __builtin_bswap64(*(uint64_t*) vla) & 0xffffffff;
   if (is_ext())
       return __builtin_bswap16(*(uint16_t*) vla);
   return payload();
 }

uint8_t eightbyte_get_byte(uint64_t source, const uint8_t byte_index,
        const bool data_is_big_endian) {
    if(data_is_big_endian) {
        source = __builtin_bswap64(source);
    }
    return (source >> (EIGHTBYTE_BIT - ((byte_index + 1) * CHAR_BIT))) & 0xFF;
}

Result ticket_get_title_id(u64* titleId, u8* ticket, size_t size) {
    if(ticket == NULL) {
        return R_APP_INVALID_ARGUMENT;
    }

    if(size < 4) {
        return R_APP_BAD_DATA;
    }

    u8 sigType = ticket[0x03];
    if(sigType >= NUM_SIG_TYPES) {
        return R_APP_BAD_DATA;
    }

    u32 offset = sigSizes[sigType] + 0x9C;
    if(offset + sizeof(u64) > size) {
        return R_APP_BAD_DATA;
    }

    if(titleId != NULL) {
        *titleId = __builtin_bswap64(*(u64*) &ticket[offset]);
    }

    return 0;
}

int
main (void)
{
  unsigned long long arr[N];
  unsigned long long expect[N];
  int i;

  for (i = 0; i < N; ++i)
    {
      arr[i] = i;
      expect[i] = __builtin_bswap64 (i);
      if (y) /* Avoid vectorisation.  */
        abort ();
    }

  vfoo64 (arr);

  for (i = 0; i < N; ++i)
    {
      if (arr[i] != expect[i])
        abort ();
    }

  return 0;
}

int crypto_stream_xor(unsigned char *out, const unsigned char *in,
                      unsigned long long inlen, const unsigned char *n,
                      const unsigned char *k)
{
#define PTR_ALIGN(ptr, mask) ((void *)((((long)(ptr)) + (mask)) & ~((long)(mask))))
    const unsigned long align = 4096;
    char ctxbuf[sizeof(struct blowfish_ctx) + align];
    struct blowfish_ctx *ctx = PTR_ALIGN(ctxbuf, align - 1);
    uint64_t iv;
    uint64_t block;

    blowfish_init(ctx, k, CRYPTO_KEYBYTES);
    iv = __builtin_bswap64(*(uint64_t *)n); /* be => le */

    while (likely(inlen >= BLOCKSIZE)) {
        block = __builtin_bswap64(iv++); /* le => be */

        blowfish_enc_blk(ctx, out, &block);

        if (unlikely(in)) {
            *(uint64_t *)out ^= *(uint64_t *)in;
            in += BLOCKSIZE;
        }

        out += BLOCKSIZE;
        inlen -= BLOCKSIZE;
    }

    if (unlikely(inlen > 0)) {
        /* handle remaining bytes */
        unsigned int i;

        block = __builtin_bswap64(iv); /* le => be */

        blowfish_enc_blk(ctx, &block, &block);

        if (in) {
            for (i = 0; i < inlen; i++)
                out[i] = in[i] ^ ((uint8_t*)&block)[i];
        } else {
            for (i = 0; i < inlen; i++)
                out[i] = ((uint8_t*)&block)[i];
        }
    }

    return 0;
}

static uint64_t swap64(uint64_t v)
{
#define IS_LITTLE_ENDIAN (*(uint16_t *)"\0\xff" >= 0x100)
    if(IS_LITTLE_ENDIAN) {
        v = __builtin_bswap64(v);
    }
    return v;
}

uint64_t foo64 (uint64_t a)
{
  uint64_t b;

  b = __builtin_bswap64 (a);

  return b;
}

inline unsigned long long
cpu_to_be_64(unsigned long long val)
{
  if (is_big_endian()) {
    return val;
  } else {
    return __builtin_bswap64(val);
  }
}

template <> constexpr inline uint64_t bswap<uint64_t>(uint64_t x) noexcept
{
#if defined(HAVE___BUILTIN_BSWAP64)
    return __builtin_bswap64(x);
#else
    /// @todo create a fallback.
    static_assert(false, "Generic bswap64() not yet implemented.");
#endif
}

int sai_deserialize_ip6_mask(
        _In_ const char *buffer,
        _Out_ sai_ip6_t mask)
{
    uint64_t value;

    int res = sai_deserialize_uint64(buffer, &value);

    if (res < 0 || value > 128)
    {
        SAI_META_LOG_WARN("failed to deserialize '%.*s' as ip6 mask", MAX_CHARS_PRINT, buffer);
        return SAI_SERIALIZE_ERROR;
    }

    uint64_t high = 0xFFFFFFFFFFFFFFFFUL;
    uint64_t low  = 0xFFFFFFFFFFFFFFFFUL;

    if (value == 128)
    {
    }
    else if (value == 64)
    {
        low = 0;
    }
    else if (value == 0)
    {
        low = 0;
        high = 0;
    }
    else if (value > 64)
    {
        low = low << (128 - value);
    }
    else
    {
        high = high << (64 - value);
        low = 0;
    }

    *((uint64_t*)mask) = __builtin_bswap64(high);
    *((uint64_t*)mask + 1) = __builtin_bswap64(low);

    return res;
}