Solana uses its own custom replacement for stdint

Author: kbowers-jump

program/src/oracle/model/model.h

@@ -1,7 +1,7 @@
 #ifndef _pyth_oracle_model_model_h_
 #define _pyth_oracle_model_model_h_
 
-#include <stdint.h>
+#include "../util/compat_stdint.h"
 #include <stdalign.h>
 
 #ifdef __cplusplus

program/src/oracle/sort/tmpl/sort_stable.c

@@ -57,8 +57,8 @@
    Other defines exist to change the sort criteria / direction, linkage
    and so forth.  See below for details. */
 
-#include <stdint.h>           /* For uint64_t */
-#include "../../util/align.h" /* For ALIGN_UP */
+#include "../../util/compat_stdint.h" /* For uint64_t */
+#include "../../util/align.h"         /* For ALIGN_UP */
 
 #ifndef SORT_NAME
 #error "Define SORT_NAME"

program/src/oracle/util/align.h

@@ -0,0 +1,57 @@
+#ifndef _pyth_oracle_util_align_h_
+#define _pyth_oracle_util_align_h_
+
+#include "compat_stdint.h" /* For uintptr_t */
+#include <stdalign.h>      /* For alignof */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* align_ispow2 returns non-zero if a is a non-negative integral power
+   of 2 and zero otherwise. */
+
+static inline int
+align_ispow2( uintptr_t a ) {
+  uintptr_t mask = a - (uintptr_t)1;
+  return (a>(uintptr_t)0) & !(a & mask);
+}
+
+/* align_isaligned returns non-zero if p has byte alignment a.  Assumes
+   align_ispow2(a) is true. */
+
+static inline int
+align_isaligned( void *    p,
+                 uintptr_t a ) {
+  uintptr_t mask = a - (uintptr_t)1;
+  return !(((uintptr_t)p) & mask);
+}
+
+/* align_dn/align_up aligns p to the first byte at or before / after p
+   with alignment a.  Assumes align_ispow2(a) is true. */
+
+static inline void *
+align_dn( void *    p,
+          uintptr_t a ) {
+  uintptr_t mask = a - (uintptr_t)1;
+  return (void *)(((uintptr_t)p) & (~mask));
+}
+
+static inline void *
+align_up( void *    p,
+          uintptr_t a ) {
+  uintptr_t mask = a - (uintptr_t)1;
+  return (void *)((((uintptr_t)p) + mask) & (~mask));
+}
+
+/* Helper macros for aligning pointers up or down to compatible
+   alignments for type T.  FIXME: ADD UNIT TEST COVERAGE */
+
+#define ALIGN_DN( p, T ) ((T *)align_dn( p, (uintptr_t)alignof(T) ))
+#define ALIGN_UP( p, T ) ((T *)align_up( p, (uintptr_t)alignof(T) ))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _pyth_oracle_util_align_h_ */

program/src/oracle/util/hash.h

