oj 3.16.11 → 3.17.6

data/ext/oj/safe.c

@@ -0,0 +1,244 @@
+
+#include "safe.h"
+
+static VALUE max_hash_size_sym, max_array_size_sym, max_depth_sym, max_total_elements_sym, max_hash_size_error_class,
+    max_array_size_error_class, max_depth_error_class, max_total_elements_error_class;
+
+static void check_object_size(safe_T safe) {
+    if (!safe->max_hash_size_isset) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_hash  = (number_of_items_in_stack - current_object_location->vi - 1) / 2;
+
+    if (safe->max_hash_size > number_of_items_in_hash) {
+        return;
+    }
+
+    rb_raise(max_hash_size_error_class, "Too many object items!");
+}
+
+static void check_array_size(safe_T safe) {
+    if (!safe->max_array_size_isset) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_array = number_of_items_in_stack - current_object_location->vi - 1;
+
+    if (safe->max_array_size > number_of_items_in_array) {
+        return;
+    }
+
+    rb_raise(max_array_size_error_class, "Too many array items!");
+}
+
+static void check_max_depth(safe_T safe, ojParser p) {
+    if (!safe->max_depth_isset || safe->max_depth >= (p->depth + 1)) {
+        return;
+    }
+
+    rb_raise(max_depth_error_class, "JSON is too deep!");
+}
+
+static void check_max_total_elements(safe_T safe) {
+    /*
+    * We check if `max_total_elements` is greater than `current_elements_count`
+    * (instead of greater than or equal) because top-level elements (e.g., [],
+    * null, true) are not counted. As a result, `current_elements_count`
+    * always holds one less than the actual total.
+    */
+    if (!safe->max_total_elements_isset || safe->max_total_elements > safe->current_elements_count) {
+        return;
+    }
+
+    rb_raise(max_total_elements_error_class, "Too many elements!");
+}
+
+static void safe_start(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size      = 0;
+    safe->current_array_size     = 0;
+    safe->current_elements_count = 0;
+
+    safe->delegated_start_func(p);
+}
+
+static void safe_open_object(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_func(p);
+}
+
+static void safe_open_array(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_func(p);
+}
+
+DEFINE_DELEGATED_FUNCTION(add_null);
+DEFINE_DELEGATED_FUNCTION(add_true);
+DEFINE_DELEGATED_FUNCTION(add_false);
+DEFINE_DELEGATED_FUNCTION(add_int);
+DEFINE_DELEGATED_FUNCTION(add_float);
+DEFINE_DELEGATED_FUNCTION(add_big);
+DEFINE_DELEGATED_FUNCTION(add_str);
+
+static void safe_open_object_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_key_func(p);
+}
+
+static void safe_open_array_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_key_func(p);
+}
+
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_null);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_true);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_false);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_int);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_float);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_big);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_str);
+
+// The counting wrappers live in the parser function table, and the option
+// setters of the usual parser write to the same slots, so an option set after
+// the parser was built puts the unwrapped handler back and the limits stop
+// being applied for that kind of value.
+#define WRAP(funcs, slot, wrapper, saved) \
+    do {                                  \
+        if (wrapper != (funcs)->slot) {   \
+            safe->saved = (funcs)->slot;  \
+        }                                 \
+        (funcs)->slot = wrapper;          \
+    } while (0)
+
+static void wrap_funcs(ojParser p, safe_T safe) {
+    Funcs f = &p->funcs[ARRAY_FUN];
+
+    WRAP(f, open_object, safe_open_object, delegated_open_object_func);
+    WRAP(f, open_array, safe_open_array, delegated_open_array_func);
+    // The following overrides are done for counting objects
+    WRAP(f, add_null, safe_add_null, delegated_add_null_func);
+    WRAP(f, add_true, safe_add_true, delegated_add_true_func);
+    WRAP(f, add_false, safe_add_false, delegated_add_false_func);
+    WRAP(f, add_int, safe_add_int, delegated_add_int_func);
+    WRAP(f, add_float, safe_add_float, delegated_add_float_func);
+    WRAP(f, add_big, safe_add_big, delegated_add_big_func);
+    WRAP(f, add_str, safe_add_str, delegated_add_str_func);
+
+    f = &p->funcs[OBJECT_FUN];
+    WRAP(f, open_object, safe_open_object_key, delegated_open_object_key_func);
+    WRAP(f, open_array, safe_open_array_key, delegated_open_array_key_func);
+    WRAP(f, add_null, safe_add_null_key, delegated_add_null_key_func);
+    WRAP(f, add_true, safe_add_true_key, delegated_add_true_key_func);
+    WRAP(f, add_false, safe_add_false_key, delegated_add_false_key_func);
+    WRAP(f, add_int, safe_add_int_key, delegated_add_int_key_func);
+    WRAP(f, add_float, safe_add_float_key, delegated_add_float_key_func);
+    WRAP(f, add_big, safe_add_big_key, delegated_add_big_key_func);
+    WRAP(f, add_str, safe_add_str_key, delegated_add_str_key_func);
+}
+
+static VALUE safe_option(ojParser p, const char *key, VALUE value) {
+    safe_T safe = (safe_T)p->ctx;
+    VALUE  rv;
+
+    if (0 == strcmp("omit_null", key)) {
+        return safe->omit_null ? Qtrue : Qfalse;
+    }
+    rv = safe->delegated_option_func(p, key, value);
+    if (0 == strcmp("omit_null=", key)) {
+        safe->omit_null = (Qtrue == rv);
+    }
+    wrap_funcs(p, safe);
+
+    return rv;
+}
+
+void oj_init_safe_parser(ojParser p, safe_T safe, VALUE options) {
+    // Safe parser inherits all members of usual parser
+    oj_init_usual(p, &safe->usual);
+
+    safe->delegated_start_func = p->start;
+    p->start                   = safe_start;
+    safe->omit_null            = false;
+
+    wrap_funcs(p, safe);
+
+    safe->delegated_option_func = p->option;
+    p->option                   = safe_option;
+
+    SET_CONFIG(max_hash_size);
+    SET_CONFIG(max_array_size);
+    SET_CONFIG(max_depth);
+    SET_CONFIG(max_total_elements);
+}
+
+void oj_set_parser_safe(ojParser p, VALUE options) {
+    safe_T s = OJ_R_ALLOC(struct _safe_S);
+
+    oj_init_safe_parser(p, s, options);
+}
+
+void oj_safe_init(VALUE parser_class) {
+    VALUE validation_error_class = rb_define_class_under(parser_class, "ValidationError", rb_eRuntimeError);
+
+    max_hash_size_error_class      = rb_define_class_under(parser_class, "HashSizeError", validation_error_class);
+    max_array_size_error_class     = rb_define_class_under(parser_class, "ArraySizeError", validation_error_class);
+    max_depth_error_class          = rb_define_class_under(parser_class, "DepthError", validation_error_class);
+    max_total_elements_error_class = rb_define_class_under(parser_class, "TotalElementsError", validation_error_class);
+
+    rb_gc_register_address(&max_hash_size_error_class);
+    rb_gc_register_address(&max_array_size_error_class);
+    rb_gc_register_address(&max_depth_error_class);
+    rb_gc_register_address(&max_total_elements_error_class);
+
+    max_hash_size_sym      = ID2SYM(rb_intern("max_hash_size"));
+    max_array_size_sym     = ID2SYM(rb_intern("max_array_size"));
+    max_depth_sym          = ID2SYM(rb_intern("max_depth"));
+    max_total_elements_sym = ID2SYM(rb_intern("max_total_elements"));
+
+    rb_gc_register_address(&max_hash_size_sym);
+    rb_gc_register_address(&max_array_size_sym);
+    rb_gc_register_address(&max_depth_sym);
+    rb_gc_register_address(&max_total_elements_sym);
+}

