diff options
Diffstat (limited to '')
52 files changed, 3344 insertions, 412 deletions
@@ -33,16 +33,47 @@ download: SUPPORTED_ARCHES =\ + ALPHA_LE\ + ALPHA_BE\ AMD64\ AMD64_X32\ + IA64_LE\ + IA64_BE\ + IA64_P32_LE\ + IA64_P32_BE\ M68K\ + MICROBLAZE_32_LE\ + MICROBLAZE_32_BE\ + MICROBLAZE_64_LE\ + MICROBLAZE_64_BE\ + MIPS_O32_LE\ + MIPS_O32_BE\ + MIPS_N32_LE\ + MIPS_N32_BE\ + MIPS_N64_LE\ + MIPS_N64_BE\ PARISC_32\ PARISC_64\ + POWERPC_32_LE\ + POWERPC_32_BE\ + POWERPC_64_LE\ + POWERPC_64_BE\ + POWERPC_NOSPU_LE\ + POWERPC_NOSPU_BE\ + POWERPC_SPU_LE\ + POWERPC_SPU_BE\ + S390_32\ + S390_64\ + SH_LE\ + SH_BE\ SPARC_32\ - I386 -# Excluded because of missing support in libsyscalls_get_datatype_description.c: -# ALPHA ARM_OABI ARM_EABI IA64 MICROBLAZE MIPS_O32 MIPS_N32 MIPS_N64 POWERPC_32 -# POWERPC_64 POWERPC_NOSPU POWERPC_SPU S390_32 S390_64 SH SPARC_64 XTENSA + SPARC_64_LE\ + SPARC_64_BE\ + I386\ + XTENSA_LE\ + XTENSA_BE +# Excluded because of incomplete support (see LIST_ARCH_SPECS in common.h): +# ARM_OABI_LE ARM_OABI_BE ARM_EABI_LE ARM_EABI_BE include $(CONFIGFILE) # Reloading the user's config in case it limits supported architectures @@ -70,13 +101,20 @@ OBJ =\ libsyscalls_get_datatype_description.o\ libsyscalls_get_integer_alignment.o\ libsyscalls_get_signals.o\ + libsyscalls_get_struct_description.o\ libsyscalls_get_syscall.o\ libsyscalls_get_syscall_display_info.o\ libsyscalls_get_syscall_errors.o\ libsyscalls_get_syscall_range.o\ + libsyscalls_make_signed_integer.o\ + libsyscalls_parse_signed_integer.o\ libsyscalls_perror.o\ + libsyscalls_section_value.o\ libsyscalls_strerror.o\ - libsyscalls_syscalls_tables_.o + libsyscalls_syscalls_tables_.o\ + libsyscalls_to_tracee_endian.o\ + libsyscalls_to_tracer_endian.o\ + libsyscalls_unsection_value.o #extended for each support operating system HDR =\ @@ -106,10 +144,16 @@ TESTUTILS =\ testutil/is-section-quarter.tu\ testutil/is-datatype-struct.tu\ testutil/list-errors.tu\ + testutil/make-signed.tu\ + testutil/parse-signed.tu\ testutil/perror-all.tu\ testutil/perror-bad.tu\ + testutil/section-value.tu\ testutil/strerror-all.tu\ - testutil/strerror-bad.tu + testutil/strerror-bad.tu\ + testutil/to-tracee-endian.tu\ + testutil/to-tracer-endian.tu\ + testutil/unsection-value.tu @@ -153,9 +197,12 @@ libsyscalls.$(LIBEXT): $(LOBJ) check: $(TESTUTILS) env CPP="$(CPP)" $(TEST_ENV) ./test - @if grep '^alias t=:' < ./test >/dev/null; then \ + @if grep '^t=:' < ./test >/dev/null; then \ printf '\033[1;33m%s\033[m\n' 'Warning! tests have been disabled' >&2; \ fi + @if grep '^alias p=' < ./test >/dev/null; then \ + printf '\033[1;33m%s\033[m\n' 'Warning! tests are running synchronously' >&2; \ + fi install: libsyscalls.a libsyscalls.$(LIBEXT) @@ -186,7 +233,7 @@ buildclean: semiclean -rm -rf -- generated/ $(OPERATING_SYSTEMS:=-src/*/) semiclean: - -rm -f -- *.o *.lo *.su *.gch *.gcov *.gcno *.gcda .*.tmp + -rm -f -- *.o *.lo *.su *.gch *.gcov *.gcno *.gcda .*.tmp .*.tmp.c -rm -f -- */*.o */*.lo */*.su */*.gch */*.gcov */*.gcno */*.gcda -rm -f -- *.a *.so *.so.* *.dll *.dylib *.$(LIBEXT) */*.tu -rm -f -- libsyscalls/short-enums.h @@ -1,5 +1,4 @@ Add calling convention -Add value decoding -Add value encoding Add man pages and README The syscall table is too big and should be compressed +Do not require user to download OS sources @@ -1,23 +1,68 @@ /* See LICENSE file for copyright and license details. */ #ifdef REQUIRE_FLEXABLE_OR_NPARAMS -# if defined(__clang__) || defined(__GNUC__) +# if defined(__clang__) # define LIBSYSCALLS_FLEXABLE_OR_NPARAMS_ +# pragma clang diagnostic ignored "-Wgnu-flexible-array-initializer" +# elif defined(__GNUC__) +# define LIBSYSCALLS_FLEXABLE_OR_NPARAMS_ +# pragma GCC diagnostic ignored "-Wpedantic" # else # define LIBSYSCALLS_FLEXABLE_OR_NPARAMS_ NPARAMS # warning Setting LIBSYSCALLS_FLEXABLE_OR_NPARAMS_ to NPARAMS as it is not known that the compiler supports static allocation of structs with flexible arrays # endif #endif +#ifdef REQUIRE_FLEXABLE_OR_NFIELDS +# if defined(__clang__) +# define LIBSYSCALLS_FLEXABLE_OR_NFIELDS_ +# pragma clang diagnostic ignored "-Wgnu-flexible-array-initializer" +# elif defined(__GNUC__) +# define LIBSYSCALLS_FLEXABLE_OR_NFIELDS_ +# pragma GCC diagnostic ignored "-Wpedantic" +# else +# define LIBSYSCALLS_FLEXABLE_OR_NFIELDS_ NFIELDS +# warning Setting LIBSYSCALLS_FLEXABLE_OR_NFIELDS_ to NFIELDS as it is not known that the compiler supports static allocation of structs with flexible arrays +# endif +#endif #include "libsyscalls.h" +#include <stdalign.h> #include <stddef.h> #include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +#if defined(__clang__) +/* We expect the user to use -Weverything */ +# pragma clang diagnostic ignored "-Wimplicit-fallthrough" /* we use GCC's fall though comments */ +# pragma clang diagnostic ignored "-Wcovered-switch-default" /* the user may input something invalid due to version differences */ +# pragma clang diagnostic ignored "-Wc++98-compat" /* don't care about C++, especially not for internal code */ +# pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" /* TODO how does that make sense in C23? */ +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang doesn't know what it is doing */ +# pragma clang diagnostic ignored "-Wvla" /* we prefer VLA over alloca (easier to support), and we are careful */ +#elif defined(__GNUC__) +/* We expect the user to use -Wall -Wextra mand maybe some other flags */ +# pragma GCC diagnostic ignored "-Wnonnull-compare" /* why should I trust that the user is using the same compiler? */ +# pragma GCC diagnostic ignored "-Winline" /* it's just a preference, up to the compiler to decide */ +#endif -#define COMMA , + +#if defined(__GNUC__) +# define PURE_FUNCTION __attribute__((__pure__)) +#else +# define PURE_FUNCTION +#endif +#define COMMA , + #define MISALIGNMENT(ADDR, ALIGN) (((ADDR) - ((ADDR) % (uintptr_t)(ALIGN))) % (uintptr_t)(ALIGN)) #define ALIGN_BUF(BUF, ALIGN) (&(BUF)[(size_t)MISALIGNMENT((uintptr_t)(char *)(BUF), (ALIGN))]) #define ELEMSOF(ARR) (sizeof(ARR) / sizeof *(ARR)) +#define MAX(A, B) ((A) > (B) ? (A) : (B)) +#define LOWEST_BIT(X) ((X) & ~((X) - 1)) +#define POST_HIGHEST_OF_CONSECUTIVELY_BITS(X) ((X) + LOWEST_BIT(X)) struct libsyscalls_symbol_printer_data { @@ -26,6 +71,61 @@ struct libsyscalls_symbol_printer_data { char buf[]; }; +enum endian { + Big, + Little +}; + + +#define LIST_ARCH_SPECS(X, D) /* byte intptr size_t endian sign */\ + X(LIBSYSCALLS_ARCH_ALPHA_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_ALPHA_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_AMD64, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_AMD64_X32, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + /* + X(LIBSYSCALLS_ARCH_ARM_OABI_LE, 8, TODO, TODO, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_ARM_OABI_BE, 8, TODO, TODO, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_ARM_EABI_LE, 8, TODO, TODO, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_ARM_EABI_BE, 8, TODO, TODO, Big, TWOS_COMPLEMENT) D\ + */\ + X(LIBSYSCALLS_ARCH_IA64_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_IA64_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_IA64_P32_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_IA64_P32_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_M68K, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MICROBLAZE_32_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MICROBLAZE_32_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MICROBLAZE_64_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MICROBLAZE_64_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_O32_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_O32_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_N32_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_N32_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_N64_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_MIPS_N64_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_PARISC_32, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_PARISC_64, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_32_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_32_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_64_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_64_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_NOSPU_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_NOSPU_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_SPU_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_POWERPC_SPU_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_S390_32, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_S390_64, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_SH_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_SH_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_SPARC_32, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_SPARC_64_LE, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_SPARC_64_BE, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_I386, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_XTENSA_LE, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ + X(LIBSYSCALLS_ARCH_XTENSA_BE, 8, 32, 32, Big, TWOS_COMPLEMENT) + /* Don't forget to update SUPPORTED_ARCHES in Makefile */ + /* TODO (alignment) means that it is missing in libsyscalls_get_integer_alignment.c and must also be added thither */ + #include "generated/oses.h" #include "generated/arches.h" @@ -47,9 +147,14 @@ LIST_OSES(X,) #endif +#define COUNT_LIST_(...) 1 +#define COUNT_LIST(LIST_MACRO) (LIST_MACRO(COUNT_LIST_,, +,)) + +#define COUNT_ARGS(...) (0 __VA_OPT__(+ COUNT_ARGS_1(__VA_ARGS__))) #define COUNT_ARG_PAIRS(...) (0 __VA_OPT__(+ COUNT_ARG_PAIRS_1(__VA_ARGS__))) -/* mk/generate.mk reads these two lines, do not format them as multiline macros! */ +/* mk/generate.mk reads these three lines, do not format them as multiline macros! */ +#define COUNT_ARGS_1(x, ...) 1 __VA_OPT__(+ COUNT_ARGS_2(__VA_ARGS__)) #define COUNT_ARG_PAIRS_1(x1, x2, ...) 1 __VA_OPT__(+ COUNT_ARG_PAIRS_2(__VA_ARGS__)) #define PARAMS_BUILD_TYPES_1(x, A, ...) LIBSYSCALLS_TYPE_##A __VA_OPT__(, PARAMS_BUILD_TYPES_2(__VA_ARGS__)) diff --git a/config-figure-this-out-for-me.mk b/config-figure-this-out-for-me.mk index 60a24de..0ba409e 100644 --- a/config-figure-this-out-for-me.mk +++ b/config-figure-this-out-for-me.mk @@ -12,7 +12,7 @@ BASECONFIG !=\ if test "$$testscript" = "util/what-architecture-am-i-using"; then \ continue; \ fi; \ - os="$$(printf '%s\n' "$$testscript" | cut -d / -f 1 | tr '[a-z]' '[A-Z]')"; \ + os="$$(dirname -- "$$testscript" | tr '[a-z]' '[A-Z]')"; \ support="$${os}_SUPPORT"; \ q=\'; \ printf '%s_ != test -z "$$(%s_)" || printf %s%%s\\n%s "$$(%s)"\n' \ @@ -30,13 +30,33 @@ BASECONFIG !=\ printf '\t\tif test $$$$? -lt 2; then printf %syes\\n%s; else printf %sno\\n%s; fi; \\\n' \ $$q $$q $$q $$q; \ printf '\tfi\n'; \ - done \ + done; \ ) > .config.mk.tmp; \ printf '%s\n' .config.mk.tmp; \ fi; include $(BASECONFIG) +HAVE_BUILTIN_FFSLL !=\ + testmk=.a-$$$$.tmp; \ + testbin=.b-$$$$.tmp; \ + testsrc=.c-$$$$.tmp.c; \ + printf 'int main() {return !(1' > $$testsrc; \ + printf ' && __builtin_ffsll(%s) == %s' 0 0 1 1 2 2 4 3 0x58 4 >> $$testsrc; \ + printf ');}\n' >> $$testsrc; \ + (set -e; \ + printf '.POSIX:\n'; \ + cat -- $(BASECONFIG); \ + printf '\nall:\n'; \ + printf '\t$$(CC) -o %s %s\n' "$$testbin" "$$testsrc"; \ + ) > $$testmk; \ + if (make -f $$testmk all && ./$$testbin) 2>/dev/null >/dev/null; then \ + printf '%s\n' -DHAVE_BUILTIN_FFSLL; \ + fi; \ + rm -f -- $$testmk $$testbin $$testsrc; + +CPPFLAGS += $(HAVE_BUILTIN_FFSLL) + DOWNLOAD !=\ if test -n "$(DOWNLOAD)"; then printf '%s\n' "$(DOWNLOAD)"; \ elif curl --version >/dev/null 2>&1; then printf 'curl --\n'; \ @@ -19,6 +19,10 @@ LDFLAGS = # system call description, but only references to them, not their # instantiations (which have static storage), for that it it relies # on compiler optimisation.) +# If you know that the compiler has __builtin_ffsll([unsigned] long long int) +# which returns the index, plus 1, of the least significant set bit +# or 0 for 0, you can add -DHAVE_BUILTIN_FFSLL to CPPFLAGS; if you +# are using GCC>=3.4 or clang>=5, this is added automatically. DOWNLOAD = curl -- diff --git a/libsyscalls.h b/libsyscalls.h index caf4a4b..382022b 100644 --- a/libsyscalls.h +++ b/libsyscalls.h @@ -31,7 +31,8 @@ X(LIBSYSCALLS_E_NOMEM, "Failed to allocate required memory") D\ X(LIBSYSCALLS_E_INVAL, "Invalid arguments passed to function") D\ X(LIBSYSCALLS_E_NOSUCHTYPE, "Type does not exist on the selected operating system or architecture") D\ - X(LIBSYSCALLS_E_ISSTRUCT, "Type is a structure or union") + X(LIBSYSCALLS_E_ISSTRUCT, "Type is a structure or union") D\ + X(LIBSYSCALLS_E_ISNOTSTRUCT, "Type is not a structure or union") /** * libsyscall error numbers @@ -51,30 +52,49 @@ enum libsyscalls_os { * Architectures */ enum libsyscalls_arch { - LIBSYSCALLS_ARCH_ALPHA, + LIBSYSCALLS_ARCH_ALPHA_LE, + LIBSYSCALLS_ARCH_ALPHA_BE, LIBSYSCALLS_ARCH_AMD64, - LIBSYSCALLS_ARCH_AMD64_X32, /* 32-bit ABI, not traditional 32-bit x86 ISA */ - LIBSYSCALLS_ARCH_ARM_OABI, - LIBSYSCALLS_ARCH_ARM_EABI, - LIBSYSCALLS_ARCH_IA64, + LIBSYSCALLS_ARCH_AMD64_X32, /* 32-bit ABI on 64-bit ISA */ + LIBSYSCALLS_ARCH_ARM_OABI_LE, + LIBSYSCALLS_ARCH_ARM_OABI_BE, + LIBSYSCALLS_ARCH_ARM_EABI_LE, + LIBSYSCALLS_ARCH_ARM_EABI_BE, + LIBSYSCALLS_ARCH_IA64_LE, /* 64-bit pointers */ + LIBSYSCALLS_ARCH_IA64_BE, /* 64-bit pointers */ + LIBSYSCALLS_ARCH_IA64_P32_LE, /* 32-bit pointers */ + LIBSYSCALLS_ARCH_IA64_P32_BE, /* 32-bit pointers */ LIBSYSCALLS_ARCH_M68K, - LIBSYSCALLS_ARCH_MICROBLAZE, - LIBSYSCALLS_ARCH_MIPS_O32, - LIBSYSCALLS_ARCH_MIPS_N32, - LIBSYSCALLS_ARCH_MIPS_N64, + LIBSYSCALLS_ARCH_MICROBLAZE_32_LE, + LIBSYSCALLS_ARCH_MICROBLAZE_32_BE, + LIBSYSCALLS_ARCH_MICROBLAZE_64_LE, + LIBSYSCALLS_ARCH_MICROBLAZE_64_BE, + LIBSYSCALLS_ARCH_MIPS_O32_LE, + LIBSYSCALLS_ARCH_MIPS_O32_BE, + LIBSYSCALLS_ARCH_MIPS_N32_LE, /* 32-bit ABI on 64-bit ISA */ + LIBSYSCALLS_ARCH_MIPS_N32_BE, /* 32-bit ABI on 64-bit ISA */ + LIBSYSCALLS_ARCH_MIPS_N64_LE, + LIBSYSCALLS_ARCH_MIPS_N64_BE, LIBSYSCALLS_ARCH_PARISC_32, LIBSYSCALLS_ARCH_PARISC_64, - LIBSYSCALLS_ARCH_POWERPC_32, - LIBSYSCALLS_ARCH_POWERPC_64, - LIBSYSCALLS_ARCH_POWERPC_NOSPU, - LIBSYSCALLS_ARCH_POWERPC_SPU, + LIBSYSCALLS_ARCH_POWERPC_32_LE, + LIBSYSCALLS_ARCH_POWERPC_32_BE, + LIBSYSCALLS_ARCH_POWERPC_64_LE, + LIBSYSCALLS_ARCH_POWERPC_64_BE, + LIBSYSCALLS_ARCH_POWERPC_NOSPU_LE, + LIBSYSCALLS_ARCH_POWERPC_NOSPU_BE, + LIBSYSCALLS_ARCH_POWERPC_SPU_LE, + LIBSYSCALLS_ARCH_POWERPC_SPU_BE, LIBSYSCALLS_ARCH_S390_32, LIBSYSCALLS_ARCH_S390_64, - LIBSYSCALLS_ARCH_SH, + LIBSYSCALLS_ARCH_SH_LE, /* does not cover SH-5 */ + LIBSYSCALLS_ARCH_SH_BE, /* does not cover SH-5 */ LIBSYSCALLS_ARCH_SPARC_32, - LIBSYSCALLS_ARCH_SPARC_64, + LIBSYSCALLS_ARCH_SPARC_64_LE, + LIBSYSCALLS_ARCH_SPARC_64_BE, LIBSYSCALLS_ARCH_I386, - LIBSYSCALLS_ARCH_XTENSA + LIBSYSCALLS_ARCH_XTENSA_LE, + LIBSYSCALLS_ARCH_XTENSA_BE }; /** @@ -174,18 +194,23 @@ enum libsyscalls_datatype { #define LIBSYSCALLS_LIST_STRUCTS_AND_UNIONS(X, SUFFIX, D, FIRST)\ X(LIBSYSCALLS_TYPE_STRUCT_AIO_SIGSET ## SUFFIX, FIRST, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_COMPAT_AIO_SIGSET ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_CACHESTAT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_CACHESTAT_RANGE ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_CLONE_ARGS ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_EPOLL_EVENT ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_OABI_EPOLL_EVENT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_FILE_HANDLE ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_FUTEX_WAITV ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_IOB ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_IOVEC ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_IO_EVENT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_IO_URING_PARAMS ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_ITIMERVAL ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_ITIMERSPEC ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_ITIMERSPEC64 ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_KEXEC_SEGMENT ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_COMPAT_KEXEC_SEGMENT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_LANDLOCK_RULESET_ATTR ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_LINUX_DIRENT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_LINUX_DIRENT64 ## SUFFIX,, "struct") D\ @@ -214,6 +239,7 @@ enum libsyscalls_datatype { X(LIBSYSCALLS_TYPE_STRUCT_POLLFD ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_RLIMIT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_RLIMIT64 ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_COMPAT_RLIMIT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_ROBUST_LIST_HEAD ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_RSEQ ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_RUSAGE ## SUFFIX,, "struct") D\ @@ -227,7 +253,7 @@ enum libsyscalls_datatype { X(LIBSYSCALLS_TYPE_STRUCT_SIGALTSTACK ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_SIGEVENT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_SIGINFO ## SUFFIX,, "struct") D\ - X(LIBSYSCALLS_TYPE_STRUCT_SOCKADDR ## SUFFIX,, "struct") D /* size is always in the next argument */\ + X(LIBSYSCALLS_TYPE_STRUCT_SOCKADDR ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_STAT ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_STAT64 ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_STATFS ## SUFFIX,, "struct") D\ @@ -235,6 +261,8 @@ enum libsyscalls_datatype { X(LIBSYSCALLS_TYPE_STRUCT_STATX ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_SYSINFO ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_TIMESPEC ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_TIMESPEC64 ## SUFFIX,, "struct") D\ + X(LIBSYSCALLS_TYPE_STRUCT_TIMEVAL ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_TIMEX ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_TIMEZONE ## SUFFIX,, "struct") D\ X(LIBSYSCALLS_TYPE_STRUCT_TMS ## SUFFIX,, "struct") D\ @@ -246,7 +274,9 @@ enum libsyscalls_datatype { X(LIBSYSCALLS_TYPE_2_INTS ## SUFFIX, FIRST, "int[2]") D\ X(LIBSYSCALLS_TYPE_2_INTS_FD ## SUFFIX,, "int[2]") D\ X(LIBSYSCALLS_TYPE_2_UINT32S ## SUFFIX,, "uint32[2]") D\ - X(LIBSYSCALLS_TYPE_FD_SET ## SUFFIX,, "unsigned long[]") /* size depends on OS, (1024 / CHAR_BIT / sizeof(long)) in Linux */ + X(LIBSYSCALLS_TYPE_FD_SET ## SUFFIX,, "unsigned long[]") /* size depends on OS, (1024/CHAR_BIT/sizeof(long)) in Linux */ D\ + X(LIBSYSCALLS_TYPE_BUFFER_9 ## SUFFIX,, "char[9]") D\ + X(LIBSYSCALLS_TYPE_BUFFER_65 ## SUFFIX,, "char[65]") /* these don't have any suffix */ LIBSYSCALLS_MAKE_SPECIAL_TYPES_(), @@ -256,7 +286,7 @@ enum libsyscalls_datatype { LIBSYSCALLS_MAKE_ANNOTATED_NUMERICALS_(), LIBSYSCALLS_MAKE_STRUCTS_AND_UNIONS_(), - /* the following are always pointers unless returned */ + /* the following are always pointers if used as a parameter */ /* size in next parameter (or the previous parameter if there is no next parameter), * updated with fill if possible, otherwise returned (these use the suffix _ARRAY) */ @@ -2074,7 +2104,7 @@ struct libsyscalls_datatype_description { * guaranteed to be split otherwise) and this value is just * the number of bits stored in the register or struct field * - * It is possible for the datatype to contain unused dummy + * It is possible for the data type to contain unused dummy * bits in order to make it a power of 2 or a multiple of * a smaller data type. For example, on x86, `long double` * uses 128 bits, even though the value only uses 80 bits. @@ -2194,7 +2224,9 @@ struct libsyscalls_datatype_description { * `sizeof(x.byteorder) / sizeof(*x.byteorder)` * elements are read (where x is the instance of the * structure) (you should definitely have your own - * macro for that one) + * macro for that one). As an alternative to + * `LIBSYSCALLS_IS_BYTEORDER_END`, you may use the + * LIBSYSCALLS_IS_BYTEORDER_END_AT macro */ unsigned char byteorder[32]; @@ -2214,6 +2246,14 @@ struct libsyscalls_datatype_description { # define LIBSYSCALLS_IS_BYTEORDER_END(SHIFT)\ (!~((SHIFT) | ~LIBSYSCALLS_FIELD_MASK_(1ULL, struct libsyscalls_datatype_description, byteorder[0]))) #endif + + /** + * Test whether `DESC->byteorder[INDEX]` is + * the (post-last) end of `DESC->byteorder` + */ +#define LIBSYSCALLS_IS_BYTEORDER_END_AT(DESC, INDEX)\ + ((size_t)(INDEX) == sizeof((DESC)->byteorder) / sizeof(*(DESC)->byteorder) || \ + LIBSYSCALLS_IS_BYTEORDER_END((DESC)->byteorder[INDEX])) }; /** @@ -2262,6 +2302,51 @@ struct libsyscalls_structure_field { unsigned short int symbolic_field : 1; /** + * Only used with .input_field set to 1 + * + * If 1, it is probably not an error if the + * field is partially initialised as long as all + * its memory is allocated + * + * In the case that a field is split using for + * example one field with the type + * LIBSYSCALLS_TYPE_UINT64_FRONT_32 and another + * field with the type + * LIBSYSCALLS_TYPE_UINT64_BACK_32 (these two + * (for some split types, their may be more than + * two fields) fields will have the same name), + * it is one is partially initialised and the + * other completely uninitialised. Generally, + * as long as at least one of the parts are + * partially initialised, the application should + * not, unless it has more detailed knowledge + * about the system call, assume that there is + * an error. This happens because kernel's version + * of the library uses a scalar field, where as + * the userspace version (usually libc's version) + * uses a union of differently sized field. It + * is not necessarily the case that it can be + * known which field in the union is used: for + * example in epoll_ctl(2), it is completely up + * to the application, and the application has + * no way of telling the kernel which is used, + * and the kernel will in epoll_wait(2) simply + * return the union's value as it was set, meaning + * that some bits may be effectively uninitialised. + * Even if the field is complete uninitialised, + * it may still be the case that this is not an + * error, however, it probably is an error; for + * example in the case of epoll(7), it is completely + * possible, albeit unlikely (because it's silly), + * that the user calls epoll_ctl(2) without the + * `.data` field set, because it doesn't look at + * in when epoll_wait(2) returns, but insteads + * just does unblocking I/O one each file + * descriptor it has added to the epoll(7). + */ + unsigned short int partial_init_ok : 1; + + /** * If 1, the field is a pointer that the reads from * * Note that there are types that fundamentally are @@ -2281,7 +2366,16 @@ struct libsyscalls_structure_field { */ unsigned short int output_pointer : 1; - unsigned short int padding1__ : 16 - (6*1); + /** + * If 1, it has been determined that the field is + * not being used (usually because that it's not + * the active field in a `union` or because a + * flag somewhere in the `struct` is either set or + * cleared) + */ + unsigned short int unused : 1; + + unsigned short int padding1__ : 16 - (8*1); #if LIBSYSCALLS_IS_PADDING_REQUIRED_(3, 16, LIBSYSCALLS_POINTER_BIT_) # if !LIBSYSCALLS_CAN_ALIGN_(3, 16, CHAR_BIT) @@ -2289,6 +2383,30 @@ struct libsyscalls_structure_field { # endif char padding2__[LIBSYSCALLS_PAD_(sizeof(void *)/sizeof(char), (3*16)/CHAR_BIT)]; #endif + + /** + * Data type description + * + * The application is free to make changes, however, + * however the pointers themselves must not be touched + */ + union { + /** + * Description to use if `.type` refers to a + * `struct` or `union`; that is, if + * `(.type & ~LIBSYSCALLS_TYPEBITSMASK) >= + * LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS` + */ + struct libsyscalls_structure_description *structure; + + /** + * Description to use if `.type` does not refer + * to a `struct` or `union`; that is, if + * `(.type & ~LIBSYSCALLS_TYPEBITSMASK) < + * LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS` + */ + struct libsyscalls_datatype_description *nonstructure; + } type_description; }; /** @@ -2320,6 +2438,12 @@ struct libsyscalls_structure_description { unsigned short int num_fields : 14; /** + * If 1, the data type is a `union`, + * if 0, the data type is a `struct` + */ + unsigned short int is_union : 1; + + /** * Only used if .array_size is 0 * * Assuming the kernel writes into the array, if 1, the number @@ -2333,18 +2457,12 @@ struct libsyscalls_structure_description { unsigned short int fill_is_known : 1; /** - * If 1, the data type is a `union`, - * if 0, the data type is a `struct` - */ - unsigned short int is_union : 1; - - /** * The size (in number of elements) of the array the data type * is used in, or 1 if the data type was not an array or * 0 if the array size is determined by another parameter/field * * If 1, .relative_position_of_size will be set to 0, - * and .absolute_position_of_size -1, hoever if that is not + * and .absolute_position_of_size -1, however if that is not * the case and this field is set to 1, then .size (which may * or may not be 0 at this point) is determined by the indicated * parameter @@ -2441,7 +2559,7 @@ libsyscalls_perror(const char *, enum libsyscalls_error); * (not [*min_out, *max_out - 1]) but there may still be numbers within * this range that does not correspond to a system call */ -LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__) +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __access__(__write_only__, 3), __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_syscall_range(enum libsyscalls_os, enum libsyscalls_arch, long long int *, long long int *); @@ -2468,7 +2586,7 @@ libsyscalls_get_syscall_range(enum libsyscalls_os, enum libsyscalls_arch, long l * of operating system (`os`) and architecture (`arch`) is * unsupported */ -LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__) +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_syscall(enum libsyscalls_os, enum libsyscalls_arch, long long int, const struct libsyscalls_syscall **); @@ -2498,6 +2616,7 @@ libsyscalls_get_syscall(enum libsyscalls_os, enum libsyscalls_arch, long long in * is not supported, however it may be successful even if the * architecture (`arch`) not supported */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 3), __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_syscall_errors(enum libsyscalls_os, enum libsyscalls_arch, const struct libsyscalls_named_number **, size_t *); @@ -2527,6 +2646,7 @@ libsyscalls_get_syscall_errors(enum libsyscalls_os, enum libsyscalls_arch, const * is not supported, however it may be successful even if the * architecture (`arch`) not supported */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 3), __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_signals(enum libsyscalls_os, enum libsyscalls_arch, const struct libsyscalls_named_number **, size_t *); @@ -2542,7 +2662,11 @@ libsyscalls_get_signals(enum libsyscalls_os, enum libsyscalls_arch, const struct * @param syscall_arguments The values store in register (as upon system call entry) * the used for the system call, in the order the registers * are used as system call arguments - * @param info_out Output parameter for the additional system call information + * @param info_out Output parameter for the additional system call information; + * the caller responsible for deallocating the `*info_out` + * with free(3) when it is no longer needed. Be aware that + * `*info_out` will only be set when LIBSYSCALLS_E_OK is + * returned. * @return LIBSYSCALLS_E_OK - On success * LIBSYSCALLS_E_OSNOSUP - The library is not compiled with support for * the selected operating system (`os`) @@ -2552,17 +2676,23 @@ libsyscalls_get_signals(enum libsyscalls_os, enum libsyscalls_arch, const struct * LIBSYSCALLS_E_NOMEM - Failed to allocate memory for `*info_out` * LIBSYSCALLS_E_INVAL - One of the arguments was NULL */ -LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __nonnull__) +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __nonnull__, __access__(__read_only__, 3), __access__(__write_only__, 6)) enum libsyscalls_error libsyscalls_get_syscall_display_info(enum libsyscalls_os, enum libsyscalls_arch, const struct libsyscalls_syscall_abi *, - long long int, unsigned long long int *, struct libsyscalls_syscall_display_info **); + long long int, const unsigned long long int *, struct libsyscalls_syscall_display_info **); /** - * Get information on how an instance of data type is to be parsed + * Get information on how an instance of non-struct, non-union + * data type is to be parsed + * + * Do not use for data types inside structures, + * instead, use `.type_description.nonstructure` + * in the structure's field, as it may contain + * important adjustments * * @param os The operating system the data type is used on * @param arch The architecture the data type is used on - * @param datatype The datatype, `LIBSYSCALLS_TYPE_DYNAMIC` can + * @param datatype The data type, `LIBSYSCALLS_TYPE_DYNAMIC` can * be used to get the size of the registers used * as system call parameters * @param description_out Output parameter for the type description @@ -2575,13 +2705,14 @@ libsyscalls_get_syscall_display_info(enum libsyscalls_os, enum libsyscalls_arch, * LIBSYSCALLS_E_INVAL - `datatype` is not a valid data type * LIBSYSCALLS_E_NOSUCHTYPE - `datatype` does not exist on the selected * operating system (`os`) or architecture (`arch`) - * LIBSYSCALLS_E_ISSTRUCT - `datatype` represents a structure + * LIBSYSCALLS_E_ISSTRUCT - `datatype` represents a structure or union, + * or an array of a structure or union * * The function may complete successfully for some data * types even if it for other data types would return * LIBSYSCALLS_E_OSNOSUP or LIBSYSCALLS_E_ARCHNOSUP */ -LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__) +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_datatype_description(enum libsyscalls_os, enum libsyscalls_arch, enum libsyscalls_datatype, struct libsyscalls_datatype_description *); @@ -2625,11 +2756,167 @@ libsyscalls_get_datatype_description(enum libsyscalls_os, enum libsyscalls_arch, * return LIBSYSCALLS_E_ARCHNOSUP, in such cases, the result * is indeed reliable */ -LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__) +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __access__(__write_only__, 4)) enum libsyscalls_error libsyscalls_get_integer_alignment(enum libsyscalls_os, enum libsyscalls_arch, unsigned, unsigned *); -/* TODO add libsyscalls_get_struct_description */ +/** + * Parse a string of bits as a signed integer + * + * In case `representation` is LIBSYSCALLS_SIGN_UNDETERMINED, + * the bits are parsed as an unsigned integer + * + * @param value_in The bits to parse as a signed integer + * @param representation The sign representation used on the interger + * @param bits The number of bits in the integer + * @param value_out Output parameter for the absolute value of the signed integer (may be NULL) + * @param negative_out Output parameter for whether the signed integer is negative (may be NULL) + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - `representation` is not recognised by the library + * LIBSYSCALLS_E_INVAL - `bits` is 0 + * LIBSYSCALLS_E_INVAL - `bits` is greater than `sizeof(long long int) * CHAR_BIT` + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 4), __access__(__write_only__, 5)) +enum libsyscalls_error +libsyscalls_parse_signed_integer(unsigned long long int, enum libsyscalls_datatype_sign_representation, + size_t, unsigned long long int *, int *); + +/** + * Create a string of bits representing a signed integer + * + * In case `representation` is LIBSYSCALLS_SIGN_UNDETERMINED, + * the bit string will represent an unsigned integer + * + * @param value_in The absolute value if the signed integer + * @param negative Whether the signed integer is negative + * @param representation The sign representation used on the interger + * @param bits The number of bits in the integer + * @param value_out Output parameter for the bit string (may be NULL) + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - `representation` is not recognised by the library + * LIBSYSCALLS_E_INVAL - `bits` is 0 + * LIBSYSCALLS_E_INVAL - `bits` is greater than `sizeof(long long int) * CHAR_BIT` + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 5)) +enum libsyscalls_error +libsyscalls_make_signed_integer(unsigned long long int, int, enum libsyscalls_datatype_sign_representation, + size_t, unsigned long long int *); + +/** + * Take bits from a section of a split value + * and shift its bit into place, so that the OR + * of the result for each section creates the + * original unsplit value + * + * If `section` is LIBSYSCALLS_SECTION_UNDETERMINED, + * no changes will be made + * + * @param value_in The contiguous bits in the section of the value + * @param bits The number of bits in the section of the value + * @param section The section of the value + * @param value_out Output parameter for the value with its bits shifted into place (may be NULL) + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - `representation` is not recognised by the library + * LIBSYSCALLS_E_INVAL - `bits` is invalid for `section` + * LIBSYSCALLS_E_INVAL - `bits` is greater than `sizeof(long long int) * CHAR_BIT` + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 4)) +enum libsyscalls_error +libsyscalls_unsection_value(unsigned long long int, size_t, enum libsyscalls_datatype_section, unsigned long long int *); + +/** + * Create a split section from a value + * + * If `section` is LIBSYSCALLS_SECTION_UNDETERMINED, + * no changes will be made + * + * @param value_in The whole value + * @param bits The number of bits in the whole value + * @param section The section of the value to return + * @param value_out Output parameter for bits in the section value shifted into contiguity (may be NULL) + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - `representation` is not recognised by the library + * LIBSYSCALLS_E_INVAL - `bits` is invalid for `section` + * LIBSYSCALLS_E_INVAL - `bits` is greater than `sizeof(long long int) * CHAR_BIT` + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__access__(__write_only__, 4)) +enum libsyscalls_error +libsyscalls_section_value(unsigned long long int, size_t, enum libsyscalls_datatype_section, unsigned long long int *); + +/** + * Converts a value from the tracee's endian to the tracer's endian + * + * @param value_in Buffer containing the value to convert (does not need to be aligned) + * @param offset_in Offset in `value_in`, in bits + * @param type Details about the data type + * @param value_out Output parameter for the value in the tracer's endian + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - Either parameter is NULL + * LIBSYSCALLS_E_INVAL - The data type is too wide + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__nonnull__, __access__(__read_only__, 1), __access__(__read_only__, 3), __access__(__write_only__, 4)) +enum libsyscalls_error +libsyscalls_to_tracer_endian(const void *, size_t, const struct libsyscalls_datatype_description *, unsigned long long int *); + +/** + * Converts a value from the tracer's endian to the tracee's endian + * + * @param value_in Buffer containing the value to convert + * @param type Details about the data type + * @param value_out Output parameter for the value in the tracee's + * endian (does not need to be aligned); preexisting + * bits that do not overlap with the position of the + * value will be retained + * @param out_offset Offset in `value_out`, in bits + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_INVAL - Either parameter is NULL + * LIBSYSCALLS_E_INVAL - The data type is too wide + */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__nonnull__, __access__(__read_only__, 2), __access__(__read_write__, 3)) +enum libsyscalls_error +libsyscalls_to_tracee_endian(unsigned long long int, const struct libsyscalls_datatype_description *, void *, size_t); + +/** + * Get information on how an instance of struct or union is to be parsed + * + * Do not use for structures inside other structures, + * instead, use `.type_description.structure` in the + * structure's field, as it may contain important + * adjustments + * + * @param os The operating system the data type is used on + * @param arch The architecture the data type is used on + * @param datatype The data type + * @param data The data that is to be parsed (may be `NULL` if `data_size` is 0) + * @param data_size The number of bytes available in `data`, may be short or in excess + * @param description_out Output parameter for the type description; + * the caller responsible for deallocating the `*info_out` + * with free(3) when it is no longer needed. Be aware that + * `*info_out` will only be set when LIBSYSCALLS_E_OK is + * returned. + * @return LIBSYSCALLS_E_OK - On success + * LIBSYSCALLS_E_OSNOSUP - The library is not compiled with support for + * the selected operating system (`os`) + * LIBSYSCALLS_E_ARCHNOSUP - The library is not compiled with support for + * the selected architecture (`arch`) on the + * selected operating system (`os`) + * LIBSYSCALLS_E_INVAL - `datatype` is not a valid data type + * LIBSYSCALLS_E_NOSUCHTYPE - `datatype` does not exist on the selected + * operating system (`os`) or architecture (`arch`) + * LIBSYSCALLS_E_ISNOTSTRUCT - `datatype` does not represent a structure or + * union, nor an array of structure or union + * + * The function may complete successfully for some data + * types even if it for other data types would return + * LIBSYSCALLS_E_ARCHNOSUP + */ +#if 0 /* work in progress */ +LIBSYSCALLS_GCC_ATTRIBUTES_(__warn_unused_result__, __access__(__read_only__, 4, 5), __access__(__write_only__, 6)) +enum libsyscalls_error +libsyscalls_get_struct_description(enum libsyscalls_os, enum libsyscalls_arch, enum libsyscalls_datatype, + const void *, size_t, struct libsyscalls_structure_description **); +#endif + /* TODO add libsyscalls_get_struct_display_info */ diff --git a/libsyscalls/internal-begin.h b/libsyscalls/internal-begin.h index 0d89bb7..56faadf 100644 --- a/libsyscalls/internal-begin.h +++ b/libsyscalls/internal-begin.h @@ -8,6 +8,13 @@ #include <stddef.h> +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdocumentation" +# pragma clang diagnostic ignored "-Wunknown-attributes" +#endif + + /** * Opaque type for symbol printer function identification */ diff --git a/libsyscalls/internal-end.h b/libsyscalls/internal-end.h index 2aeb2f0..e75a5ce 100644 --- a/libsyscalls/internal-end.h +++ b/libsyscalls/internal-end.h @@ -22,3 +22,8 @@ #undef LIBSYSCALLS_MAKE_ANNOTATED_NUMERICALS_ #undef LIBSYSCALLS_MAKE_STRUCTS_AND_UNIONS_ #undef LIBSYSCALLS_MAKE_FIXED_ARRAYS_ + + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif diff --git a/libsyscalls_get_datatype_description.c b/libsyscalls_get_datatype_description.c index 71a2170..a418eb3 100644 --- a/libsyscalls_get_datatype_description.c +++ b/libsyscalls_get_datatype_description.c @@ -1,56 +1,5 @@ /* See LICENSE file for copyright and license details. */ #include "common.h" -#include <stdlib.h> -#include <string.h> - - -#define COUNT_(...) 1 -#define COUNT(LIST_MACRO) (LIST_MACRO(COUNT_,, +,)) - -enum endian { - Big, - Little, -}; - -#define LIST_ARCH_SPECS(X, D) /* byte intptr size_t endian sign */\ - /* - X(LIBSYSCALLS_ARCH_ALPHA, 8, 64, 64, TODO(bi), TWOS_COMPLEMENT) D\ - */\ - X(LIBSYSCALLS_ARCH_AMD64, 8, 64, 64, Little, TWOS_COMPLEMENT) D\ - X(LIBSYSCALLS_ARCH_AMD64_X32, 8, 32, 32, Little, TWOS_COMPLEMENT) D /* amd64, 32-bit convesion */\ - /* - X(LIBSYSCALLS_ARCH_ARM_OABI, 8, TODO, TODO, TODO(bi), TWOS_COMPLEMENT) D / * TODO (alignment) * / \ - X(LIBSYSCALLS_ARCH_ARM_EABI, 8, TODO, TODO, TODO(bi), TWOS_COMPLEMENT) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_IA64, 8, 64, 64, TODO, TWOS_COMPLEMENT) D\ - */\ - X(LIBSYSCALLS_ARCH_M68K, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ - /* - X(LIBSYSCALLS_ARCH_MICROBLAZE, 8, TODO, TODO, TODO, TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_MIPS_O32, 8, 32, 32, TODO(bi), TWOS_COMPLEMENT) D / * mips32 * /\ - X(LIBSYSCALLS_ARCH_MIPS_N32, 8, 32, 32, TODO(bi), TWOS_COMPLEMENT) D / * TODO (alignment) * / / * mips64, 32-bit convention * /\ - X(LIBSYSCALLS_ARCH_MIPS_N64, 8, 64, 64, TODO(bi), TWOS_COMPLEMENT) D / * TODO (alignment) * / / * mips64 * /\ - */\ - X(LIBSYSCALLS_ARCH_PARISC_32, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ - X(LIBSYSCALLS_ARCH_PARISC_64, 8, 64, 64, Big, TWOS_COMPLEMENT) D\ - /* - X(LIBSYSCALLS_ARCH_POWERPC_32, 8, 32, 32, TODO(bi), TODO) D\ - X(LIBSYSCALLS_ARCH_POWERPC_64, 8, 64, 64, TODO(bi), TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_POWERPC_NOSPU, 8, 64, 64, TODO(bi), TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_POWERPC_SPU, 8, 64, 64, TODO(bi), TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_S390_32, 8, 32, 32, Big, TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_S390_64, 8, 64, 64, Big, TODO) D / * TODO (alignment) * /\ - X(LIBSYSCALLS_ARCH_SH, 8, 32, 32, TODO(bi), TODO) D / * TODO (alignment) * / / * not sh-5 * /\ - */\ - X(LIBSYSCALLS_ARCH_SPARC_32, 8, 32, 32, Big, TWOS_COMPLEMENT) D\ - /* - X(LIBSYSCALLS_ARCH_SPARC_64, 8, 64, 64, TODO(bi), TWOS_COMPLEMENT) D\ - */\ - X(LIBSYSCALLS_ARCH_I386, 8, 32, 32, Little, TWOS_COMPLEMENT) D\ - /* - X(LIBSYSCALLS_ARCH_XTENSA, 8, 32, 32, TODO, TODO) - */ - /* Don't forget to update SUPPORTED_ARCHES in Makefile */ - /* TODO (alignment) means that it is missing in libsyscalls_get_integer_alignment.c and must also be added thither */ #include "generated/types.c" @@ -154,6 +103,14 @@ libsyscalls_get_datatype_description(enum libsyscalls_os os, enum libsyscalls_ar datatype = LIBSYSCALLS_TYPE_UINT32; description_out->array_size = 2; break; + case LIBSYSCALLS_TYPE_BUFFER_9: + datatype = LIBSYSCALLS_TYPE_CHAR; + description_out->array_size = 9; + break; + case LIBSYSCALLS_TYPE_BUFFER_65: + datatype = LIBSYSCALLS_TYPE_CHAR; + description_out->array_size = 65; + break; case LIBSYSCALLS_TYPE_FD_SET: goto os_dependent; default: @@ -190,7 +147,7 @@ libsyscalls_get_datatype_description(enum libsyscalls_os os, enum libsyscalls_ar } else if (datatype >= LIBSYSCALLS_TYPEOFFSET_UNANNOTATED_NUMERICALS) { unannotated: - if (datatype - LIBSYSCALLS_TYPEOFFSET_UNANNOTATED_NUMERICALS >= COUNT(LIBSYSCALLS_LIST_UNANNOTATED_NUMERICALS)) { + if (datatype - LIBSYSCALLS_TYPEOFFSET_UNANNOTATED_NUMERICALS >= COUNT_LIST(LIBSYSCALLS_LIST_UNANNOTATED_NUMERICALS)) { return LIBSYSCALLS_E_INVAL; } else if (datatype == LIBSYSCALLS_TYPE_MEMORY_ADDRESS) { datatype = LIBSYSCALLS_TYPE_INTPTR; @@ -206,7 +163,7 @@ libsyscalls_get_datatype_description(enum libsyscalls_os os, enum libsyscalls_ar } else if (datatype >= LIBSYSCALLS_TYPEOFFSET_COMPOSITE_PRIMITIVES) { if (class != LIBSYSCALLS_TYPEBITS_SCALAR) return LIBSYSCALLS_E_INVAL; - if (datatype - LIBSYSCALLS_TYPEOFFSET_COMPOSITE_PRIMITIVES >= COUNT(LIBSYSCALLS_LIST_COMPOSITE_PRIMITIVES)) + if (datatype - LIBSYSCALLS_TYPEOFFSET_COMPOSITE_PRIMITIVES >= COUNT_LIST(LIBSYSCALLS_LIST_COMPOSITE_PRIMITIVES)) return LIBSYSCALLS_E_INVAL; datatype = LIBSYSCALLS_TYPE_MEMORY_ADDRESS; goto unannotated; @@ -376,8 +333,6 @@ not_os_dependent: #if defined(__clang__) # pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -# pragma clang diagnostic push # pragma clang diagnostic ignored "-Wimplicit-int-conversion" /* we don't want to hardcode the type here */ #elif defined(__GNUC__) # pragma GCC diagnostic push @@ -406,23 +361,20 @@ not_os_dependent: if (half) { unsigned long long int bytemask, coverage = 0; unsigned long long int remmask; - unsigned char bytebits = UCHAR_MAX; + unsigned long long int bytebits; - for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END(larger_type.byteorder[i]); i++) - if (larger_type.byteorder[i] && larger_type.byteorder[i] < bytebits) - bytebits = larger_type.byteorder[i]; + bytebits = (unsigned long long int)larger_type.width_in_bits; + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(&larger_type, i); i++) + if (larger_type.byteorder[i] && (unsigned long long int)larger_type.byteorder[i] < bytebits) + bytebits = (unsigned long long int)larger_type.byteorder[i]; bytemask = (1ULL << bytebits) - 1ULL; remmask = 0xFFFFFFFFULL; /* we known from the code above that we are working with 32-bit sections */ - for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END(larger_type.byteorder[i]); i++) { + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(&larger_type, i); i++) { coverage |= (remmask & bytemask) << larger_type.byteorder[i]; remmask >>= bytebits; } -#if defined(__clang__) -# pragma clang diagnostic pop -#endif - /* we known from the code above that we are working with split 64-bit integers */ if (half == +1) coverage ^= 0xFFFFFFFFFFFFFFFFull; diff --git a/libsyscalls_get_integer_alignment.c b/libsyscalls_get_integer_alignment.c index 7802a06..1c2d10e 100644 --- a/libsyscalls_get_integer_alignment.c +++ b/libsyscalls_get_integer_alignment.c @@ -19,20 +19,50 @@ libsyscalls_get_integer_alignment(enum libsyscalls_os os, enum libsyscalls_arch break; case LIBSYSCALLS_ARCH_I386: + case LIBSYSCALLS_ARCH_ARM_OABI_LE: /* https://wiki.debian.org/ArmEabiPort#A64-bit_data_type_alignment */ + case LIBSYSCALLS_ARCH_ARM_OABI_BE: + case LIBSYSCALLS_ARCH_SH_LE: /* https://www.st.com/resource/en/reference_manual/rm0197-sh4-generic-and-c-specific-application-binary-interface-stmicroelectronics.pdf (page 12) */ + case LIBSYSCALLS_ARCH_SH_BE: + case LIBSYSCALLS_ARCH_MICROBLAZE_32_LE: /* https://www.ecb.torontomu.ca/~courses/ee8205/Data-Sheets/sopc/MicroBlaze_DataSheet.pdf */ + case LIBSYSCALLS_ARCH_MICROBLAZE_32_BE: maxalign = 32; break; case LIBSYSCALLS_ARCH_AMD64: case LIBSYSCALLS_ARCH_AMD64_X32: - case LIBSYSCALLS_ARCH_ALPHA: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ - case LIBSYSCALLS_ARCH_IA64: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ - case LIBSYSCALLS_ARCH_MIPS_O32: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_ARM_EABI_LE: /* https://wiki.debian.org/ArmEabiPort#A64-bit_data_type_alignment */ + case LIBSYSCALLS_ARCH_ARM_EABI_BE: + case LIBSYSCALLS_ARCH_ALPHA_LE: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_ALPHA_BE: + case LIBSYSCALLS_ARCH_IA64_LE: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_IA64_BE: + case LIBSYSCALLS_ARCH_IA64_P32_LE: + case LIBSYSCALLS_ARCH_IA64_P32_BE: + case LIBSYSCALLS_ARCH_MIPS_O32_LE: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_MIPS_O32_BE: + case LIBSYSCALLS_ARCH_MIPS_N32_LE: /* https://s3-eu-west-1.amazonaws.com/downloads-mips/documents/MD00083-2B-MIPS64INT-AFP-05.04.pdf (page 40) */ + case LIBSYSCALLS_ARCH_MIPS_N32_BE: + case LIBSYSCALLS_ARCH_MIPS_N64_LE: + case LIBSYSCALLS_ARCH_MIPS_N64_BE: case LIBSYSCALLS_ARCH_PARISC_32: /* https://www.ece.lsu.edu/ee4720/doc/pa1.1.pdf (page 26) */ case LIBSYSCALLS_ARCH_PARISC_64: - case LIBSYSCALLS_ARCH_POWERPC_32: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_POWERPC_32_LE: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_POWERPC_32_BE: + case LIBSYSCALLS_ARCH_POWERPC_64_LE: /* https://www.slac.stanford.edu/exp/npa/software/eabi_app.pdf */ + case LIBSYSCALLS_ARCH_POWERPC_64_BE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_BE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_BE: + case LIBSYSCALLS_ARCH_S390_32: /* https://refspecs.linuxbase.org/ELF/zSeries/lzsabi0_s390.html */ + case LIBSYSCALLS_ARCH_S390_64: case LIBSYSCALLS_ARCH_SPARC_32: /* https://www.gaisler.com/doc/sparcv8.pdf (page 46) */ - case LIBSYSCALLS_ARCH_SPARC_64: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ - case LIBSYSCALLS_ARCH_XTENSA: /* https://loboris.eu/ESP32/Xtensa_lx%20Overview%20handbook.pdf (page 97) */ + case LIBSYSCALLS_ARCH_SPARC_64_LE: /* https://static.lwn.net/images/pdf/LDD3/ch11.pdf */ + case LIBSYSCALLS_ARCH_SPARC_64_BE: + case LIBSYSCALLS_ARCH_XTENSA_LE: /* https://loboris.eu/ESP32/Xtensa_lx%20Overview%20handbook.pdf (page 97) */ + case LIBSYSCALLS_ARCH_XTENSA_BE: + case LIBSYSCALLS_ARCH_MICROBLAZE_64_LE: /* https://www.amd.com/content/dam/xilinx/support/documents/sw_manuals/xilinx2021_2/ug984-vivado-microblaze-ref.pdf */ + case LIBSYSCALLS_ARCH_MICROBLAZE_64_BE: maxalign = 64; break; diff --git a/libsyscalls_get_struct_description.c b/libsyscalls_get_struct_description.c new file mode 100644 index 0000000..4d9ce68 --- /dev/null +++ b/libsyscalls_get_struct_description.c @@ -0,0 +1,656 @@ +/* See LICENSE file for copyright and license details. */ +#define REQUIRE_FLEXABLE_OR_NFIELDS +#include "common.h" + + +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-macros" +#endif + +#define IN .input_field = 1 +#define OUT .output_field = 1 +#define ERR .error_field = 1 +#define SYM .symbolic_field = 1 +#define PARTIAL .partial_init_ok = 1 +#define INPTR .input_pointer = 1 +#define OUTPTR .output_pointer = 1 + +#define BITFIELD(N) .bitlength = (N) +#define FIELD(NAME, TYPE, ...)\ + {.name = NAME,\ + .type = LIBSYSCALLS_TYPE_##TYPE\ + __VA_OPT__(, __VA_ARGS__)} +#define STRUCT(PRINTER, ...) STRUCT_OR_UNION_(0, PRINTER __VA_OPT__(, __VA_ARGS__)) +#define UNION(PRINTER, ...) STRUCT_OR_UNION_(1, PRINTER __VA_OPT__(, __VA_ARGS__)) +#define STRUCT_OR_UNION_(IS_UNION, PRINTER, ...)\ + {.is_union = (IS_UNION),\ + .symbol_printer = (PRINTER),\ + .num_fields = COUNT_ARGS(__VA_ARGS__)\ + __VA_OPT__(, .fields = {__VA_ARGS__})} + +#if defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + + +struct padding { + unsigned short int size; + unsigned short int after; +}; + + +static enum libsyscalls_error +get_struct_description(enum libsyscalls_os os, enum libsyscalls_arch arch, enum libsyscalls_datatype datatype, const void *data, + size_t data_size, struct libsyscalls_structure_description **description_out, size_t *extra_sizep); + + +static struct libsyscalls_structure_description * +copy_struct(const struct libsyscalls_structure_description *prototype) +{ + struct libsyscalls_structure_description *ret; + size_t size = offsetof(struct libsyscalls_structure_description, fields); + size += prototype->num_fields * sizeof(*prototype->fields); + ret = malloc(size); + if (!ret) + return NULL; + memcpy(ret, prototype, size); + return ret; +} + + +static struct libsyscalls_datatype_description * +create_pad_description(enum libsyscalls_os os, enum libsyscalls_arch arch, unsigned short int size) +{ + struct libsyscalls_datatype_description *ret; + ret = calloc(1, sizeof(*ret)); + if (!ret) + return NULL; + if (libsyscalls_get_datatype_description(os, arch, LIBSYSCALLS_TYPE_CHAR, ret)) + abort(); + ret->width_in_bits = size; + return ret; +} + + +static enum libsyscalls_error +shift_fields(enum libsyscalls_os os, enum libsyscalls_arch arch, struct libsyscalls_structure_description *description, + const struct padding *paddings, size_t npaddings) +{ + signed short int shift, map[description->num_fields], abs, rel; + unsigned short int i, j, k; + int is_struct; + + /* Adjust field references */ + for (i = 0; i < description->num_fields; i++) + map[i] = (signed short int)i; + shift = 0; + i = j = 0; + while (i < (unsigned short int)npaddings && j < description->num_fields) { + if (j > paddings[i].after) + shift += 1; + map[j] += shift; + } + for (; j < description->num_fields; j++) + map[j] += shift; + for (i = 0; i < description->num_fields; i++) { + is_struct = (description->fields[i].type & ~LIBSYSCALLS_TYPEBITSMASK) >= LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS; + + if (is_struct) { + abs = description->fields[i].type_description.structure->absolute_position_of_size; + rel = description->fields[i].type_description.structure->relative_position_of_size; + } else { + abs = description->fields[i].type_description.nonstructure->absolute_position_of_array_size; + rel = description->fields[i].type_description.nonstructure->relative_position_of_array_size; + } + + if (abs >= 0) { + if ((unsigned short int)abs > description->num_fields) + abort(); + abs = map[abs]; + } + if (rel != 0) { + if (rel + (signed short int)i < 0) + abort(); + if ((unsigned short int)(rel + (signed short int)i) > description->num_fields) + abort(); + rel = map[rel + (signed short int)i]; + rel -= (signed short int)i; + } + +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wconversion" +#endif + if (is_struct) { + description->fields[i].type_description.structure->absolute_position_of_size = abs; + description->fields[i].type_description.structure->relative_position_of_size = rel; + } else { + description->fields[i].type_description.nonstructure->absolute_position_of_array_size = abs; + description->fields[i].type_description.nonstructure->relative_position_of_array_size = rel; + } +#if defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + } + + /* Insert padding fields */ + i = description->num_fields; + j = i + (unsigned short int)shift; + k = (unsigned short int)(npaddings - 1); + while (i) { + memcpy(&description->fields[--j], &description->fields[--i], sizeof(*description->fields)); + while (i <= paddings[k].after) { + j--; + description->size += paddings[k].size; + memset(&description->fields[j], 0, sizeof(*description->fields)); + description->fields[j].name = NULL; + description->fields[j].type = LIBSYSCALLS_TYPE_VOID; + description->fields[j].unused = 1; + description->fields[j].type_description.nonstructure = create_pad_description(os, arch, paddings[k].size); + if (!description->fields[j].type_description.structure) + return LIBSYSCALLS_E_NOMEM; + if (!k--) + return LIBSYSCALLS_E_OK; + } + } + + return LIBSYSCALLS_E_OK; +} + + +static void +free_subdescriptions(struct libsyscalls_structure_description *description) +{ + unsigned short int i; + for (i = 0; i < description->num_fields; i++) { + if ((description->fields[i].type & ~LIBSYSCALLS_TYPEBITSMASK) >= LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS) + free_subdescriptions(description->fields[i].type_description.structure); + free(description->fields[i].type_description.structure); + } +} + + +static void +move_in_subdescriptions(char *buffer, size_t *offsetp, struct libsyscalls_structure_description *description, + int include_nonstructures, int include_structures) +{ + unsigned short int i; + size_t size; + for (i = 0; i < description->num_fields; i++) { + if ((description->fields[i].type & ~LIBSYSCALLS_TYPEBITSMASK) >= LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS) { + move_in_subdescriptions(buffer, offsetp, description->fields[i].type_description.structure, + include_nonstructures, include_structures); + if (!include_structures) + continue; + size = (size_t)description->fields[i].type_description.structure->num_fields; + size *= sizeof(*description->fields[i].type_description.structure->fields); + size += offsetof(struct libsyscalls_structure_description, fields); + } else { + if (!include_nonstructures) + continue; + size = sizeof(struct libsyscalls_datatype_description); + } + memcpy(&buffer[*offsetp], description->fields[i].type_description.structure, size); + free(description->fields[i].type_description.structure); + description->fields[i].type_description.structure = (void *)&buffer[*offsetp]; + *offsetp += size; + } +} + + +static unsigned long long int +read_field(const void *data, size_t data_size, const size_t *field_offsets, + const struct libsyscalls_structure_description *description, unsigned short int i, int *undetermined_out) +{ + size_t offset, width, bits = 0; + enum libsyscalls_datatype type = description->fields[i].type; + const struct libsyscalls_datatype_description *type_description = description->fields[i].type_description.nonstructure; + unsigned splits, expected_splits, end; + unsigned long long int result = 0, subresult; + signed long long int sresult; + int is_negative; + + if ((type & LIBSYSCALLS_TYPEBITSMASK) != LIBSYSCALLS_TYPEBITS_SCALAR) + abort(); + type ^= LIBSYSCALLS_TYPEBITS_SCALAR; + if (type >= LIBSYSCALLS_TYPEOFFSET_SPLIT_PRIMITIVES && type < LIBSYSCALLS_TYPEOFFSET_COMPOSITE_PRIMITIVES) + splits = LIBSYSCALLS_GET_SECTION_FRACTION(type_description->section); + else if (type >= LIBSYSCALLS_TYPEOFFSET_UNANNOTATED_NUMERICALS && type < LIBSYSCALLS_TYPEOFFSET_FIXED_ARRAYS) + splits = 1; + else + abort(); + + expected_splits = splits; + end = i + splits; + goto start; + + for (; i < end; i++) { + if ((type & LIBSYSCALLS_TYPEBITSMASK) != LIBSYSCALLS_TYPEBITS_SCALAR) + abort(); + type ^= LIBSYSCALLS_TYPEBITS_SCALAR; + if (type >= LIBSYSCALLS_TYPEOFFSET_SPLIT_PRIMITIVES && type < LIBSYSCALLS_TYPEOFFSET_COMPOSITE_PRIMITIVES) + splits = LIBSYSCALLS_GET_SECTION_FRACTION(type_description->section); + else if (type >= LIBSYSCALLS_TYPEOFFSET_UNANNOTATED_NUMERICALS && type < LIBSYSCALLS_TYPEOFFSET_FIXED_ARRAYS) + splits = 1; + else + abort(); + + if (splits != expected_splits) + abort(); + + start: + offset = field_offsets[i]; + width = (size_t)type_description->width_in_bits; + bits += width; + + if (offset > data_size || width > data_size - offset) + goto undetermined; + + if (libsyscalls_to_tracer_endian(&((const char *)data)[offset / CHAR_BIT], offset % CHAR_BIT, + type_description, &subresult)) + abort(); + + if (libsyscalls_unsection_value(subresult, width, type_description->section, &subresult)) + abort(); + + result |= subresult; + } + + if (type_description->is_signed) { + if (libsyscalls_parse_signed_integer(result, type_description->sign_representation, bits, &result, &is_negative)) + abort(); + if (is_negative) { +#if LLONG_MIN == -LLONG_MAX + if (result >> (bits - 1)) + goto undetermined; +#endif + sresult = (signed long long int)result; + sresult = -sresult; + } + result = *(unsigned long long int *)&sresult; + } + + return result; + +undetermined: + *undetermined_out = 1; + return 0; +} + + +static enum libsyscalls_error +pad_structure_into_alignment(struct padding **paddingsp, size_t *npaddingsp, size_t *paddings_sizep, + const struct libsyscalls_structure_description *description) +{ + unsigned short int alignment_mask, misalignment; + void *new; + + alignment_mask = (unsigned short int)(description->alignment - 1U); + misalignment = (unsigned short int)(description->size & alignment_mask); + if (misalignment) { + if (*npaddingsp == *paddings_sizep) { + *paddings_sizep += 16; + new = realloc(*paddingsp, *paddings_sizep * sizeof(**paddingsp)); + if (!new) + return LIBSYSCALLS_E_NOMEM; + *paddingsp = new; + } + (*paddingsp)[*npaddingsp].size = (unsigned short int)(description->alignment - misalignment); + (*paddingsp)[*npaddingsp].after = description->num_fields; + *npaddingsp += 1; + } + + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +pad_field_into_alignment(struct padding **paddingsp, size_t *npaddingsp, size_t *paddings_sizep, + const struct libsyscalls_structure_description *description, + unsigned short int i, unsigned subalign, size_t *field_offsetp) +{ + unsigned short int misalignment, alignment_mask, padding; + void *new; + + alignment_mask = (unsigned short int)(subalign - 1U); + misalignment = (unsigned short int)(description->size & alignment_mask); + + if (misalignment) { + if (i == 0) + abort(); + padding = (unsigned short int)(subalign - (unsigned)misalignment); + if (*npaddingsp == *paddings_sizep) { + *paddings_sizep += 16; + new = realloc(*paddingsp, *paddings_sizep * sizeof(**paddingsp)); + if (!new) + return LIBSYSCALLS_E_NOMEM; + *paddingsp = new; + } + *field_offsetp += (size_t)padding; + (*paddingsp)[*npaddingsp].size = (unsigned short int)padding; + (*paddingsp)[*npaddingsp].after = (unsigned short int)(i - 1U); + *npaddingsp += 1; + } + + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +apply_padding(enum libsyscalls_os os, enum libsyscalls_arch arch, struct padding *paddings, + size_t npaddings, struct libsyscalls_structure_description **descriptionp) +{ + struct libsyscalls_structure_description *description = *descriptionp; + enum libsyscalls_error r; + size_t size; + + if (npaddings && description->alignment > 1) { + size = offsetof(struct libsyscalls_structure_description, fields); + size += (size_t)(description->num_fields + npaddings) * sizeof(*description->fields); + description = realloc(description, size); + if (!description) + return LIBSYSCALLS_E_NOMEM; + *descriptionp = description; + + r = shift_fields(os, arch, description, paddings, npaddings); + if (r) + return r; + } + + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +adjust_for_nonstruct(enum libsyscalls_os os, enum libsyscalls_arch arch, + const struct libsyscalls_datatype_description *int_description, + struct libsyscalls_structure_description *description, unsigned short int i, + unsigned *subsizep, unsigned *subalignp, size_t *extra_sizep) +{ + enum libsyscalls_error r; + + *subsizep = int_description->width_in_bits; + /* TODO deal with array_size, keep in mind that it can be 0 because we have (type[]) or (type *); be aware of padding */ + r = libsyscalls_get_integer_alignment(os, arch, *subsizep, subalignp); + if (r) + return r; + + description->fields[i].type_description.nonstructure = malloc(sizeof(*int_description)); + if (!description->fields[i].type_description.nonstructure) + return LIBSYSCALLS_E_NOMEM; + memcpy(description->fields[i].type_description.nonstructure, int_description, sizeof(*int_description)); + *extra_sizep += sizeof(*int_description); + + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +adjust_for_struct(enum libsyscalls_os os, enum libsyscalls_arch arch, const void *data, size_t data_size, + struct libsyscalls_structure_description *description, unsigned short int i, size_t *field_offsets, + unsigned *subsizep, unsigned *subalignp, size_t *extra_sizep, int *undetermined_sizep) +{ + struct libsyscalls_structure_description *struct_description; + size_t misalignment, subextra_size; + unsigned long long int uvalue; + unsigned short int field; + enum libsyscalls_error r; + + r = get_struct_description(os, arch, description->fields[i].type, &((const char *)data)[field_offsets[i]], + data_size < field_offsets[i] ? 0 : data_size - field_offsets[i], + &struct_description, extra_sizep); + if (r) + return r; + + *subsizep = struct_description->size * struct_description->array_size; + *subalignp = struct_description->alignment; + if (struct_description->array_size <= 1) { + if (struct_description->relative_position_of_size != 0) { + if (struct_description->relative_position_of_size > 1) + abort(); + if ((unsigned short int)-struct_description->relative_position_of_size > i) + abort(); + field = (unsigned short int)((ssize_t)i + (ssize_t)struct_description->relative_position_of_size); + goto set_subsize; + } else if (struct_description->absolute_position_of_size != -1) { + field = (unsigned short int)struct_description->absolute_position_of_size; + if (field > i) + abort(); + set_subsize: + uvalue = read_field(data, data_size, field_offsets, description, i, undetermined_sizep); + /* TODO set `*subsizep` to `uvalue` (may overflow) */ + } + if (!struct_description->array_size) + *subsizep *= struct_description->size; + } + if (!*subsizep) + *undetermined_sizep = 1; + + description->fields[i].type_description.structure = struct_description; + subextra_size = offsetof(struct libsyscalls_structure_description, fields); + subextra_size += (size_t)struct_description->num_fields * sizeof(*struct_description->fields); + misalignment = subextra_size % alignof(struct libsyscalls_structure_description); + misalignment = alignof(struct libsyscalls_structure_description) - misalignment; + misalignment %= alignof(struct libsyscalls_structure_description); + subextra_size += misalignment; + *extra_sizep += subextra_size; + + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +adjust_for_fields(enum libsyscalls_os os, enum libsyscalls_arch arch, const void *data, size_t data_size, + struct padding **paddingsp, size_t *npaddingsp, size_t *paddings_sizep, + struct libsyscalls_structure_description *description, int dont_align_fields, size_t *extra_sizep) +{ + size_t field_offsets[description->num_fields]; + struct libsyscalls_datatype_description int_description; + int undetermined_size = 0; + size_t field_offset = 0; + unsigned short int i; + unsigned subalign, subsize; + enum libsyscalls_error r; + + /* TODO deal with pointer fields */ + for (i = 0; i < description->num_fields && !undetermined_size; i++) { + field_offsets[i] = field_offset; + r = libsyscalls_get_datatype_description(os, arch, description->fields[i].type, &int_description); + if (r == LIBSYSCALLS_E_OK) + r = adjust_for_nonstruct(os, arch, &int_description, description, i, + &subsize, &subalign, extra_sizep); + else if (r == LIBSYSCALLS_E_ISSTRUCT) + r = adjust_for_struct(os, arch, data, data_size, description, i, field_offsets, + &subsize, &subalign, extra_sizep, &undetermined_size); + else + return r; + if (r) + return r; + + /* TODO deal with bitlength */ + + if (!dont_align_fields) { + r = pad_field_into_alignment(paddingsp, npaddingsp, paddings_sizep, + description, i, subalign, &field_offset); + if (r) + return r; + } + + field_offset += subsize; + description->size += (unsigned short int)subsize; + if (!dont_align_fields) + description->alignment = (unsigned short int)MAX(description->alignment, subalign); + } + + if (undetermined_size) + description->size = 0; + + return LIBSYSCALLS_E_OK; +} + + +#include "generated/structs.c" + + +static enum libsyscalls_error +get_struct_description(enum libsyscalls_os os, enum libsyscalls_arch arch, enum libsyscalls_datatype datatype, const void *data, + size_t data_size, struct libsyscalls_structure_description **description_out, size_t *extra_sizep) +{ + unsigned char fill_is_known; + unsigned short int array_size; + signed short int relative_position_of_size; + signed short int absolute_position_of_size; + struct libsyscalls_structure_description *description = NULL; + enum libsyscalls_error r; + unsigned class; + int dont_align_fields = 0; + size_t npaddings = 0, paddings_size = 0; + struct padding *paddings = NULL; + + if ((unsigned)datatype & ~(LIBSYSCALLS_TYPEBITSMASK | (LIBSYSCALLS_TYPEBITSMASK - 1U))) + return LIBSYSCALLS_E_INVAL; + + datatype ^= class = datatype & LIBSYSCALLS_TYPEBITSMASK; + + if (class == LIBSYSCALLS_TYPEBITS_SCALAR) { + fill_is_known = 1; + array_size = 1; + relative_position_of_size = 0; + absolute_position_of_size = -1; + + } else if (class == LIBSYSCALLS_TYPEBITS_ARRAY) { + fill_is_known = 1; + array_size = 0; + relative_position_of_size = +1; + absolute_position_of_size = -1; + + } else if (class == LIBSYSCALLS_TYPEBITS_ARRAY_UNKNOWN_FILL) { + fill_is_known = 0; + array_size = 0; + relative_position_of_size = +1; + absolute_position_of_size = -1; + + } else { + return LIBSYSCALLS_E_INVAL; + } + + if (datatype < LIBSYSCALLS_TYPEOFFSET_STRUCTS_AND_UNIONS) + return LIBSYSCALLS_E_ISNOTSTRUCT; + +#define CASE(UPPERCASE, LOWERCASE)\ + case LIBSYSCALLS_OS_##UPPERCASE:\ + r = get_##LOWERCASE##_struct_description(arch, datatype, class, data, data_size,\ + &description, &dont_align_fields);\ + break + + switch ((int)os) { + LIST_OSES(CASE, ;); + default: + r = LIBSYSCALLS_E_OSNOSUP; + goto fail; + } + if (r) + goto fail; + +#undef CASE + +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wconversion" +#endif + + description->fill_is_known = fill_is_known; + description->array_size = array_size; + description->relative_position_of_size = relative_position_of_size; + description->absolute_position_of_size = absolute_position_of_size; + description->alignment = MAX(description->alignment, 1); + +#if defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + + r = adjust_for_fields(os, arch, data, data_size, &paddings, &npaddings, &paddings_size, + description, dont_align_fields, extra_sizep); + if (r) + goto fail; + +#define CASE(UPPERCASE, LOWERCASE)\ + case LIBSYSCALLS_OS_##UPPERCASE:\ + r = fix_##LOWERCASE##_struct_description(arch, datatype, class, data, data_size, description);\ + break + + switch ((int)os) { + LIST_OSES(CASE, ;); + default: + abort(); + } + if (r) + goto fail; + +#undef CASE + + r = pad_structure_into_alignment(&paddings, &npaddings, &paddings_size, description); + if (r) + goto fail; + + r = apply_padding(os, arch, paddings, npaddings, &description); + if (r) + goto fail; + + free(paddings); + *description_out = description; + return LIBSYSCALLS_E_OK; + +fail: + if (description) { + free_subdescriptions(description); + free(description); + } + free(paddings); + return r; +} + + +enum libsyscalls_error +libsyscalls_get_struct_description(enum libsyscalls_os os, enum libsyscalls_arch arch, enum libsyscalls_datatype datatype, + const void *data, size_t data_size, struct libsyscalls_structure_description **description_out) +{ + struct libsyscalls_structure_description *description, *new; + size_t extra_size = 0, size, nalign, salign, align; + enum libsyscalls_error r; + + if (!description_out) + return LIBSYSCALLS_E_INVAL; + + r = get_struct_description(os, arch, datatype, data, data_size, &description, &extra_size); + if (r) + return r; + if (!extra_size) { + *description_out = description; + return LIBSYSCALLS_E_OK; + } + + nalign = alignof(struct libsyscalls_datatype_description); + salign = alignof(struct libsyscalls_structure_description); + align = MAX(nalign, salign); + + size = offsetof(struct libsyscalls_structure_description, fields); + size += (size_t)description->num_fields * sizeof(*description->fields); + size += (align - (size & (align - 1))) & (align - 1); + + new = realloc(description, size + extra_size); + if (!new) { + free_subdescriptions(description); + free(description); + return LIBSYSCALLS_E_NOMEM; + } + description = new; + + move_in_subdescriptions((void *)description, &size, description, nalign == align, salign == align); + if (nalign != align || salign != align) + move_in_subdescriptions((void *)description, &size, description, nalign != align, salign != align); + + *description_out = description; + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_get_syscall.c b/libsyscalls_get_syscall.c index aea4d2f..e025e18 100644 --- a/libsyscalls_get_syscall.c +++ b/libsyscalls_get_syscall.c @@ -18,17 +18,8 @@ libsyscalls_get_syscall(enum libsyscalls_os os, enum libsyscalls_arch arch, long return LIBSYSCALLS_E_NOSUCHSYSCALL; /* buffer access is validated by libsyscalls_get_syscall_range() */ -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -#endif - syscalldesc = libsyscalls_syscalls_tables_[os][arch][syscallnr - min]; -#if defined(__clang__) -# pragma clang diagnostic pop -#endif - if (!syscalldesc) return LIBSYSCALLS_E_NOSUCHSYSCALL; if (syscall_out) diff --git a/libsyscalls_get_syscall_display_info.c b/libsyscalls_get_syscall_display_info.c index f9bbf1a..60bbe8a 100644 --- a/libsyscalls_get_syscall_display_info.c +++ b/libsyscalls_get_syscall_display_info.c @@ -1,30 +1,53 @@ /* See LICENSE file for copyright and license details. */ #include "common.h" -#include <stdalign.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#if defined(__GNUC__) -# pragma GCC diagnostic ignored "-Winline" + +static inline signed char +trailing_zeroes(unsigned long long int x) +{ +#ifndef HAVE_BUILTIN_FFSLL +# if defined(__HAVE_BUILTIN_FFSLL) +# define HAVE_BUILTIN_FFSLL +# elif defined(__clang__) +# if __clang_major__ >= 5 +# define HAVE_BUILTIN_FFSLL +# endif +# elif defined(__GNUC__) +# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# define HAVE_BUILTIN_FFSLL +# endif +# endif #endif +#ifdef HAVE_BUILTIN_FFSLL +# if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif -#define LOWEST_BIT(X) ((X) & ~((X) - 1)) -#define POST_HIGHEST_OF_CONSECUTIVELY_BITS(X) ((X) + LOWEST_BIT(X)) + return (signed char)(__builtin_ffsll(x) - 1); /* the type for x has changed over time */ +# if defined(__GNUC__) +# pragma GCC diagnostic pop +# endif +#else -static inline signed char -trailing_zeroes(unsigned long long int x) { /* TODO use builtin function if available */ int r = 0; if (x == 0) return -1; for (; (x & 1) == 0; x >>= 1) r += 1; return (signed char)r; + +#endif } +#define USE_INTERPOLATION_SEARCH /* TODO validate; should be configurable and (if good) default on systems with intrinsic divsion */ +#ifndef USE_INTERPOLATION_SEARCH + + +PURE_FUNCTION static int signed_named_number_cmp(const void *a_, const void *b_) { @@ -33,6 +56,7 @@ signed_named_number_cmp(const void *a_, const void *b_) } +PURE_FUNCTION static int unsigned_named_number_cmp(const void *a_, const void *b_) { @@ -41,6 +65,106 @@ unsigned_named_number_cmp(const void *a_, const void *b_) } +#else + + +/* convertion to unsigned is a modulo (unsigned maximum + 1) operation */ +#define DIFF(TYPE, A, B) ((unsigned TYPE)(A) - (unsigned TYPE)(B)) + +#define INTERPOL_SEARCH(KEY, BASE, N, READ)\ + do {\ + double guess_d;\ + unsigned long long int guess;\ + size_t h = (N);\ + \ + if (!h--)\ + return NULL;\ + \ + if ((KEY) <= READ((BASE), 0))\ + return (KEY) == READ((BASE), 0) ? (BASE) : NULL;\ + if ((KEY) >= READ((BASE), h))\ + return (KEY) == READ((BASE), h) ? (BASE) : NULL;\ + if (READ((BASE), 0) == READ((BASE), h))\ + return NULL;\ + \ + guess = DIFF(long long int, (KEY), READ((BASE), 0));\ + if (h > ULLONG_MAX / guess)\ + goto use_double;\ + \ + for (;;) {\ + guess = DIFF(long long int, (KEY), READ((BASE), 0));\ + guess *= (unsigned long long int)h;\ + guess /= DIFF(long long int, READ((BASE), h), READ((BASE), 0));\ + \ + if (READ((BASE), guess) < (KEY)) {\ + h -= guess += 1;\ + (BASE) = &(BASE)[guess];\ + } else if (READ((BASE), guess) > (KEY)) {\ + h -= guess -= 1;\ + } else {\ + return &(BASE)[guess];\ + }\ + \ + if (READ((BASE), 0) == READ((BASE), h))\ + return (KEY) == READ((BASE), 0) ? (BASE) : NULL;\ + if ((KEY) < READ((BASE), 0))\ + return NULL;\ + if ((KEY) > READ((BASE), h))\ + return NULL;\ + }\ + \ + use_double:\ + for (;;) {\ + guess = DIFF(long long int, (KEY), READ((BASE), 0));\ + guess_d = (double)guess * (double)h;\ + guess = DIFF(long long int, READ((BASE), h), READ((BASE), 0));\ + guess_d /= (double)guess;\ + guess = (unsigned long long int)guess_d;\ + \ + if (READ((BASE), guess) < (KEY)) {\ + h -= guess += 1;\ + (BASE) = &(BASE)[guess];\ + } else if (READ((BASE), guess) > (KEY)) {\ + h -= guess -= 1;\ + } else {\ + return &(BASE)[guess];\ + }\ + \ + if (READ((BASE), 0) == READ((BASE), h))\ + return (KEY) == READ((BASE), 0) ? (BASE) : NULL;\ + if ((KEY) < READ((BASE), 0))\ + return NULL;\ + if ((KEY) > READ((BASE), h))\ + return NULL;\ + }\ + } while (0) + + +PURE_FUNCTION +static const struct libsyscalls_named_number * +interpol_search_signed_named_number(signed long long int key, const struct libsyscalls_named_number *base, size_t n) +{ +#define X(ARR, I) ((ARR)[I].number.s) + INTERPOL_SEARCH(key, base, n, X); +#undef X +} + + +PURE_FUNCTION +static const struct libsyscalls_named_number * +interpol_search_unsigned_named_number(unsigned long long int key, const struct libsyscalls_named_number *base, size_t n) +{ +#define X(ARR, I) ((ARR)[I].number.u) + INTERPOL_SEARCH(key, base, n, X); +#undef X +} + +#undef DIFF + + +#endif + + static const char * extract_signal(enum libsyscalls_os os, enum libsyscalls_arch arch, unsigned long long int *valuep, char *fallback_out, int is_signed) @@ -52,23 +176,23 @@ extract_signal(enum libsyscalls_os os, enum libsyscalls_arch arch, if (libsyscalls_get_signals(os, arch, &signals, &nsignals)) return NULL; - found = bsearch(&key, signals, nsignals, sizeof(key), /* TODO interpolation search may be better */ +#ifndef USE_INTERPOLATION_SEARCH + found = bsearch(&key, signals, nsignals, sizeof(key), is_signed ? &signed_named_number_cmp : &unsigned_named_number_cmp); +#else + found = is_signed ? interpol_search_signed_named_number(key.number.s, signals, nsignals) + : interpol_search_unsigned_named_number(key.number.u, signals, nsignals); +#endif if (!found) return NULL; - (void)fallback_out; + (void) fallback_out; *valuep = 0; return found->name; } -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -#endif - static struct libsyscalls_syscall_display_info * build_syscall_display_info(void *data, size_t data_size, size_t data_align, libsyscalls_symbol_printer_function **funcs, @@ -123,24 +247,15 @@ build_syscall_display_info(void *data, size_t data_size, size_t data_align, return ret; } -#if defined(__clang__) -# pragma clang diagnostic pop -#endif - #include "generated/symbols.c" - -#if defined(__GNUC__) && !defined(__clang__) -# pragma GCC diagnostic ignored "-Wnonnull-compare" /* Why should I trust that the user is using the same compiler? */ -#endif - enum libsyscalls_error libsyscalls_get_syscall_display_info(enum libsyscalls_os os, enum libsyscalls_arch arch, const struct libsyscalls_syscall_abi *syscall, long long int syscall_number, - unsigned long long int *syscall_arguments, + const unsigned long long int *syscall_arguments, struct libsyscalls_syscall_display_info **info_out) { struct libsyscalls_syscall_display_info *info; diff --git a/libsyscalls_make_signed_integer.c b/libsyscalls_make_signed_integer.c new file mode 100644 index 0000000..b4142dc --- /dev/null +++ b/libsyscalls_make_signed_integer.c @@ -0,0 +1,56 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +enum libsyscalls_error +libsyscalls_make_signed_integer(unsigned long long int value_in, int negative, + enum libsyscalls_datatype_sign_representation representation, + size_t bits, unsigned long long int *value_out) +{ + unsigned long long int value = value_in, mask, highbit; + + if (!bits || bits > sizeof(value) / sizeof(char) * CHAR_BIT) + return LIBSYSCALLS_E_INVAL; + + switch (representation) { + case LIBSYSCALLS_SIGN_UNDETERMINED: + break; + + case LIBSYSCALLS_SIGN_TWOS_COMPLEMENT: + if (negative && value) { + highbit = 1ULL << (bits - 1U); + mask = highbit - 1ULL; + value = ~(value - 1) & mask; + value |= highbit; + } + break; + + case LIBSYSCALLS_SIGN_ONES_COMPLEMENT: + if (negative) { + highbit = 1ULL << (bits - 1U); + mask = highbit - 1ULL; + value = ~value & mask; + value |= highbit; + } + break; + + case LIBSYSCALLS_SIGN_SIGN_MAGNITUDE: + if (negative) + value ^= 1ULL << (bits - 1); + break; + + case LIBSYSCALLS_SIGN_EXCESS_HALF: + if (!negative) + value ^= 1ULL << (bits - 1); + else + value = (1ULL << (bits - 1)) - value; + break; + + default: + return LIBSYSCALLS_E_INVAL; + } + + if (value_out) + *value_out = value; + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_parse_signed_integer.c b/libsyscalls_parse_signed_integer.c new file mode 100644 index 0000000..da6f078 --- /dev/null +++ b/libsyscalls_parse_signed_integer.c @@ -0,0 +1,61 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +enum libsyscalls_error +libsyscalls_parse_signed_integer(unsigned long long int value_in, enum libsyscalls_datatype_sign_representation representation, + size_t bits, unsigned long long int *value_out, int *negative_out) +{ + unsigned long long int value = value_in, mask; + int negative = 0; + + if (!bits || bits > sizeof(value) / sizeof(char) * CHAR_BIT) + return LIBSYSCALLS_E_INVAL; + + switch (representation) { + case LIBSYSCALLS_SIGN_UNDETERMINED: + break; + + case LIBSYSCALLS_SIGN_TWOS_COMPLEMENT: + if (value >> (bits - 1U)) { + mask = (1ULL << (bits - 1U)) - 1ULL; + value = ~value & mask; + value += 1ULL; + negative = 1; + } + break; + + case LIBSYSCALLS_SIGN_ONES_COMPLEMENT: + if (value >> (bits - 1U)) { + mask = (1ULL << (bits - 1U)) - 1ULL; + value = ~value & mask; + negative = 1; + } + break; + + case LIBSYSCALLS_SIGN_SIGN_MAGNITUDE: + if (value >> (bits - 1U)) { + value ^= 1ULL << (bits - 1U); + negative = 1; + } + break; + + case LIBSYSCALLS_SIGN_EXCESS_HALF: + if (value >> (bits - 1U)) { + value ^= 1ULL << (bits - 1U); + } else { + value = (1ULL << (bits - 1U)) - value; + negative = 1; + } + break; + + default: + return LIBSYSCALLS_E_INVAL; + } + + if (value_out) + *value_out = value; + if (negative_out) + *negative_out = negative; + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_perror.c b/libsyscalls_perror.c index 4b110c7..f4f3a0c 100644 --- a/libsyscalls_perror.c +++ b/libsyscalls_perror.c @@ -1,8 +1,6 @@ /* See LICENSE file for copyright and license details. */ #include "common.h" -#include <stdio.h> - void libsyscalls_perror(const char *prefix, enum libsyscalls_error error) diff --git a/libsyscalls_section_value.c b/libsyscalls_section_value.c new file mode 100644 index 0000000..dc86cca --- /dev/null +++ b/libsyscalls_section_value.c @@ -0,0 +1,74 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +enum libsyscalls_error +libsyscalls_section_value(unsigned long long int value_in, size_t bits, + enum libsyscalls_datatype_section section, unsigned long long int *value_out) +{ + unsigned long long int value = value_in, mask, shift; + + if (bits > sizeof(value) / sizeof(char) * CHAR_BIT || + bits & (size_t)(LIBSYSCALLS_GET_SECTION_FRACTION(section) - 1U)) + return LIBSYSCALLS_E_INVAL; + + bits /= (size_t)LIBSYSCALLS_GET_SECTION_FRACTION(section); + if (bits == sizeof(mask) / sizeof(char) * CHAR_BIT) + mask = ~0ULL; + else + mask = (1ULL << bits) - 1ULL; + + switch (section) { + case LIBSYSCALLS_SECTION_UNDETERMINED: + case LIBSYSCALLS_SECTION_WHOLE: /* 0xFFFFFFFFFFFFFFFF */ + case LIBSYSCALLS_SECTION_LOWER_HALF: /* 0x00000000FFFFFFFF */ + case LIBSYSCALLS_SECTION_LOWER_QUARTER: /* 0x000000000000FFFF */ + break; + + case LIBSYSCALLS_SECTION_UPPER_HALF: /* 0xFFFFFFFF00000000 */ + case LIBSYSCALLS_SECTION_LOWER_MID_QUARTER: /* 0x00000000FFFF0000 */ + value >>= bits; + break; + + case LIBSYSCALLS_SECTION_INNER_HALF: /* 0x0000FFFFFFFF0000 */ + value >>= bits / 2; + break; + + case LIBSYSCALLS_SECTION_UPPER_MID_QUARTER: /* 0x0000FFFF00000000 */ + value >>= bits * 2; + break; + + case LIBSYSCALLS_SECTION_UPPER_QUARTER: /* 0xFFFF000000000000 */ + value >>= bits * 3; + break; + + case LIBSYSCALLS_SECTION_OUTER_HALF: /* 0xFFFF00000000FFFF */ + value = ((value & (mask << (bits + bits / 2))) >> bits) | (value & (mask >> (bits / 2))); + break; + + case LIBSYSCALLS_SECTION_ODD_QUARTERS_AS_HALF: /* 0xFFFF0000FFFF0000 */ + value >>= bits / 2; + /* fall through */ + case LIBSYSCALLS_SECTION_EVEN_QUARTERS_AS_HALF: /* 0x0000FFFF0000FFFF */ + value = ((value & (mask << (bits / 2)) & ~mask) >> (bits / 2)) | (value & (mask >> (bits / 2))); + break; + + case LIBSYSCALLS_SECTION_ODD_BYTES_AS_HALF: /* 0xFF00FF00FF00FF00 */ + value_in >>= 8; + /* fall through */ + case LIBSYSCALLS_SECTION_EVEN_BYTES_AS_HALF: /* 0x00FF00FF00FF00FF */ + value = 0; + for (shift = 0; value_in; value_in >>= 16, shift += 8) + value |= (value_in & 0x00FFU) << shift; + break; + + default: + return LIBSYSCALLS_E_INVAL; + } + + value &= mask; +masked: + if (value_out) + *value_out = value; + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_to_tracee_endian.c b/libsyscalls_to_tracee_endian.c new file mode 100644 index 0000000..94c44eb --- /dev/null +++ b/libsyscalls_to_tracee_endian.c @@ -0,0 +1,60 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +/* XXX be smarter if using the same byteorder */ +enum libsyscalls_error +libsyscalls_to_tracee_endian(unsigned long long int value_in, + const struct libsyscalls_datatype_description *type, + void *value_out, size_t out_offset) +{ + const unsigned long long int limit = sizeof(long long int) / sizeof(char) * CHAR_BIT; + unsigned long long int bytebits, bytemask, byte, remmask, valmask; + unsigned long long int offset, offset_byte, offset_bit; + unsigned char *out = value_out; + size_t i; + + if (!type || !value_out || (unsigned long long int)type->width_in_bits > limit) + return LIBSYSCALLS_E_INVAL; + + bytebits = (unsigned long long int)type->width_in_bits; + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(type, i); i++) + if (type->byteorder[i] && (unsigned long long int)type->byteorder[i] < bytebits) + bytebits = (unsigned long long int)type->byteorder[i]; + + if (bytebits > limit) + return LIBSYSCALLS_E_INVAL; + else if (bytebits == limit) + bytemask = ~0ULL; + else + bytemask = (1ULL << bytebits) - 1ULL; + + if ((unsigned long long int)type->width_in_bits == limit) + valmask = ~0ULL; + else + valmask = (1ULL << (unsigned long long int)type->width_in_bits) - 1ULL; + + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(type, i); i++) { + offset = out_offset; + offset_byte = offset / CHAR_BIT; + offset_bit = offset % CHAR_BIT; + out_offset += bytebits; + + byte = value_in >> type->byteorder[i]; + byte &= remmask = bytemask & (valmask >> type->byteorder[i]); + + out[offset_byte] &= (unsigned char)~(remmask << offset_bit); + out[offset_byte] |= (unsigned char)(byte << offset_bit); + if (bytebits != limit && (remmask >>= CHAR_BIT - offset_bit)) { + byte >>= CHAR_BIT - offset_bit; + do { + offset_byte += 1; + out[offset_byte] &= (unsigned char)~remmask; + out[offset_byte] |= (unsigned char)byte; + byte >>= CHAR_BIT; + } while (remmask >>= CHAR_BIT); + } + } + + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_to_tracer_endian.c b/libsyscalls_to_tracer_endian.c new file mode 100644 index 0000000..ad3b8a4 --- /dev/null +++ b/libsyscalls_to_tracer_endian.c @@ -0,0 +1,59 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +/* XXX be smarter if using the same byteorder */ +enum libsyscalls_error +libsyscalls_to_tracer_endian(const void *value_in, size_t in_offset, + const struct libsyscalls_datatype_description *type, + unsigned long long int *value_out) +{ + const unsigned long long int limit = sizeof(long long int) / sizeof(char) * CHAR_BIT; + unsigned long long int bytebits, bytemask, byte, value, remmask, valmask; + unsigned long long int offset = in_offset, offset_byte, offset_bit, off; + const unsigned char *in = value_in; + size_t i; + + if (!type || !value_in || !value_out || (unsigned long long int)type->width_in_bits > limit) + return LIBSYSCALLS_E_INVAL; + + bytebits = (unsigned long long int)type->width_in_bits; + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(type, i); i++) + if (type->byteorder[i] && (unsigned long long int)type->byteorder[i] < bytebits) + bytebits = (unsigned long long int)type->byteorder[i]; + + if (bytebits > limit) + return LIBSYSCALLS_E_INVAL; + else if (bytebits == limit) + bytemask = ~0ULL; + else + bytemask = (1ULL << bytebits) - 1ULL; + + if ((unsigned long long int)type->width_in_bits == limit) + valmask = ~0ULL; + else + valmask = (1ULL << (unsigned long long int)type->width_in_bits) - 1ULL; + + value = 0; + for (i = 0; !LIBSYSCALLS_IS_BYTEORDER_END_AT(type, i); i++) { + offset_byte = offset / CHAR_BIT; + offset_bit = offset % CHAR_BIT; + offset += bytebits; + + byte = (unsigned long long int)in[offset_byte] >> offset_bit; + remmask = bytemask & (valmask >> type->byteorder[i]); + + off = CHAR_BIT - offset_bit; + if (remmask >>= off) { + do { + byte |= (unsigned long long int)in[++offset_byte] << off; + off += CHAR_BIT; + } while (remmask >>= CHAR_BIT); + } + byte &= bytemask & (valmask >> type->byteorder[i]); + value |= byte << type->byteorder[i]; + } + + *value_out = value; + return LIBSYSCALLS_E_OK; +} diff --git a/libsyscalls_unsection_value.c b/libsyscalls_unsection_value.c new file mode 100644 index 0000000..6cd797e --- /dev/null +++ b/libsyscalls_unsection_value.c @@ -0,0 +1,76 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" + + +enum libsyscalls_error +libsyscalls_unsection_value(unsigned long long int value_in, size_t bits, + enum libsyscalls_datatype_section section, unsigned long long int *value_out) +{ + unsigned long long int value = value_in, mask, shift; + + if (bits > sizeof(value) / sizeof(char) * CHAR_BIT || + bits & (size_t)(LIBSYSCALLS_GET_SECTION_FRACTION(section) - 1U)) + return LIBSYSCALLS_E_INVAL; + + switch (section) { + case LIBSYSCALLS_SECTION_UNDETERMINED: + case LIBSYSCALLS_SECTION_WHOLE: /* 0xFFFFFFFFFFFFFFFF */ + break; + + case LIBSYSCALLS_SECTION_LOWER_HALF: /* 0x00000000FFFFFFFF */ + case LIBSYSCALLS_SECTION_LOWER_QUARTER: /* 0x000000000000FFFF */ + break; + + case LIBSYSCALLS_SECTION_UPPER_HALF: /* 0xFFFFFFFF00000000 */ + case LIBSYSCALLS_SECTION_LOWER_MID_QUARTER: /* 0x00000000FFFF0000 */ + value <<= bits; + break; + + case LIBSYSCALLS_SECTION_INNER_HALF: /* 0x0000FFFFFFFF0000 */ + value <<= bits / 2; + break; + + case LIBSYSCALLS_SECTION_UPPER_MID_QUARTER: /* 0x0000FFFF00000000 */ + value <<= bits * 2; + break; + + case LIBSYSCALLS_SECTION_UPPER_QUARTER: /* 0xFFFF000000000000 */ + value <<= bits * 3; + break; + + case LIBSYSCALLS_SECTION_OUTER_HALF: /* 0xFFFF00000000FFFF */ + mask = (1ULL << (bits / 2)) - 1ULL; + value = ((value & ~mask) << bits) | (value & mask); + break; + + case LIBSYSCALLS_SECTION_EVEN_QUARTERS_AS_HALF: /* 0x0000FFFF0000FFFF */ + mask = (1ULL << (bits / 2)) - 1ULL; + value = ((value & ~mask) << (bits / 2)) | (value & mask); + break; + + case LIBSYSCALLS_SECTION_ODD_QUARTERS_AS_HALF: /* 0xFFFF0000FFFF0000 */ + mask = (1ULL << (bits / 2)) - 1ULL; + value = ((value & ~mask) << (bits / 2)) | (value & mask); + value <<= bits / 2; + break; + + case LIBSYSCALLS_SECTION_EVEN_BYTES_AS_HALF: /* 0x00FF00FF00FF00FF */ + value = 0; + for (shift = 0; value_in; value_in >>= 8, shift += 16) + value |= (value_in & 0xFFU) << shift; + break; + + case LIBSYSCALLS_SECTION_ODD_BYTES_AS_HALF: /* 0xFF00FF00FF00FF00 */ + value = 0; + for (shift = 8; value_in; value_in >>= 8, shift += 16) + value |= (value_in & 0xFFU) << shift; + break; + + default: + return LIBSYSCALLS_E_INVAL; + } + + if (value_out) + *value_out = value; + return LIBSYSCALLS_E_OK; +} diff --git a/linux/errors.c b/linux/errors.c index 94c3cd2..0b1c2ea 100644 --- a/linux/errors.c +++ b/linux/errors.c @@ -14,7 +14,8 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na goto out switch ((int)arch) { - case LIBSYSCALLS_ARCH_ALPHA: + case LIBSYSCALLS_ARCH_ALPHA_LE: + case LIBSYSCALLS_ARCH_ALPHA_BE: #ifdef LIST_LINUX_ERRORS_FOR_ALPHA CASE(alpha); #else @@ -30,15 +31,18 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na break; #endif - case LIBSYSCALLS_ARCH_ARM_OABI: - case LIBSYSCALLS_ARCH_ARM_EABI: + case LIBSYSCALLS_ARCH_ARM_OABI_LE: + case LIBSYSCALLS_ARCH_ARM_OABI_BE: + case LIBSYSCALLS_ARCH_ARM_EABI_LE: + case LIBSYSCALLS_ARCH_ARM_EABI_BE: #ifdef LIST_LINUX_ERRORS_FOR_ARM CASE(arm); #else break; #endif - case LIBSYSCALLS_ARCH_IA64: + case LIBSYSCALLS_ARCH_IA64_LE: + case LIBSYSCALLS_ARCH_IA64_BE: #ifdef LIST_LINUX_ERRORS_FOR_IA64 CASE(ia64); #else @@ -52,16 +56,20 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na break; #endif - case LIBSYSCALLS_ARCH_MICROBLAZE: -#ifdef LIST_LINUX_ERRORS_FOR_MICROBLAZE + case LIBSYSCALLS_ARCH_MICROBLAZE_32_LE: + case LIBSYSCALLS_ARCH_MICROBLAZE_32_BE: +#ifdef LIST_LINUX_ERRORS_FOR_MICROBLAZE_32 CASE(microblaze); #else break; #endif - case LIBSYSCALLS_ARCH_MIPS_O32: - case LIBSYSCALLS_ARCH_MIPS_N32: - case LIBSYSCALLS_ARCH_MIPS_N64: + case LIBSYSCALLS_ARCH_MIPS_O32_LE: + case LIBSYSCALLS_ARCH_MIPS_O32_BE: + case LIBSYSCALLS_ARCH_MIPS_N32_LE: + case LIBSYSCALLS_ARCH_MIPS_N32_BE: + case LIBSYSCALLS_ARCH_MIPS_N64_LE: + case LIBSYSCALLS_ARCH_MIPS_N64_BE: #ifdef LIST_LINUX_ERRORS_FOR_MIPS CASE(mips); #else @@ -76,10 +84,14 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na break; #endif - case LIBSYSCALLS_ARCH_POWERPC_32: - case LIBSYSCALLS_ARCH_POWERPC_64: - case LIBSYSCALLS_ARCH_POWERPC_NOSPU: - case LIBSYSCALLS_ARCH_POWERPC_SPU: + case LIBSYSCALLS_ARCH_POWERPC_32_LE: + case LIBSYSCALLS_ARCH_POWERPC_32_BE: + case LIBSYSCALLS_ARCH_POWERPC_64_LE: + case LIBSYSCALLS_ARCH_POWERPC_64_BE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_BE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_BE: #ifdef LIST_LINUX_ERRORS_FOR_POWERPC CASE(powerpc); #else @@ -94,7 +106,8 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na break; #endif - case LIBSYSCALLS_ARCH_SH: + case LIBSYSCALLS_ARCH_SH_LE: + case LIBSYSCALLS_ARCH_SH_BE: #ifdef LIST_LINUX_ERRORS_FOR_SH CASE(sh); #else @@ -102,14 +115,16 @@ get_linux_syscall_errors(enum libsyscalls_arch arch, const struct libsyscalls_na #endif case LIBSYSCALLS_ARCH_SPARC_32: - case LIBSYSCALLS_ARCH_SPARC_64: + case LIBSYSCALLS_ARCH_SPARC_64_LE: + case LIBSYSCALLS_ARCH_SPARC_64_BE: #ifdef LIST_LINUX_ERRORS_FOR_SPARC CASE(sparc); #else break; #endif - case LIBSYSCALLS_ARCH_XTENSA: + case LIBSYSCALLS_ARCH_XTENSA_LE: + case LIBSYSCALLS_ARCH_XTENSA_BE: #ifdef LIST_LINUX_ERRORS_FOR_XTENSA CASE(xtensa); #else diff --git a/linux/linux-support.mk b/linux/linux-support.mk index c4a3f94..6756e87 100644 --- a/linux/linux-support.mk +++ b/linux/linux-support.mk @@ -6,30 +6,45 @@ LINUX_VERSION = 6.6 # works afterwards SUPPORTED_LINUX_ARCHES =\ - ALPHA\ + ALPHA_LE\ + ALPHA_BE\ AMD64\ AMD64_X32\ - ARM_OABI\ - ARM_EABI\ - IA64\ + ARM_OABI_LE\ + ARM_OABI_BE\ + ARM_EABI_LE\ + ARM_EABI_BE\ + IA64_LE\ + IA64_BE\ M68K\ - MICROBLAZE\ - MIPS_O32\ - MIPS_N32\ - MIPS_N64\ + MICROBLAZE_32_LE\ + MICROBLAZE_32_BE\ + MIPS_O32_LE\ + MIPS_O32_BE\ + MIPS_N32_LE\ + MIPS_N32_BE\ + MIPS_N64_LE\ + MIPS_N64_BE\ PARISC_32\ PARISC_64\ - POWERPC_32\ - POWERPC_64\ - POWERPC_NOSPU\ - POWERPC_SPU\ + POWERPC_32_LE\ + POWERPC_32_BE\ + POWERPC_64_LE\ + POWERPC_64_BE\ + POWERPC_NOSPU_LE\ + POWERPC_NOSPU_BE\ + POWERPC_SPU_LE\ + POWERPC_SPU_BE\ S390_32\ S390_64\ - SH\ + SH_LE\ + SH_BE\ SPARC_32\ - SPARC_64\ + SPARC_64_LE\ + SPARC_64_BE\ I386\ - XTENSA + XTENSA_LE\ + XTENSA_BE OPERATING_SYSTEMS += linux NPARAMS += 8 @@ -45,6 +60,7 @@ include linux/download.mk include linux/errors.mk include linux/integers.mk include linux/signals.mk +include linux/structs.mk include linux/syscalls.mk include linux/syscall-table.mk include linux/symbols.mk @@ -57,4 +73,16 @@ generated/linux-arches.h: linux/linux-support.mk mkdir -p -- generated (printf '\43define LIST_LINUX_ARCHES(X, D)\\\n' && \ printf '\tX(%s) D\\\n' $(SUPPORTED_LINUX_ARCHES); \ - ) | sed '$$s/ D\\//' > $@ + ) | sed '/X()/d' | sed '$$s/\\$$//' | sed '$$s/ D$$//' > $@ + (printf '\43define LIST_LINUX_ARCHES_WITH_BIENDIAN(X, D)\\\n' && \ + printf '\tX(%s) D\\\n' $(SUPPORTED_LINUX_ARCHES) \ + | sed -n 's/_LE)/)/p'; \ + ) | sed '/X()/d' | sed '$$s/\\$$//' | sed '$$s/ D$$//' >> $@ + (printf '\43define LIST_LINUX_ARCHES_WITH_UNIENDIAN(X, D)\\\n' && \ + printf '\tX(%s) D\\\n' $(SUPPORTED_LINUX_ARCHES); \ + ) | sed '/_[LB]E)/d' \ + | sed '/X()/d' | sed '$$s/\\$$//' | sed '$$s/ D$$//' >> $@ + (printf '\43define LIST_LINUX_ARCHES_WITHOUT_ENDIANS(X, D)\\\n' && \ + printf '\tX(%s) D\\\n' $(SUPPORTED_LINUX_ARCHES); \ + ) | sed 's/_[LB]E)/)/' | uniq \ + | sed '/X()/d' | sed '$$s/\\$$//' | sed '$$s/ D$$//' >> $@ diff --git a/linux/signals.c b/linux/signals.c index 743fc89..7adc44c 100644 --- a/linux/signals.c +++ b/linux/signals.c @@ -14,7 +14,8 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num goto out switch ((int)arch) { - case LIBSYSCALLS_ARCH_ALPHA: + case LIBSYSCALLS_ARCH_ALPHA_LE: + case LIBSYSCALLS_ARCH_ALPHA_BE: #ifdef LIST_LINUX_SIGNALS_FOR_ALPHA CASE(alpha); #else @@ -30,15 +31,18 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num break; #endif - case LIBSYSCALLS_ARCH_ARM_OABI: - case LIBSYSCALLS_ARCH_ARM_EABI: + case LIBSYSCALLS_ARCH_ARM_OABI_LE: + case LIBSYSCALLS_ARCH_ARM_OABI_BE: + case LIBSYSCALLS_ARCH_ARM_EABI_LE: + case LIBSYSCALLS_ARCH_ARM_EABI_BE: #ifdef LIST_LINUX_SIGNALS_FOR_ARM CASE(arm); #else break; #endif - case LIBSYSCALLS_ARCH_IA64: + case LIBSYSCALLS_ARCH_IA64_LE: + case LIBSYSCALLS_ARCH_IA64_BE: #ifdef LIST_LINUX_SIGNALS_FOR_IA64 CASE(ia64); #else @@ -52,16 +56,20 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num break; #endif - case LIBSYSCALLS_ARCH_MICROBLAZE: -#ifdef LIST_LINUX_SIGNALS_FOR_MICROBLAZE + case LIBSYSCALLS_ARCH_MICROBLAZE_32_LE: + case LIBSYSCALLS_ARCH_MICROBLAZE_32_BE: +#ifdef LIST_LINUX_SIGNALS_FOR_MICROBLAZE_32 CASE(microblaze); #else break; #endif - case LIBSYSCALLS_ARCH_MIPS_O32: - case LIBSYSCALLS_ARCH_MIPS_N32: - case LIBSYSCALLS_ARCH_MIPS_N64: + case LIBSYSCALLS_ARCH_MIPS_O32_LE: + case LIBSYSCALLS_ARCH_MIPS_O32_BE: + case LIBSYSCALLS_ARCH_MIPS_N32_LE: + case LIBSYSCALLS_ARCH_MIPS_N32_BE: + case LIBSYSCALLS_ARCH_MIPS_N64_LE: + case LIBSYSCALLS_ARCH_MIPS_N64_BE: #ifdef LIST_LINUX_SIGNALS_FOR_MIPS CASE(mips); #else @@ -76,10 +84,14 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num break; #endif - case LIBSYSCALLS_ARCH_POWERPC_32: - case LIBSYSCALLS_ARCH_POWERPC_64: - case LIBSYSCALLS_ARCH_POWERPC_NOSPU: - case LIBSYSCALLS_ARCH_POWERPC_SPU: + case LIBSYSCALLS_ARCH_POWERPC_32_LE: + case LIBSYSCALLS_ARCH_POWERPC_32_BE: + case LIBSYSCALLS_ARCH_POWERPC_64_LE: + case LIBSYSCALLS_ARCH_POWERPC_64_BE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_NOSPU_BE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_LE: + case LIBSYSCALLS_ARCH_POWERPC_SPU_BE: #ifdef LIST_LINUX_SIGNALS_FOR_POWERPC CASE(powerpc); #else @@ -94,7 +106,8 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num break; #endif - case LIBSYSCALLS_ARCH_SH: + case LIBSYSCALLS_ARCH_SH_LE: + case LIBSYSCALLS_ARCH_SH_BE: #ifdef LIST_LINUX_SIGNALS_FOR_SH CASE(sh); #else @@ -102,14 +115,16 @@ get_linux_signals(enum libsyscalls_arch arch, const struct libsyscalls_named_num #endif case LIBSYSCALLS_ARCH_SPARC_32: - case LIBSYSCALLS_ARCH_SPARC_64: + case LIBSYSCALLS_ARCH_SPARC_64_LE: + case LIBSYSCALLS_ARCH_SPARC_64_BE: #ifdef LIST_LINUX_SIGNALS_FOR_SPARC CASE(sparc); #else break; #endif - case LIBSYSCALLS_ARCH_XTENSA: + case LIBSYSCALLS_ARCH_XTENSA_LE: + case LIBSYSCALLS_ARCH_XTENSA_BE: #ifdef LIST_LINUX_SIGNALS_FOR_XTENSA CASE(xtensa); #else diff --git a/linux/structs.c b/linux/structs.c new file mode 100644 index 0000000..d9ac2d7 --- /dev/null +++ b/linux/structs.c @@ -0,0 +1,248 @@ +/* See LICENSE file for copyright and license details. */ + +/* This file is included from ../libsyscalls_get_struct_description.c */ + + +/* Don't forget to add new ones to ../libsyscalls.h */ +#define LIST_LINUX_STRUCTS(X, D)\ + X(STRUCT, AIO_SIGSET, 0 /* TODO bitmask */,\ + FIELD("sigmask", ULONG_ARRAY, IN, INPTR),\ + FIELD("sigsetsize", SIZE, IN)) D\ + X(STRUCT, COMPAT_AIO_SIGSET, 0 /* TODO bitmask */,\ + FIELD("sigmask", UINT32, IN, OUT),\ + FIELD("sigsetsize", UINT32, IN, OUT)) D\ + X(STRUCT, CACHESTAT, 0,\ + FIELD("nr_cache", UINT64, IN, OUT),\ + FIELD("nr_dirty", UINT64, IN, OUT),\ + FIELD("nr_writeback", UINT64, IN, OUT),\ + FIELD("nr_evicted", UINT64, IN, OUT),\ + FIELD("nr_recently_evicted", UINT64, IN, OUT)) D\ + X(STRUCT, CACHESTAT_RANGE, 0,\ + FIELD("off", UINT64, IN, OUT),\ + FIELD("len", UINT64, IN, OUT)) D\ + X(STRUCT, CLONE_ARGS, 0, /* TODO which fields are IN and OUT? */\ + FIELD("flags", UINT64, IN) /* TODO bitmask */,\ + FIELD("pidfd", UINT64, IN) /* TODO actually (int *) */,\ + FIELD("child_tid", UINT64, IN) /* TODO actually (pid_t *) */,\ + FIELD("parent_tid", UINT64, IN) /* TODO actually (pid_t *) */,\ + FIELD("exit_signal", UINT64, IN) /* TODO actually INT_SIGNAL */,\ + FIELD("stack", UINT64, IN),\ + FIELD("stack_size", UINT64, IN),\ + FIELD("tls", UINT64, IN), /* TODO actually MEMORY_ADDRESS */\ + /* Since Linux 5.5: */\ + FIELD("set_tid", UINT64, IN), /* TODO acually (pid_t *) with count in next field */\ + FIELD("set_tid_size", UINT64, IN),\ + FIELD("cgroup", UINT64, IN)) /* TODO actually INT_FD */ D\ + X(STRUCT, EPOLL_EVENT, 0, /* TODO different in libc */\ + FIELD("events", UINT, IN, OUT) /* TODO bitmask */,\ + FIELD("data", UINT64, PARTIAL, IN, OUT)) D\ + X(STRUCT, OABI_EPOLL_EVENT, 0, /* TODO different in libc */\ + FIELD("events", UINT, IN, OUT) /* TODO bitmask */,\ + FIELD("data", UINT64_FRONT_32, PARTIAL, IN, OUT),\ + FIELD("data", UINT64_BACK_32, PARTIAL, IN, OUT)) D\ + X(STRUCT, FILE_HANDLE, 0) D /* TODO */\ + X(STRUCT, FUTEX_WAITV, 0,\ + FIELD("val", UINT64, IN, OUT),\ + FIELD("uaddr", UINT64, IN, OUT), /* TODO actually (void *) */\ + FIELD("flags", UINT32, IN, OUT), /* TODO bitmask */\ + FIELD(NULL, UINT32, IN, OUT)) D\ + X(STRUCT, IOB, 0) D /* TODO */\ + X(STRUCT, IOVEC, 0) D /* TODO */\ + X(STRUCT, IO_EVENT, 0,\ + FIELD("data", UINT64, IN, OUT),\ + FIELD("obj", UINT64, IN, OUT),\ + FIELD("res", INT64, IN, OUT),\ + FIELD("res2", INT64, IN, OUT)) D\ + X(STRUCT, IO_URING_PARAMS, 0) D /* TODO */\ + X(STRUCT, ITIMERSPEC, 0,\ + FIELD("it_interval", STRUCT_TIMESPEC, IN, OUT),\ + FIELD("it_value", STRUCT_TIMESPEC, IN, OUT)) D\ + X(STRUCT, ITIMERSPEC64, 0,\ + FIELD("it_interval", STRUCT_TIMESPEC64, IN, OUT),\ + FIELD("it_value", STRUCT_TIMESPEC64, IN, OUT)) D\ + X(STRUCT, KEXEC_SEGMENT, 0) D /* TODO */\ + X(STRUCT, COMPAT_KEXEC_SEGMENT, 0) D /* TODO */\ + X(STRUCT, LANDLOCK_RULESET_ATTR, 0) D /* TODO */\ + X(STRUCT, LINUX_DIRENT, 0) D /* TODO */\ + X(STRUCT, LINUX_DIRENT64, 0) D /* TODO */\ + X(STRUCT, MMAP_ARG_STRUCT, 0) D /* TODO */\ + X(STRUCT, MMSGHDR, 0) D /* TODO */\ + X(STRUCT, MOUNT_ATTR, 0) D /* TODO */\ + X(STRUCT, MQ_ATTR, 0) D /* TODO */\ + X(STRUCT, MSGBUF, 0) D /* TODO */\ + X(STRUCT, MSGHDR, 0) D /* TODO */\ + X(STRUCT, MSQID_DS, 0) D /* TODO */\ + X(STRUCT, NEW_UTSNAME, 0,\ + FIELD("sysname", BUFFER_65, OUT),\ + FIELD("nodename", BUFFER_65, OUT),\ + FIELD("release", BUFFER_65, OUT),\ + FIELD("version", BUFFER_65, OUT),\ + FIELD("machine", BUFFER_65, OUT),\ + FIELD("domainname", BUFFER_65, OUT)) D\ + X(STRUCT, OLDOLD_UTSNAME, 0,\ + FIELD("sysname", BUFFER_9, OUT),\ + FIELD("nodename", BUFFER_9, OUT),\ + FIELD("release", BUFFER_9, OUT),\ + FIELD("version", BUFFER_9, OUT),\ + FIELD("machine", BUFFER_9, OUT)) D\ + X(STRUCT, OLD_ITIMERSPEC32, 0,\ + FIELD("it_interval", STRUCT_OLD_TIMESPEC32, IN, OUT),\ + FIELD("it_value", STRUCT_OLD_TIMESPEC32, IN, OUT)) D\ + X(STRUCT, ITIMERVAL, 0,\ + FIELD("it_interval", STRUCT_TIMEVAL, IN, OUT),\ + FIELD("it_value", STRUCT_TIMEVAL, IN, OUT)) D\ + X(STRUCT, OLD_ITIMERVAL, 0,\ + FIELD("it_interval", STRUCT_OLD_TIMEVAL, IN, OUT),\ + FIELD("it_value", STRUCT_OLD_TIMEVAL, IN, OUT)) D\ + X(STRUCT, OLD_LINUX_DIRENT, 0) D /* TODO */\ + X(STRUCT, OLD_SIGACTION, 0) D /* TODO */\ + X(STRUCT, OLD_STAT, 0) D /* TODO */\ + X(STRUCT, OLD_TIMESPEC32, 0) D /* TODO */\ + X(STRUCT, OLD_TIMEVAL, 0) D /* TODO */\ + X(STRUCT, OLD_TIMEVAL32, 0) D /* TODO */\ + X(STRUCT, OLD_TIMEX32, 0) D /* TODO */\ + X(STRUCT, OLD_UTIMBUF32, 0) D /* TODO */\ + X(STRUCT, OLD_UTSNAME, 0,\ + FIELD("sysname", BUFFER_65, OUT),\ + FIELD("nodename", BUFFER_65, OUT),\ + FIELD("release", BUFFER_65, OUT),\ + FIELD("version", BUFFER_65, OUT),\ + FIELD("machine", BUFFER_65, OUT)) D\ + X(STRUCT, OPEN_HOW, 0) D /* TODO */\ + X(STRUCT, PERF_EVENT_ATTR, 0) D /* TODO */\ + X(STRUCT, POLLFD, 0,\ + FIELD("pollfd", INT_FD, IN),\ + FIELD("events", SHORT, IN), /* TODO bitmask */\ + FIELD("revents", SHORT, OUT)) D /* TODO bitmask */\ + X(STRUCT, RLIMIT, 0,\ + FIELD("rlim_cur", ULONG, IN, OUT),\ + FIELD("rlim_max", ULONG, IN, OUT)) D\ + X(STRUCT, RLIMIT64, 0,\ + FIELD("rlim_cur", UINT64, IN, OUT),\ + FIELD("rlim_max", UINT64, IN, OUT)) D\ + X(STRUCT, COMPAT_RLIMIT, 0,\ + FIELD("rlim_cur", UINT32, IN, OUT),\ + FIELD("rlim_max", UINT32, IN, OUT)) D\ + X(STRUCT, ROBUST_LIST_HEAD, 0) D /* TODO */\ + X(STRUCT, RSEQ, 0) D /* TODO */\ + X(STRUCT, RUSAGE, 0) D /* TODO */\ + X(STRUCT, SCHED_ATTR, 0,\ + FIELD("size", UINT32, IN, OUT),\ + FIELD("sched_policy", UINT32, IN, OUT),\ + FIELD("sched_flags", UINT64, IN, OUT),\ + FIELD("sched_nice", INT32, IN, OUT),\ + FIELD("sched_priority", UINT32, IN, OUT),\ + FIELD("sched_runtime", UINT64, IN, OUT),\ + FIELD("sched_deadline", UINT32, IN, OUT),\ + FIELD("sched_period", UINT32, IN, OUT)) D\ + X(STRUCT, SCHED_PARAM, 0,\ + FIELD("sched_priority", INT, IN, OUT)) D\ + X(STRUCT, SEL_ARG_STRUCT, 0) D /* TODO */\ + X(STRUCT, SEMBUF, 0,\ + FIELD("sem_num", USHORT, IN, OUT),\ + FIELD("sem_op", SHORT, IN, OUT), /* TODO enum */\ + FIELD("sem_flg", SHORT, IN, OUT)) D /* TODO bitmask */\ + X(STRUCT, SEMID_DS, 0) D /* TODO */\ + X(STRUCT, SHMID_DS, 0) D /* TODO */\ + X(STRUCT, SIGACTION, 0) D /* TODO */\ + X(STRUCT, SIGALTSTACK, 0) D /* TODO */\ + X(STRUCT, SIGEVENT, 0) D /* TODO */\ + X(STRUCT, SIGINFO, 0) D /* TODO */\ + X(STRUCT, SOCKADDR, 0) D /* TODO */\ + X(STRUCT, STAT, 0) D /* TODO */\ + X(STRUCT, STAT64, 0) D /* TODO */\ + X(STRUCT, STATFS, 0) D /* TODO */\ + X(STRUCT, STATFS64, 0) D /* TODO */\ + X(STRUCT, STATX, 0) D /* TODO */\ + X(STRUCT, SYSINFO, 0) D /* TODO */\ + X(STRUCT, TIMESPEC, 0) D /* TODO */\ + X(STRUCT, TIMESPEC64, 0) D /* TODO */\ + X(STRUCT, TIMEVAL, 0) D /* TODO */\ + X(STRUCT, TIMEX, 0) D /* TODO */\ + X(STRUCT, TIMEZONE, 0) D /* TODO */\ + X(STRUCT, TMS, 0) D /* TODO */\ + X(STRUCT, USTAT, 0) D /* TODO */\ + X(STRUCT, UTIMBUF, 0) D /* TODO */\ + X(UNION, BPF_ATTR, 0) /* TODO */ + + +#define X(TYPE, NAME, ...)\ + static struct libsyscalls_structure_description linux_##TYPE##_##NAME##_prototype = TYPE(__VA_ARGS__) + LIST_LINUX_STRUCTS(X, ;); +#undef X + + +static enum libsyscalls_error +fix_linux_struct_description(enum libsyscalls_arch arch, enum libsyscalls_datatype datatype, unsigned class, + const void *data, size_t data_size, struct libsyscalls_structure_description *description) +{ + switch ((int)datatype) { + case LIBSYSCALLS_TYPE_STRUCT_SOCKADDR: + if (class != LIBSYSCALLS_TYPEBITS_SCALAR) + return LIBSYSCALLS_E_NOSUCHTYPE; + description->size = 0; + description->relative_position_of_size = +1; + description->absolute_position_of_size = -1; + /* TODO that is the alignment of `struct sockaddr`? */ + break; + + case LIBSYSCALLS_TYPE_STRUCT_CLONE_ARGS: + description->alignment = 64; + break; + + case LIBSYSCALLS_TYPE_STRUCT_RSEQ: + description->alignment = 4 * 64; + break; + + default: + break; + } + + (void) arch; + (void) data; + (void) data_size; + return LIBSYSCALLS_E_OK; +} + + +static enum libsyscalls_error +get_linux_struct_description(enum libsyscalls_arch arch, enum libsyscalls_datatype datatype, unsigned class, + const void *data, size_t data_size, struct libsyscalls_structure_description **description_out, + int *dont_align_fields_out) +{ + struct libsyscalls_structure_description *description; + + switch ((int)datatype) { + case LIBSYSCALLS_TYPE_STRUCT_EPOLL_EVENT: + if (arch == LIBSYSCALLS_ARCH_AMD64 || arch == LIBSYSCALLS_ARCH_AMD64_X32) + datatype = LIBSYSCALLS_TYPE_STRUCT_OABI_EPOLL_EVENT; + break; + + default: + break; + } + +#define CASE(TYPE, NAME, ...)\ + case LIBSYSCALLS_TYPE_##TYPE##_##NAME:\ + description = copy_struct(&linux_##TYPE##_##NAME##_prototype);\ + break + + switch ((int)datatype) { + LIST_LINUX_STRUCTS(CASE, ;); + default: + return LIBSYSCALLS_E_NOSUCHTYPE; + } + +#undef CASE + + if (!description) + return LIBSYSCALLS_E_NOMEM; + + (void) class; + (void) data; + (void) data_size; + + *description_out = description; + *dont_align_fields_out = 0; + return LIBSYSCALLS_E_OK; +} diff --git a/linux/structs.mk b/linux/structs.mk new file mode 100644 index 0000000..748db51 --- /dev/null +++ b/linux/structs.mk @@ -0,0 +1,4 @@ +# See LICENSE file for copyright and license details. + +libsyscalls_get_struct_description.o: linux/structs.c +libsyscalls_get_struct_description.lo: linux/structs.c diff --git a/linux/symbols.c b/linux/symbols.c index 7a3c8e5..ac90b80 100644 --- a/linux/symbols.c +++ b/linux/symbols.c @@ -32,11 +32,6 @@ extract_linux_symbol_signal(struct libsyscalls_symbol_printer_data *data, unsign } -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -#endif - static const char * extract_linux_symbol_mode(struct libsyscalls_symbol_printer_data *data, unsigned long long int *valuep, char *fallback_out) { @@ -133,10 +128,6 @@ extract_linux_symbol_umask(struct libsyscalls_symbol_printer_data *data, unsigne return data->buf; } -#if defined(__clang__) -# pragma clang diagnostic pop -#endif - static const char * extract_linux_symbol_dev(struct libsyscalls_symbol_printer_data *data, unsigned long long int *valuep, char *fallback_out) @@ -279,14 +270,9 @@ have_fun: } -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -#endif - static struct libsyscalls_syscall_display_info * get_linux_syscall_display_info(enum libsyscalls_arch arch, const struct libsyscalls_syscall_abi *syscall, - long long int syscall_number, unsigned long long int *syscall_argument) + long long int syscall_number, const unsigned long long int *syscall_argument) { LIBSYSCALLS_SYMBOL_PRINTER_DATA *data; libsyscalls_symbol_printer_function **funcs; @@ -314,18 +300,9 @@ get_linux_syscall_display_info(enum libsyscalls_arch arch, const struct libsysca } { -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wvla" -#endif - char data_vla_buf[(size_t)(nargs + 1) * data_size + data_align]; libsyscalls_symbol_printer_function *funcs_vla[nargs + 1]; -#if defined(__clang__) -# pragma clang diagnostic pop -#endif - data = (void *)ALIGN_BUF(data_vla_buf, data_align); funcs = funcs_vla; @@ -343,7 +320,3 @@ get_linux_syscall_display_info(enum libsyscalls_arch arch, const struct libsysca return build_syscall_display_info(data, data_size, data_align, funcs, syscall, nargs, nsyms); } } - -#if defined(__clang__) -# pragma clang diagnostic pop -#endif diff --git a/linux/syscall-table.c b/linux/syscall-table.c index 5a5d9c2..0b1e0a0 100644 --- a/linux/syscall-table.c +++ b/linux/syscall-table.c @@ -43,8 +43,8 @@ #define X(ARCH)\ - LIST_LINUX_SYSCALLS_FOR_##ARCH(MAKE_##ARCH##_SYSCALL_WITHOUT_COMPAT, MAKE_##ARCH##_SYSCALL_WITH_COMPAT, ;) -LIST_LINUX_ARCHES(X, ;); + LIST_LINUX_SYSCALLS_FOR_##ARCH(MAKE_##ARCH##_SYSCALL_WITHOUT_COMPAT, MAKE_##ARCH##_SYSCALL_WITH_COMPAT, ;); +LIST_LINUX_ARCHES_WITHOUT_ENDIANS(X,) #undef X #ifndef CREATING_DEDUP_TABLE @@ -57,13 +57,13 @@ LIST_LINUX_ARCHES(X, ;); #define X(ARCH)\ static const struct libsyscalls_syscall *const linux_##ARCH##_syscalls_table[] = {\ LIST_LINUX_SYSCALLS_FOR_##ARCH(MAKE_##ARCH##_SYSCALL_TABLE_ENTRY, MAKE_##ARCH##_SYSCALL_TABLE_ENTRY, COMMA)\ - } -LIST_LINUX_ARCHES(X, ;); + }; +LIST_LINUX_ARCHES_WITHOUT_ENDIANS(X,) #undef X - const struct libsyscalls_syscall *const *const libsyscalls_linux_syscalls_table_[] = { -#define X(ARCH) [LIBSYSCALLS_ARCH_##ARCH] = linux_##ARCH##_syscalls_table +#define X(ARCH)\ + [LIBSYSCALLS_ARCH_##ARCH] = linux_##ARCH##_syscalls_table LIST_LINUX_ARCHES(X, COMMA) #undef X }; diff --git a/linux/syscall-table.mk b/linux/syscall-table.mk index 7e6fb1a..a90be35 100644 --- a/linux/syscall-table.mk +++ b/linux/syscall-table.mk @@ -10,7 +10,7 @@ libsyscalls_get_syscall_range.o: $(LINUX_SYSCALLS_HDR) libsyscalls_get_syscall_range.lo: $(LINUX_SYSCALLS_HDR) -generated/linux-syscall-table.h: linux/syscall-table.c common.h linux/linux-support.mk +generated/linux-syscall-table.h: linux/syscall-table.c common.h linux/linux-support.mk linux/syscall-table.mk set -e; \ macros="$$(sed -n 's/^$(s)*$(h)$(s)*define$(s)\{1,\}MAKE_\([^(]*\)(.*$$/\1/p' < linux/syscall-table.c)"; \ for arch in $(SUPPORTED_LINUX_ARCHES); do \ @@ -18,17 +18,19 @@ generated/linux-syscall-table.h: linux/syscall-table.c common.h linux/linux-supp printf '\43define MAKE_%s_%s(...) MAKE_%s(%s, __VA_ARGS__)\n' \ "$$arch" "$$macro" "$$macro" "$$arch"; \ done; \ - done > $@ + done \ + | sed 's/_[BL]E\([_,]\)/\1/g' \ + | sort -u > $@ -generated/linux-syscalls.h: linux/syscalls.mk +generated/linux-syscalls.h: linux/syscalls.mk linux/syscall-table.mk mkdir -p -- generated printf '\43include "%s"\n' $(LINUX_SYSCALLS_HDR) \ | grep -v '"$@"' \ | sed 's:generated/::' > $@ -generated/linux-syscall-ranges.h: $(LINUX_SYSCALLS_ARCH_HDR) +generated/linux-syscall-ranges.h: $(LINUX_SYSCALLS_ARCH_HDR) linux/syscall-table.mk printf '%s\n' 'This may take some time ...'; \ set -e; arch=; \ cat -- $(LINUX_SYSCALLS_ARCH_HDR) \ @@ -60,3 +62,7 @@ generated/linux-syscall-ranges.h: $(LINUX_SYSCALLS_ARCH_HDR) MIN "$$arch" "$$min" \ MAX "$$arch" "$$max"; \ ) > $@ + printf '\43define MIN_LINUX_SYSCALL_FOR_%s\n' $(SUPPORTED_LINUX_ARCHES) \ + | sed -n 's/\(MIN_LINUX_SYSCALL_FOR_.*\)_[LB]E$$/& \1/p' >> $@ + printf '\43define MAX_LINUX_SYSCALL_FOR_%s\n' $(SUPPORTED_LINUX_ARCHES) \ + | sed -n 's/\(MAX_LINUX_SYSCALL_FOR_.*\)_[LB]E$$/& \1/p' >> $@ diff --git a/linux/syscalls.h b/linux/syscalls.h index f55dac5..36c1236 100644 --- a/linux/syscalls.h +++ b/linux/syscalls.h @@ -115,15 +115,6 @@ _Static_assert(END_OF_LINUX_SYMBOL_PRINTERS <= 0xFF, "LINUX_SYMBOL_PRINTER enums #ifndef SYMBOL_PRINTERS_ONLY -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wgnu-flexible-array-initializer" -# pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" /* TODO how does that make sense in C23? */ -#elif defined(__GNUC__) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wpedantic" -#endif - #define SYS(...) SYSCALL_ABI(linux, __VA_ARGS__) #define SYMBOLS(A, ...) .symbol_printer = (LINUX_SYMBOL_PRINTER_##A __VA_OPT__(SYMBOLS_2(__VA_ARGS__))) @@ -420,7 +411,7 @@ TODO_SYS(sys_sched_setaffinity, SCHEDULING, SET, 3, ZERO(INT), PARAMS(_,INT, _,U #undef TODO_SYS -#define XXX TODO /* when none on the architectures is not support yet by libsyscalls's core */ +#define XXX TODO static struct libsyscalls_syscall_abi TODO = {.category = LIBSYSCALLS_CAT_SUPPORT_PENDING, .min_argument_count = -1, @@ -725,11 +716,11 @@ static struct libsyscalls_syscall_abi TODO = #define linux_syscall_sys_idle XXX /* arm alpha */ #define linux_syscall_sys_pciconfig_iobase XXX /* arm alpha powerpc */ -#define linux_syscall_sys_pciconfig_read TODO /* arm alpha powerpc sparc ia64 */ -#define linux_syscall_sys_pciconfig_write TODO /* arm alpha powerpc sparc ia64 */ +#define linux_syscall_sys_pciconfig_read XXX /* arm alpha powerpc sparc ia64 */ +#define linux_syscall_sys_pciconfig_write XXX /* arm alpha powerpc sparc ia64 */ #define linux_syscall_sys_syscall XXX /* arm mips */ -#define linux_syscall_sys_mmap2 TODO /* arm microblaze parisc powerpc sparc ia64 m64k sh */ -#define linux_syscall_sys_rt_sigreturn_wrapper TODO /* arm microblaze parisc */ +#define linux_syscall_sys_mmap2 XXX /* arm microblaze parisc powerpc sparc ia64 m64k sh */ +#define linux_syscall_sys_rt_sigreturn_wrapper XXX /* arm microblaze parisc */ #define linux_syscall_sys_afs_syscall XXX /* arm */ #define linux_syscall_sys_arm_fadvise64_64 XXX /* arm */ #define linux_syscall_sys_break XXX /* arm */ @@ -764,16 +755,16 @@ static struct libsyscalls_syscall_abi TODO = #define linux_syscall_sys_stty XXX /* arm */ #define linux_syscall_sys_ulimit XXX /* arm */ -#define linux_syscall_compat_sys_epoll_pwait TODO /* mips parisc powerpc sparc s390 */ -#define linux_syscall_compat_sys_fanotify_mark TODO /* mips parisc powerpc sparc s390 */ -#define linux_syscall_compat_sys_fcntl TODO /* mips parisc powerpc sparc s390 */ -#define linux_syscall_sys_cacheflush TODO /* mips parisc m68k sh */ -#define linux_syscall_sys32_rt_sigreturn TODO /* mips sparc */ -#define linux_syscall_sys32_sigreturn TODO /* mips sparc */ +#define linux_syscall_compat_sys_epoll_pwait XXX /* mips parisc powerpc sparc s390 */ +#define linux_syscall_compat_sys_fanotify_mark XXX /* mips parisc powerpc sparc s390 */ +#define linux_syscall_compat_sys_fcntl XXX /* mips parisc powerpc sparc s390 */ +#define linux_syscall_sys_cacheflush XXX /* mips parisc m68k sh */ +#define linux_syscall_sys32_rt_sigreturn XXX /* mips sparc */ +#define linux_syscall_sys32_sigreturn XXX /* mips sparc */ #define linux_syscall_compat_sys_recv XXX /* mips powerpc */ -#define linux_syscall___sys_clone TODO /* mips m68k */ -#define linux_syscall___sys_clone3 TODO /* mips m68k */ -#define linux_syscall___sys_fork TODO /* mips m68k */ +#define linux_syscall___sys_clone XXX /* mips m68k */ +#define linux_syscall___sys_clone3 XXX /* mips m68k */ +#define linux_syscall___sys_fork XXX /* mips m68k */ #define linux_syscall___sys_sysmips XXX /* mips */ #define linux_syscall_compat_sys_old_msgctl XXX /* mips */ #define linux_syscall_compat_sys_old_semctl XXX /* mips */ @@ -797,9 +788,9 @@ static struct libsyscalls_syscall_abi TODO = #define linux_syscall_sysm_pipe XXX /* mips */ #define linux_syscall_sysn32_rt_sigreturn XXX /* mips */ -#define linux_syscall_sys_stime TODO /* powerpc parisc sparc */ -#define linux_syscall_compat_sys_sendfile64 TODO /* powerpc parisc s390 */ -#define linux_syscall_compat_sys_fallocate TODO /* powerpc sparc */ +#define linux_syscall_sys_stime XXX /* powerpc parisc sparc */ +#define linux_syscall_compat_sys_sendfile64 XXX /* powerpc parisc s390 */ +#define linux_syscall_compat_sys_fallocate XXX /* powerpc sparc */ #define linux_syscall_alpha_syscall_zero XXX /* alpha */ #define linux_syscall_sys_getdtablesize XXX /* alpha */ @@ -851,75 +842,75 @@ static struct libsyscalls_syscall_abi TODO = #define linux_syscall_sys_pread_wrapper XXX /* sh */ #define linux_syscall_sys_pwrite_wrapper XXX /* sh */ -#define linux_syscall___sys_vfork TODO /* m68k */ -#define linux_syscall_sys_atomic_barrier TODO /* m68k */ -#define linux_syscall_sys_atomic_cmpxchg_32 TODO /* m68k */ - -#define linux_syscall_compat_sys_io_pgetevents_time64 TODO /* parisc */ -#define linux_syscall_parisc_compat_signalfd4 TODO /* parisc */ -#define linux_syscall_parisc_eventfd2 TODO /* parisc */ -#define linux_syscall_parisc_fadvise64_64 TODO /* parisc */ -#define linux_syscall_parisc_fallocate TODO /* parisc */ -#define linux_syscall_parisc_ftruncate64 TODO /* parisc */ -#define linux_syscall_parisc_inotify_init1 TODO /* parisc */ -#define linux_syscall_parisc_madvise TODO /* parisc */ -#define linux_syscall_parisc_personality TODO /* parisc */ -#define linux_syscall_parisc_pipe2 TODO /* parisc */ -#define linux_syscall_parisc_pread64 TODO /* parisc */ -#define linux_syscall_parisc_pwrite64 TODO /* parisc */ -#define linux_syscall_parisc_readahead TODO /* parisc */ -#define linux_syscall_parisc_signalfd4 TODO /* parisc */ -#define linux_syscall_parisc_sync_file_range TODO /* parisc */ -#define linux_syscall_parisc_timerfd_create TODO /* parisc */ -#define linux_syscall_parisc_truncate64 TODO /* parisc */ -#define linux_syscall_parisc_userfaultfd TODO /* parisc */ -#define linux_syscall_sys32_fanotify_mark TODO /* parisc */ -#define linux_syscall_sys32_unimplemented TODO /* parisc */ -#define linux_syscall_sys_acl_get TODO /* parisc */ -#define linux_syscall_sys_acl_set TODO /* parisc */ -#define linux_syscall_sys_alloc_hugepages TODO /* parisc */ -#define linux_syscall_sys_attrctl TODO /* parisc */ -#define linux_syscall_sys_clone3_wrapper TODO /* parisc */ -#define linux_syscall_sys_clone_wrapper TODO /* parisc */ -#define linux_syscall_sys_fork_wrapper TODO /* parisc */ -#define linux_syscall_sys_free_hugepages TODO /* parisc */ -#define linux_syscall_sys_timerfd TODO /* parisc */ -#define linux_syscall_sys_vfork_wrapper TODO /* parisc */ - -#define linux_syscall_compat_sys_fadvise64 TODO /* sparc */ -#define linux_syscall_compat_sys_fadvise64_64 TODO /* sparc */ -#define linux_syscall_compat_sys_fstat64 TODO /* sparc */ -#define linux_syscall_compat_sys_fstatat64 TODO /* sparc */ -#define linux_syscall_compat_sys_lstat64 TODO /* sparc */ -#define linux_syscall_compat_sys_pread64 TODO /* sparc */ -#define linux_syscall_compat_sys_pwrite64 TODO /* sparc */ -#define linux_syscall_compat_sys_readahead TODO /* sparc */ -#define linux_syscall_compat_sys_sparc_sigaction TODO /* sparc */ -#define linux_syscall_compat_sys_stat64 TODO /* sparc */ -#define linux_syscall_compat_sys_sync_file_range TODO /* sparc */ -#define linux_syscall_sparc_exit TODO /* sparc */ -#define linux_syscall_sparc_exit_group TODO /* sparc */ -#define linux_syscall_sunos_execv TODO /* sparc */ -#define linux_syscall_sys32_execve TODO /* sparc */ -#define linux_syscall_sys32_execveat TODO /* sparc */ -#define linux_syscall_sys32_mmap2 TODO /* sparc */ -#define linux_syscall_sys32_socketcall TODO /* sparc */ -#define linux_syscall_sys64_execve TODO /* sparc */ -#define linux_syscall_sys64_execveat TODO /* sparc */ -#define linux_syscall_sys_64_mremap TODO /* sparc */ -#define linux_syscall_sys_64_munmap TODO /* sparc */ -#define linux_syscall_sys_getdomainname TODO /* sparc */ -#define linux_syscall_sys_kern_features TODO /* sparc */ -#define linux_syscall_sys_memory_ordering TODO /* sparc */ -#define linux_syscall_sys_nis_syscall TODO /* sparc */ -#define linux_syscall_sys_sparc64_personality TODO /* sparc */ -#define linux_syscall_sys_sparc_adjtimex TODO /* sparc */ -#define linux_syscall_sys_sparc_clock_adjtime TODO /* sparc */ -#define linux_syscall_sys_sparc_ipc TODO /* sparc */ -#define linux_syscall_sys_sparc_pipe TODO /* sparc */ -#define linux_syscall_sys_sparc_remap_file_pages TODO /* sparc */ -#define linux_syscall_sys_sparc_sigaction TODO /* sparc */ -#define linux_syscall_sys_utrap_install TODO /* sparc */ +#define linux_syscall___sys_vfork XXX /* m68k */ +#define linux_syscall_sys_atomic_barrier XXX /* m68k */ +#define linux_syscall_sys_atomic_cmpxchg_32 XXX /* m68k */ + +#define linux_syscall_compat_sys_io_pgetevents_time64 XXX /* parisc */ +#define linux_syscall_parisc_compat_signalfd4 XXX /* parisc */ +#define linux_syscall_parisc_eventfd2 XXX /* parisc */ +#define linux_syscall_parisc_fadvise64_64 XXX /* parisc */ +#define linux_syscall_parisc_fallocate XXX /* parisc */ +#define linux_syscall_parisc_ftruncate64 XXX /* parisc */ +#define linux_syscall_parisc_inotify_init1 XXX /* parisc */ +#define linux_syscall_parisc_madvise XXX /* parisc */ +#define linux_syscall_parisc_personality XXX /* parisc */ +#define linux_syscall_parisc_pipe2 XXX /* parisc */ +#define linux_syscall_parisc_pread64 XXX /* parisc */ +#define linux_syscall_parisc_pwrite64 XXX /* parisc */ +#define linux_syscall_parisc_readahead XXX /* parisc */ +#define linux_syscall_parisc_signalfd4 XXX /* parisc */ +#define linux_syscall_parisc_sync_file_range XXX /* parisc */ +#define linux_syscall_parisc_timerfd_create XXX /* parisc */ +#define linux_syscall_parisc_truncate64 XXX /* parisc */ +#define linux_syscall_parisc_userfaultfd XXX /* parisc */ +#define linux_syscall_sys32_fanotify_mark XXX /* parisc */ +#define linux_syscall_sys32_unimplemented XXX /* parisc */ +#define linux_syscall_sys_acl_get XXX /* parisc */ +#define linux_syscall_sys_acl_set XXX /* parisc */ +#define linux_syscall_sys_alloc_hugepages XXX /* parisc */ +#define linux_syscall_sys_attrctl XXX /* parisc */ +#define linux_syscall_sys_clone3_wrapper XXX /* parisc */ +#define linux_syscall_sys_clone_wrapper XXX /* parisc */ +#define linux_syscall_sys_fork_wrapper XXX /* parisc */ +#define linux_syscall_sys_free_hugepages XXX /* parisc */ +#define linux_syscall_sys_timerfd XXX /* parisc */ +#define linux_syscall_sys_vfork_wrapper XXX /* parisc */ + +#define linux_syscall_compat_sys_fadvise64 XXX /* sparc */ +#define linux_syscall_compat_sys_fadvise64_64 XXX /* sparc */ +#define linux_syscall_compat_sys_fstat64 XXX /* sparc */ +#define linux_syscall_compat_sys_fstatat64 XXX /* sparc */ +#define linux_syscall_compat_sys_lstat64 XXX /* sparc */ +#define linux_syscall_compat_sys_pread64 XXX /* sparc */ +#define linux_syscall_compat_sys_pwrite64 XXX /* sparc */ +#define linux_syscall_compat_sys_readahead XXX /* sparc */ +#define linux_syscall_compat_sys_sparc_sigaction XXX /* sparc */ +#define linux_syscall_compat_sys_stat64 XXX /* sparc */ +#define linux_syscall_compat_sys_sync_file_range XXX /* sparc */ +#define linux_syscall_sparc_exit XXX /* sparc */ +#define linux_syscall_sparc_exit_group XXX /* sparc */ +#define linux_syscall_sunos_execv XXX /* sparc */ +#define linux_syscall_sys32_execve XXX /* sparc */ +#define linux_syscall_sys32_execveat XXX /* sparc */ +#define linux_syscall_sys32_mmap2 XXX /* sparc */ +#define linux_syscall_sys32_socketcall XXX /* sparc */ +#define linux_syscall_sys64_execve XXX /* sparc */ +#define linux_syscall_sys64_execveat XXX /* sparc */ +#define linux_syscall_sys_64_mremap XXX /* sparc */ +#define linux_syscall_sys_64_munmap XXX /* sparc */ +#define linux_syscall_sys_getdomainname XXX /* sparc */ +#define linux_syscall_sys_kern_features XXX /* sparc */ +#define linux_syscall_sys_memory_ordering XXX /* sparc */ +#define linux_syscall_sys_nis_syscall XXX /* sparc */ +#define linux_syscall_sys_sparc64_personality XXX /* sparc */ +#define linux_syscall_sys_sparc_adjtimex XXX /* sparc */ +#define linux_syscall_sys_sparc_clock_adjtime XXX /* sparc */ +#define linux_syscall_sys_sparc_ipc XXX /* sparc */ +#define linux_syscall_sys_sparc_pipe XXX /* sparc */ +#define linux_syscall_sys_sparc_remap_file_pages XXX /* sparc */ +#define linux_syscall_sys_sparc_sigaction XXX /* sparc */ +#define linux_syscall_sys_utrap_install XXX /* sparc */ #define linux_syscall_compat_sys_mmap2 XXX /* powerpc */ #define linux_syscall_compat_sys_ppc32_fadvise64 XXX /* powerpc */ @@ -978,11 +969,5 @@ static struct libsyscalls_syscall_abi TODO = #define linux_syscall_sys_s390_runtime_instr XXX /* s390 */ #define linux_syscall_sys_s390_sthyi XXX /* s390 */ -#if defined(__clang__) -# pragma clang diagnostic pop -#else -# pragma GCC diagnostic pop -#endif - #endif /* !SYMBOL_PRINTERS_ONLY */ diff --git a/linux/syscalls.mk b/linux/syscalls.mk index de748b3..190f170 100644 --- a/linux/syscalls.mk +++ b/linux/syscalls.mk @@ -161,7 +161,7 @@ generated/linux-syscalls/m68k.h: $(LINUX_SYSCALL_DIR)/m68k.tbl linux/syscalls.mk generated/linux-syscalls/microblaze.h: $(LINUX_SYSCALL_DIR)/microblaze.tbl linux/syscalls.mk mkdir -p -- generated/linux-syscalls - printf '\43define LIST_LINUX_SYSCALLS_FOR_MICROBLAZE(X, _X_COMPAT, D)\\\n' > $@ + printf '\43define LIST_LINUX_SYSCALLS_FOR_MICROBLAZE_32(X, _X_COMPAT, D)\\\n' > $@ printf '%i common %s %s\n' \ 251 set_zone_reclaim sys_set_zone_reclaim \ 285 setaltroot sys_setaltroot \ @@ -450,3 +450,5 @@ generated/linux-syscall-dedup.h: $(HDR) $(LINUX_SYSCALLS_HDR) linux/syscalls.h l fi; \ done \ ) > $@ + printf '\43define linux_%s_syscalls_table\n' $(SUPPORTED_LINUX_ARCHES) \ + | sed -n 's/ linux_\(.*\)_[LB]E_syscalls_table/& linux_\1_syscalls_table/p' >> $@ diff --git a/linux/types.c b/linux/types.c index 66bb276..83f2bd1 100644 --- a/linux/types.c +++ b/linux/types.c @@ -3,9 +3,7 @@ /* This file is included from ../libsyscalls_get_datatype_description.c */ -/* If new architectures are added, the table at the top of - * ../libsyscalls_get_datatype_description.c must be updated */ - +/* If new architectures are added, LIST_ARCH_SPECS in ../common.h must be updated */ static enum libsyscalls_error get_linux_datatype_description(enum libsyscalls_arch arch, enum libsyscalls_datatype *datatype, @@ -17,7 +15,7 @@ get_linux_datatype_description(enum libsyscalls_arch arch, enum libsyscalls_data * and long long int as 64 bit (it's code even make such assumptions), * however that's is not necessarily the case for more exotic * architectures, for example, some specialised processors have 16 bit - * chars and run Linux (although not mainline). Linux also used + * chars and run Linux (although not mainline). Linux also uses * long int for addresses (intptr_t), which is normally how it should * be done but Windows always set long int to 32 bit (at least on x86/amd64) * for backwards compatibility, and of course it cannot be assumed that diff --git a/mk/generate.mk b/mk/generate.mk index f5361c4..7e81fb4 100644 --- a/mk/generate.mk +++ b/mk/generate.mk @@ -25,6 +25,9 @@ libsyscalls_get_datatype_description.lo: generated/types.c libsyscalls_get_integer_alignment.o: generated/integers.c libsyscalls_get_integer_alignment.lo: generated/integers.c +libsyscalls_get_struct_description.o: generated/structs.c +libsyscalls_get_struct_description.lo: generated/structs.c + $(GET_SYSCALL_RANGE_GEN): get_syscall_range.template.c mk/generate.mk mkdir -p -- generated @@ -56,6 +59,10 @@ generated/integers.c: Makefile mk/generate.mk mkdir -p -- generated printf '\43include "../%s/integers.c"\n' $(OPERATING_SYSTEMS) > $@ +generated/structs.c: Makefile mk/generate.mk + mkdir -p -- generated + printf '\43include "../%s/structs.c"\n' $(OPERATING_SYSTEMS) > $@ + generated/arches.h: Makefile mk/generate.mk mkdir -p -- generated printf '\43include "%s-arches.h"\n' $(OPERATING_SYSTEMS) > $@ @@ -94,14 +101,23 @@ libsyscalls/short-enums.h: libsyscalls.h mk/generate.mk generated/macros.h: common.h mk/generate.mk set -e;\ + for find in COUNT_ARGS; do \ + text="$$(sed -n 's/^$(s)*$(h)$(s)*define$(s)\{1,\}'"$$find"'_1(/&/p' < common.h)"; \ + i=1; while (( i <= $(NFIELDS) )); do \ + j=$$(( i + 1 )); \ + printf '%s\n' "$$text" | sed -e "s/_1/_ZZZ/g" -e "s/_2/_$$j/g" -e "s/_ZZZ/_$$i/g"; \ + i=$$j; \ + done; \ + done > $@; + set -e;\ for find in COUNT_ARG_PAIRS PARAMS_BUILD_TYPES; do \ text="$$(sed -n 's/^$(s)*$(h)$(s)*define$(s)\{1,\}'"$$find"'_1(/&/p' < common.h)"; \ i=1; while (( i <= $(NPARAMS) )); do \ j=$$(( i + 1 )); \ - printf '%s\n' "$$text" | sed -e "s/_2/_$$j/g" -e "s/_1/_$$i/g"; \ + printf '%s\n' "$$text" | sed -e "s/_1/_ZZZ/g" -e "s/_2/_$$j/g" -e "s/_ZZZ/_$$i/g"; \ i=$$j; \ done; \ - done > $@; + done >> $@; (set -e; \ nparamspairs="$$(i=1; while (( i <= $(NPARAMS) )); do printf '%s\n' $$i $$i; : $$(( i++ )); done)"; \ printf '\43define PARAMS_BUILD_MASK(MASK, ...)\\\n'; \ @@ -1,68 +1,49 @@ #!/bin/sh # See LICENSE file for copyright and license details. -if test $# = 0; then - if "$0" fail for me; then - printf 'Testing is broken!\n' >&2 - exit 2 - fi - set +e - "$0" $$ - r=$? - rm -f -- .?-$$.tmp - exit $r -fi +. tests/preamble - -set -e -test $# = 1 -pid=$1 -a=.a-$pid.tmp -b=.b-$pid.tmp -PATH="$(dirname -- "$0")/testutil:$PATH" -export PATH - -. tests/load-functions - -alias t=. +t=. # this is for test development; set to : to skip tests # have already been written and passed, set to . otherwise - -if ! env | grep '^SUPPORTED_OSES=' >/dev/null; then - printf '%s\n' \ - "The test's environment has not been set up;" \ - 'you should run the test via `make check`' - exit 1 -fi +# t is used to synchronous tests, +# p is used for asynchronous tests, and use t to determine whether to run +# If you want to force all tests to run synchronous, uncomment the next line +#alias p=t set -v -(. tests/test-self-check) >/dev/null 2>/dev/null t tests/enums . tests/load-types -t tests/errors -t tests/syscall-ranges -t tests/syscall-errors -t tests/signals -t tests/split-register-classes +p tests/errors +p tests/syscall-ranges +p tests/syscall-errors +p tests/signals +p tests/split-register-classes +p tests/signness +p tests/endians +p tests/sections +await . tests/load-archinfo t tests/archinfo -t tests/fundamental-primitives -t tests/is-struct -t tests/array-types -t tests/fixed-array-types -t tests/split-register-types -t tests/os-dependent-primitives -t tests/os-dependent-arrays -t tests/os-dependent-integers - +p tests/fundamental-primitives +p tests/is-struct +p tests/array-types +p tests/fixed-array-types +p tests/split-register-types +p tests/os-dependent-primitives +p tests/os-dependent-arrays +p tests/os-dependent-integers +await +# TODO test libsyscalls_get_struct_description +# TODO test libsyscalls_get_struct_display_info # TODO test libsyscalls_get_syscall # TODO test libsyscalls_get_syscall_display_info diff --git a/tests/default-integers b/tests/default-integers index 12faa5a..a33e51a 100644 --- a/tests/default-integers +++ b/tests/default-integers @@ -9,7 +9,13 @@ for arch in $(getnamelist ARCH); do if test $arch = M68K; then maxalign=16 - elif test $arch = I386; then + elif test $arch = I386 || \ + test $arch = ARM_OABI_LE || \ + test $arch = ARM_OABI_BE || \ + test $arch = SH_LE || \ + test $arch = SH_BE || \ + test $arch = MICROBLAZE_32_LE || \ + test $arch = MICROBLAZE_32_BE; then maxalign=32 else maxalign=64 diff --git a/tests/endians b/tests/endians new file mode 100644 index 0000000..13f29f8 --- /dev/null +++ b/tests/endians @@ -0,0 +1,175 @@ +# -*- sh -*- +# See LICENSE file for copyright and license details. + +check_endian () { + xvalue="$1" + text0="$2" + text1="$3" + textoff="$4" + bits="$5" + shift 5 + + sxvalue="$(printf '%s\n' "$xvalue" | sed 's/^0*//' | sed 's/^$/0/')" + + test "$(to-tracer-endian.tu $text0 $textoff $bits $@)" = "$sxvalue" + test "$(to-tracer-endian.tu $text1 $textoff $bits $@)" = "$sxvalue" + test "$(to-tracee-endian.tu $xvalue $textoff $bits $@)" = "$text0 $text1" +} + +check_endian0 () { + xvalue="$1" + text="$2" + textoff="$3" + bits="$4" + shift 4 + check_endian $xvalue $text $text $textoff $bits $@ +} + +check_endian 0 00 FE 0 1 0 +check_endian 0 00 FD 1 1 0 +check_endian 0 00 FB 2 1 0 +check_endian 0 00 F7 3 1 0 +check_endian 0 00 EF 4 1 0 +check_endian 0 00 DF 5 1 0 +check_endian 0 00 BF 6 1 0 +check_endian 0 00 7F 7 1 0 +check_endian 0 0000 FFFE 8 1 0 + +check_endian 1 01 FF 0 1 0 +check_endian 1 02 FF 1 1 0 +check_endian 1 04 FF 2 1 0 +check_endian 1 08 FF 3 1 0 +check_endian 1 10 FF 4 1 0 +check_endian 1 20 FF 5 1 0 +check_endian 1 40 FF 6 1 0 +check_endian 1 80 FF 7 1 0 +check_endian 1 0001 FFFF 8 1 0 + +check_endian 0 00 F0 0 4 0 +check_endian 1 01 F1 0 4 0 +check_endian 2 02 F2 0 4 0 +check_endian 3 03 F3 0 4 0 +check_endian 4 04 F4 0 4 0 +check_endian 8 08 F8 0 4 0 +check_endian A 0A FA 0 4 0 +check_endian F 0F FF 0 4 0 + +check_endian 0 00 E1 1 4 0 +check_endian 0 00 C3 2 4 0 +check_endian 0 00 87 3 4 0 +check_endian 0 00 0F 4 4 0 +check_endian F 1E FF 1 4 0 +check_endian F 3C FF 2 4 0 +check_endian F 78 FF 3 4 0 +check_endian F F0 FF 4 4 0 +check_endian 0 0000 1FFE 5 4 0 +check_endian F E001 FFFF 5 4 0 +check_endian 0 0000 3FFC 6 4 0 +check_endian F C003 FFFF 6 4 0 + +check_endian0 00 00 0 8 0 +check_endian0 10 10 0 8 0 +check_endian0 01 01 0 8 0 +check_endian0 80 80 0 8 0 +check_endian0 08 08 0 8 0 +check_endian0 FF FF 0 8 0 + +check_endian 00 0000 01FE 1 8 0 +check_endian FF FE01 FFFF 1 8 0 + +check_endian 000 0000 00FE 0 9 0 +check_endian 1FF FF01 FFFF 0 9 0 + +check_endian 000 0000 00FC 0 10 0 +check_endian 3FF FF03 FFFF 0 10 0 + +check_endian 000 0000 01FC 1 9 0 +check_endian 1FF FE03 FFFF 1 9 0 + +check_endian 000 0000 01F8 1 10 0 +check_endian 3FF FE07 FFFF 1 10 0 + +check_endian0 0000 0000 0 16 8 0 +check_endian0 FFFF FFFF 0 16 8 0 +check_endian0 1234 1234 0 16 8 0 +check_endian0 0800 0800 0 16 8 0 + +check_endian0 0000 0000 0 16 0 8 +check_endian0 FFFF FFFF 0 16 0 8 +check_endian0 1234 3412 0 16 0 8 +check_endian0 0800 0008 0 16 0 8 + +check_endian0 0000 0000 0 16 0 +check_endian0 FFFF FFFF 0 16 0 +check_endian0 1234 3412 0 16 0 +check_endian0 0800 0008 0 16 0 + +check_endian0 000000 000000 0 24 16 8 0 +check_endian0 FFFFFF FFFFFF 0 24 16 8 0 +check_endian0 160800 160800 0 24 16 8 0 + +check_endian0 000000 000000 0 24 16 0 8 +check_endian0 FFFFFF FFFFFF 0 24 16 0 8 +check_endian0 160800 160008 0 24 16 0 8 + +check_endian0 000000 000000 0 24 0 8 16 +check_endian0 FFFFFF FFFFFF 0 24 0 8 16 +check_endian0 160800 000816 0 24 0 8 16 + +check_endian0 000000 000000 0 24 8 0 16 +check_endian0 FFFFFF FFFFFF 0 24 8 0 16 +check_endian0 160800 080016 0 24 8 0 16 + +check_endian0 000000 000000 0 24 0 16 8 +check_endian0 FFFFFF FFFFFF 0 24 0 16 8 +check_endian0 160800 001608 0 24 0 16 8 + +check_endian0 000000 000000 0 24 8 16 0 +check_endian0 FFFFFF FFFFFF 0 24 8 16 0 +check_endian0 160800 081600 0 24 8 16 0 + +check_endian0 00000000 00000000 0 32 24 16 8 0 +check_endian0 FFFFFFFF FFFFFFFF 0 32 24 16 8 0 +check_endian0 12345678 12345678 0 32 24 16 8 0 +check_endian0 24160800 24160800 0 32 24 16 8 0 + +check_endian0 00000000 00000000 0 32 8 0 24 16 +check_endian0 FFFFFFFF FFFFFFFF 0 32 8 0 24 16 +check_endian0 12345678 56781234 0 32 8 0 24 16 +check_endian0 24160800 08002416 0 32 8 0 24 16 + +check_endian0 00000000 00000000 0 32 0 8 16 24 +check_endian0 FFFFFFFF FFFFFFFF 0 32 0 8 16 24 +check_endian0 12345678 78563412 0 32 0 8 16 24 +check_endian0 24160800 00081624 0 32 0 8 16 24 + +check_endian0 00000000 00000000 0 32 0 16 8 24 +check_endian0 FFFFFFFF FFFFFFFF 0 32 0 16 8 24 +check_endian0 12345678 78345612 0 32 0 16 8 24 +check_endian0 24160800 00160824 0 32 0 16 8 24 + +check_endian0 0000000000000000 0000000000000000 0 64 56 48 40 32 24 16 8 0 +check_endian0 FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF 0 64 56 48 40 32 24 16 8 0 +check_endian0 0123456789ABCDEF 0123456789ABCDEF 0 64 56 48 40 32 24 16 8 0 +check_endian0 5648403224160800 5648403224160800 0 64 56 48 40 32 24 16 8 0 + +check_endian0 0000000000000000 0000000000000000 0 64 24 16 8 0 56 48 40 32 +check_endian0 FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF 0 64 24 16 8 0 56 48 40 32 +check_endian0 0123456789ABCDEF 89ABCDEF01234567 0 64 24 16 8 0 56 48 40 32 +check_endian0 5648403224160800 2416080056484032 0 64 24 16 8 0 56 48 40 32 + +check_endian0 0000000000000000 0000000000000000 0 64 8 0 24 16 40 32 56 48 +check_endian0 FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF 0 64 8 0 24 16 40 32 56 48 +check_endian0 0123456789ABCDEF CDEF89AB45670123 0 64 8 0 24 16 40 32 56 48 +check_endian0 5648403224160800 0800241640325648 0 64 8 0 24 16 40 32 56 48 + +check_endian0 0000000000000000 0000000000000000 0 64 0 8 16 24 32 40 48 56 +check_endian0 FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF 0 64 0 8 16 24 32 40 48 56 +check_endian0 0123456789ABCDEF EFCDAB8967452301 0 64 0 8 16 24 32 40 48 56 +check_endian0 5648403224160800 0008162432404856 0 64 0 8 16 24 32 40 48 56 + +check_endian 000 0000 00FE 0 9 0 8 +check_endian 1FF FF01 FFFF 0 9 0 8 + +check_endian 000 0000 FE00 0 9 8 0 +check_endian 1FF 01FF FFFF 0 9 8 0 diff --git a/tests/errors b/tests/errors index 8c74731..9e098d1 100644 --- a/tests/errors +++ b/tests/errors @@ -55,5 +55,6 @@ cat > $a <<. 7 LIBSYSCALLS_E_INVAL Invalid arguments passed to function 8 LIBSYSCALLS_E_NOSUCHTYPE Type does not exist on the selected operating system or architecture 9 LIBSYSCALLS_E_ISSTRUCT Type is a structure or union +10 LIBSYSCALLS_E_ISNOTSTRUCT Type is not a structure or union . list-errors.tu | diff -u $a - diff --git a/tests/fixed-array-types b/tests/fixed-array-types index 070920e..06dcbb5 100644 --- a/tests/fixed-array-types +++ b/tests/fixed-array-types @@ -29,5 +29,14 @@ for os in $(getnamelist OS); do | sed 's/^\(array_size\) = 1$/\1 = 2/' > $a get-datatype-description.tu $osn $archn $(lookupnum "$types" $atype) $os $arch $atype > $b diff -u $a $b + + for n in 9 65; do + ptype=CHAR + atype=BUFFER_$n + get-datatype-description.tu $osn $archn $(lookupnum "$types" $ptype) $os $arch $ptype \ + | sed 's/^\(array_size\) = 1$/\1 = '$n/ > $a + get-datatype-description.tu $osn $archn $(lookupnum "$types" $atype) $os $arch $atype > $b + diff -u $a $b + done done done diff --git a/tests/load-archinfo b/tests/load-archinfo index 09d472b..e5413b4 100644 --- a/tests/load-archinfo +++ b/tests/load-archinfo @@ -18,7 +18,7 @@ getbyteorder () { printf '%s\n' "$byteorders" | grep "^$1$2 " | cut -d ' ' -f 2- } -sed '1,/LIST_ARCH_SPECS/d' < libsyscalls_get_datatype_description.c \ +sed '1,/LIST_ARCH_SPECS/d' < common.h \ | sed '/#include/q' \ | sed 's/\(TO''DO\)[[:space:]]*([^)]*)/\1/g' \ | sed -n 's/^[[:space:]]*[A-Z_]\{1,\}(LIBSYSCALLS_ARCH_\([^)]*\)).*$/\1/p' \ diff --git a/tests/load-functions b/tests/load-functions index 2e9ddda..3436158 100644 --- a/tests/load-functions +++ b/tests/load-functions @@ -1,6 +1,30 @@ # -*- sh -*- # See LICENSE file for copyright and license details. +parallelindex=0 +p () { + ( + set +ev + pid=$$-$parallelindex + a=.a-$pid.tmp + b=.b-$pid.tmp + log=.x-$pid.tmp + ( set -ev ; $t "$@" ) > $log 2>&1 + r=$? + test $r = 0 || cat -- $log >&2 + rm -f -- .?-$pid.tmp + exit $r + ) & + eval parallelpid$(( ++parallelindex ))=$! +} +await () { + while (( parallelindex )); do + parallelvar=parallelpid$(( parallelindex-- )) + eval wait '$'$parallelvar + done +} + + stderr () { ("$@") 2>&1 >/dev/null } diff --git a/tests/preamble b/tests/preamble new file mode 100644 index 0000000..527a098 --- /dev/null +++ b/tests/preamble @@ -0,0 +1,41 @@ +# -*- sh -*- +# See LICENSE file for copyright and license details. + +if test $# = 0; then + if "$0" fail for me; then + printf 'Testing is broken!\n' >&2 + exit 2 + fi + set +e + "$0" $$ + r=$? + rm -f -- .?-$$.tmp + exit $r +fi + + +set -e +test $# = 1 +pid=$1 +a=.a-$pid.tmp +b=.b-$pid.tmp +PATH="$(dirname -- "$0")/testutil:$PATH" +export PATH + + +if ! env | grep '^SUPPORTED_OSES=' >/dev/null; then + printf '%s\n' \ + "The test's environment has not been set up;" \ + 'you should run the test via `make check`' + exit 1 +fi + +. tests/load-functions + +alias t='$t' + +if ! (. tests/test-self-check) >/dev/null 2>/dev/null; then + printf '%s\n' \ + "The test's self-check failed" + exit 1 +fi diff --git a/tests/sections b/tests/sections new file mode 100644 index 0000000..1574b8d --- /dev/null +++ b/tests/sections @@ -0,0 +1,90 @@ +# -*- sh -*- +# See LICENSE file for copyright and license details. + +check_section () { + sectionn=$1 + whole=$2 + splitinwhole=$3 + split=$(printf '%s\n' $splitinwhole | tr -d -- -) + wholebits=$(( ( $(printf '%s\n' $whole | sed 's/./+1/g') ) * 4 )) + splitbits=$(( ( $(printf '%s\n' $split | sed 's/./+1/g') ) * 4 )) + ssplit=$(printf '%s\n' $split | sed 's/^0*//' | sed 's/^$/0/' ) + ssplitinwhole=$(printf '%s\n' $splitinwhole | tr -- - 0 | sed 's/^0*//' | sed 's/^$/0/' ) + + test $(section-value.tu $sectionn $whole $wholebits) = $ssplit + test $(unsection-value.tu $sectionn $split $splitbits) = $ssplitinwhole +} + +test $(section-value.tu 32767 0 8) = inval +test $(unsection-value.tu 32767 0 8) = inval + +for section in $(getnamelist SECTION); do + sectionn=$(getnum SECTION $section) + if test $section = UNDETERMINED || test $section = WHOLE; then + check_section $sectionn 12 12 + check_section $sectionn 1234 1234 + check_section $sectionn 12345678 12345678 + check_section $sectionn 123456789ABC 123456789ABC + check_section $sectionn 0123456789ABCDEF 0123456789ABCDEF + + elif test $section = UPPER_HALF; then + check_section $sectionn 1234 12-- + check_section $sectionn 12345678 1234---- + check_section $sectionn 123456789ABC 123456------ + check_section $sectionn 0123456789ABCDEF 01234567-------- + + elif test $section = LOWER_HALF; then + check_section $sectionn 1234 --34 + check_section $sectionn 12345678 ----5678 + check_section $sectionn 123456789ABC ------789ABC + check_section $sectionn 0123456789ABCDEF --------89ABCDEF + + elif test $section = INNER_HALF; then + check_section $sectionn 12345678 --3456-- + check_section $sectionn 0123456789ABCDEF ----456789AB---- + + elif test $section = OUTER_HALF; then + check_section $sectionn 12345678 12----78 + check_section $sectionn 0123456789ABCDEF 0123--------CDEF + + elif test $section = EVEN_QUARTERS_AS_HALF; then + check_section $sectionn 12345678 --34--78 + check_section $sectionn 0123456789ABCDEF ----4567----CDEF + + elif test $section = ODD_QUARTERS_AS_HALF; then + check_section $sectionn 12345678 12--56-- + check_section $sectionn 0123456789ABCDEF 0123----89AB---- + + elif test $section = EVEN_BYTES_AS_HALF; then + check_section $sectionn 1234 --34 + check_section $sectionn 12345678 --34--78 + check_section $sectionn 123456789ABC --34--78--BC + check_section $sectionn 0123456789ABCDEF --23--67--AB--EF + + elif test $section = ODD_BYTES_AS_HALF; then + check_section $sectionn 1234 12-- + check_section $sectionn 12345678 12--56-- + check_section $sectionn 123456789ABC 12--56--9A-- + check_section $sectionn 0123456789ABCDEF 01--45--89--CD-- + + elif test $section = UPPER_QUARTER; then + check_section $sectionn 12345678 12------ + check_section $sectionn 0123456789ABCDEF 0123------------ + + elif test $section = UPPER_MID_QUARTER; then + check_section $sectionn 12345678 --34---- + check_section $sectionn 0123456789ABCDEF ----4567-------- + + elif test $section = LOWER_MID_QUARTER; then + check_section $sectionn 12345678 ----56-- + check_section $sectionn 0123456789ABCDEF --------89AB---- + + elif test $section = LOWER_QUARTER; then + check_section $sectionn 12345678 ------78 + check_section $sectionn 0123456789ABCDEF ------------CDEF + + else + printf 'Missing test for LIBSYSCALLS_SECTION_%s in tests/sections\n' "$section" >&2 + false + fi +done diff --git a/tests/signals b/tests/signals index 4052402..733baa4 100644 --- a/tests/signals +++ b/tests/signals @@ -6,11 +6,11 @@ for os in $(getnamelist OS); do for arch in $(getnamelist ARCH); do archn=$(getnum ARCH $arch) get-signals.tu $osn $archn $os $arch > $a - grep -v '^[0-9]\{1,\} -' >/dev/null < $a - grep -v '^-' < $a > $b - grep '^\([0-9]\{1,\}\) \1 ' < $a | diff -u $a - if issupported $os $arch; then (! test "$(cat $a)" = x) + grep -v '^[0-9]\{1,\} -' >/dev/null < $a + grep -v '^-' < $a > $b + grep '^\([0-9]\{1,\}\) \1 ' < $a | diff -u $a - if test "$os" = LINUX; then signed=1 grep '^[0-9]\{1,\} [0-9]\{1,\} [A-Z0-9_+]\{1,\}$' >/dev/null < $a diff --git a/tests/signness b/tests/signness new file mode 100644 index 0000000..8c29fe4 --- /dev/null +++ b/tests/signness @@ -0,0 +1,296 @@ +# -*- sh -*- +# See LICENSE file for copyright and license details. + +test $(parse-signed.tu 32767 32 0) = inval +test $(make-signed.tu 32767 32 0) = inval + +check_signed () { + test $(parse-signed.tu $1 $2 $3) = $4 + test $(make-signed.tu $1 $2 $4) = $3 +} + +ucheck_signed () { + check_signed "$@" + test $(make-signed.tu $1 $2 -$4) = $3 +} + +for sign in $(getnamelist SIGN); do + signn=$(getnum SIGN $sign) + if test $sign = UNDETERMINED; then + ucheck_signed $signn 1 0 0 + ucheck_signed $signn 1 1 1 + ucheck_signed $signn 2 0 0 + ucheck_signed $signn 2 1 1 + ucheck_signed $signn 2 2 2 + ucheck_signed $signn 2 3 3 + ucheck_signed $signn 4 4 4 + ucheck_signed $signn 4 9 9 + ucheck_signed $signn 4 A A + ucheck_signed $signn 4 C C + ucheck_signed $signn 4 F F + ucheck_signed $signn 7 00 00 + ucheck_signed $signn 7 08 08 + ucheck_signed $signn 7 70 70 + ucheck_signed $signn 7 7F 7F + ucheck_signed $signn 8 00 00 + ucheck_signed $signn 8 08 08 + ucheck_signed $signn 8 80 80 + ucheck_signed $signn 8 FF FF + ucheck_signed $signn 16 0001 0001 + ucheck_signed $signn 16 0020 0020 + ucheck_signed $signn 16 0300 0300 + ucheck_signed $signn 16 4000 4000 + ucheck_signed $signn 16 0008 0008 + ucheck_signed $signn 16 0090 0090 + ucheck_signed $signn 16 0A00 0A00 + ucheck_signed $signn 16 B000 B000 + ucheck_signed $signn 17 08100 08100 + ucheck_signed $signn 17 00820 00820 + ucheck_signed $signn 17 00083 00083 + ucheck_signed $signn 17 04008 04008 + ucheck_signed $signn 17 11008 11008 + ucheck_signed $signn 17 10280 10280 + ucheck_signed $signn 17 10830 10830 + ucheck_signed $signn 17 18004 18004 + ucheck_signed $signn 32 12345678 12345678 + ucheck_signed $signn 32 9ABCDEF0 9ABCDEF0 + ucheck_signed $signn 32 87654321 87654321 + ucheck_signed $signn 32 0FEDCBA9 0FEDCBA9 + ucheck_signed $signn 64 0123456789ABCDEF 0123456789ABCDEF + ucheck_signed $signn 64 123456789ABCDEF0 123456789ABCDEF0 + ucheck_signed $signn 64 23456789ABCDEF01 23456789ABCDEF01 + ucheck_signed $signn 64 3456789ABCDEF012 3456789ABCDEF012 + ucheck_signed $signn 64 89ABCDEF01234567 89ABCDEF01234567 + ucheck_signed $signn 64 9ABCDEF012345678 9ABCDEF012345678 + ucheck_signed $signn 64 ABCDEF0123456789 ABCDEF0123456789 + ucheck_signed $signn 64 BCDEF0123456789A BCDEF0123456789A + ucheck_signed $signn 64 0000000000000000 0000000000000000 + ucheck_signed $signn 64 7FFFFFFFFFFFFFFF 7FFFFFFFFFFFFFFF + ucheck_signed $signn 64 8000000000000000 8000000000000000 + ucheck_signed $signn 64 FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF + + elif test $sign = SIGN_MAGNITUDE; then + check_signed $signn 1 0 0 + check_signed $signn 1 1 -0 + check_signed $signn 2 0 0 + check_signed $signn 2 1 1 + check_signed $signn 2 2 -0 + check_signed $signn 2 3 -1 + check_signed $signn 4 4 4 + check_signed $signn 4 9 -1 + check_signed $signn 4 A -2 + check_signed $signn 4 C -4 + check_signed $signn 4 F -7 + check_signed $signn 7 00 00 + check_signed $signn 7 08 08 + check_signed $signn 7 70 -30 + check_signed $signn 7 7F -3F + check_signed $signn 8 00 00 + check_signed $signn 8 08 08 + check_signed $signn 8 80 -00 + check_signed $signn 8 FF -7F + check_signed $signn 16 0001 0001 + check_signed $signn 16 0020 0020 + check_signed $signn 16 0300 0300 + check_signed $signn 16 4000 4000 + check_signed $signn 16 0008 0008 + check_signed $signn 16 0090 0090 + check_signed $signn 16 0A00 0A00 + check_signed $signn 16 B000 -3000 + check_signed $signn 17 08100 08100 + check_signed $signn 17 00820 00820 + check_signed $signn 17 00083 00083 + check_signed $signn 17 04008 04008 + check_signed $signn 17 11008 -01008 + check_signed $signn 17 10280 -00280 + check_signed $signn 17 10830 -00830 + check_signed $signn 17 18004 -08004 + check_signed $signn 32 12345678 12345678 + check_signed $signn 32 9ABCDEF0 -1ABCDEF0 + check_signed $signn 32 87654321 -07654321 + check_signed $signn 32 0FEDCBA9 0FEDCBA9 + check_signed $signn 64 0123456789ABCDEF 0123456789ABCDEF + check_signed $signn 64 123456789ABCDEF0 123456789ABCDEF0 + check_signed $signn 64 23456789ABCDEF01 23456789ABCDEF01 + check_signed $signn 64 3456789ABCDEF012 3456789ABCDEF012 + check_signed $signn 64 89ABCDEF01234567 -09ABCDEF01234567 + check_signed $signn 64 9ABCDEF012345678 -1ABCDEF012345678 + check_signed $signn 64 ABCDEF0123456789 -2BCDEF0123456789 + check_signed $signn 64 BCDEF0123456789A -3CDEF0123456789A + check_signed $signn 64 0000000000000000 0000000000000000 + check_signed $signn 64 7FFFFFFFFFFFFFFF 7FFFFFFFFFFFFFFF + check_signed $signn 64 8000000000000000 -0000000000000000 + check_signed $signn 64 FFFFFFFFFFFFFFFF -7FFFFFFFFFFFFFFF + + elif test $sign = ONES_COMPLEMENT; then + check_signed $signn 1 0 0 + check_signed $signn 1 1 -0 + check_signed $signn 2 0 0 + check_signed $signn 2 1 1 + check_signed $signn 2 2 -1 + check_signed $signn 2 3 -0 + check_signed $signn 4 4 4 + check_signed $signn 4 9 -6 + check_signed $signn 4 A -5 + check_signed $signn 4 C -3 + check_signed $signn 4 F -0 + check_signed $signn 7 00 00 + check_signed $signn 7 08 08 + check_signed $signn 7 70 -0F + check_signed $signn 7 7F -00 + check_signed $signn 8 00 00 + check_signed $signn 8 08 08 + check_signed $signn 8 80 -7F + check_signed $signn 8 FF -00 + check_signed $signn 16 0001 0001 + check_signed $signn 16 0020 0020 + check_signed $signn 16 0300 0300 + check_signed $signn 16 4000 4000 + check_signed $signn 16 0008 0008 + check_signed $signn 16 0090 0090 + check_signed $signn 16 0A00 0A00 + check_signed $signn 16 B000 -4FFF + check_signed $signn 17 08100 08100 + check_signed $signn 17 00820 00820 + check_signed $signn 17 00083 00083 + check_signed $signn 17 04008 04008 + check_signed $signn 17 11008 -0EFF7 + check_signed $signn 17 10280 -0FD7F + check_signed $signn 17 10830 -0F7CF + check_signed $signn 17 18004 -07FFB + check_signed $signn 32 12345678 12345678 + check_signed $signn 32 9ABCDEF0 -6543210F + check_signed $signn 32 87654321 -789ABCDE + check_signed $signn 32 0FEDCBA9 0FEDCBA9 + check_signed $signn 64 0123456789ABCDEF 0123456789ABCDEF + check_signed $signn 64 123456789ABCDEF0 123456789ABCDEF0 + check_signed $signn 64 23456789ABCDEF01 23456789ABCDEF01 + check_signed $signn 64 3456789ABCDEF012 3456789ABCDEF012 + check_signed $signn 64 89ABCDEF01234567 -76543210FEDCBA98 + check_signed $signn 64 9ABCDEF012345678 -6543210FEDCBA987 + check_signed $signn 64 ABCDEF0123456789 -543210FEDCBA9876 + check_signed $signn 64 BCDEF0123456789A -43210FEDCBA98765 + check_signed $signn 64 0000000000000000 0000000000000000 + check_signed $signn 64 7FFFFFFFFFFFFFFF 7FFFFFFFFFFFFFFF + check_signed $signn 64 8000000000000000 -7FFFFFFFFFFFFFFF + check_signed $signn 64 FFFFFFFFFFFFFFFF -0000000000000000 + + elif test $sign = TWOS_COMPLEMENT; then + check_signed $signn 1 0 0 + check_signed $signn 1 1 -1 + check_signed $signn 2 0 0 + check_signed $signn 2 1 1 + check_signed $signn 2 2 -2 + check_signed $signn 2 3 -1 + check_signed $signn 4 4 4 + check_signed $signn 4 9 -7 + check_signed $signn 4 A -6 + check_signed $signn 4 C -4 + check_signed $signn 4 F -1 + check_signed $signn 7 00 00 + check_signed $signn 7 08 08 + check_signed $signn 7 70 -10 + check_signed $signn 7 7F -01 + check_signed $signn 8 00 00 + check_signed $signn 8 08 08 + check_signed $signn 8 80 -80 + check_signed $signn 8 FF -01 + check_signed $signn 16 0001 0001 + check_signed $signn 16 0020 0020 + check_signed $signn 16 0300 0300 + check_signed $signn 16 4000 4000 + check_signed $signn 16 0008 0008 + check_signed $signn 16 0090 0090 + check_signed $signn 16 0A00 0A00 + check_signed $signn 16 B000 -5000 + check_signed $signn 17 08100 08100 + check_signed $signn 17 00820 00820 + check_signed $signn 17 00083 00083 + check_signed $signn 17 04008 04008 + check_signed $signn 17 11008 -0EFF8 + check_signed $signn 17 10280 -0FD80 + check_signed $signn 17 10830 -0F7D0 + check_signed $signn 17 18004 -07FFC + check_signed $signn 32 12345678 12345678 + check_signed $signn 32 9ABCDEF0 -65432110 + check_signed $signn 32 87654321 -789ABCDF + check_signed $signn 32 0FEDCBA9 0FEDCBA9 + check_signed $signn 64 0123456789ABCDEF 0123456789ABCDEF + check_signed $signn 64 123456789ABCDEF0 123456789ABCDEF0 + check_signed $signn 64 23456789ABCDEF01 23456789ABCDEF01 + check_signed $signn 64 3456789ABCDEF012 3456789ABCDEF012 + check_signed $signn 64 89ABCDEF01234567 -76543210FEDCBA99 + check_signed $signn 64 9ABCDEF012345678 -6543210FEDCBA988 + check_signed $signn 64 ABCDEF0123456789 -543210FEDCBA9877 + check_signed $signn 64 BCDEF0123456789A -43210FEDCBA98766 + check_signed $signn 64 0000000000000000 0000000000000000 + check_signed $signn 64 7FFFFFFFFFFFFFFF 7FFFFFFFFFFFFFFF + check_signed $signn 64 8000000000000000 -8000000000000000 + check_signed $signn 64 FFFFFFFFFFFFFFFF -0000000000000001 + test $(make-signed.tu $signn 1 -0) = 0 + test $(make-signed.tu $signn 4 -0) = 0 + + elif test $sign = EXCESS_HALF; then + check_signed $signn 1 0 -1 + check_signed $signn 1 1 0 + check_signed $signn 2 0 -2 + check_signed $signn 2 1 -1 + check_signed $signn 2 2 0 + check_signed $signn 2 3 1 + check_signed $signn 4 4 -4 + check_signed $signn 4 9 1 + check_signed $signn 4 A 2 + check_signed $signn 4 C 4 + check_signed $signn 4 F 7 + check_signed $signn 7 00 -40 + check_signed $signn 7 08 -38 + check_signed $signn 7 70 30 + check_signed $signn 7 7F 3F + check_signed $signn 8 00 -80 + check_signed $signn 8 08 -78 + check_signed $signn 8 80 00 + check_signed $signn 8 FF 7F + check_signed $signn 16 0001 -7FFF + check_signed $signn 16 0020 -7FE0 + check_signed $signn 16 0300 -7D00 + check_signed $signn 16 4000 -4000 + check_signed $signn 16 0008 -7FF8 + check_signed $signn 16 0090 -7F70 + check_signed $signn 16 0A00 -7600 + check_signed $signn 16 B000 3000 + check_signed $signn 17 08100 -07F00 + check_signed $signn 17 00820 -0F7E0 + check_signed $signn 17 00083 -0FF7D + check_signed $signn 17 04008 -0BFF8 + check_signed $signn 17 11008 01008 + check_signed $signn 17 10280 00280 + check_signed $signn 17 10830 00830 + check_signed $signn 17 18004 08004 + check_signed $signn 32 12345678 -6DCBA988 + check_signed $signn 32 9ABCDEF0 1ABCDEF0 + check_signed $signn 32 87654321 07654321 + check_signed $signn 32 0FEDCBA9 -70123457 + check_signed $signn 64 0123456789ABCDEF -7EDCBA9876543211 + check_signed $signn 64 123456789ABCDEF0 -6DCBA98765432110 + check_signed $signn 64 23456789ABCDEF01 -5CBA9876543210FF + check_signed $signn 64 3456789ABCDEF012 -4BA9876543210FEE + check_signed $signn 64 89ABCDEF01234567 09ABCDEF01234567 + check_signed $signn 64 9ABCDEF012345678 1ABCDEF012345678 + check_signed $signn 64 ABCDEF0123456789 2BCDEF0123456789 + check_signed $signn 64 BCDEF0123456789A 3CDEF0123456789A + check_signed $signn 64 0000000000000000 -8000000000000000 + check_signed $signn 64 7FFFFFFFFFFFFFFF -0000000000000001 + check_signed $signn 64 8000000000000000 0000000000000000 + check_signed $signn 64 FFFFFFFFFFFFFFFF 7FFFFFFFFFFFFFFF + test $(make-signed.tu $signn 1 -0) = 1 + test $(make-signed.tu $signn 4 -0) = 8 + + else + printf 'Missing test for LIBSYSCALLS_SIGN_%s in tests/signness\n' "$sign" >&2 + false + fi + test $(parse-signed.tu $signn 0 0) = inval + test $(parse-signed.tu $signn 32767 0) = inval + test $(make-signed.tu $signn 0 0) = inval + test $(make-signed.tu $signn 32767 0) = inval +done diff --git a/tests/syscall-errors b/tests/syscall-errors index 8d85ded..4608fe7 100644 --- a/tests/syscall-errors +++ b/tests/syscall-errors @@ -6,11 +6,11 @@ for os in $(getnamelist OS); do for arch in $(getnamelist ARCH); do archn=$(getnum ARCH $arch) get-syscall-errors.tu $osn $archn $os $arch > $a - grep -v '^[0-9]\{1,\} -' >/dev/null < $a - grep -v '^-' < $a > $b - grep '^\([0-9]\{1,\}\) \1 ' < $a | diff -u $a - if issupported $os $arch; then (! test "$(cat $a)" = x) + grep -v '^[0-9]\{1,\} -' >/dev/null < $a + grep -v '^-' < $a > $b + grep '^\([0-9]\{1,\}\) \1 ' < $a | diff -u $a - if test "$os" = LINUX; then signed=1 grep '^[0-9]\{1,\} [0-9]\{1,\} [A-Z0-9_]\{1,\}$' >/dev/null < $a diff --git a/tests/test-self-check b/tests/test-self-check index 8e42f18..c0e1d0d 100644 --- a/tests/test-self-check +++ b/tests/test-self-check @@ -9,6 +9,9 @@ stderr_printf () { test "$(stderr_printf 'hello\n')" = '' test "$(stderr stderr_printf 'hello\n' 2>&1)" = 'hello' +failing_function () { false; true; } # use of { } rather than ( ) is important +( ! failing_function ) + (! (false > $a) ) getname OS 0 @@ -39,6 +42,10 @@ printf 'a\n' > $a printf 'a\n' > $b diff -u $a $b +true & wait $! +( false & ! wait $! ) +await + for os in ${SUPPORTED_OSES}; do issupported $os for arch in $(env | sed -n 's/^SUPPORTED_'"$os"'_ARCHES=//p' | xargs printf '%s\n'); do diff --git a/testutil/get-integer-alignment.c b/testutil/get-integer-alignment.c index 6c91824..7d0fcc3 100644 --- a/testutil/get-integer-alignment.c +++ b/testutil/get-integer-alignment.c @@ -15,7 +15,7 @@ int main(int argc, char **argv) { int os, arch, width; - unsigned alignment = -1; + unsigned alignment = 0; enum libsyscalls_error err; if (argc != 6) { diff --git a/testutil/make-signed.c b/testutil/make-signed.c new file mode 100644 index 0000000..7cd0134 --- /dev/null +++ b/testutil/make-signed.c @@ -0,0 +1,56 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +int +main(int argc, char **argv) +{ + int sign, neg = -1; + size_t bits; + const char *xval; + enum libsyscalls_error err; + unsigned long long int value; + char *end; + + if (argc != 4) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + + sign = atoi(argv[1]); + bits = (unsigned long long int)atoll(argv[2]); + xval = argv[3]; + neg = *xval == '-'; + xval = &xval[neg]; + errno = 0; + value = strtoull(xval, &end, 16); + if (errno || *end) + goto usage; + + err = libsyscalls_make_signed_integer(value, neg, (enum libsyscalls_datatype_sign_representation)sign, bits, &value); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + printf("%0*llX\n", (int)strlen(xval), value); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} diff --git a/testutil/parse-signed.c b/testutil/parse-signed.c new file mode 100644 index 0000000..0fea405 --- /dev/null +++ b/testutil/parse-signed.c @@ -0,0 +1,56 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +int +main(int argc, char **argv) +{ + int sign, neg = -1; + size_t bits; + const char *xval; + enum libsyscalls_error err; + unsigned long long int value; + char *end; + + if (argc != 4) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + + sign = atoi(argv[1]); + bits = (unsigned long long int)atoll(argv[2]); + xval = argv[3]; + errno = 0; + value = strtoull(xval, &end, 16); + if (errno || *end) + goto usage; + + err = libsyscalls_parse_signed_integer(value, (enum libsyscalls_datatype_sign_representation)sign, bits, &value, &neg); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + if (neg != 0 && neg != 1) + abort(); + printf("%.*s%0*llX\n", neg, "-", (int)strlen(xval), value); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} diff --git a/testutil/section-value.c b/testutil/section-value.c new file mode 100644 index 0000000..b4c0304 --- /dev/null +++ b/testutil/section-value.c @@ -0,0 +1,52 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +int +main(int argc, char **argv) +{ + enum libsyscalls_datatype_section section; + unsigned long long int value; + size_t bits; + char *end; + enum libsyscalls_error err; + + if (argc != 4) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + + section = (enum libsyscalls_datatype_section)atoi(argv[1]); + errno = 0; + value = strtoull(argv[2], &end, 16); + if (errno || *end) + goto usage; + bits = (size_t)atol(argv[3]); + + err = libsyscalls_section_value(value, bits, section, &value); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + + printf("%llX\n", value); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} diff --git a/testutil/to-tracee-endian.c b/testutil/to-tracee-endian.c new file mode 100644 index 0000000..4346883 --- /dev/null +++ b/testutil/to-tracee-endian.c @@ -0,0 +1,111 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <errno.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +static void +make_hex(char *out, const char *in, size_t n) +{ + for (; n--; in++) { + *out++ = "0123456789ABCDEF"[((unsigned)*in >> 4) & 0xFU]; + *out++ = "0123456789ABCDEF"[((unsigned)*in >> 0) & 0xFU]; + } + *out = '\0'; +} + + +int +main(int argc, char **argv) +{ + struct libsyscalls_datatype_description type; + char *data, *end, *text0, *text1; + size_t dataoff, i, datasize; + unsigned long long int value; + enum libsyscalls_error err; + + _Static_assert(CHAR_BIT, "We only support 8-bit char at the moment in testutil/to-tracee-endian.c"); + + if (argc < 5) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wconversion" +#endif + + errno = 0; + value = strtoull(argv[1], &end, 16); + if (errno || *end) + goto usage; + dataoff = (size_t)atol(argv[2]); + type.width_in_bits = (unsigned short int)atoi(argv[3]); + argv = &argv[4]; + i = 0; + for (; argv[i] && i < sizeof(type.byteorder) / sizeof(*type.byteorder); i++) + type.byteorder[i] = (unsigned)atoi(argv[i]); + if (argv[i]) + goto usage; + for (; i < sizeof(type.byteorder) / sizeof(*type.byteorder); i++) { + type.byteorder[i] = 0U; + type.byteorder[i] = ~type.byteorder[i]; + } + +#if defined(__clang__) +# pragma GCC diagnostic pop +#endif + + datasize = ((size_t)type.width_in_bits + dataoff + 7UL) / 8UL; + data = malloc(datasize); + text0 = malloc(datasize * 2UL + 1UL); + text1 = malloc(datasize * 2UL + 1UL); + + memset(data, 0, datasize); + err = libsyscalls_to_tracee_endian(value, &type, data, dataoff); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + free(data); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + make_hex(text0, data, datasize); + + memset(data, ~0, datasize); + err = libsyscalls_to_tracee_endian(value, &type, data, dataoff); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + free(data); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + make_hex(text1, data, datasize); + + free(data); + + printf("%s %s\n", text0, text1); + + free(text0); + free(text1); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} diff --git a/testutil/to-tracer-endian.c b/testutil/to-tracer-endian.c new file mode 100644 index 0000000..53cb380 --- /dev/null +++ b/testutil/to-tracer-endian.c @@ -0,0 +1,83 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +int +main(int argc, char **argv) +{ + struct libsyscalls_datatype_description type; + const char *text; + char *data; + size_t dataoff, i; + unsigned long long int value; + unsigned char high, low; + enum libsyscalls_error err; + + _Static_assert(CHAR_BIT, "We only support 8-bit char at the moment in testutil/to-tracer-endian.c"); + + if (argc < 5) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wconversion" +#endif + + text = argv[1]; + dataoff = (size_t)atol(argv[2]); + type.width_in_bits = (unsigned short int)atoi(argv[3]); + argv = &argv[4]; + i = 0; + for (; argv[i] && i < sizeof(type.byteorder) / sizeof(*type.byteorder); i++) + type.byteorder[i] = (unsigned)atoi(argv[i]); + if (argv[i]) + goto usage; + for (; i < sizeof(type.byteorder) / sizeof(*type.byteorder); i++) { + type.byteorder[i] = 0U; + type.byteorder[i] = ~type.byteorder[i]; + } + +#if defined(__clang__) +# pragma GCC diagnostic pop +#endif + + if (strlen(text) & 1 || !strlen(text)) + goto usage; + data = malloc(strlen(text) / 2); + for (i = 0; *text; i++) { + high = (unsigned char)*text++; + low = (unsigned char)*text++; + high = (unsigned char)((high & 15U) + (high > '9' ? 9U : 0U)); + low = (unsigned char)((low & 15U) + (low > '9' ? 9U : 0U)); + data[i] = (char)((high << 4) | low); + } + + err = libsyscalls_to_tracer_endian(data, dataoff, &type, &value); + free(data); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + printf("%llX\n", value); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} diff --git a/testutil/unsection-value.c b/testutil/unsection-value.c new file mode 100644 index 0000000..9c85b3b --- /dev/null +++ b/testutil/unsection-value.c @@ -0,0 +1,52 @@ +/* See LICENSE file for copyright and license details. */ +#include "../libsyscalls.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunsafe-buffer-usage" /* clang is just being silly */ +#endif + + +int +main(int argc, char **argv) +{ + enum libsyscalls_datatype_section section; + unsigned long long int value; + size_t bits; + char *end; + enum libsyscalls_error err; + + if (argc != 4) { + usage: + fprintf(stderr, "usage error\n"); + return 1; + } + + section = (enum libsyscalls_datatype_section)atoi(argv[1]); + errno = 0; + value = strtoull(argv[2], &end, 16); + if (errno || *end) + goto usage; + bits = (size_t)atol(argv[3]); + + err = libsyscalls_unsection_value(value, bits, section, &value); + if (err == LIBSYSCALLS_E_INVAL) { + printf("inval\n"); + goto out; + } else if (err) { + libsyscalls_perror(NULL, err); + return 1; + } + + printf("%llX\n", value); + +out: + if (fflush(stdout) || fclose(stdout)) { + perror(NULL); + return 1; + } + return 0; +} |