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;
}
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(®s, 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, ®s.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;
}
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;
}
inline uint64_t LoadBigEndian64(uint64_t v)
{
#if defined(__GNUC__)
return __builtin_bswap64(v);
#elif defined(_MSC_VER)
return _byteswap_uint64(v);
#else
#error unsupported compiler
#endif
}
__INTRIN_INLINE uint64_t byteswap64(uint64_t value)
{
#if defined(__GNUC__) || defined(__clang__)
return __builtin_bswap64(value);
#elif defined(_MSC_VER)
return _byteswap_uint64(value);
#else
# error Unsupported platform
#endif
}
static Result networkinstall_get_src_size(void* data, u32 handle, u64* size) {
network_install_data* networkInstallData = (network_install_data*) data;
u64 netSize = 0;
if(recvwait(networkInstallData->clientSocket, &netSize, sizeof(netSize), 0) < 0) {
return R_FBI_ERRNO;
}
*size = __builtin_bswap64(netSize);
return 0;
}
T le()
{
if(bits == 16)
return __builtin_bswap16(this->val);
else if(bits == 32)
return __builtin_bswap32(this->val);
else
return __builtin_bswap64(this->val);
}
Result tmd_get_title_id(u64* titleId, u8* tmd, size_t size) {
u8* data = NULL;
Result res = tmd_get(&data, tmd, size, 0x4C, sizeof(u64));
if(R_FAILED(res)) {
return res;
}
if(titleId != NULL) {
*titleId = __builtin_bswap64(*(u64*) data);
}
return 0;
}
int sai_serialize_ip6_mask(
_Out_ char *buffer,
_In_ const sai_ip6_t mask)
{
uint32_t n = 64;
uint64_t tmp = 0xFFFFFFFFFFFFFFFFUL;
uint64_t high = *((const uint64_t*)mask);
uint64_t low = *((const uint64_t*)mask + 1);
high = __builtin_bswap64(high);
low = __builtin_bswap64(low);
if (high == tmp)
{
for (; (tmp != low) && tmp; tmp <<= 1, n--);
if (tmp == low)
{
return sai_serialize_uint32(buffer, 64 + n);
}
}
else if (low == 0)
{
for (; (tmp != high) && tmp; tmp <<= 1, n--);
if (tmp == high)
{
return sai_serialize_uint32(buffer, n);
}
}
char buf[PRIMITIVE_BUFFER_SIZE];
sai_serialize_ip6(buf, mask);
SAI_META_LOG_WARN("ipv6 mask %s has holes", buf);
return SAI_SERIALIZE_ERROR;
}
void DoubleFloatParser::doParseHead()
{
object().setSize(64);
union {
int64_t i;
double f;
} val;
object().file().read(reinterpret_cast<char* >(&val.i), 64);
if(object().endianness() == Object::bigEndian)
val.i = __builtin_bswap64(val.i);
object().setValue(val.f);
}
/* { dg-options "-O" } */
int
main (void)
{
/* Test constant folding. */
extern void link_error (void);
if (__builtin_bswap32(0xaabbccdd) != 0xddccbbaa)
link_error ();
if (__builtin_bswap64(0x1122334455667788ULL) != 0x8877665544332211ULL)
link_error ();
return 0;
}
inline void byteswap<8>(const char* data, char* result) {
#ifdef PROTOZERO_USE_BUILTIN_BSWAP
*reinterpret_cast<uint64_t*>(result) = __builtin_bswap64(*reinterpret_cast<const uint64_t*>(data));
#else
result[7] = data[0];
result[6] = data[1];
result[5] = data[2];
result[4] = data[3];
result[3] = data[4];
result[2] = data[5];
result[1] = data[6];
result[0] = data[7];
#endif
}
void set_payload(const size_t len)
{
uint16_t pbits = len;
if (len > 65535) pbits = 127;
else if (len > 125) pbits = 126;
bits &= 0x80ff;
bits |= (pbits & 0x7f) << 8;
if (is_ext())
*(uint16_t*) vla = __builtin_bswap16(len);
else if (is_ext2())
*(uint64_t*) vla = __builtin_bswap64(len);
assert(data_length() == len);
}
int
main (void)
{
int i;
for (i = 0; i < N(uint32_ts); i++)
if (__builtin_bswap32 (uint32_ts[i]) != my_bswap32 (uint32_ts[i]))
abort ();
for (i = 0; i < N(uint64_ts); i++)
if (__builtin_bswap64 (uint64_ts[i]) != my_bswap64 (uint64_ts[i]))
abort ();
return 0;
}
static uint64_t calc_hash(const char *url, size_t url_len, const char *etag, size_t etag_len)
{
SHA256_CTX ctx;
union {
unsigned char bytes[SHA256_DIGEST_LENGTH];
uint64_t u64;
} md;
SHA256_Init(&ctx);
SHA256_Update(&ctx, url, url_len);
SHA256_Update(&ctx, etag, etag_len);
SHA256_Final(md.bytes, &ctx);
if (*(uint16_t *)"\xde\xad" == 0xdead)
return md.u64;
else
return __builtin_bswap64(md.u64);
}
int main(int argc, char **argv) {
int a;
a = __builtin_bswap32(a);
a = __builtin_bswap64(a);
a = __builtin_constant_p(1);
a = __builtin_constant_p("string");
char *b = __builtin_strchr("string", 's');
a = __builtin_expect(1, a);
a = __builtin_strlen("string");
a = __builtin_strcmp("string1", "string2");
a = __builtin_offsetof(struct point, y);
char c[100];
b = __builtin_strcpy(c, "a");
b = __builtin_strncpy(c, "a", 1);
a = __builtin_ctzl(a);
varargsfn(0);
__builtin_prefetch(b);
__builtin_prefetch(b, 1);
__builtin_prefetch(b, 1, 1);
return a;
}
static void reverse(
char* const inout,
const size_t chunk_count) {
const size_t count = chunk_count * 64;
for (size_t i = 0; i < count; i += 64) {
//_mm_prefetch(inout + i + 8 * 64, _MM_HINT_T0);
const uint64_t byteswap[8] = {
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[0]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[1]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[2]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[3]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[4]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[5]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[6]),
__builtin_bswap64(reinterpret_cast< uint64_t* >(inout + i)[7])
};
for (size_t j = 0; j < 8; ++j)
reinterpret_cast< uint64_t* >(inout + i)[j] = byteswap[7 - j];
}
}
OrderBook &Subscribe(std::string instrument, void *data = NULL) {
if (instrument.size() < 8) {
instrument.insert(instrument.size(), 8 - instrument.size(), ' ');
}
uint64_t symbol = __builtin_bswap64(
*reinterpret_cast<const uint64_t *>(instrument.data()));
auto it = symbols_.find(symbol);
if (it != symbols_.end()) {
return books_[it->second];
}
if (books_.size() == MAXBOOK) {
throw std::runtime_error("too many subscriptions");
}
books_.push_back(OrderBook());
symbols_.emplace(symbol, books_.size() - 1);
OrderBook &book = books_.back();
book.SetUserData(data);
return book;
}
