#pragma GCC diagnostic push

 #if defined(__clang__)

 #pragma GCC diagnostic ignored "-Wsync-fetch-and-nand-semantics-changed"

 #pragma GCC diagnostic ignored "-Wsync-nand"

 #endif

 StgWord

 hs_ctz64(StgWord64 x)

 {

   /* On Linux/i386, the 64bit `__builtin_ctzll()` intrinsic doesn't

      get inlined by GCC but rather a short `__ctzdi2` runtime function

      is inserted when needed into compiled object files.

     x86_init_fpu();

 }

 void __attribute__((alias("_fpreset"))) fpreset(void);

 /* Set the console's CodePage to UTF-8 if using the new I/O manager and the CP

    is still the default one.  */

       RTS_INTCHAR_SYMBOLS

 // 64-bit support functions in libgcc.a

 #define RTS_LIBGCC_SYMBOLS                             \

       SymI_NeedsProto(__divdi3)                        \

       SymI_NeedsProto(__udivdi3)                       \

       SymI_NeedsProto(__ashrdi3)                       \

       SymI_NeedsProto(__lshrdi3)                       \

       SymI_NeedsProto(__fixunsdfdi)

 #define RTS_LIBGCC_SYMBOLS                             \

       SymI_NeedsProto(__udivti3)                       \

       SymI_NeedsProto(__umodti3)

 #include "rts/Types.h"

 #include "rts/Time.h"

 #define ATTRIBUTE_ALIGNED(n) __attribute__((aligned(n)))

 // Symbols that are extern, but private to the RTS, are declared

 // with visibility "hidden" to hide them outside the RTS shared

 // library.

 #define RTS_PRIVATE  GNUC3_ATTRIBUTE(visibility("hidden"))

 #define RTS_UNLIKELY(p) __builtin_expect((p),0)

 #define RTS_LIKELY(p) __builtin_expect(!!(p), 1)

 /* __builtin_unreachable is supported since GNU C 4.5 */

 #define RTS_UNREACHABLE __builtin_unreachable()

 /* Prefetch primitives */

 #define prefetchForRead(ptr) __builtin_prefetch(ptr, 0)

    Useful macros and inline functions

    -------------------------------------------------------------------------- */

 #define stg_min(a,b) ({typeof(a) _a = (a), _b = (b); _a <= _b ? _a : _b; })

 #define stg_max(a,b) ({typeof(a) _a = (a), _b = (b); _a <= _b ? _b : _a; })

 /* -------------------------------------------------------------------------- */

 /*

  * GCC attributes

  */

 #define GNU_ATTRIBUTE(at) __attribute__((at))

 #define GNUC3_ATTRIBUTE(at) __attribute__((at))

 /* Used to mark a switch case that falls-through */

 // N.B. Don't enable fallthrough annotations when compiling with Clang.

 // Apparently clang doesn't enable implicitly fallthrough warnings by default

 // http://llvm.org/viewvc/llvm-project?revision=167655&view=revision

 #define FALLTHROUGH ((void)0)

 #endif /* __GNUC__ >= 7 */

 #define GNUC_ATTR_HOT __attribute__((hot))

 #else

 #define GNUC_ATTR_HOT /* nothing */

    See Note [Windows Stack allocations] */

 #if defined(__clang__)

 #define STG_NO_OPTIMIZE __attribute__((optnone))

 #else

 #endif

 // Mark a function as accepting a printf-like format string.

 /* However, on OS X, "gnu_printf" isn't recognised */

 #define STG_PRINTF_ATTR(fmt_arg, rest) GNUC3_ATTRIBUTE(format(printf, fmt_arg, rest))

 #define STG_RESTRICT __restrict__

 # define stg__has_attribute(attr) (0)

 #endif

     ((__GNUC__ > (major)) || \

       ((__GNUC__ == (major)) && (__GNUC_MINOR__ >= (minor))))

 /*

  * The versions of the `__malloc__` attribute which take arguments are only

 #include <stddef.h>

 #include <stdbool.h>

 typedef struct StgClosure_   StgClosure;

 typedef struct StgInfoTable_ StgInfoTable;

 typedef struct StgTSO_       StgTSO;

 log_2(W_ n)

 {

     ASSERT(n > 0 && n < (1<<NUM_FREE_LISTS));

     return CLZW(n) ^ (sizeof(StgWord)*8 - 1);

     // generates good code on x86.  __builtin_clz() compiles to bsr+xor, but

     // we want just bsr, so the xor here cancels out gcc's xor.

 }

 // log base 2 (ceiling), needs to support up to (2^NUM_FREE_LISTS)-1

 log_2_ceil(W_ n)

 {

     ASSERT(n > 0 && n < (1<<NUM_FREE_LISTS));

     uint32_t r = log_2(n);

     return (n & (n-1)) ? r+1 : r;

 }

 STATIC_INLINE void

 //         registers EAX, EDX, and ECX instead of on the stack. Functions that

 //         take a variable number of arguments will continue to be passed all of

 //         their arguments on the stack.

 #define REGPARM1 __attribute__((regparm(1)))

 #else

 #define REGPARM1

 #include <libkern/OSCacheControl.h>

 #endif

 /* On ARM and other platforms, we need to flush the cache after

    writing code into memory, so the processor reliably sees it. */

 void flushExec (W_ len, AdjustorExecutable exec_addr)

   /* On iOS we need to use the special 'sys_icache_invalidate' call. */

   sys_icache_invalidate(exec_addr, len);

 #elif defined(wasm32_HOST_ARCH)

   unsigned char* begin = (unsigned char*)exec_addr;

   unsigned char* end   = begin + len;

   __builtin___clear_cache((void*)begin, (void*)end);

 #endif

 }