pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/port/pg_bitutils.h

@@ -1,339 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_bitutils.h
- *	  Miscellaneous functions for bit-wise operations.
- *
- *
- * Copyright (c) 2019-2023, PostgreSQL Global Development Group
- *
- * src/include/port/pg_bitutils.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_BITUTILS_H
-#define PG_BITUTILS_H
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#define HAVE_BITSCAN_FORWARD
-#define HAVE_BITSCAN_REVERSE
-
-#else
-#if defined(HAVE__BUILTIN_CTZ)
-#define HAVE_BITSCAN_FORWARD
-#endif
-
-#if defined(HAVE__BUILTIN_CLZ)
-#define HAVE_BITSCAN_REVERSE
-#endif
-#endif							/* _MSC_VER */
-
-extern PGDLLIMPORT const uint8 pg_leftmost_one_pos[256];
-extern PGDLLIMPORT const uint8 pg_rightmost_one_pos[256];
-extern PGDLLIMPORT const uint8 pg_number_of_ones[256];
-
-/*
- * pg_leftmost_one_pos32
- *		Returns the position of the most significant set bit in "word",
- *		measured from the least significant bit.  word must not be 0.
- */
-static inline int
-pg_leftmost_one_pos32(uint32 word)
-{
-#ifdef HAVE__BUILTIN_CLZ
-	Assert(word != 0);
-
-	return 31 - __builtin_clz(word);
-#elif defined(_MSC_VER)
-	unsigned long result;
-	bool		non_zero;
-
-	non_zero = _BitScanReverse(&result, word);
-	Assert(non_zero);
-	return (int) result;
-#else
-	int			shift = 32 - 8;
-
-	Assert(word != 0);
-
-	while ((word >> shift) == 0)
-		shift -= 8;
-
-	return shift + pg_leftmost_one_pos[(word >> shift) & 255];
-#endif							/* HAVE__BUILTIN_CLZ */
-}
-
-/*
- * pg_leftmost_one_pos64
- *		As above, but for a 64-bit word.
- */
-static inline int
-pg_leftmost_one_pos64(uint64 word)
-{
-#ifdef HAVE__BUILTIN_CLZ
-	Assert(word != 0);
-
-#if defined(HAVE_LONG_INT_64)
-	return 63 - __builtin_clzl(word);
-#elif defined(HAVE_LONG_LONG_INT_64)
-	return 63 - __builtin_clzll(word);
-#else
-#error must have a working 64-bit integer datatype
-#endif							/* HAVE_LONG_INT_64 */
-
-#elif defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_ARM64))
-	unsigned long result;
-	bool		non_zero;
-
-	non_zero = _BitScanReverse64(&result, word);
-	Assert(non_zero);
-	return (int) result;
-#else
-	int			shift = 64 - 8;
-
-	Assert(word != 0);
-
-	while ((word >> shift) == 0)
-		shift -= 8;
-
-	return shift + pg_leftmost_one_pos[(word >> shift) & 255];
-#endif							/* HAVE__BUILTIN_CLZ */
-}
-
-/*
- * pg_rightmost_one_pos32
- *		Returns the position of the least significant set bit in "word",
- *		measured from the least significant bit.  word must not be 0.
- */
-static inline int
-pg_rightmost_one_pos32(uint32 word)
-{
-#ifdef HAVE__BUILTIN_CTZ
-	Assert(word != 0);
-
-	return __builtin_ctz(word);
-#elif defined(_MSC_VER)
-	unsigned long result;
-	bool		non_zero;
-
-	non_zero = _BitScanForward(&result, word);
-	Assert(non_zero);
-	return (int) result;
-#else
-	int			result = 0;
-
-	Assert(word != 0);
-
-	while ((word & 255) == 0)
-	{
-		word >>= 8;
-		result += 8;
-	}
-	result += pg_rightmost_one_pos[word & 255];
-	return result;
-#endif							/* HAVE__BUILTIN_CTZ */
-}
-
-/*
- * pg_rightmost_one_pos64
- *		As above, but for a 64-bit word.
- */
-static inline int
-pg_rightmost_one_pos64(uint64 word)
-{
-#ifdef HAVE__BUILTIN_CTZ
-	Assert(word != 0);
-
-#if defined(HAVE_LONG_INT_64)
-	return __builtin_ctzl(word);
-#elif defined(HAVE_LONG_LONG_INT_64)
-	return __builtin_ctzll(word);
-#else
-#error must have a working 64-bit integer datatype
-#endif							/* HAVE_LONG_INT_64 */
-
-#elif defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_ARM64))
-	unsigned long result;
-	bool		non_zero;
-
-	non_zero = _BitScanForward64(&result, word);
-	Assert(non_zero);
-	return (int) result;
-#else
-	int			result = 0;
-
-	Assert(word != 0);
-
-	while ((word & 255) == 0)
-	{
-		word >>= 8;
-		result += 8;
-	}
-	result += pg_rightmost_one_pos[word & 255];
-	return result;
-#endif							/* HAVE__BUILTIN_CTZ */
-}
-
-/*
- * pg_nextpower2_32
- *		Returns the next higher power of 2 above 'num', or 'num' if it's
- *		already a power of 2.
- *
- * 'num' mustn't be 0 or be above PG_UINT32_MAX / 2 + 1.
- */
-static inline uint32
-pg_nextpower2_32(uint32 num)
-{
-	Assert(num > 0 && num <= PG_UINT32_MAX / 2 + 1);
-
-	/*
-	 * A power 2 number has only 1 bit set.  Subtracting 1 from such a number
-	 * will turn on all previous bits resulting in no common bits being set
-	 * between num and num-1.
-	 */
-	if ((num & (num - 1)) == 0)
-		return num;				/* already power 2 */
-
-	return ((uint32) 1) << (pg_leftmost_one_pos32(num) + 1);
-}
-
-/*
- * pg_nextpower2_64
- *		Returns the next higher power of 2 above 'num', or 'num' if it's
- *		already a power of 2.
- *
- * 'num' mustn't be 0 or be above PG_UINT64_MAX / 2  + 1.
- */
-static inline uint64
-pg_nextpower2_64(uint64 num)
-{
-	Assert(num > 0 && num <= PG_UINT64_MAX / 2 + 1);
-
-	/*
-	 * A power 2 number has only 1 bit set.  Subtracting 1 from such a number
-	 * will turn on all previous bits resulting in no common bits being set
-	 * between num and num-1.
-	 */
-	if ((num & (num - 1)) == 0)
-		return num;				/* already power 2 */
-
-	return ((uint64) 1) << (pg_leftmost_one_pos64(num) + 1);
-}
-
-/*
- * pg_prevpower2_32
- *		Returns the next lower power of 2 below 'num', or 'num' if it's
- *		already a power of 2.
- *
- * 'num' mustn't be 0.
- */
-static inline uint32
-pg_prevpower2_32(uint32 num)
-{
-	return ((uint32) 1) << pg_leftmost_one_pos32(num);
-}
-
-/*
- * pg_prevpower2_64
- *		Returns the next lower power of 2 below 'num', or 'num' if it's
- *		already a power of 2.
- *
- * 'num' mustn't be 0.
- */
-static inline uint64
-pg_prevpower2_64(uint64 num)
-{
-	return ((uint64) 1) << pg_leftmost_one_pos64(num);
-}
-
-/*
- * pg_ceil_log2_32
- *		Returns equivalent of ceil(log2(num))
- */
-static inline uint32
-pg_ceil_log2_32(uint32 num)
-{
-	if (num < 2)
-		return 0;
-	else
-		return pg_leftmost_one_pos32(num - 1) + 1;
-}
-
-/*
- * pg_ceil_log2_64
- *		Returns equivalent of ceil(log2(num))
- */
-static inline uint64
-pg_ceil_log2_64(uint64 num)
-{
-	if (num < 2)
-		return 0;
-	else
-		return pg_leftmost_one_pos64(num - 1) + 1;
-}
-
-/*
- * With MSVC on x86_64 builds, try using native popcnt instructions via the
- * __popcnt and __popcnt64 intrinsics.  These don't work the same as GCC's
- * __builtin_popcount* intrinsic functions as they always emit popcnt
- * instructions.
- */
-#if defined(_MSC_VER) && defined(_M_AMD64)
-#define HAVE_X86_64_POPCNTQ
-#endif
-
-/*
- * On x86_64, we can use the hardware popcount instruction, but only if
- * we can verify that the CPU supports it via the cpuid instruction.
- *
- * Otherwise, we fall back to a hand-rolled implementation.
- */
-#ifdef HAVE_X86_64_POPCNTQ
-#if defined(HAVE__GET_CPUID) || defined(HAVE__CPUID)
-#define TRY_POPCNT_FAST 1
-#endif
-#endif
-
-#ifdef TRY_POPCNT_FAST
-/* Attempt to use the POPCNT instruction, but perform a runtime check first */
-extern int	(*pg_popcount32) (uint32 word);
-extern int	(*pg_popcount64) (uint64 word);
-
-#else
-/* Use a portable implementation -- no need for a function pointer. */
-extern int	pg_popcount32(uint32 word);
-extern int	pg_popcount64(uint64 word);
-
-#endif							/* TRY_POPCNT_FAST */
-
-/* Count the number of one-bits in a byte array */
-extern uint64 pg_popcount(const char *buf, int bytes);
-
-/*
- * Rotate the bits of "word" to the right/left by n bits.
- */
-static inline uint32
-pg_rotate_right32(uint32 word, int n)
-{
-	return (word >> n) | (word << (32 - n));
-}
-
-static inline uint32
-pg_rotate_left32(uint32 word, int n)
-{
-	return (word << n) | (word >> (32 - n));
-}
-
-/* size_t variants of the above, as required */
-
-#if SIZEOF_SIZE_T == 4
-#define pg_leftmost_one_pos_size_t pg_leftmost_one_pos32
-#define pg_nextpower2_size_t pg_nextpower2_32
-#define pg_prevpower2_size_t pg_prevpower2_32
-#else
-#define pg_leftmost_one_pos_size_t pg_leftmost_one_pos64
-#define pg_nextpower2_size_t pg_nextpower2_64
-#define pg_prevpower2_size_t pg_prevpower2_64
-#endif
-
-#endif							/* PG_BITUTILS_H */