@@ -0,0 +1,74 @@
+#ifndef _pyth_oracle_util_hash_h_
+#define _pyth_oracle_util_hash_h_
+
+/* Useful hashing utilities */
+
+#include "compat_stdint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* High quality (full avalanche) high speed integer to integer hashing.
+   hash_uint32 has the properties that [0,2^32) hashes to a random
+   looking permutation of [0,2^32) and hash(0)==0.  Similarly for
+   hash_uint64.  Based on Google's Murmur3 hash finalizer (public
+   domain).  Not cryptographically secure but passes various strict
+   tests of randomness when used as a PRNG (see prng.h). */
+
+static inline uint32_t
+hash_uint32( uint32_t x ) {
+  x ^= x >> 16;
+  x *= UINT32_C( 0x85ebca6b );
+  x ^= x >> 13;
+  x *= UINT32_C( 0xc2b2ae35 );
+  x ^= x >> 16;
+  return x;
+}
+
+static inline uint64_t
+hash_uint64( uint64_t x ) {
+  x ^= x >> 33;
+  x *= UINT64_C( 0xff51afd7ed558ccd );
+  x ^= x >> 33;
+  x *= UINT64_C( 0xc4ceb9fe1a85ec53 );
+  x ^= x >> 33;
+  return x;
+}
+
+/* Inverses of the above.  E.g.:
+     hash_inverse_uint32( hash_uint32( (uint32_t)x ) )==(uint32_t)x
+   and:
+     hash_uint32( hash_inverse_uint32( (uint32_t)x ) )==(uint32_t)x
+   Similarly for hash_inverse_uint64.  These by themselves are similar
+   quality hashes to the above and having the inverses of the above can
+   be useful.  The fact these have (nearly) identical operations /
+   operation counts concretely demonstrates that none of these are
+   standalone cryptographically secure. */
+
+static inline uint32_t
+hash_inverse_uint32( uint32_t x ) {
+  x ^= x >> 16;
+  x *= UINT32_C( 0x7ed1b41d );
+  x ^= (x >> 13) ^ (x >> 26);
+  x *= UINT32_C( 0xa5cb9243 );
+  x ^= x >> 16;
+  return x;
+}
+
+static inline uint64_t
+hash_inverse_uint64( uint64_t x ) {
+  x ^= x >> 33;
+  x *= UINT64_C( 0x9cb4b2f8129337db );
+  x ^= x >> 33;
+  x *= UINT64_C( 0x4f74430c22a54005 );
+  x ^= x >> 33;
+  return x;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _pyth_oracle_util_hash_h_ */
+

program/src/oracle/util/sar.h

@@ -0,0 +1,74 @@
+#ifndef _pyth_oracle_util_sar_h_
+#define _pyth_oracle_util_sar_h_
+
+/* Portable arithmetic shift right. */
+
+#include "compat_stdint.h"
+
+/* Define PYTH_ORACLE_UTIL_SAR_USE_PLATFORM to non-zero if the platform
+   does arithmetic right shift signed integer and zero if the platform
+   does not or is not known to.  PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+   defaults to zero. */
+
+#ifndef PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+#define PYTH_ORACLE_UTIL_SAR_USE_PLATFORM 0
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static inline int8_t
+sar_int8( int8_t x,
+          int    n ) { /* Assumed in [0,7] */
+# if PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+  return x >> n;
+# else
+  uint8_t ux = (uint8_t)x;
+  uint8_t s  = (uint8_t)-(ux >> 7); /* get the sign, ((int8_t)s)==-1 if x<0 and 0 otherwise */
+  return (int8_t)(((ux ^ s) >> n) ^ s);
+# endif
+}
+
+static inline int16_t
+sar_int16( int16_t x,
+           int     n ) { /* Assumed in [0,15] */
+# if PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+  return x >> n;
+# else
+  uint16_t ux = (uint16_t)x;
+  uint16_t s  = (uint16_t)-(ux >> 15); /* get the sign, ((int16_t)s)==-1 if x<0 and 0 otherwise */
+  return (int16_t)(((ux ^ s) >> n) ^ s);
+# endif
+}
+
+static inline int32_t
+sar_int32( int32_t x,
+           int     n ) { /* Assumed in [0,31] */
+# if PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+  return x >> n;
+# else
+  uint32_t ux = (uint32_t)x;
+  uint32_t s  = -(ux >> 31); /* get the sign, ((int32_t)s)==-1 if x<0 and 0 otherwise */
+  return (int32_t)(((ux ^ s) >> n) ^ s);
+# endif
+}
+
+static inline int64_t
+sar_int64( int64_t x,
+           int     n ) { /* Assumed in [0,63] */
+# if PYTH_ORACLE_UTIL_SAR_USE_PLATFORM
+  return x >> n;
+# else
+  uint64_t ux = (uint64_t)x;
+  uint64_t s  = -(ux >> 63); /* get the sign, ((int64_t)s)==-1 if x<0 and 0 otherwise */
+  return (int64_t)(((ux ^ s) >> n) ^ s);
+# endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _pyth_oracle_util_sar_h_ */
+