Initial version.

src/nxt_clang.h

@@ -0,0 +1,214 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) NGINX, Inc.
+ */
+
+#ifndef _NXT_CLANG_H_INCLUDED_
+#define _NXT_CLANG_H_INCLUDED_
+
+
+#define nxt_inline     static inline __attribute__((always_inline))
+#define nxt_noinline   __attribute__((noinline))
+#define nxt_cdecl
+
+
+#if (NXT_CLANG)
+
+/* Any __asm__ directive disables loop vectorization in GCC and Clang. */
+#define                                                                       \
+nxt_pragma_loop_disable_vectorization                                         \
+    __asm__("")
+
+#else
+
+#define                                                                       \
+nxt_pragma_loop_disable_vectorization
+
+#endif
+
+
+#if (NXT_HAVE_BUILTIN_EXPECT)
+
+#define                                                                       \
+nxt_fast_path(x)                                                              \
+    __builtin_expect((long) (x), 1)
+
+#define                                                                       \
+nxt_slow_path(x)                                                              \
+    __builtin_expect((long) (x), 0)
+
+
+#else
+
+#define                                                                       \
+nxt_fast_path(x)                                                              \
+    (x)
+
+#define                                                                       \
+nxt_slow_path(x)                                                              \
+    (x)
+
+#endif
+
+
+#if (NXT_HAVE_BUILTIN_UNREACHABLE)
+
+#define                                                                       \
+nxt_unreachable()                                                             \
+    __builtin_unreachable()
+
+#else
+
+#define                                                                       \
+nxt_unreachable()
+
+#endif
+
+
+#if (NXT_HAVE_BUILTIN_PREFETCH)
+
+#define                                                                       \
+nxt_prefetch(a)                                                               \
+    __builtin_prefetch(a)
+
+#else
+
+#define                                                                       \
+nxt_prefetch(a)
+
+#endif
+
+
+#if (NXT_HAVE_GCC_ATTRIBUTE_VISIBILITY)
+
+#define NXT_EXPORT         __attribute__((visibility("default")))
+
+#else
+
+#define NXT_EXPORT
+
+#endif
+
+
+#if (NXT_HAVE_GCC_ATTRIBUTE_MALLOC)
+
+#define NXT_MALLOC_LIKE    __attribute__((__malloc__))
+
+#else
+
+#define NXT_MALLOC_LIKE
+
+#endif
+
+
+#if (NXT_HAVE_GCC_ATTRIBUTE_ALIGNED)
+
+#define nxt_aligned(x)     __attribute__((aligned(x)))
+
+#else
+
+#define nxt_aligned(x)
+
+#endif
+
+
+#ifndef NXT_ALIGNMENT
+
+#if (NXT_SOLARIS)
+#define NXT_ALIGNMENT      _POINTER_ALIGNMENT     /* x86_64: 8,   i386: 4    */
+                                                  /* sparcv9: 8,  sparcv8: 4 */
+#elif (__i386__ || __i386)
+#define NXT_ALIGNMENT      4
+
+#elif (__arm__)
+#define NXT_ALIGNMENT      8         /* 32-bit ARM may use 64-bit load/store */
+
+#elif (__ia64__)
+#define NXT_ALIGNMENT      8         /* long long */
+
+#else
+#define NXT_ALIGNMENT      NXT_PTR_SIZE
+#endif
+
+#endif
+
+
+#ifndef NXT_MAX_ALIGNMENT
+
+#if (NXT_SOLARIS)
+#define NXT_MAX_ALIGNMENT  _MAX_ALIGNMENT        /* x86_64: 16,   i386: 4    */
+                                                 /* sparcv9: 16,  sparcv8: 8 */
+#elif (__i386__ || __i386)
+#define NXT_MAX_ALIGNMENT  4
+
+#elif (__arm__)
+#define NXT_MAX_ALIGNMENT  16
+
+#elif (__ia64__)
+#define NXT_MAX_ALIGNMENT  16
+
+#else
+#define NXT_MAX_ALIGNMENT  16
+#endif
+
+#endif
+
+
+#define                                                                       \
+nxt_alloca(size)                                                              \
+    alloca(size)
+
+
+#define                                                                       \
+nxt_container_of(p, type, field)                                              \
+    (type *) ((u_char *) (p) - offsetof(type, field))
+
+
+#define                                                                       \
+nxt_nitems(x)                                                                 \
+    (sizeof(x) / sizeof((x)[0]))
+
+
+/* GCC and Clang use __builtin_abs() instead of libc abs(). */
+
+#define                                                                       \
+nxt_abs(val)                                                                  \
+    abs(val)
+
+
+#define                                                                       \
+nxt_max(val1, val2)                                                           \
+    ((val1 < val2) ? (val2) : (val1))
+
+
+#define                                                                       \
+nxt_min(val1, val2)                                                           \
+    ((val1 > val2) ? (val2) : (val1))
+
+
+#define                                                                       \
+nxt_bswap32(val)                                                              \
+    (   ((val)               >> 24)                                           \
+     | (((val) & 0x00ff0000) >>  8)                                           \
+     | (((val) & 0x0000ff00) <<  8)                                           \
+     |  ((val)               << 24))
+
+
+
+#define                                                                       \
+nxt_align_size(d, a)                                                          \
+    (((d) + ((size_t) (a) - 1)) & ~((size_t) (a) - 1))
+
+
+#define                                                                       \
+nxt_align_ptr(p, a)                                                           \
+    (u_char *) (((uintptr_t) (p) + ((uintptr_t) (a) - 1))                     \
+                  & ~((uintptr_t) (a) - 1))
+
+#define                                                                       \
+nxt_trunc_ptr(p, a)                                                           \
+    (u_char *) ((uintptr_t) (p) & ~((uintptr_t) (a) - 1))
+
+
+#endif /* _NXT_CLANG_H_INCLUDED_ */