data/ext/pg_query/include/port/pg_bswap.h

@@ -1,161 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_bswap.h
- *	  Byte swapping.
- *
- * Macros for reversing the byte order of 16, 32 and 64-bit unsigned integers.
- * For example, 0xAABBCCDD becomes 0xDDCCBBAA.  These are just wrappers for
- * built-in functions provided by the compiler where support exists.
- *
- * Note that all of these functions accept unsigned integers as arguments and
- * return the same.  Use caution when using these wrapper macros with signed
- * integers.
- *
- * Copyright (c) 2015-2023, PostgreSQL Global Development Group
- *
- * src/include/port/pg_bswap.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_BSWAP_H
-#define PG_BSWAP_H
-
-
-/*
- * In all supported versions msvc provides _byteswap_* functions in stdlib.h,
- * already included by c.h.
- */
-
-
-/* implementation of uint16 pg_bswap16(uint16) */
-#if defined(HAVE__BUILTIN_BSWAP16)
-
-#define pg_bswap16(x) __builtin_bswap16(x)
-
-#elif defined(_MSC_VER)
-
-#define pg_bswap16(x) _byteswap_ushort(x)
-
-#else
-
-static inline uint16
-pg_bswap16(uint16 x)
-{
-	return
-		((x << 8) & 0xff00) |
-		((x >> 8) & 0x00ff);
-}
-
-#endif							/* HAVE__BUILTIN_BSWAP16 */
-
-
-/* implementation of uint32 pg_bswap32(uint32) */
-#if defined(HAVE__BUILTIN_BSWAP32)
-
-#define pg_bswap32(x) __builtin_bswap32(x)
-
-#elif defined(_MSC_VER)
-
-#define pg_bswap32(x) _byteswap_ulong(x)
-
-#else
-
-static inline uint32
-pg_bswap32(uint32 x)
-{
-	return
-		((x << 24) & 0xff000000) |
-		((x << 8) & 0x00ff0000) |
-		((x >> 8) & 0x0000ff00) |
-		((x >> 24) & 0x000000ff);
-}
-
-#endif							/* HAVE__BUILTIN_BSWAP32 */
-
-
-/* implementation of uint64 pg_bswap64(uint64) */
-#if defined(HAVE__BUILTIN_BSWAP64)
-
-#define pg_bswap64(x) __builtin_bswap64(x)
-
-
-#elif defined(_MSC_VER)
-
-#define pg_bswap64(x) _byteswap_uint64(x)
-
-#else
-
-static inline uint64
-pg_bswap64(uint64 x)
-{
-	return
-		((x << 56) & UINT64CONST(0xff00000000000000)) |
-		((x << 40) & UINT64CONST(0x00ff000000000000)) |
-		((x << 24) & UINT64CONST(0x0000ff0000000000)) |
-		((x << 8) & UINT64CONST(0x000000ff00000000)) |
-		((x >> 8) & UINT64CONST(0x00000000ff000000)) |
-		((x >> 24) & UINT64CONST(0x0000000000ff0000)) |
-		((x >> 40) & UINT64CONST(0x000000000000ff00)) |
-		((x >> 56) & UINT64CONST(0x00000000000000ff));
-}
-#endif							/* HAVE__BUILTIN_BSWAP64 */
-
-
-/*
- * Portable and fast equivalents for ntohs, ntohl, htons, htonl,
- * additionally extended to 64 bits.
- */
-#ifdef WORDS_BIGENDIAN
-
-#define pg_hton16(x)		(x)
-#define pg_hton32(x)		(x)
-#define pg_hton64(x)		(x)
-
-#define pg_ntoh16(x)		(x)
-#define pg_ntoh32(x)		(x)
-#define pg_ntoh64(x)		(x)
-
-#else
-
-#define pg_hton16(x)		pg_bswap16(x)
-#define pg_hton32(x)		pg_bswap32(x)
-#define pg_hton64(x)		pg_bswap64(x)
-
-#define pg_ntoh16(x)		pg_bswap16(x)
-#define pg_ntoh32(x)		pg_bswap32(x)
-#define pg_ntoh64(x)		pg_bswap64(x)
-
-#endif							/* WORDS_BIGENDIAN */
-
-
-/*
- * Rearrange the bytes of a Datum from big-endian order into the native byte
- * order.  On big-endian machines, this does nothing at all.  Note that the C
- * type Datum is an unsigned integer type on all platforms.
- *
- * One possible application of the DatumBigEndianToNative() macro is to make
- * bitwise comparisons cheaper.  A simple 3-way comparison of Datums
- * transformed by the macro (based on native, unsigned comparisons) will return
- * the same result as a memcmp() of the corresponding original Datums, but can
- * be much cheaper.  It's generally safe to do this on big-endian systems
- * without any special transformation occurring first.
- *
- * If SIZEOF_DATUM is not defined, then postgres.h wasn't included and these
- * macros probably shouldn't be used, so we define nothing.  Note that
- * SIZEOF_DATUM == 8 would evaluate as 0 == 8 in that case, potentially
- * leading to the wrong implementation being selected and confusing errors, so
- * defining nothing is safest.
- */
-#ifdef SIZEOF_DATUM
-#ifdef WORDS_BIGENDIAN
-#define		DatumBigEndianToNative(x)	(x)
-#else							/* !WORDS_BIGENDIAN */
-#if SIZEOF_DATUM == 8
-#define		DatumBigEndianToNative(x)	pg_bswap64(x)
-#else							/* SIZEOF_DATUM != 8 */
-#define		DatumBigEndianToNative(x)	pg_bswap32(x)
-#endif							/* SIZEOF_DATUM == 8 */
-#endif							/* WORDS_BIGENDIAN */
-#endif							/* SIZEOF_DATUM */
-
-#endif							/* PG_BSWAP_H */