data/ext/oj/safe.h

@@ -0,0 +1,91 @@
+#include <ruby.h>
+
+#include "parser.h"
+#include "usual.h"
+
+#define SET_CONFIG(config_name)                                                        \
+    do {                                                                               \
+        VALUE rb_##config_name = rb_hash_aref(options, config_name##_sym);             \
+                                                                                       \
+        if (RB_INTEGER_TYPE_P(rb_##config_name)) {                                     \
+            safe->config_name         = NUM2LONG(rb_##config_name);                    \
+            safe->config_name##_isset = true;                                          \
+        } else if (!NIL_P(rb_##config_name)) {                                         \
+            rb_raise(rb_eArgError, "Incorrect value provided for `" #config_name "`"); \
+        } else {                                                                       \
+            safe->config_name         = 0;                                             \
+            safe->config_name##_isset = false;                                         \
+        }                                                                              \
+    } while (0);
+
+#define DEFINE_DELEGATED_FUNCTION(function_name)   \
+    static void safe_##function_name(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;              \
+                                                   \
+        safe->current_elements_count++;            \
+                                                   \
+        check_array_size(safe);                    \
+        check_max_total_elements(safe);            \
+                                                   \
+        safe->delegated_##function_name##_func(p); \
+    }
+
+#define DEFINE_DELEGATED_OBJECT_FUNCTION(function_name)  \
+    static void safe_##function_name##_key(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;                    \
+                                                         \
+        safe->current_elements_count += 2;               \
+                                                         \
+        check_object_size(safe);                         \
+        check_max_total_elements(safe);                  \
+                                                         \
+        safe->delegated_##function_name##_key_func(p);   \
+    }
+
+typedef struct _safe_S {
+    struct _usual usual;
+
+    long int max_hash_size;
+    long int max_array_size;
+    long int max_depth;
+    long int max_total_elements;
+    long int max_json_size_bytes;
+
+    bool max_hash_size_isset;
+    bool max_array_size_isset;
+    bool max_depth_isset;
+    bool max_total_elements_isset;
+
+    long int current_hash_size;
+    long int current_array_size;
+    long int current_elements_count;
+
+    // omit_null is kept here because the usual parser reports it by looking at
+    // the add_null slot, which is one of the slots wrapped below.
+    bool omit_null;
+
+    VALUE (*delegated_option_func)(struct _ojParser *p, const char *key, VALUE value);
+    void (*delegated_start_func)(struct _ojParser *p);
+
+    // Array functions
+    void (*delegated_open_object_func)(struct _ojParser *p);
+    void (*delegated_open_array_func)(struct _ojParser *p);
+    void (*delegated_add_null_func)(struct _ojParser *p);
+    void (*delegated_add_true_func)(struct _ojParser *p);
+    void (*delegated_add_false_func)(struct _ojParser *p);
+    void (*delegated_add_int_func)(struct _ojParser *p);
+    void (*delegated_add_float_func)(struct _ojParser *p);
+    void (*delegated_add_big_func)(struct _ojParser *p);
+    void (*delegated_add_str_func)(struct _ojParser *p);
+
+    // Object functions
+    void (*delegated_open_object_key_func)(struct _ojParser *p);
+    void (*delegated_open_array_key_func)(struct _ojParser *p);
+    void (*delegated_add_null_key_func)(struct _ojParser *p);
+    void (*delegated_add_true_key_func)(struct _ojParser *p);
+    void (*delegated_add_false_key_func)(struct _ojParser *p);
+    void (*delegated_add_int_key_func)(struct _ojParser *p);
+    void (*delegated_add_float_key_func)(struct _ojParser *p);
+    void (*delegated_add_big_key_func)(struct _ojParser *p);
+    void (*delegated_add_str_key_func)(struct _ojParser *p);
+} *safe_T;

data/ext/oj/saj.c

@@ -82,7 +82,14 @@ inline static void next_non_white(ParseInfo pi) {
         case '\f':
         case '\n':
         case '\r': break;
-        case '/': skip_comment(pi); break;
+        case '/':
+            skip_comment(pi);
+            /* A comment that is not terminated by a newline ends on the null
+             * terminator. Stop here so the loop does not step past it. */
+            if ('\0' == *pi->s) {
+                return;
+            }
+            break;
         default: return;
         }
     }
@@ -118,14 +125,15 @@ static void skip_comment(ParseInfo pi) {
             if ('*' == *pi->s && '/' == *(pi->s + 1)) {
                 pi->s++;
                 return;
-            } else if ('\0' == *pi->s) {
-                if (pi->has_error) {
-                    call_error("comment not terminated", pi, __FILE__, __LINE__);
-                } else {
-                    raise_error("comment not terminated", pi->str, pi->s);
-                }
             }
         }
+        /* The loop only ends on the null terminator so the comment was never
+         * closed. */
+        if (pi->has_error) {
+            call_error("comment not terminated", pi, __FILE__, __LINE__);
+        } else {
+            raise_error("comment not terminated", pi->str, pi->s);
+        }
     } else if ('/' == *pi->s) {
         for (; 1; pi->s++) {
             switch (*pi->s) {
@@ -190,6 +198,12 @@ static void read_hash(ParseInfo pi, const char *key) {
     } else {
         while (1) {
             next_non_white(pi);
+            if ('"' != *pi->s) {
+                if (pi->has_error) {
+                    call_error("invalid format, expected a key", pi, __FILE__, __LINE__);
+                }
+                raise_error("invalid format, expected a key", pi->str, pi->s);
+            }
             ks = read_quoted_value(pi);
             next_non_white(pi);
             if (':' == *pi->s) {
@@ -606,6 +620,19 @@ static void saj_parse(VALUE handler, char *json) {
     }
 }
 
+struct _sajArgs {
+    VALUE handler;
+    char *json;
+};
+
+static VALUE protect_saj_parse(VALUE x) {
+    struct _sajArgs *args = (struct _sajArgs *)x;
+
+    saj_parse(args->handler, args->json);
+
+    return Qnil;
+}
+
 /* call-seq: saj_parse(handler, io)
  *
  * Parses an IO stream or file containing an JSON document. Raises an exception
@@ -648,8 +675,16 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             len = lseek(fd, 0, SEEK_END);
             lseek(fd, 0, SEEK_SET);
             json = OJ_R_ALLOC_N(char, len + 1);
-            if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
-                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            {
+                size_t total = 0;
+
+                while (total < len) {
+                    cnt = read(fd, json + total, len - total);
+                    if (cnt <= 0) {
+                        rb_raise(rb_eIOError, "failed to read from IO Object.");
+                    }
+                    total += cnt;
+                }
             }
             json[len] = '\0';
 #endif
@@ -662,8 +697,17 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
         }
     }
-    saj_parse(*argv, json);
-    OJ_R_FREE(json);
-
+    {
+        // saj_parse() raises on a malformed document so the json buffer has to
+        // be freed even when the parse does not return normally.
+        struct _sajArgs args = {*argv, json};
+        int             ex   = 0;
+
+        rb_protect(protect_saj_parse, (VALUE)&args, &ex);
+        OJ_R_FREE(json);
+        if (0 != ex) {
+            rb_jump_tag(ex);
+        }
+    }
     return Qnil;
 }

data/ext/oj/simd.h

@@ -1,10 +1,219 @@
 #ifndef OJ_SIMD_H
 #define OJ_SIMD_H
 
+// SIMD architecture detection and configuration
+// This header provides unified SIMD support across different CPU architectures
+// with cross-platform runtime detection (Windows/Linux/Mac)
+
+// SIMD implementation enum - used for runtime selection
+typedef enum _simd_implementation { SIMD_NONE, SIMD_NEON, SIMD_SSE2, SIMD_SSE42 } SIMD_Implementation;
+
+// Define in oj.c.
+extern SIMD_Implementation SIMD_Impl;
+
+// Runtime CPU detection function (implemented in oj.c)
+SIMD_Implementation oj_get_simd_implementation(void);
+
+// =============================================================================
+// Compiler compatibility macros
+// =============================================================================
+
+// Branch prediction hints
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_LIKELY(x) __builtin_expect(!!(x), 1)
+#define OJ_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define OJ_LIKELY(x) (x)
+#define OJ_UNLIKELY(x) (x)
+#endif
+
+// Prefetch hints
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_PREFETCH(addr) __builtin_prefetch(addr, 0, 0)
+#elif defined(_MSC_VER)
+#include <intrin.h>
+#define OJ_PREFETCH(addr) _mm_prefetch((const char *)(addr), _MM_HINT_T0)
+#else
+#define OJ_PREFETCH(addr) ((void)0)
+#endif
+
+// Count trailing zeros (for SSE2 mask scanning)
+#if defined(__GNUC__) || defined(__clang__)
+#define OJ_CTZ(x) __builtin_ctz(x)
+#define OJ_CTZ64(x) __builtin_ctzll(x)
+#elif defined(_MSC_VER)
+#include <intrin.h>
+static __inline int oj_ctz_msvc(unsigned int x) {
+    unsigned long index;
+    if (0 == x) {
+        return 32;
+    }
+    _BitScanForward(&index, x);
+    return (int)index;
+}
+static __inline int oj_ctz64_msvc(uint64_t x) {
+    unsigned long index;
+    if (_BitScanForward64(&index, x)) {
+        return (int)index;
+    }
+    return 64;
+}
+#define OJ_CTZ(x) oj_ctz_msvc(x)
+#define OJ_CTZ64(x) oj_ctz64_msvc(x)
+#else
+// Fallback: naive implementation
+static inline int oj_ctz_fallback(unsigned int x) {
+    int count = 0;
+    while ((x & 1) == 0 && count < 32) {
+        x >>= 1;
+        count++;
+    }
+    return count;
+}
+
+static inline int oj_ctz64_fallback(uint64_t x) {
+    int count = 0;
+    while ((x & 1) == 0 && count < 64) {
+        x >>= 1;
+        count++;
+    }
+    return count;
+}
+#define OJ_CTZ(x) oj_ctz_fallback(x)
+#define OJ_CTZ64(x) oj_ctz64_fallback(x)
+#endif
+
+// =============================================================================
+// x86/x86_64 SIMD detection
+// =============================================================================
+#if defined(__x86_64__) || defined(__i386__) || defined(_M_IX86) || defined(_M_X64)
+#define HAVE_SIMD_X86 1
+
+// Include appropriate SIMD headers
+#if defined(_MSC_VER)
+// MSVC: use intrin.h for all intrinsics
+#include <intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif defined(__GNUC__) || defined(__clang__)
+// GCC/Clang: check for header availability and include them
+// We include headers but use target attributes to enable instructions per-function
+// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable
+#if __has_include(<cpuid.h>)
+#include <cpuid.h>
+#endif
+#if defined(__SSE4_2__) || defined(__SSE2__)
+// If any SSE is enabled globally, x86intrin.h should be available
+#include <x86intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#else
+// Try to include headers anyway for target attribute functions
+#if __has_include(<x86intrin.h>)
+#include <x86intrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif __has_include(<nmmintrin.h>)
+#include <nmmintrin.h>
+#define HAVE_SIMD_SSE4_2 1
+#define HAVE_SIMD_SSE2 1
+#elif __has_include(<emmintrin.h>)
+#include <emmintrin.h>
+#define HAVE_SIMD_SSE2 1
+#endif
+#endif
+#endif
+
+// Target attribute macros for function-level SIMD enabling
+#if defined(__clang__) || defined(__GNUC__)
+#define OJ_TARGET_SSE42 __attribute__((target("sse4.2")))
+#define OJ_TARGET_SSE2 __attribute__((target("sse2")))
+#else
+// MSVC doesn't need target attributes - intrinsics are always available
+#define OJ_TARGET_SSE42
+#define OJ_TARGET_SSE2
+#endif
+
+#endif  // x86/x86_64
+
+// =============================================================================
+// ARM NEON detection
+// =============================================================================
 #if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM64)
 #define HAVE_SIMD_NEON 1
 #define SIMD_MINIMUM_THRESHOLD 6
 #include <arm_neon.h>
 #endif
 
-#endif /* OJ_SIMD_H */
+// =============================================================================
+// SIMD type string for debugging/logging
+// =============================================================================
+#if defined(HAVE_SIMD_SSE4_2) || defined(HAVE_SIMD_SSE2)
+#define HAVE_SIMD_STRING_SCAN 1
+#define SIMD_TYPE "x86 (runtime detected)"
+#elif defined(HAVE_SIMD_NEON)
+#define HAVE_SIMD_STRING_SCAN 1
+#define SIMD_TYPE "NEON"
+#else
+#define SIMD_TYPE "none"
+#endif
+
+#if defined(HAVE_SIMD_SSE4_2)
+
+#define SIMD_MINIMUM_THRESHOLD 6
+
+extern void initialize_sse42(void);
+
+static inline OJ_TARGET_SSE42 __m128i vector_lookup_sse42(__m128i input, __m128i *lookup_table, int tab_size) {
+    // Extract high 4 bits to determine which 16-byte chunk (0-15)
+    __m128i hi_index = _mm_and_si128(_mm_srli_epi32(input, 4), _mm_set1_epi8(0x0F));
+
+    // Extract low 4 bits for index within the chunk (0-15)
+    __m128i low_index = _mm_and_si128(input, _mm_set1_epi8(0x0F));
+
+    // Perform lookups in all 16 tables
+    __m128i results[16];
+    for (int i = 0; i < tab_size; i++) {
+        results[i] = _mm_shuffle_epi8(lookup_table[i], low_index);
+    }
+
+    // Create masks for each chunk and blend results
+    __m128i final_result = _mm_setzero_si128();
+
+    for (int i = 0; i < tab_size; i++) {
+        __m128i mask          = _mm_cmpeq_epi8(hi_index, _mm_set1_epi8(i));
+        __m128i masked_result = _mm_and_si128(mask, results[i]);
+        final_result          = _mm_or_si128(final_result, masked_result);
+    }
+
+    return final_result;
+}
+
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#if __has_builtin(__builtin_memcpy)
+#define HAVE_FAST_MEMCPY 1
+
+inline static void fast_memcpy16(void *dest, const void *src, size_t n) {
+    char *d = (char *)dest;
+    char *s = (char *)src;
+    if (n >= 8) {
+        __builtin_memcpy(d, s, 8);
+        __builtin_memcpy(d + n - 8, s + n - 8, 8);
+    } else if (n >= 4) {
+        __builtin_memcpy(d, s, 4);
+        __builtin_memcpy(d + n - 4, s + n - 4, 4);
+    } else if (n >= 2) {
+        __builtin_memcpy(d, s, 2);
+        __builtin_memcpy(d + n - 2, s + n - 2, 2);
+    } else if (n >= 1) {
+        *d = *s;
+    }
+}
+#endif
+
+#endif /* OJ_SIMD_H */