This replaces bswap.h and integer.h.
The tuklib module uses <byteswap.h> on GNU,
<sys/endian.h> on *BSDs and <sys/byteorder.h>
on Solaris, which may contain optimized code
like inline assembly.
AM_CONDITIONAL(COND_ASM_X86_64, test "x$enable_assembler" = xx86_64)
-################################
-# Fast unaligned memory access #
-################################
-
-AC_MSG_CHECKING([if unaligned memory access should be used])
-AC_ARG_ENABLE([unaligned-access], AC_HELP_STRING([--enable-unaligned-access],
- [Enable if the system supports *fast* unaligned memory access
- with 16-bit and 32-bit integers. By default, this is enabled
- only on x86, x86_64, and big endian PowerPC.]),
- [], [enable_unaligned_access=auto])
-if test "x$enable_unaligned_access" = xauto ; then
- case $host_cpu in
- i?86|x86_64|powerpc|powerpc64)
- enable_unaligned_access=yes
- ;;
- *)
- enable_unaligned_access=no
- ;;
- esac
-fi
-if test "x$enable_unaligned_access" = xyes ; then
- AC_DEFINE([HAVE_FAST_UNALIGNED_ACCESS], [1], [Define to 1 if
- the system supports fast unaligned memory access.])
- AC_MSG_RESULT([yes])
-else
- AC_MSG_RESULT([no])
-fi
-
-
#####################
# Size optimization #
#####################
[],
[AC_MSG_ERROR([Required header file(s) are missing.])])
-# If any of these headers are missing, things should still work correctly:
-AC_CHECK_HEADERS([byteswap.h])
-
-# Even if we have byteswap.h, we may lack the specific macros/functions.
-if test x$ac_cv_header_byteswap_h = xyes ; then
- m4_foreach([FUNC], [bswap_16,bswap_32,bswap_64], [
- AC_MSG_CHECKING([if FUNC is available])
- AC_LINK_IFELSE([AC_LANG_SOURCE([
-#include <byteswap.h>
-int
-main(void)
-{
- FUNC[](42);
- return 0;
-}
- ])], [
- AC_DEFINE(HAVE_[]m4_toupper(FUNC), [1],
- [Define to 1 if] FUNC [is available.])
- AC_MSG_RESULT([yes])
- ], [AC_MSG_RESULT([no])])
-
- ])dnl
-fi
-
###############################################################################
# Checks for typedefs, structures, and compiler characteristics.
AC_CHECK_FUNCS([futimens futimes futimesat utimes utime], [break])
TUKLIB_PROGNAME
+TUKLIB_INTEGER
TUKLIB_PHYSMEM
TUKLIB_CPUCORES
--- /dev/null
+#
+# SYNOPSIS
+#
+# TUKLIB_INTEGER
+#
+# DESCRIPTION
+#
+# Checks for tuklib_integer.h:
+# - Endianness
+# - Does operating system provide byte swapping macros
+# - Does the hardware support fast unaligned access to 16-bit
+# and 32-bit integers
+#
+# COPYING
+#
+# Author: Lasse Collin
+#
+# This file has been put into the public domain.
+# You can do whatever you want with this file.
+#
+
+AC_DEFUN_ONCE([TUKLIB_INTEGER], [
+AC_REQUIRE([TUKLIB_COMMON])
+AC_REQUIRE([AC_C_BIGENDIAN])
+AC_CHECK_HEADERS([byteswap.h sys/endian.h sys/byteorder.h], [break])
+
+# Even if we have byteswap.h, we may lack the specific macros/functions.
+if test x$ac_cv_header_byteswap_h = xyes ; then
+ m4_foreach([FUNC], [bswap_16,bswap_32,bswap_64], [
+ AC_MSG_CHECKING([if FUNC is available])
+ AC_LINK_IFELSE([AC_LANG_SOURCE([
+#include <byteswap.h>
+int
+main(void)
+{
+ FUNC[](42);
+ return 0;
+}
+ ])], [
+ AC_DEFINE(HAVE_[]m4_toupper(FUNC), [1],
+ [Define to 1 if] FUNC [is available.])
+ AC_MSG_RESULT([yes])
+ ], [AC_MSG_RESULT([no])])
+
+ ])dnl
+fi
+
+AC_MSG_CHECKING([if unaligned memory access should be used])
+AC_ARG_ENABLE([unaligned-access], AC_HELP_STRING([--enable-unaligned-access],
+ [Enable if the system supports *fast* unaligned memory access
+ with 16-bit and 32-bit integers. By default, this is enabled
+ only on x86, x86_64, and big endian PowerPC.]),
+ [], [enable_unaligned_access=auto])
+if test "x$enable_unaligned_access" = xauto ; then
+ # TODO: There may be other architectures, on which unaligned access
+ # is OK.
+ case $host_cpu in
+ i?86|x86_64|powerpc|powerpc64)
+ enable_unaligned_access=yes
+ ;;
+ *)
+ enable_unaligned_access=no
+ ;;
+ esac
+fi
+if test "x$enable_unaligned_access" = xyes ; then
+ AC_DEFINE([TUKLIB_FAST_UNALIGNED_ACCESS], [1], [Define to 1 if
+ the system supports fast unaligned access to 16-bit and
+ 32-bit integers.])
+ AC_MSG_RESULT([yes])
+else
+ AC_MSG_RESULT([no])
+fi
+])dnl
+++ /dev/null
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file bswap.h
-/// \brief Byte swapping
-//
-// Author: Lasse Collin
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_BSWAP_H
-#define LZMA_BSWAP_H
-
-// NOTE: We assume that config.h is already #included.
-
-// At least glibc has byteswap.h which contains inline assembly code for
-// byteswapping. Some systems have byteswap.h but lack one or more of the
-// bswap_xx macros/functions, which is why we check them separately even
-// if byteswap.h is available.
-
-#ifdef HAVE_BYTESWAP_H
-# include <byteswap.h>
-#endif
-
-#ifndef HAVE_BSWAP_16
-# define bswap_16(num) \
- (((num) << 8) | ((num) >> 8))
-#endif
-
-#ifndef HAVE_BSWAP_32
-# define bswap_32(num) \
- ( (((num) << 24) ) \
- | (((num) << 8) & UINT32_C(0x00FF0000)) \
- | (((num) >> 8) & UINT32_C(0x0000FF00)) \
- | (((num) >> 24) ) )
-#endif
-
-#ifndef HAVE_BSWAP_64
-# define bswap_64(num) \
- ( (((num) << 56) ) \
- | (((num) << 40) & UINT64_C(0x00FF000000000000)) \
- | (((num) << 24) & UINT64_C(0x0000FF0000000000)) \
- | (((num) << 8) & UINT64_C(0x000000FF00000000)) \
- | (((num) >> 8) & UINT64_C(0x00000000FF000000)) \
- | (((num) >> 24) & UINT64_C(0x0000000000FF0000)) \
- | (((num) >> 40) & UINT64_C(0x000000000000FF00)) \
- | (((num) >> 56) ) )
-#endif
-
-#endif
+++ /dev/null
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file integer.h
-/// \brief Reading and writing integers from and to buffers
-//
-// Author: Lasse Collin
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_INTEGER_H
-#define LZMA_INTEGER_H
-
-// On big endian, we need byte swapping. These macros may be used outside
-// this file, so don't put these inside HAVE_FAST_UNALIGNED_ACCESS.
-#ifdef WORDS_BIGENDIAN
-# include "bswap.h"
-# define integer_le_16(n) bswap_16(n)
-# define integer_le_32(n) bswap_32(n)
-# define integer_le_64(n) bswap_64(n)
-#else
-# define integer_le_16(n) (n)
-# define integer_le_32(n) (n)
-# define integer_le_64(n) (n)
-#endif
-
-
-// I'm aware of AC_CHECK_ALIGNED_ACCESS_REQUIRED from Autoconf archive, but
-// it's not useful here. We don't care if unaligned access is supported,
-// we care if it is fast. Some systems can emulate unaligned access in
-// software, which is horribly slow; we want to use byte-by-byte access on
-// such systems but the Autoconf test would detect such a system as
-// supporting unaligned access.
-//
-// NOTE: HAVE_FAST_UNALIGNED_ACCESS indicates only support for 16-bit and
-// 32-bit integer loads and stores. 64-bit integers may or may not work.
-// That's why 64-bit functions are commented out.
-//
-// TODO: Big endian PowerPC supports byte swapping load and store instructions
-// that also allow unaligned access. Inline assembler could be OK for that.
-//
-// Performance of these functions isn't that important until LZMA3, but it
-// doesn't hurt to have these ready already.
-#ifdef HAVE_FAST_UNALIGNED_ACCESS
-
-static inline uint16_t
-integer_read_16(const uint8_t buf[static 2])
-{
- uint16_t ret = *(const uint16_t *)(buf);
- return integer_le_16(ret);
-}
-
-
-static inline uint32_t
-integer_read_32(const uint8_t buf[static 4])
-{
- uint32_t ret = *(const uint32_t *)(buf);
- return integer_le_32(ret);
-}
-
-
-/*
-static inline uint64_t
-integer_read_64(const uint8_t buf[static 8])
-{
- uint64_t ret = *(const uint64_t *)(buf);
- return integer_le_64(ret);
-}
-*/
-
-
-static inline void
-integer_write_16(uint8_t buf[static 2], uint16_t num)
-{
- *(uint16_t *)(buf) = integer_le_16(num);
-}
-
-
-static inline void
-integer_write_32(uint8_t buf[static 4], uint32_t num)
-{
- *(uint32_t *)(buf) = integer_le_32(num);
-}
-
-
-/*
-static inline void
-integer_write_64(uint8_t buf[static 8], uint64_t num)
-{
- *(uint64_t *)(buf) = integer_le_64(num);
-}
-*/
-
-
-#else
-
-static inline uint16_t
-integer_read_16(const uint8_t buf[static 2])
-{
- uint16_t ret = buf[0] | (buf[1] << 8);
- return ret;
-}
-
-
-static inline uint32_t
-integer_read_32(const uint8_t buf[static 4])
-{
- uint32_t ret = buf[0];
- ret |= (uint32_t)(buf[1]) << 8;
- ret |= (uint32_t)(buf[2]) << 16;
- ret |= (uint32_t)(buf[3]) << 24;
- return ret;
-}
-
-
-/*
-static inline uint64_t
-integer_read_64(const uint8_t buf[static 8])
-{
- uint64_t ret = buf[0];
- ret |= (uint64_t)(buf[1]) << 8;
- ret |= (uint64_t)(buf[2]) << 16;
- ret |= (uint64_t)(buf[3]) << 24;
- ret |= (uint64_t)(buf[4]) << 32;
- ret |= (uint64_t)(buf[5]) << 40;
- ret |= (uint64_t)(buf[6]) << 48;
- ret |= (uint64_t)(buf[7]) << 56;
- return ret;
-}
-*/
-
-
-static inline void
-integer_write_16(uint8_t buf[static 2], uint16_t num)
-{
- buf[0] = (uint8_t)(num);
- buf[1] = (uint8_t)(num >> 8);
-}
-
-
-static inline void
-integer_write_32(uint8_t buf[static 4], uint32_t num)
-{
- buf[0] = (uint8_t)(num);
- buf[1] = (uint8_t)(num >> 8);
- buf[2] = (uint8_t)(num >> 16);
- buf[3] = (uint8_t)(num >> 24);
-}
-
-
-/*
-static inline void
-integer_write_64(uint8_t buf[static 8], uint64_t num)
-{
- buf[0] = (uint8_t)(num);
- buf[1] = (uint8_t)(num >> 8);
- buf[2] = (uint8_t)(num >> 16);
- buf[3] = (uint8_t)(num >> 24);
- buf[4] = (uint8_t)(num >> 32);
- buf[5] = (uint8_t)(num >> 40);
- buf[6] = (uint8_t)(num >> 48);
- buf[7] = (uint8_t)(num >> 56);
-}
-*/
-
-#endif
-
-#endif
-#include "sysdefs.h"
+#ifdef HAVE_CONFIG_H
+# include "sysdefs.h"
+#else
+# include <stddef.h>
+# include <inttypes.h>
+# include <limits.h>
+#endif
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file tuklib_integer.h
+/// \brief Byte swapping and endianness related macros and functions
+///
+/// This file provides macros or functions to do basic endianness related
+/// integer operations (XX = 16, 32, or 64; Y = b or l):
+/// - Byte swapping: bswapXX(num)
+/// - Byte order conversions to/from native: convXXYe(num)
+/// - Aligned reads: readXXYe(ptr)
+/// - Aligned writes: writeXXYe(ptr, num)
+/// - Unaligned reads (16/32-bit only): unaligned_readXXYe(ptr)
+/// - Unaligned writes (16/32-bit only): unaligned_writeXXYe(ptr, num)
+///
+/// Since they can macros, the arguments should have no side effects since
+/// they may be evaluated more than once.
+///
+/// \todo PowerPC and possibly some other architectures support
+/// byte swapping load and store instructions. This file
+/// doesn't take advantage of those instructions.
+//
+// Author: Lasse Collin
+//
+// This file has been put into the public domain.
+// You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef TUKLIB_INTEGER_H
+#define TUKLIB_INTEGER_H
+
+#include "tuklib_common.h"
+
+
+////////////////////////////////////////
+// Operating system specific features //
+////////////////////////////////////////
+
+#if defined(HAVE_BYTESWAP_H)
+ // glibc, uClibc, dietlibc
+# include <byteswap.h>
+# ifdef HAVE_BSWAP_16
+# define bswap16(num) bswap_16(num)
+# endif
+# ifdef HAVE_BSWAP_32
+# define bswap32(num) bswap_32(num)
+# endif
+# ifdef HAVE_BSWAP_64
+# define bswap64(num) bswap_64(num)
+# endif
+
+#elif defined(HAVE_SYS_ENDIAN_H)
+ // *BSDs and Darwin
+# include <sys/endian.h>
+
+#elif defined(HAVE_SYS_BYTEORDER_H)
+ // Solaris
+# include <sys/byteorder.h>
+# ifdef BSWAP_16
+# define bswap16(num) BSWAP_16(num)
+# endif
+# ifdef BSWAP_32
+# define bswap32(num) BSWAP_32(num)
+# endif
+# ifdef BSWAP_64
+# define bswap64(num) BSWAP_64(num)
+# endif
+# ifdef BE_16
+# define conv16be(num) BE_16(num)
+# endif
+# ifdef BE_32
+# define conv32be(num) BE_32(num)
+# endif
+# ifdef BE_64
+# define conv64be(num) BE_64(num)
+# endif
+# ifdef LE_16
+# define conv16le(num) LE_16(num)
+# endif
+# ifdef LE_32
+# define conv32le(num) LE_32(num)
+# endif
+# ifdef LE_64
+# define conv64le(num) LE_64(num)
+# endif
+#endif
+
+
+///////////////////
+// Byte swapping //
+///////////////////
+
+#ifndef bswap16
+# define bswap16(num) \
+ (((uint16_t)(num) << 8) | ((uint16_t)(num) >> 8))
+#endif
+
+#ifndef bswap32
+# define bswap32(num) \
+ ( (((uint32_t)(num) << 24) ) \
+ | (((uint32_t)(num) << 8) & UINT32_C(0x00FF0000)) \
+ | (((uint32_t)(num) >> 8) & UINT32_C(0x0000FF00)) \
+ | (((uint32_t)(num) >> 24) ) )
+#endif
+
+#ifndef bswap64
+# define bswap64(num) \
+ ( (((uint64_t)(num) << 56) ) \
+ | (((uint64_t)(num) << 40) & UINT64_C(0x00FF000000000000)) \
+ | (((uint64_t)(num) << 24) & UINT64_C(0x0000FF0000000000)) \
+ | (((uint64_t)(num) << 8) & UINT64_C(0x000000FF00000000)) \
+ | (((uint64_t)(num) >> 8) & UINT64_C(0x00000000FF000000)) \
+ | (((uint64_t)(num) >> 24) & UINT64_C(0x0000000000FF0000)) \
+ | (((uint64_t)(num) >> 40) & UINT64_C(0x000000000000FF00)) \
+ | (((uint64_t)(num) >> 56) ) )
+#endif
+
+// Define conversion macros using the basic byte swapping macros.
+#ifdef WORDS_BIGENDIAN
+# ifndef conv16be
+# define conv16be(num) ((uint16_t)(num))
+# endif
+# ifndef conv32be
+# define conv32be(num) ((uint32_t)(num))
+# endif
+# ifndef conv64be
+# define conv64be(num) ((uint64_t)(num))
+# endif
+# ifndef conv16le
+# define conv16le(num) bswap16(num)
+# endif
+# ifndef conv32le
+# define conv32le(num) bswap32(num)
+# endif
+# ifndef conv64le
+# define conv64le(num) bswap64(num)
+# endif
+#else
+# ifndef conv16be
+# define conv16be(num) bswap16(num)
+# endif
+# ifndef conv32be
+# define conv32be(num) bswap32(num)
+# endif
+# ifndef conv64be
+# define conv64be(num) bswap64(num)
+# endif
+# ifndef conv16le
+# define conv16le(num) ((uint16_t)(num))
+# endif
+# ifndef conv32le
+# define conv32le(num) ((uint32_t)(num))
+# endif
+# ifndef conv64le
+# define conv64le(num) ((uint64_t)(num))
+# endif
+#endif
+
+
+//////////////////////////////
+// Aligned reads and writes //
+//////////////////////////////
+
+static inline uint16_t
+read16be(const uint8_t *buf)
+{
+ uint16_t num = *(const uint16_t *)buf;
+ return conv16be(num);
+}
+
+
+static inline uint16_t
+read16le(const uint8_t *buf)
+{
+ uint16_t num = *(const uint16_t *)buf;
+ return conv16le(num);
+}
+
+
+static inline uint32_t
+read32be(const uint8_t *buf)
+{
+ uint32_t num = *(const uint32_t *)buf;
+ return conv32be(num);
+}
+
+
+static inline uint32_t
+read32le(const uint8_t *buf)
+{
+ uint32_t num = *(const uint32_t *)buf;
+ return conv32le(num);
+}
+
+
+static inline uint64_t
+read64be(const uint8_t *buf)
+{
+ uint64_t num = *(const uint64_t *)buf;
+ return conv64be(num);
+}
+
+
+static inline uint64_t
+read64le(const uint8_t *buf)
+{
+ uint64_t num = *(const uint64_t *)buf;
+ return conv64le(num);
+}
+
+
+// NOTE: Possible byte swapping must be done in a macro to allow GCC
+// to optimize byte swapping of constants when using glibc's or *BSD's
+// byte swapping macros. The actual write is done in an inline function
+// to make type checking of the buf pointer possible similarly to readXXYe()
+// functions. This also seems to silence a probably bogus GCC warning about
+// strict aliasing when buf points to the beginning of an uint8_t array.
+
+#define write16be(buf, num) write16ne((buf), conv16be(num))
+#define write16le(buf, num) write16ne((buf), conv16le(num))
+#define write32be(buf, num) write32ne((buf), conv32be(num))
+#define write32le(buf, num) write32ne((buf), conv32le(num))
+#define write64be(buf, num) write64ne((buf), conv64be(num))
+#define write64le(buf, num) write64ne((buf), conv64le(num))
+
+
+static inline void
+write16ne(uint8_t *buf, uint16_t num)
+{
+ *(uint16_t *)buf = num;
+ return;
+}
+
+
+static inline void
+write32ne(uint8_t *buf, uint32_t num)
+{
+ *(uint32_t *)buf = num;
+ return;
+}
+
+
+static inline void
+write64ne(uint8_t *buf, uint64_t num)
+{
+ *(uint64_t *)buf = num;
+ return;
+}
+
+
+////////////////////////////////
+// Unaligned reads and writes //
+////////////////////////////////
+
+// NOTE: TUKLIB_FAST_UNALIGNED_ACCESS indicates only support for 16-bit and
+// 32-bit unaligned integer loads and stores. It's possible that 64-bit
+// unaligned access doesn't work or is slower than byte-by-byte access.
+// Since unaligned 64-bit is probably not needed as often as 16-bit or
+// 32-bit, we simply don't support 64-bit unaligned access for now.
+#ifdef TUKLIB_FAST_UNALIGNED_ACCESS
+# define unaligned_read16be read16be
+# define unaligned_read16le read16le
+# define unaligned_read32be read32be
+# define unaligned_read32le read32le
+# define unaligned_write16be write16be
+# define unaligned_write16le write16le
+# define unaligned_write32be write32be
+# define unaligned_write32le write32le
+
+#else
+
+static inline uint16_t
+unaligned_read16be(const uint8_t *buf)
+{
+ uint16_t num = ((uint16_t)buf[0] << 8) | buf[1];
+ return num;
+}
+
+
+static inline uint16_t
+unaligned_read16le(const uint8_t *buf)
+{
+ uint16_t num = ((uint32_t)buf[0]) | ((uint16_t)buf[1] << 8);
+ return num;
+}
+
+
+static inline uint32_t
+unaligned_read32be(const uint8_t *buf)
+{
+ uint32_t num = (uint32_t)buf[0] << 24;
+ num |= (uint32_t)buf[1] << 16;
+ num |= (uint32_t)buf[2] << 8;
+ num |= (uint32_t)buf[3];
+ return num;
+}
+
+
+static inline uint32_t
+unaligned_read32le(const uint8_t *buf)
+{
+ uint32_t num = (uint32_t)buf[0];
+ num |= (uint32_t)buf[1] << 8;
+ num |= (uint32_t)buf[2] << 16;
+ num |= (uint32_t)buf[3] << 24;
+ return num;
+}
+
+
+static inline void
+unaligned_write16be(uint8_t *buf, uint16_t num)
+{
+ buf[0] = num >> 8;
+ buf[1] = num;
+ return;
+}
+
+
+static inline void
+unaligned_write16le(uint8_t *buf, uint16_t num)
+{
+ buf[0] = num;
+ buf[1] = num >> 8;
+ return;
+}
+
+
+static inline void
+unaligned_write32be(uint8_t *buf, uint32_t num)
+{
+ buf[0] = num >> 24;
+ buf[1] = num >> 16;
+ buf[2] = num >> 8;
+ buf[3] = num;
+ return;
+}
+
+
+static inline void
+unaligned_write32le(uint8_t *buf, uint32_t num)
+{
+ buf[0] = num;
+ buf[1] = num >> 8;
+ buf[2] = num >> 16;
+ buf[3] = num >> 24;
+ return;
+}
+
+#endif
+#endif
switch (type) {
#ifdef HAVE_CHECK_CRC32
case LZMA_CHECK_CRC32:
- check->buffer.u32[0] = integer_le_32(check->state.crc32);
+ check->buffer.u32[0] = conv32le(check->state.crc32);
break;
#endif
#ifdef HAVE_CHECK_CRC64
case LZMA_CHECK_CRC64:
- check->buffer.u64[0] = integer_le_64(check->state.crc64);
+ check->buffer.u64[0] = conv64le(check->state.crc64);
break;
#endif
crc = ~crc;
#ifdef WORDS_BIGENDIAN
- crc = bswap_32(crc);
+ crc = bswap32(crc);
#endif
if (size > 8) {
crc = lzma_crc32_table[0][*buf++ ^ A(crc)] ^ S8(crc);
#ifdef WORDS_BIGENDIAN
- crc = bswap_32(crc);
+ crc = bswap32(crc);
#endif
return ~crc;
//
///////////////////////////////////////////////////////////////////////////////
-#include <inttypes.h>
#include <stdio.h>
-
-#ifdef WORDS_BIGENDIAN
-# include "../../common/bswap.h"
-#endif
+#include "../../common/tuklib_integer.h"
static uint32_t crc32_table[8][256];
#ifdef WORDS_BIGENDIAN
for (size_t s = 0; s < 8; ++s)
for (size_t b = 0; b < 256; ++b)
- crc32_table[s][b] = bswap_32(crc32_table[s][b]);
+ crc32_table[s][b] = bswap32(crc32_table[s][b]);
#endif
return;
crc = ~crc;
#ifdef WORDS_BIGENDIAN
- crc = bswap_64(crc);
+ crc = bswap64(crc);
#endif
if (size > 4) {
crc = lzma_crc64_table[0][*buf++ ^ A1(crc)] ^ S8(crc);
#ifdef WORDS_BIGENDIAN
- crc = bswap_64(crc);
+ crc = bswap64(crc);
#endif
return ~crc;
//
///////////////////////////////////////////////////////////////////////////////
-#include <inttypes.h>
#include <stdio.h>
-
-#ifdef WORDS_BIGENDIAN
-# include "../../common/bswap.h"
-#endif
+#include "../../common/tuklib_integer.h"
static uint64_t crc64_table[4][256];
#ifdef WORDS_BIGENDIAN
for (size_t s = 0; s < 4; ++s)
for (size_t b = 0; b < 256; ++b)
- crc64_table[s][b] = bswap_64(crc64_table[s][b]);
+ crc64_table[s][b] = bswap64(crc64_table[s][b]);
#endif
return;
///////////////////////////////////////////////////////////////////////////////
#ifdef WORDS_BIGENDIAN
-# include "../../common/bswap.h"
-
# define A(x) ((x) >> 24)
# define B(x) (((x) >> 16) & 0xFF)
# define C(x) (((x) >> 8) & 0xFF)
#include "check.h"
-#ifndef WORDS_BIGENDIAN
-# include "../../common/bswap.h"
-#endif
-
// At least on x86, GCC is able to optimize this to a rotate instruction.
#define rotr_32(num, amount) ((num) >> (amount) | (num) << (32 - (amount)))
uint32_t data[16];
for (size_t i = 0; i < 16; ++i)
- data[i] = bswap_32(check->buffer.u32[i]);
+ data[i] = bswap32(check->buffer.u32[i]);
transform(check->state.sha256.state, data);
#endif
// Convert the message size from bytes to bits.
check->state.sha256.size *= 8;
-#ifdef WORDS_BIGENDIAN
- check->buffer.u64[(64 - 8) / 8] = check->state.sha256.size;
-#else
- check->buffer.u64[(64 - 8) / 8] = bswap_64(check->state.sha256.size);
-#endif
+ check->buffer.u64[(64 - 8) / 8] = conv64be(check->state.sha256.size);
process(check);
for (size_t i = 0; i < 8; ++i)
-#ifdef WORDS_BIGENDIAN
- check->buffer.u32[i] = check->state.sha256.state[i];
-#else
- check->buffer.u32[i] = bswap_32(check->state.sha256.state[i]);
-#endif
+ check->buffer.u32[i] = conv32be(check->state.sha256.state[i]);
return;
}
if (d != UINT32_MAX)
++d;
- integer_write_32(next->coder->header + 1, d);
+ unaligned_write32le(next->coder->header + 1, d);
// - Uncompressed size (always unknown and using EOPM)
memset(next->coder->header + 1 + 4, 0xFF, 8);
const size_t in_size = block->header_size - 4;
// Verify CRC32
- if (lzma_crc32(in, in_size, 0) != integer_read_32(in + in_size))
+ if (lzma_crc32(in, in_size, 0) != unaligned_read32le(in + in_size))
return LZMA_DATA_ERROR;
// Check for unsupported flags.
memzero(out + out_pos, out_size - out_pos);
// CRC32
- integer_write_32(out + out_size, lzma_crc32(out, out_size, 0));
+ unaligned_write32le(out + out_size, lzma_crc32(out, out_size, 0));
return LZMA_OK;
}
#include "sysdefs.h"
#include "mythread.h"
-#include "integer.h"
+#include "tuklib_integer.h"
#if defined(_WIN32) || defined(__CYGWIN__)
# ifdef DLL_EXPORT
// and unsupported files.
const uint32_t crc = lzma_crc32(in + sizeof(lzma_header_magic),
LZMA_STREAM_FLAGS_SIZE, 0);
- if (crc != integer_read_32(in + sizeof(lzma_header_magic)
+ if (crc != unaligned_read32le(in + sizeof(lzma_header_magic)
+ LZMA_STREAM_FLAGS_SIZE))
return LZMA_DATA_ERROR;
// CRC32
const uint32_t crc = lzma_crc32(in + sizeof(uint32_t),
sizeof(uint32_t) + LZMA_STREAM_FLAGS_SIZE, 0);
- if (crc != integer_read_32(in))
+ if (crc != unaligned_read32le(in))
return LZMA_DATA_ERROR;
// Stream Flags
return LZMA_OPTIONS_ERROR;
// Backward Size
- options->backward_size = integer_read_32(in + sizeof(uint32_t));
+ options->backward_size = unaligned_read32le(in + sizeof(uint32_t));
options->backward_size = (options->backward_size + 1) * 4;
return LZMA_OK;
const uint32_t crc = lzma_crc32(out + sizeof(lzma_header_magic),
LZMA_STREAM_FLAGS_SIZE, 0);
- integer_write_32(out + sizeof(lzma_header_magic)
+ unaligned_write32le(out + sizeof(lzma_header_magic)
+ LZMA_STREAM_FLAGS_SIZE, crc);
return LZMA_OK;
if (!is_backward_size_valid(options))
return LZMA_PROG_ERROR;
- integer_write_32(out + 4, options->backward_size / 4 - 1);
+ unaligned_write32le(out + 4, options->backward_size / 4 - 1);
// Stream Flags
if (stream_flags_encode(options, out + 2 * 4))
const uint32_t crc = lzma_crc32(
out + 4, 4 + LZMA_STREAM_FLAGS_SIZE, 0);
- integer_write_32(out, crc);
+ unaligned_write32le(out, crc);
// Magic
memcpy(out + 2 * 4 + LZMA_STREAM_FLAGS_SIZE,
#define FIX_5_HASH_SIZE (HASH_2_SIZE + HASH_3_SIZE + HASH_4_SIZE)
// Endianness doesn't matter in hash_2_calc() (no effect on the output).
-#ifdef HAVE_FAST_UNALIGNED_ACCESS
+#ifdef TUKLIB_FAST_UNALIGNED_ACCESS
# define hash_2_calc() \
const uint32_t hash_value = *(const uint16_t *)(cur);
#else
// All dictionary sizes are accepted, including zero. LZ decoder
// will automatically use a dictionary at least a few KiB even if
// a smaller dictionary is requested.
- opt->dict_size = integer_read_32(props + 1);
+ opt->dict_size = unaligned_read32le(props + 1);
opt->preset_dict = NULL;
opt->preset_dict_size = 0;
if (lzma_lzma_lclppb_encode(opt, out))
return LZMA_PROG_ERROR;
- integer_write_32(out + 1, opt->dict_size);
+ unaligned_write32le(out + 1, opt->dict_size);
return LZMA_OK;
}
// needed in lzma_lzma_optimum_*() to test if the match is at least
// MATCH_LEN_MIN bytes. Unaligned access gives tiny gain so there's no
// reason to not use it when it is supported.
-#ifdef HAVE_FAST_UNALIGNED_ACCESS
+#ifdef TUKLIB_FAST_UNALIGNED_ACCESS
# define not_equal_16(a, b) \
(*(const uint16_t *)(a) != *(const uint16_t *)(b))
#else
if (opt == NULL)
return LZMA_MEM_ERROR;
- opt->start_offset = integer_read_32(props);
+ opt->start_offset = unaligned_read32le(props);
// Don't leave an options structure allocated if start_offset is zero.
if (opt->start_offset == 0)
if (opt == NULL || opt->start_offset == 0)
return LZMA_OK;
- integer_write_32(out, opt->start_offset);
+ unaligned_write32le(out, opt->start_offset);
return LZMA_OK;
}
// Unsupported filter
// NOTE: This may need updating when new IDs become supported.
buf[2] ^= 0x1F;
- integer_write_32(buf + known_options.header_size - 4,
+ unaligned_write32le(buf + known_options.header_size - 4,
lzma_crc32(buf, known_options.header_size - 4, 0));
expect(lzma_block_header_decode(&decoded_options, NULL, buf)
== LZMA_OPTIONS_ERROR);
// Non-nul Padding
buf[known_options.header_size - 4 - 1] ^= 1;
- integer_write_32(buf + known_options.header_size - 4,
+ unaligned_write32le(buf + known_options.header_size - 4,
lzma_crc32(buf, known_options.header_size - 4, 0));
expect(lzma_block_header_decode(&decoded_options, NULL, buf)
== LZMA_OPTIONS_ERROR);
// Test 2a (valid CRC32)
uint32_t crc = lzma_crc32(buffer + 6, 2, 0);
- integer_write_32(buffer + 8, crc);
+ unaligned_write32le(buffer + 8, crc);
succeed(test_header_decoder(LZMA_OK));
// Test 2b (invalid Stream Flags with valid CRC32)
buffer[6] ^= 0x20;
crc = lzma_crc32(buffer + 6, 2, 0);
- integer_write_32(buffer + 8, crc);
+ unaligned_write32le(buffer + 8, crc);
succeed(test_header_decoder(LZMA_OPTIONS_ERROR));
// Test 3 (invalid CRC32)
expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
buffer[9] ^= 0x40;
crc = lzma_crc32(buffer + 4, 6, 0);
- integer_write_32(buffer, crc);
+ unaligned_write32le(buffer, crc);
succeed(test_footer_decoder(LZMA_OPTIONS_ERROR));
// Test 5 (invalid Magic Bytes)
#define LZMA_TESTS_H
#include "sysdefs.h"
-#include "integer.h"
+#include "tuklib_integer.h"
#include "lzma.h"
#include <stdio.h>
projects / platform / upstream / xz.git / commitdiff