data/ext/pg_query/include/port/pg_crc32c.h

@@ -1,101 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_crc32c.h
- *	  Routines for computing CRC-32C checksums.
- *
- * The speed of CRC-32C calculation has a big impact on performance, so we
- * jump through some hoops to get the best implementation for each
- * platform. Some CPU architectures have special instructions for speeding
- * up CRC calculations (e.g. Intel SSE 4.2), on other platforms we use the
- * Slicing-by-8 algorithm which uses lookup tables.
- *
- * The public interface consists of four macros:
- *
- * INIT_CRC32C(crc)
- *		Initialize a CRC accumulator
- *
- * COMP_CRC32C(crc, data, len)
- *		Accumulate some (more) bytes into a CRC
- *
- * FIN_CRC32C(crc)
- *		Finish a CRC calculation
- *
- * EQ_CRC32C(c1, c2)
- *		Check for equality of two CRCs.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/port/pg_crc32c.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_CRC32C_H
-#define PG_CRC32C_H
-
-#include "port/pg_bswap.h"
-
-typedef uint32 pg_crc32c;
-
-/* The INIT and EQ macros are the same for all implementations. */
-#define INIT_CRC32C(crc) ((crc) = 0xFFFFFFFF)
-#define EQ_CRC32C(c1, c2) ((c1) == (c2))
-
-#if defined(USE_SSE42_CRC32C)
-/* Use Intel SSE4.2 instructions. */
-#define COMP_CRC32C(crc, data, len) \
-	((crc) = pg_comp_crc32c_sse42((crc), (data), (len)))
-#define FIN_CRC32C(crc) ((crc) ^= 0xFFFFFFFF)
-
-extern pg_crc32c pg_comp_crc32c_sse42(pg_crc32c crc, const void *data, size_t len);
-
-#elif defined(USE_ARMV8_CRC32C)
-/* Use ARMv8 CRC Extension instructions. */
-
-#define COMP_CRC32C(crc, data, len)							\
-	((crc) = pg_comp_crc32c_armv8((crc), (data), (len)))
-#define FIN_CRC32C(crc) ((crc) ^= 0xFFFFFFFF)
-
-extern pg_crc32c pg_comp_crc32c_armv8(pg_crc32c crc, const void *data, size_t len);
-
-#elif defined(USE_SSE42_CRC32C_WITH_RUNTIME_CHECK) || defined(USE_ARMV8_CRC32C_WITH_RUNTIME_CHECK)
-
-/*
- * Use Intel SSE 4.2 or ARMv8 instructions, but perform a runtime check first
- * to check that they are available.
- */
-#define COMP_CRC32C(crc, data, len) \
-	((crc) = pg_comp_crc32c((crc), (data), (len)))
-#define FIN_CRC32C(crc) ((crc) ^= 0xFFFFFFFF)
-
-extern pg_crc32c pg_comp_crc32c_sb8(pg_crc32c crc, const void *data, size_t len);
-extern pg_crc32c (*pg_comp_crc32c) (pg_crc32c crc, const void *data, size_t len);
-
-#ifdef USE_SSE42_CRC32C_WITH_RUNTIME_CHECK
-extern pg_crc32c pg_comp_crc32c_sse42(pg_crc32c crc, const void *data, size_t len);
-#endif
-#ifdef USE_ARMV8_CRC32C_WITH_RUNTIME_CHECK
-extern pg_crc32c pg_comp_crc32c_armv8(pg_crc32c crc, const void *data, size_t len);
-#endif
-
-#else
-/*
- * Use slicing-by-8 algorithm.
- *
- * On big-endian systems, the intermediate value is kept in reverse byte
- * order, to avoid byte-swapping during the calculation. FIN_CRC32C reverses
- * the bytes to the final order.
- */
-#define COMP_CRC32C(crc, data, len) \
-	((crc) = pg_comp_crc32c_sb8((crc), (data), (len)))
-#ifdef WORDS_BIGENDIAN
-#define FIN_CRC32C(crc) ((crc) = pg_bswap32(crc) ^ 0xFFFFFFFF)
-#else
-#define FIN_CRC32C(crc) ((crc) ^= 0xFFFFFFFF)
-#endif
-
-extern pg_crc32c pg_comp_crc32c_sb8(pg_crc32c crc, const void *data, size_t len);
-
-#endif
-
-#endif							/* PG_CRC32C_H */