1.1-7 (10d2920f) · Commits · Debian Med / libssw

debian/changelog

+5 −3

Original line number	Diff line number	Diff line
		libssw (1.1-7) UNRELEASED; urgency=medium
		libssw (1.1-7) unstable; urgency=medium

		* debian/patches/malloc: Include definition for malloc & free
		* debian/include/simde/x86/sse.h: drop "using"
		* debian/include/simde: sync with upstream 2019-12-27
		(098d150385ba618f945f953bc4d5ae306fd22f2e)
		* debian/libssw0.symbols: start tracking the library symbols

		-- Michael R. Crusoe <michael.crusoe@gmail.com> Fri, 13 Dec 2019 16:17:12 +0100
		-- Michael R. Crusoe <michael.crusoe@gmail.com> Thu, 26 Dec 2019 16:59:08 +0100

		libssw (1.1-6) unstable; urgency=medium

debian/include/simde/hedley.h

+565 −187

File changed.

Preview size limit exceeded, changes collapsed.

debian/include/simde/simde-common.h

+54 −23

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@
		HEDLEY_TINYC_VERSION_CHECK(0,9,24) \|\| \
		HEDLEY_TI_VERSION_CHECK(8,1,0)
		# define SIMDE_ALIGN(alignment) __attribute__((aligned(alignment)))
		#elif defined(_MSC_VER) && (!defined(_M_IX86) \|\| defined(_M_AMD64))
		#elif defined(_MSC_VER) && !(defined(_M_ARM) && !defined(_M_ARM64))
		# define SIMDE_ALIGN(alignment) __declspec(align(alignment))
		#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
		# define SIMDE_ALIGN(alignment) _Alignas(alignment)
		@@ -50,22 +50,22 @@
		#endif

		#define simde_assert_aligned(alignment, val) \
		simde_assert_int(((uintptr_t) (val)) % (alignment), ==, 0)
		simde_assert_int(HEDLEY_REINTERPRET_CAST(uintptr_t, HEDLEY_CONST_CAST(void, HEDLEY_REINTERPRET_CAST(const void, (val)))) % (alignment), ==, 0)

		/* TODO: this should really do something like
		HEDLEY_STATIC_CAST(T, (simde_assert_int(alignment, v), v))
		but I need to think about how to handle it in all compilers...
		may end up moving to Hedley, too. */
		#if HEDLEY_HAS_BUILTIN(__builtin_assume_aligned)
		# define SIMDE_CAST_ALIGN(alignment, T, v) ((T) __builtin_assume_aligned(v, alignment))
		# define SIMDE_CAST_ALIGN(alignment, T, v) HEDLEY_REINTERPRET_CAST(T, __builtin_assume_aligned(v, alignment))
		#elif HEDLEY_HAS_WARNING("-Wcast-align")
		# define SIMDE_CAST_ALIGN(alignment, T, v) \
		HEDLEY_DIAGNOSTIC_PUSH \
		_Pragma("clang diagnostic ignored \"-Wcast-align\"") \
		HEDLEY_STATIC_CAST(T, v) \
		HEDLEY_REINTERPRET_CAST(T, (v)) \
		HEDLEY_DIAGNOSTIC_POP
		#else
		# define SIMDE_CAST_ALIGN(alignment, T, v) HEDLEY_STATIC_CAST(T, v)
		# define SIMDE_CAST_ALIGN(alignment, T, v) HEDLEY_REINTERPRET_CAST(T, (v))
		#endif

		#if HEDLEY_GCC_HAS_ATTRIBUTE(vector_size,4,6,0)
		@@ -145,10 +145,21 @@
		# define SIMDE__END_DECLS HEDLEY_END_C_DECLS
		#endif

		#if HEDLEY_HAS_WARNING("-Wpedantic")
		# define SIMDE_DIAGNOSTIC_DISABLE_INT128 _Pragma("clang diagnostic ignored \"-Wpedantic\"")
		#elif defined(HEDLEY_GCC_VERSION)
		# define SIMDE_DIAGNOSTIC_DISABLE_INT128 _Pragma("GCC diagnostic ignored \"-Wpedantic\"")
		#else
		# define SIMDE_DIAGNOSTIC_DISABLE_INT128
		#endif

		#if defined(__SIZEOF_INT128__)
		# define SIMDE__HAVE_INT128
		HEDLEY_DIAGNOSTIC_PUSH
		SIMDE_DIAGNOSTIC_DISABLE_INT128
		typedef __int128 simde_int128;
		typedef unsigned __int128 simde_uint128;
		HEDLEY_DIAGNOSTIC_POP
		#endif

		/* TODO: we should at least make an attempt to detect the correct
		@@ -211,7 +222,10 @@ HEDLEY_STATIC_ASSERT(sizeof(simde_float64) == 8, "Unable to find 64-bit floating
		#if HEDLEY_HAS_BUILTIN(__builtin_shufflevector)
		# define SIMDE__SHUFFLE_VECTOR(elem_size, vec_size, a, b, ...) __builtin_shufflevector(a, b, __VA_ARGS__)
		#elif HEDLEY_GCC_HAS_BUILTIN(__builtin_shuffle,4,7,0) && !defined(__INTEL_COMPILER)
		# define SIMDE__SHUFFLE_VECTOR(elem_size, vec_size, a, b, ...) __builtin_shuffle(a, b, (int##elem_size##_t __attribute__((__vector_size__(vec_size)))) { __VA_ARGS__ })
		# define SIMDE__SHUFFLE_VECTOR(elem_size, vec_size, a, b, ...) (__extension__ ({ \
		int##elem_size##_t __attribute__((__vector_size__(vec_size))) simde_shuffle_ = { __VA_ARGS__ }; \
		__builtin_shuffle(a, b, simde_shuffle_); \
		}))
		#endif

		#if HEDLEY_GCC_HAS_BUILTIN(__builtin_convertvector,9,0,0)
		@@ -222,12 +236,21 @@ HEDLEY_STATIC_ASSERT(sizeof(simde_float64) == 8, "Unable to find 64-bit floating
		# define SIMDE_CONVERT_FTOI(T,v) \
		HEDLEY_DIAGNOSTIC_PUSH \
		_Pragma("clang diagnostic ignored \"-Wbad-function-cast\"") \
		((T) (v)) \
		HEDLEY_STATIC_CAST(T, (v)) \
		HEDLEY_DIAGNOSTIC_POP
		#else
		# define SIMDE_CONVERT_FTOI(T,v) ((T) (v))
		#endif


		#if HEDLEY_HAS_WARNING("-Wfloat-equal")
		# define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL _Pragma("clang diagnostic ignored \"-Wfloat-equal\"")
		#elif HEDLEY_GCC_VERSION_CHECK(3,0,0)
		# define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"")
		#else
		# define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL
		#endif

		/* Some algorithms are iterative, and fewer iterations means less
		accuracy. Lower values here will result in faster, but less
		accurate, calculations for some functions. */
		@@ -305,21 +328,29 @@ HEDLEY_STATIC_ASSERT(sizeof(simde_float64) == 8, "Unable to find 64-bit floating
		# endif
		#endif

		#if !defined(__cplusplus)
		#define SIMDE_F64_ALL_SET (((union { uint64_t u64; simde_float64 f64; }) { .u64 = ~UINT64_C(0x0) }).f64)
		#define SIMDE_F64_ALL_UNSET (((union { uint64_t u64; simde_float64 f64; }) { .u64 = UINT64_C(0x0) }).f64)
		#define SIMDE_F32_ALL_SET (((union { uint32_t u32; simde_float32 f32; }) { .u32 = ~UINT32_C(0x0) }).f32)
		#define SIMDE_F32_ALL_UNSET (((union { uint32_t u32; simde_float32 f32; }) { .u32 = UINT32_C(0x0) }).f32)
		#else
		static const union { uint64_t u64; simde_float64 f64; } simde_f64_all_set = { .u64 = ~UINT64_C(0) };
		static const union { uint64_t u64; simde_float64 f64; } simde_f64_all_unset = { .u64 = UINT64_C(0) };
		static const union { uint64_t u32; simde_float64 f32; } simde_f32_all_set = { .u32 = ~UINT32_C(0) };
		static const union { uint64_t u32; simde_float64 f32; } simde_f32_all_unset = { .u32 = UINT32_C(0) };

		# define SIMDE_F64_ALL_SET (simde_f64_all_set.f64)
		# define SIMDE_F64_ALL_UNSET (simde_f64_all_unset.f64)
		# define SIMDE_F32_ALL_SET (simde_f32_all_set.f32)
		# define SIMDE_F32_ALL_UNSET (simde_f32_all_unset.f32)
		#endif
		HEDLEY_ALWAYS_INLINE static
		simde_float32 simde_u32_to_f32(uint32_t val) {
		union {
		uint32_t u32;
		simde_float32 f32;
		} u;
		u.u32 = val;
		return u.f32;
		}

		HEDLEY_ALWAYS_INLINE static
		simde_float64 simde_u64_to_f64(uint64_t val) {
		union {
		uint64_t u64;
		simde_float64 f64;
		} u;
		u.u64 = val;
		return u.f64;
		}

		#define SIMDE_F32_ALL_SET (simde_u32_to_f32(~UINT32_C(0)))
		#define SIMDE_F32_ALL_UNSET (simde_u32_to_f32( UINT32_C(0)))
		#define SIMDE_F64_ALL_SET (simde_u64_to_f64(~UINT64_C(0)))
		#define SIMDE_F64_ALL_UNSET (simde_u64_to_f64( UINT64_C(0)))

		#endif /* !defined(SIMDE_COMMON_H) */

debian/include/simde/x86/mmx.h

+40 −11

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@

		# if defined(SIMDE_MMX_FORCE_NATIVE)
		# define SIMDE_MMX_NATIVE
		# elif defined(__MMX__) && !defined(SIMDE_MMX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE)
		# elif (defined(__MMX__) \|\| (defined(_MSC_VER) && defined(_M_IX86))) && !defined(SIMDE_MMX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE)
		# define SIMDE_MMX_NATIVE
		# elif defined(__ARM_NEON) && !defined(SIMDE_MMX_NO_NEON) && !defined(SIMDE_NO_NEON)
		# define SIMDE_MMX_NEON
		@@ -101,6 +101,13 @@ typedef union {
		#endif
		HEDLEY_STATIC_ASSERT(8 == sizeof(simde__m64), "__m64 size incorrect");

		HEDLEY_DIAGNOSTIC_PUSH

		/* Function has no EMMS instruction */
		#if defined(HEDLEY_MSVC_VERSION)
		#pragma warning(disable:4799)
		#endif

		#if defined(SIMDE_MMX_NATIVE)
		SIMDE__FUNCTION_ATTRIBUTES simde__m64 SIMDE__M64_FROM_NATIVE(__m64 v) { simde__m64 r; r.n = v; return r; }
		# define SIMDE__M64_TO_NATIVE(v) (v.n)
		@@ -721,11 +728,19 @@ simde_mm_set_pi8 (int8_t e7, int8_t e6, int8_t e5, int8_t e4, int8_t e3, int8_t
		SIMDE__FUNCTION_ATTRIBUTES
		simde__m64
		simde_x_mm_set_pu8 (uint8_t e7, uint8_t e6, uint8_t e5, uint8_t e4, uint8_t e3, uint8_t e2, uint8_t e1, uint8_t e0) {
		simde__m64 r;

		#if defined(SIMDE_MMX_NATIVE)
		return SIMDE__M64_FROM_NATIVE(_mm_set_pi8((int8_t) e7, (int8_t) e6, (int8_t) e5, (int8_t) e4,
		(int8_t) e3, (int8_t) e2, (int8_t) e1, (int8_t) e0));
		r.n = _mm_set_pi8(
		HEDLEY_STATIC_CAST(int8_t, e7),
		HEDLEY_STATIC_CAST(int8_t, e6),
		HEDLEY_STATIC_CAST(int8_t, e5),
		HEDLEY_STATIC_CAST(int8_t, e4),
		HEDLEY_STATIC_CAST(int8_t, e3),
		HEDLEY_STATIC_CAST(int8_t, e2),
		HEDLEY_STATIC_CAST(int8_t, e1),
		HEDLEY_STATIC_CAST(int8_t, e0));
		#else
		simde__m64 r;
		r.u8[0] = e0;
		r.u8[1] = e1;
		r.u8[2] = e2;
		@@ -734,8 +749,9 @@ simde_x_mm_set_pu8 (uint8_t e7, uint8_t e6, uint8_t e5, uint8_t e4, uint8_t e3,
		r.u8[5] = e5;
		r.u8[6] = e6;
		r.u8[7] = e7;
		return r;
		#endif

		return r;
		}

		SIMDE__FUNCTION_ATTRIBUTES
		@@ -759,29 +775,40 @@ simde_mm_set_pi16 (int16_t e3, int16_t e2, int16_t e1, int16_t e0) {
		SIMDE__FUNCTION_ATTRIBUTES
		simde__m64
		simde_x_mm_set_pu16 (uint16_t e3, uint16_t e2, uint16_t e1, uint16_t e0) {
		simde__m64 r;

		#if defined(SIMDE_MMX_NATIVE)
		return SIMDE__M64_FROM_NATIVE(_mm_set_pi16((int16_t) e3, (int16_t) e2, (int16_t) e1, (int16_t) e0));
		r.n = _mm_set_pi16(
		HEDLEY_STATIC_CAST(int16_t, e3),
		HEDLEY_STATIC_CAST(int16_t, e2),
		HEDLEY_STATIC_CAST(int16_t, e1),
		HEDLEY_STATIC_CAST(int16_t, e0)
		);
		#else
		simde__m64 r;
		r.u16[0] = e0;
		r.u16[1] = e1;
		r.u16[2] = e2;
		r.u16[3] = e3;
		return r;
		#endif

		return r;
		}

		SIMDE__FUNCTION_ATTRIBUTES
		simde__m64
		simde_x_mm_set_pu32 (uint32_t e1, uint32_t e0) {
		simde__m64 r;

		#if defined(SIMDE_MMX_NATIVE)
		return SIMDE__M64_FROM_NATIVE(_mm_set_pi32((int32_t) e1, (int32_t) e0));
		r.n = _mm_set_pi32(
		HEDLEY_STATIC_CAST(int32_t, e1),
		HEDLEY_STATIC_CAST(int32_t, e0));
		#else
		simde__m64 r;
		r.u32[0] = e0;
		r.u32[1] = e1;
		return r;
		#endif

		return r;
		}

		SIMDE__FUNCTION_ATTRIBUTES
		@@ -1574,6 +1601,8 @@ simde_m_to_int (simde__m64 a) {
		# define _m_to_int(a) simde_m_to_int(SIMDE__M64_FROM_NATIVE(a))
		#endif

		HEDLEY_DIAGNOSTIC_POP

		SIMDE__END_DECLS

		#endif /* !defined(SIMDE__MMX_H) */

debian/include/simde/x86/sse.h

+6 −2

Original line number	Diff line number	Diff line
		@@ -38,6 +38,10 @@
		# define SIMDE_SSE_NATIVE
		# elif defined(__SSE__) && !defined(SIMDE_SSE_NO_NATIVE) && !defined(SIMDE_NO_NATIVE)
		# define SIMDE_SSE_NATIVE
		# elif defined(_M_IX86_FP) && !defined(SIMDE_SSE_NO_NATIVE) && !defined(SIMDE_NO_NATIVE)
		# if (_M_IX86_FP >= 1)
		# define SIMDE_SSE_NATIVE
		# endif
		# elif defined(__ARM_NEON) && !defined(SIMDE_SSE_NO_NEON) && !defined(SIMDE_NO_NEON)
		# define SIMDE_SSE_NEON
		# endif
		@@ -1584,7 +1588,7 @@ simde_mm_loadh_pi (simde__m128 a, simde__m64 const* mem_addr) {
		simde__m128 r;

		#if defined(SIMDE_SSE_NATIVE)
		r.n = _mm_loadh_pi(a.n, (__m64*) mem_addr);
		r.n = _mm_loadh_pi(a.n, HEDLEY_REINTERPRET_CAST(__m64 const*, mem_addr));
		#else
		r.f32[0] = a.f32[0];
		r.f32[1] = a.f32[1];
		@@ -1604,7 +1608,7 @@ simde_mm_loadl_pi (simde__m128 a, simde__m64 const* mem_addr) {
		simde__m128 r;

		#if defined(SIMDE_SSE_NATIVE)
		r.n = _mm_loadl_pi(a.n, (__m64*) mem_addr);
		r.n = _mm_loadl_pi(a.n, HEDLEY_REINTERPRET_CAST(__m64 const*, mem_addr));
		#else
		r.f32[0] = mem_addr->f32[0];
		r.f32[1] = mem_addr->f32[1];