diff options
| -rw-r--r-- | CMakeLists.txt | 17 | ||||
| -rw-r--r-- | include/endian.h | 23 | ||||
| -rw-r--r-- | include/ucode/chunk.h | 4 | ||||
| -rw-r--r-- | include/ucode/lib.h | 2 | ||||
| -rw-r--r-- | include/ucode/platform.h | 79 | ||||
| -rw-r--r-- | include/ucode/program.h | 4 | ||||
| -rw-r--r-- | include/ucode/source.h | 2 | ||||
| -rw-r--r-- | include/ucode/types.h | 3 | ||||
| -rw-r--r-- | lexer.c | 2 | ||||
| -rw-r--r-- | lib.c | 209 | ||||
| -rw-r--r-- | lib/debug.c | 1631 | ||||
| -rw-r--r-- | lib/fs.c | 5 | ||||
| -rw-r--r-- | lib/nl80211.c | 2 | ||||
| -rw-r--r-- | lib/rtnl.c | 2 | ||||
| -rw-r--r-- | lib/uloop.c | 6 | ||||
| -rw-r--r-- | platform.c | 242 | ||||
| -rw-r--r-- | program.c | 2 | ||||
| -rw-r--r-- | source.c | 2 | ||||
| -rw-r--r-- | types.c | 1 | ||||
| -rw-r--r-- | vallist.c | 2 | ||||
| -rw-r--r-- | vm.c | 35 |
21 files changed, 1996 insertions, 279 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index d8dd34a..9c2aead 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,7 @@ IF(NOT COMPILE_SUPPORT) ADD_DEFINITIONS(-DNO_COMPILE) ENDIF() +OPTION(DEBUG_SUPPORT "Debug plugin support" ON) OPTION(FS_SUPPORT "Filesystem plugin support" ON) OPTION(MATH_SUPPORT "Math plugin support" ON) OPTION(UBUS_SUPPORT "Ubus plugin support" ON) @@ -50,7 +51,7 @@ INCLUDE(FindPkgConfig) PKG_CHECK_MODULES(JSONC REQUIRED json-c) INCLUDE_DIRECTORIES(${JSONC_INCLUDE_DIRS}) -SET(UCODE_SOURCES lexer.c lib.c vm.c chunk.c vallist.c compiler.c source.c types.c program.c) +SET(UCODE_SOURCES lexer.c lib.c vm.c chunk.c vallist.c compiler.c source.c types.c program.c platform.c) ADD_LIBRARY(libucode SHARED ${UCODE_SOURCES}) SET(SOVERSION 0 CACHE STRING "Override ucode library version") SET_TARGET_PROPERTIES(libucode PROPERTIES OUTPUT_NAME ucode SOVERSION ${SOVERSION}) @@ -89,6 +90,20 @@ UNSET(CMAKE_REQUIRED_LIBRARIES) SET(LIBRARIES "") +IF(DEBUG_SUPPORT) + SET(LIBRARIES ${LIBRARIES} debug_lib) + ADD_LIBRARY(debug_lib MODULE lib/debug.c) + SET_TARGET_PROPERTIES(debug_lib PROPERTIES OUTPUT_NAME debug PREFIX "") + TARGET_LINK_OPTIONS(debug_lib PRIVATE ${UCODE_MODULE_LINK_OPTIONS}) + FIND_LIBRARY(ubox NAMES ubox) + IF(ubox) + FIND_PATH(uloop_include_dir NAMES libubox/uloop.h) + INCLUDE_DIRECTORIES(${uloop_include_dir}) + TARGET_LINK_LIBRARIES(debug_lib ${ubox} ${libucode}) + SET_TARGET_PROPERTIES(debug_lib PROPERTIES COMPILE_DEFINITIONS HAVE_ULOOP) + ENDIF() +ENDIF() + IF(FS_SUPPORT) SET(LIBRARIES ${LIBRARIES} fs_lib) ADD_LIBRARY(fs_lib MODULE lib/fs.c) diff --git a/include/endian.h b/include/endian.h deleted file mode 100644 index 198cf7c..0000000 --- a/include/endian.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifdef __APPLE__ - -# include <machine/endian.h> -# include <libkern/OSByteOrder.h> - -# define htobe16(x) OSSwapHostToBigInt16(x) -# define htole16(x) OSSwapHostToLittleInt16(x) -# define be16toh(x) OSSwapBigToHostInt16(x) -# define le16toh(x) OSSwapLittleToHostInt16(x) - -# define htobe32(x) OSSwapHostToBigInt32(x) -# define htole32(x) OSSwapHostToLittleInt32(x) -# define be32toh(x) OSSwapBigToHostInt32(x) -# define le32toh(x) OSSwapLittleToHostInt32(x) - -# define htobe64(x) OSSwapHostToBigInt64(x) -# define htole64(x) OSSwapHostToLittleInt64(x) -# define be64toh(x) OSSwapBigToHostInt64(x) -# define le64toh(x) OSSwapLittleToHostInt64(x) - -#else -# include_next <endian.h> -#endif diff --git a/include/ucode/chunk.h b/include/ucode/chunk.h index a5f0b1c..1e6ab1f 100644 --- a/include/ucode/chunk.h +++ b/include/ucode/chunk.h @@ -30,8 +30,8 @@ __hidden size_t uc_chunk_add(uc_chunk_t *chunk, uint8_t byte, size_t line); __hidden void uc_chunk_pop(uc_chunk_t *chunk); -__hidden size_t uc_chunk_debug_get_srcpos(uc_chunk_t *chunk, size_t off); +size_t uc_chunk_debug_get_srcpos(uc_chunk_t *chunk, size_t offset); __hidden void uc_chunk_debug_add_variable(uc_chunk_t *chunk, size_t from, size_t to, size_t slot, bool upval, uc_value_t *name); -__hidden uc_value_t *uc_chunk_debug_get_variable(uc_chunk_t *chunk, size_t off, size_t slot, bool upval); +uc_value_t *uc_chunk_debug_get_variable(uc_chunk_t *chunk, size_t offset, size_t slot, bool upval); #endif /* UCODE_CHUNK_H */ diff --git a/include/ucode/lib.h b/include/ucode/lib.h index 74d8866..cf5f12f 100644 --- a/include/ucode/lib.h +++ b/include/ucode/lib.h @@ -31,7 +31,7 @@ extern const uc_function_list_t uc_stdlib_functions[]; void uc_stdlib_load(uc_value_t *scope); uc_cfn_ptr_t uc_stdlib_function(const char *name); -__hidden bool uc_source_context_format(uc_stringbuf_t *buf, uc_source_t *src, size_t off, bool compact); +bool uc_source_context_format(uc_stringbuf_t *buf, uc_source_t *src, size_t off, bool compact); __hidden bool uc_error_context_format(uc_stringbuf_t *buf, uc_source_t *src, uc_value_t *stacktrace, size_t off); __hidden void uc_error_message_indent(char **msg); diff --git a/include/ucode/platform.h b/include/ucode/platform.h new file mode 100644 index 0000000..52eb391 --- /dev/null +++ b/include/ucode/platform.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2023 Jo-Philipp Wich <jo@mein.io> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef UCODE_PLATFORM_H +#define UCODE_PLATFORM_H + +#include <signal.h> +#include <fcntl.h> +#include <time.h> + +#include "ucode/util.h" + +#ifdef NSIG +# define UC_SYSTEM_SIGNAL_COUNT NSIG +#else +# define UC_SYSTEM_SIGNAL_COUNT (_SIGMAX + 1) +#endif + +extern const char *uc_system_signal_names[]; + +#if defined(__linux__) +# include <endian.h> +# include <sys/sysmacros.h> +#elif defined(__APPLE__) +# include <unistd.h> +# include <crt_externs.h> +# include <machine/endian.h> +# include <libkern/OSByteOrder.h> + +# define htobe16(x) OSSwapHostToBigInt16(x) +# define htole16(x) OSSwapHostToLittleInt16(x) +# define be16toh(x) OSSwapBigToHostInt16(x) +# define le16toh(x) OSSwapLittleToHostInt16(x) + +# define htobe32(x) OSSwapHostToBigInt32(x) +# define htole32(x) OSSwapHostToLittleInt32(x) +# define be32toh(x) OSSwapBigToHostInt32(x) +# define le32toh(x) OSSwapLittleToHostInt32(x) + +# define htobe64(x) OSSwapHostToBigInt64(x) +# define htole64(x) OSSwapHostToLittleInt64(x) +# define be64toh(x) OSSwapBigToHostInt64(x) +# define le64toh(x) OSSwapLittleToHostInt64(x) + +# define environ (*_NSGetEnviron()) + +__hidden int pipe2(int[2], int); +__hidden int sigtimedwait(const sigset_t *, siginfo_t *, const struct timespec *); + +static inline int +execvpe(const char *program, char **argv, char **envp) +{ + char **saved = environ; + int rc; + + environ = envp; + rc = execvp(program, argv); + environ = saved; + + return rc; +} +#else +# error Unsupported platform +#endif + +#endif /* UCODE_PLATFORM_H */ diff --git a/include/ucode/program.h b/include/ucode/program.h index 19c8bdf..76b54b4 100644 --- a/include/ucode/program.h +++ b/include/ucode/program.h @@ -51,8 +51,8 @@ uc_program_put(uc_program_t *prog) { __hidden uc_function_t *uc_program_function_new(uc_program_t *, const char *, uc_source_t *, size_t); __hidden size_t uc_program_function_id(uc_program_t *, uc_function_t *); __hidden uc_function_t *uc_program_function_load(uc_program_t *, size_t); -__hidden uc_source_t *uc_program_function_source(uc_function_t *); -__hidden size_t uc_program_function_srcpos(uc_function_t *, size_t); +uc_source_t *uc_program_function_source(uc_function_t *); +size_t uc_program_function_srcpos(uc_function_t *, size_t); __hidden void uc_program_function_free(uc_function_t *); __hidden uc_value_t *uc_program_get_constant(uc_program_t *, size_t); diff --git a/include/ucode/source.h b/include/ucode/source.h index e1fd211..92011d8 100644 --- a/include/ucode/source.h +++ b/include/ucode/source.h @@ -35,7 +35,7 @@ typedef enum { uc_source_t *uc_source_new_file(const char *path); uc_source_t *uc_source_new_buffer(const char *name, char *buf, size_t len); -__hidden size_t uc_source_get_line(uc_source_t *source, size_t *offset); +size_t uc_source_get_line(uc_source_t *source, size_t *offset); static inline uc_source_t * uc_source_get(uc_source_t *source) { diff --git a/include/ucode/types.h b/include/ucode/types.h index 641c469..7fcc7f1 100644 --- a/include/ucode/types.h +++ b/include/ucode/types.h @@ -24,6 +24,7 @@ #include <json-c/json.h> #include "util.h" +#include "platform.h" /* Value types and generic value header */ @@ -314,7 +315,7 @@ struct uc_vm { uc_exception_handler_t *exhandler; FILE *output; struct { - uint64_t raised[((NSIG + 63) & ~63) / 64]; + uint64_t raised[((UC_SYSTEM_SIGNAL_COUNT + 63) & ~63) / 64]; uc_value_t *handler; struct sigaction sa; int sigpipe[2]; @@ -23,11 +23,11 @@ #include <regex.h> #include <math.h> #include <errno.h> -#include <endian.h> #include "ucode/vm.h" #include "ucode/lib.h" #include "ucode/lexer.h" +#include "ucode/platform.h" struct keyword { unsigned type; @@ -50,6 +50,7 @@ #include "ucode/lib.h" #include "ucode/source.h" #include "ucode/program.h" +#include "ucode/platform.h" static void format_context_line(uc_stringbuf_t *buf, const char *line, size_t off, bool compact) @@ -3734,107 +3735,6 @@ uc_warn(uc_vm_t *vm, size_t nargs) return uc_print_common(vm, nargs, stderr); } -#ifdef __APPLE__ -/* - * sigtimedwait() implementation based on - * https://comp.unix.programmer.narkive.com/rEDH0sPT/sigtimedwait-implementation - * and - * https://github.com/wahern/lunix/blob/master/src/unix.c - */ -static void -sigtimedwait_consume_signal(int signo) -{ -} - -static int -sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout) -{ - struct timespec elapsed = { 0, 0 }, sleep, rem; - sigset_t pending, unblock, omask; - struct sigaction sa, osa; - int signo; - bool lt; - - while (true) { - sigemptyset(&pending); - sigpending(&pending); - - for (signo = 1; signo < NSIG; signo++) { - if (!sigismember(set, signo) || !sigismember(&pending, signo)) - continue; - - sa.sa_handler = sigtimedwait_consume_signal; - sa.sa_flags = 0; - sigfillset(&sa.sa_mask); - - sigaction(signo, &sa, &osa); - - sigemptyset(&unblock); - sigaddset(&unblock, signo); - sigprocmask(SIG_UNBLOCK, &unblock, &omask); - sigprocmask(SIG_SETMASK, &omask, NULL); - - sigaction(signo, &osa, NULL); - - if (info) { - memset(info, 0, sizeof(*info)); - info->si_signo = signo; - } - - return signo; - } - - sleep.tv_sec = 0; - sleep.tv_nsec = 200000000L; /* 2/10th second */ - rem = sleep; - - if (nanosleep(&sleep, &rem) == 0) { - elapsed.tv_sec += sleep.tv_sec; - elapsed.tv_nsec += sleep.tv_nsec; - - if (elapsed.tv_nsec > 1000000000) { - elapsed.tv_sec++; - elapsed.tv_nsec -= 1000000000; - } - } - else if (errno == EINTR) { - sleep.tv_sec -= rem.tv_sec; - sleep.tv_nsec -= rem.tv_nsec; - - if (sleep.tv_nsec < 0) { - sleep.tv_sec--; - sleep.tv_nsec += 1000000000; - } - - elapsed.tv_sec += sleep.tv_sec; - elapsed.tv_nsec += sleep.tv_nsec; - - if (elapsed.tv_nsec > 1000000000) { - elapsed.tv_sec++; - elapsed.tv_nsec -= 1000000000; - } - } - else { - return errno; - } - - lt = timeout - ? ((elapsed.tv_sec == timeout->tv_sec) - ? (elapsed.tv_nsec < timeout->tv_nsec) - : (elapsed.tv_sec < timeout->tv_sec)) - : true; - - if (!lt) - break; - } - - errno = EAGAIN; - - return -1; -} - -#endif - /** * Executes the given command, waits for completion, and returns the resulting * exit code. @@ -5501,7 +5401,6 @@ uc_loadstring(uc_vm_t *vm, size_t nargs) * @example * loadfile("./templates/example.uc"); // function main() { ... } */ - static uc_value_t * uc_loadfile(uc_vm_t *vm, size_t nargs) { @@ -5646,100 +5545,6 @@ uc_callfunc(uc_vm_t *vm, size_t nargs) return res; } - -static const char *signal_names[] = { -#if defined(SIGINT) - [SIGINT] = "INT", -#endif -#if defined(SIGILL) - [SIGILL] = "ILL", -#endif -#if defined(SIGABRT) - [SIGABRT] = "ABRT", -#endif -#if defined(SIGFPE) - [SIGFPE] = "FPE", -#endif -#if defined(SIGSEGV) - [SIGSEGV] = "SEGV", -#endif -#if defined(SIGTERM) - [SIGTERM] = "TERM", -#endif -#if defined(SIGHUP) - [SIGHUP] = "HUP", -#endif -#if defined(SIGQUIT) - [SIGQUIT] = "QUIT", -#endif -#if defined(SIGTRAP) - [SIGTRAP] = "TRAP", -#endif -#if defined(SIGKILL) - [SIGKILL] = "KILL", -#endif -#if defined(SIGPIPE) - [SIGPIPE] = "PIPE", -#endif -#if defined(SIGALRM) - [SIGALRM] = "ALRM", -#endif -#if defined(SIGSTKFLT) - [SIGSTKFLT] = "STKFLT", -#endif -#if defined(SIGPWR) - [SIGPWR] = "PWR", -#endif -#if defined(SIGBUS) - [SIGBUS] = "BUS", -#endif -#if defined(SIGSYS) - [SIGSYS] = "SYS", -#endif -#if defined(SIGURG) - [SIGURG] = "URG", -#endif -#if defined(SIGSTOP) - [SIGSTOP] = "STOP", -#endif -#if defined(SIGTSTP) - [SIGTSTP] = "TSTP", -#endif -#if defined(SIGCONT) - [SIGCONT] = "CONT", -#endif -#if defined(SIGCHLD) - [SIGCHLD] = "CHLD", -#endif -#if defined(SIGTTIN) - [SIGTTIN] = "TTIN", -#endif -#if defined(SIGTTOU) - [SIGTTOU] = "TTOU", -#endif -#if defined(SIGPOLL) - [SIGPOLL] = "POLL", -#endif -#if defined(SIGXFSZ) - [SIGXFSZ] = "XFSZ", -#endif -#if defined(SIGXCPU) - [SIGXCPU] = "XCPU", -#endif -#if defined(SIGVTALRM) - [SIGVTALRM] = "VTALRM", -#endif -#if defined(SIGPROF) - [SIGPROF] = "PROF", -#endif -#if defined(SIGUSR1) - [SIGUSR1] = "USR1", -#endif -#if defined(SIGUSR2) - [SIGUSR2] = "USR2", -#endif -}; - /** * Set or query process signal handler function. * @@ -5822,7 +5627,10 @@ uc_signal(uc_vm_t *vm, size_t nargs) if (ucv_type(signame) == UC_INTEGER) { sig = (int)ucv_int64_get(signame); - if (errno || sig >= (int)ARRAY_SIZE(signal_names) || !signal_names[sig]) + if (errno || sig < 0 || sig >= UC_SYSTEM_SIGNAL_COUNT) + return NULL; + + if (!uc_system_signal_names[sig]) return NULL; } else if (ucv_type(signame) == UC_STRING) { @@ -5831,11 +5639,12 @@ uc_signal(uc_vm_t *vm, size_t nargs) if (!strncasecmp(sigstr, "SIG", 3)) sigstr += 3; - for (sig = 0; sig < (int)ARRAY_SIZE(signal_names); sig++) - if (signal_names[sig] && !strcasecmp(signal_names[sig], sigstr)) + for (sig = 0; sig < UC_SYSTEM_SIGNAL_COUNT; sig++) + if (uc_system_signal_names[sig] && + !strcasecmp(uc_system_signal_names[sig], sigstr)) break; - if (sig == (int)ARRAY_SIZE(signal_names)) + if (sig == UC_SYSTEM_SIGNAL_COUNT) return NULL; } else { diff --git a/lib/debug.c b/lib/debug.c new file mode 100644 index 0000000..de2711b --- /dev/null +++ b/lib/debug.c @@ -0,0 +1,1631 @@ +/* + * Copyright (C) 2023 Jo-Philipp Wich <jo@mein.io> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * This module provides runtime debug functionality for ucode scripts. + * + * Functions can be individually imported and directly accessed using the + * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#named_import named import} + * syntax: + * + * ``` + * import { memdump, traceback } from 'debug'; + * + * let stacktrace = traceback(1); + * + * memdump("/tmp/dump.txt"); + * ``` + * + * Alternatively, the module namespace can be imported + * using a wildcard import statement: + * + * ``` + * import * as debug from 'debug'; + * + * let stacktrace = debug.traceback(1); + * + * debug.memdump("/tmp/dump.txt"); + * ``` + * + * Additionally, the debug module namespace may also be imported by invoking the + * `ucode` interpreter with the `-ldebug` switch. + * + * Upon loading, the `debug` module will register a `SIGUSR2` signal handler + * which, upon receipt of the signal, will write a memory dump of the currently + * running program to `/tmp/ucode.$timestamp.$pid.memdump`. This default + * behavior can be inhibited by setting the `UCODE_DEBUG_MEMDUMP_ENABLED` + * environment variable to `0` when starting the process. The memory dump signal + * and output directory can be overridden with the `UCODE_DEBUG_MEMDUMP_SIGNAL` + * and `UCODE_DEBUG_MEMDUMP_PATH` environment variables respectively. + * + * @module debug + */ + +#include <stdio.h> +#include <stdlib.h> +#include <assert.h> +#include <unistd.h> +#include <errno.h> + +#ifdef HAVE_ULOOP +#include <libubox/uloop.h> +#endif + +#include <json-c/printbuf.h> +#include <json-c/linkhash.h> + +#include "ucode/module.h" +#include "ucode/platform.h" + + +static char *memdump_signal = "USR2"; +static char *memdump_directory = "/tmp"; + +struct memdump_walk_ctx { + FILE *out; + uc_closure_t *current_closure; + struct lh_table *seen; +}; + +static uc_callframe_t * +debuginfo_stackslot_to_callframe(uc_vm_t *vm, size_t slot) +{ + size_t stackframe, i; + + for (i = vm->callframes.count; i > 0; i--) { + stackframe = vm->callframes.entries[i - 1].stackframe; + + if (vm->callframes.entries[i - 1].mcall) + stackframe--; + + if (stackframe <= slot) + return &vm->callframes.entries[i - 1]; + } + + return NULL; +} + +static void +uc_debug_discover_ucv(uc_value_t *uv, struct lh_table *seen); + +static void +uc_debug_discover_ucv(uc_value_t *uv, struct lh_table *seen) +{ + uc_function_t *function; + uc_closure_t *closure; + uc_upvalref_t *upval; + uc_object_t *object; + uc_array_t *array; + uc_resource_t *resource; + uc_program_t *program; + struct lh_entry *entry; + unsigned long hash; + size_t i; + + hash = lh_get_hash(seen, uv); + + if (ucv_is_scalar(uv)) + return; + + if (lh_table_lookup_entry_w_hash(seen, uv, hash)) + return; + + lh_table_insert_w_hash(seen, uv, NULL, hash, 0); + + switch (ucv_type(uv)) { + case UC_ARRAY: + array = (uc_array_t *)uv; + + uc_debug_discover_ucv(array->proto, seen); + + for (i = 0; i < array->count; i++) + uc_debug_discover_ucv(array->entries[i], seen); + + break; + + case UC_OBJECT: + object = (uc_object_t *)uv; + + uc_debug_discover_ucv(object->proto, seen); + + lh_foreach(object->table, entry) + uc_debug_discover_ucv((uc_value_t *)lh_entry_v(entry), seen); + + break; + + case UC_CLOSURE: + closure = (uc_closure_t *)uv; + function = closure->function; + + for (i = 0; i < function->nupvals; i++) + uc_debug_discover_ucv(&closure->upvals[i]->header, seen); + + uc_debug_discover_ucv(&function->program->header, seen); + + break; + + case UC_UPVALUE: + upval = (uc_upvalref_t *)uv; + uc_debug_discover_ucv(upval->value, seen); + break; + + case UC_RESOURCE: + resource = (uc_resource_t *)uv; + + if (resource->type) + uc_debug_discover_ucv(resource->type->proto, seen); + + break; + + case UC_PROGRAM: + program = (uc_program_t *)uv; + + for (i = 0; i < program->sources.count; i++) + uc_debug_discover_ucv(&program->sources.entries[i]->header, seen); + + for (i = 0; i < program->exports.count; i++) + uc_debug_discover_ucv(&program->exports.entries[i]->header, seen); + + break; + + default: + break; + } +} + +static void +print_value(FILE *out, size_t pad, struct lh_table *seen, + uc_vm_t *vm, uc_value_t *uv); + +static void +print_value(FILE *out, size_t pad, struct lh_table *seen, + uc_vm_t *vm, uc_value_t *uv) +{ + uc_resource_t *resource; + uc_closure_t *closure; + uc_object_t *object; + uc_array_t *array; + size_t i, j; + char *s; + + fprintf(out, "%s", ucv_typename(uv)); + + if (!uv) { + fprintf(out, "\n"); + + return; + } + + if (!ucv_is_scalar(uv)) + fprintf(out, "; %" PRIu32 " refs", uv->refcount); + + if (!lh_table_lookup_entry(seen, uv)) + fprintf(out, "; unreachable"); + + if (ucv_is_constant(uv)) + fprintf(out, "; constant"); + + fprintf(out, "\n"); + + for (j = 0; j < pad + 1; j++) + fprintf(out, " "); + + s = ucv_to_string(NULL, uv); + fprintf(out, "#value = %s\n", s); + free(s); + + if (ucv_type(uv) == UC_CLOSURE) { + closure = (uc_closure_t *)uv; + + for (i = 0; i < closure->function->nupvals; i++) { + for (j = 0; j < pad + 1; j++) + fprintf(out, " "); + + fprintf(out, "#upvalue[%zu] ", i); + + if (closure->upvals[i]->closed) { + fprintf(out, "closed; "); + print_value(out, pad + 1, seen, vm, closure->upvals[i]->value); + } + else { + fprintf(out, "open; stack slot %zu\n", + closure->upvals[i]->slot); + } + } + } + else if (ucv_type(uv) == UC_OBJECT) { + object = (uc_object_t *)uv; + + if (object->proto) { + for (j = 0; j < pad + 1; j++) + fprintf(out, " "); + + fprintf(out, "#prototype = "); + print_value(out, pad + 1, seen, vm, object->proto); + } + } + else if (ucv_type(uv) == UC_ARRAY) { + array = (uc_array_t *)uv; + + if (array->proto) { + for (j = 0; j < pad + 1; j++) + fprintf(out, " "); + + fprintf(out, "#prototype = "); + print_value(out, pad + 1, seen, vm, array->proto); + } + } + else if (ucv_type(uv) == UC_RESOURCE) { + resource = (uc_resource_t *)uv; + + if (resource->type) { + for (j = 0; j < pad + 1; j++) + fprintf(out, " "); + + fprintf(out, "#type %s\n", resource->type->name); + + if (resource->type->proto) { + for (j = 0; j < pad + 2; j++) + fprintf(out, " "); + + fprintf(out, "#prototype = "); + print_value(out, pad + 2, seen, vm, resource->type->proto); + } + } + } +} + +static size_t +insnoff_to_srcpos(uc_function_t *function, size_t *insnoff) +{ + size_t byteoff, lineno; + uc_source_t *source; + + source = uc_program_function_source(function); + byteoff = uc_program_function_srcpos(function, *insnoff); + lineno = uc_source_get_line(source, &byteoff); + + *insnoff = byteoff; + + return lineno; +} + +static void +print_declaration_srcpos(FILE *out, uc_callframe_t *frame, size_t off, size_t slot, bool upval) +{ + uc_function_t *function = frame->closure->function; + uc_variables_t *variables = &function->chunk.debuginfo.variables; + size_t i, line; + + assert(slot <= ((size_t)-1 / 2)); + + if (upval) + slot += (size_t)-1 / 2; + + for (i = 0; i < variables->count; i++) { + if (variables->entries[i].slot != slot || + variables->entries[i].from > off || + variables->entries[i].to < off) + continue; + + off = variables->entries[i].from; + line = insnoff_to_srcpos(function, &off); + + fprintf(out, "%s:%zu:%zu", + uc_program_function_source(function)->filename, line, off); + + return; + } + + fprintf(out, "[unknown source position]"); +} + +static void +print_function_srcpos(FILE *out, uc_closure_t *closure) +{ + size_t line, off; + + if (!closure) + return; + + off = 0; + line = insnoff_to_srcpos(closure->function, &off); + + fprintf(out, " @ %s:%zu:%zu", + uc_program_function_source(closure->function)->filename, line, off); +} + +static void +print_ip_srcpos(FILE *out, uc_callframe_t *frame) +{ + uc_function_t *function; + size_t line, off; + + if (!frame->closure) + return; + + function = frame->closure->function; + off = frame->ip - function->chunk.entries; + line = insnoff_to_srcpos(function, &off); + + fprintf(out, " @ %s:%zu:%zu", + uc_program_function_source(function)->filename, line, off); +} + +static void +print_memdump(uc_vm_t *vm, FILE *out) +{ + struct memdump_walk_ctx ctx = { 0 }; + uc_callframe_t *frame; + uc_chunk_t *chunk; + uc_weakref_t *ref; + uc_value_t *uv; + size_t i; + char *s; + + ctx.out = out; + ctx.seen = lh_kptr_table_new(16, NULL); + + if (!ctx.seen) { + fprintf(stderr, "Unable to allocate lookup table: %m\n"); + + return; + } + + fprintf(ctx.out, "STACK\n"); + + for (i = 0; i < vm->stack.count; i++) { + fprintf(ctx.out, "[%zu]", i); + + frame = debuginfo_stackslot_to_callframe(vm, i); + + if (frame) { + chunk = frame->closure ? &frame->closure->function->chunk : NULL; + uv = chunk ? uc_chunk_debug_get_variable( + chunk, + frame->ip - chunk->entries + 1, + i - frame->stackframe, + false) : NULL; + + if (uv) { + fprintf(ctx.out, " %s @ ", + ucv_string_get(uv)); + + print_declaration_srcpos(ctx.out, frame, + frame->ip - chunk->entries + 1, + i - frame->stackframe, false); + + ucv_put(uv); + } + else if (frame->mcall && i == frame->stackframe - 1) { + fprintf(ctx.out, " (this)"); + + if (frame->closure) + print_function_srcpos(ctx.out, frame->closure); + else + fprintf(ctx.out, " @ [C function \"%s\"]", + frame->cfunction->name); + } + else if (i == frame->stackframe) { + fprintf(ctx.out, " (callee)"); + + if (frame->closure) + print_function_srcpos(ctx.out, frame->closure); + else + fprintf(ctx.out, " @ [C function \"%s\"]", + frame->cfunction->name); + } + else if (i > frame->stackframe) { + fprintf(ctx.out, " (argument #%zu)", + i - frame->stackframe); + + if (frame->closure) + print_function_srcpos(ctx.out, frame->closure); + else + fprintf(ctx.out, " @ [C function \"%s\"]", + frame->cfunction->name); + } + } + + fprintf(ctx.out, "\n"); + + uc_debug_discover_ucv(vm->stack.entries[i], ctx.seen); + + s = ucv_to_string(NULL, vm->stack.entries[i]); + fprintf(ctx.out, " #value = %s\n", s); + free(s); + } + + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "CALLFRAMES\n"); + + for (i = 0; i < vm->callframes.count; i++) { + fprintf(ctx.out, "[%zu]", i); + print_ip_srcpos(ctx.out, &vm->callframes.entries[i]); + fprintf(ctx.out, "\n"); + + uc_debug_discover_ucv(vm->callframes.entries[i].ctx, + ctx.seen); + + uc_debug_discover_ucv(&vm->callframes.entries[i].closure->header, + ctx.seen); + + uc_debug_discover_ucv(&vm->callframes.entries[i].cfunction->header, + ctx.seen); + + s = ucv_to_string(NULL, vm->callframes.entries[i].ctx); + fprintf(ctx.out, " #context = %s\n", s); + free(s); + + if (vm->callframes.entries[i].closure) { + s = ucv_to_string(NULL, + &vm->callframes.entries[i].closure->header); + fprintf(ctx.out, " #closure = %s\n", s); + free(s); + } + + if (vm->callframes.entries[i].cfunction) { + s = ucv_to_string(NULL, + &vm->callframes.entries[i].cfunction->header); + + fprintf(ctx.out, " #cfunction = %s\n", s); + free(s); + } + } + + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "GLOBALS\n"); + uc_debug_discover_ucv(vm->globals, ctx.seen); + i = 0; + ucv_object_foreach(vm->globals, gk, gv) { + s = ucv_to_string(NULL, gv); + fprintf(ctx.out, "[%zu] %s\n", i++, gk); + fprintf(ctx.out, " #value = %s\n", s); + free(s); + } + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "REGISTRY\n"); + uc_debug_discover_ucv(vm->registry, ctx.seen); + i = 0; + ucv_object_foreach(vm->registry, rk, rv) { + s = ucv_to_string(NULL, rv); + fprintf(ctx.out, "[%zu] %s\n", i++, rk); + fprintf(ctx.out, " #value = %s\n", s); + free(s); + } + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "EXCEPTION\n"); + uc_debug_discover_ucv(vm->exception.stacktrace, ctx.seen); + s = ucv_to_string(NULL, vm->exception.stacktrace); + fprintf(ctx.out, "%s\n", s); + free(s); + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "RESOURCE TYPES\n"); + + for (i = 0; i < vm->restypes.count; i++) { + fprintf(ctx.out, "[%zu] %s\n", i, + vm->restypes.entries[i]->name); + + uc_debug_discover_ucv(vm->restypes.entries[i]->proto, ctx.seen); + + s = ucv_to_string(NULL, vm->restypes.entries[i]->proto); + fprintf(ctx.out, " #prototype = %s\n", s); + free(s); + } + + fprintf(ctx.out, "---\n\n"); + + fprintf(ctx.out, "OBJECT POOL\n"); + + for (ref = vm->values.next, i = 0; + ref != &vm->values; + ref = ref->next, i++) { + + uv = (uc_value_t *)((uintptr_t)ref - offsetof(uc_array_t, ref)); + + fprintf(ctx.out, "[%zu] ", i); + print_value(ctx.out, 0, ctx.seen, vm, uv); + } + + lh_table_free(ctx.seen); +} + +static uc_value_t * +debug_handle_memdump(uc_vm_t *vm, size_t nargs) +{ + char *path; + FILE *out; + + xasprintf(&path, "%s/ucode.%llu.%llu.memdump", + memdump_directory, + (long long unsigned int)time(NULL), + (long long unsigned int)getpid()); + + out = fopen(path, "w"); + + if (!out) { + fprintf(stderr, "Unable to open memdump file '%s': %m\n", path); + + return NULL; + } + + print_memdump(vm, out); + + fclose(out); + free(path); + + return NULL; +} + +#ifdef HAVE_ULOOP +/* The uloop signal handling activation has been intentionally copied from + the uloop module here to ensure that uloop signal dispatching also works + when just loading the debug module without the uloop one. */ +static struct { + struct uloop_fd ufd; + uc_vm_t *vm; +} signal_handle; + +static void +uc_uloop_signal_cb(struct uloop_fd *ufd, unsigned int events) +{ + if (uc_vm_signal_dispatch(signal_handle.vm) != EXCEPTION_NONE) + uloop_end(); +} + +static void +debug_setup_uloop(uc_vm_t *vm) +{ + int signal_fd = uc_vm_signal_notifyfd(vm); + + if (signal_fd != -1 && uloop_init() == 0) { + signal_handle.vm = vm; + signal_handle.ufd.cb = uc_uloop_signal_cb; + signal_handle.ufd.fd = signal_fd; + + uloop_fd_add(&signal_handle.ufd, ULOOP_READ); + } +} +#else +static void debug_setup_uloop(uc_vm_t *vm) {} +#endif + +static void +debug_setup_memdump(uc_vm_t *vm) +{ + uc_cfn_ptr_t ucsignal = uc_stdlib_function("signal"); + uc_value_t *memdump = ucv_cfunction_new("memdump", debug_handle_memdump); + char *ev; + + ev = getenv("UCODE_DEBUG_MEMDUMP_PATH"); + memdump_directory = ev ? ev : memdump_directory; + + ev = getenv("UCODE_DEBUG_MEMDUMP_SIGNAL"); + memdump_signal = ev ? ev : memdump_signal; + + debug_setup_uloop(vm); + + uc_vm_stack_push(vm, ucv_string_new(memdump_signal)); + uc_vm_stack_push(vm, memdump); + + if (ucsignal(vm, 2) != memdump) + fprintf(stderr, "Unable to install debug signal handler\n"); + + ucv_put(uc_vm_stack_pop(vm)); + ucv_put(uc_vm_stack_pop(vm)); +} + +static void +debug_setup(uc_vm_t *vm) +{ + char *ev; + + ev = getenv("UCODE_DEBUG_MEMDUMP_ENABLED"); + + if (!ev || !strcmp(ev, "1") || !strcmp(ev, "yes") || !strcmp(ev, "true")) + debug_setup_memdump(vm); +} + + +/** + * Write a memory dump report to the given file. + * + * This function generates a human readable memory dump of ucode values + * currently managed by the running VM which is useful to track down logical + * memory leaks in scripts. + * + * The file parameter can be either a string value containing a file path, in + * which case this function tries to create and write the report file at the + * given location, or an already open file handle this function should write to. + * + * Returns `true` if the report has been written. + * + * Returns `null` if the file could not be opened or if the handle was invalid. + * + * @function module:debug#memdump + * + * @param {string|module:fs.file|module:fs.proc} file + * The file path or open file handle to write report to. + * + * @return {boolean|null} + */ +static uc_value_t * +uc_memdump(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *file = uc_fn_arg(0); + FILE *fp = NULL; + + if (ucv_type(file) == UC_RESOURCE) { + fp = ucv_resource_data(file, "fs.file"); + + if (!fp) + fp = ucv_resource_data(file, "fs.proc"); + } + else if (ucv_type(file) == UC_STRING) { + fp = fopen(ucv_string_get(file), "w"); + } + + if (!fp) + return NULL; + + print_memdump(vm, fp); + + return ucv_boolean_new(true); +} + +/** + * Capture call stack trace. + * + * This function captures the current call stack and returns it. The optional + * level parameter controls how many calls up the trace should start. It + * defaults to `1`, that is the function calling this `traceback()` function. + * + * Returns an array of stack trace entries describing the function invocations + * up to the point where `traceback()` is called. + * + * @function module:debug#traceback + * + * @param {number} [level=1] + * The number of callframes up the call trace should start, `0` is this function + * itself, `1` the function calling it and so on. + * + * @return {module:debug.StackTraceEntry[]} + */ + +/** + * @typedef {Object} module:debug.StackTraceEntry + * + * @property {function} callee + * The function that was called. + * + * @property {*} this + * The `this` context the function was called with. + * + * @property {boolean} mcall + * Indicates whether the function was invoked as a method. + * + * @property {boolean} [strict] + * Indicates whether the VM was running in strict mode when the function was + * called (only applicable to non-C, pure ucode calls). + * + * @property {string} [filename] + * The name of the source file that called the function (only applicable to + * non-C, pure ucode calls). + * + * @property {number} [line] + * The source line of the function call (only applicable to non-C, pure ucode + * calls). + * + * @property {number} [byte] + * The source line offset of the function call (only applicable to non-C, pure + * ucode calls). + * + * @property {string} [context] + * The surrounding source code context formatted as human-readable string, + * useful for generating debug messages (only applicable to non-C, pure ucode + * calls). + */ + +static uc_value_t * +uc_traceback(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *stacktrace, *entry, *level = uc_fn_arg(0); + uc_function_t *function; + uc_stringbuf_t *context; + uc_callframe_t *frame; + uc_source_t *source; + size_t off, srcpos; + size_t i, lv; + + lv = level ? ucv_uint64_get(level) : 1; + + if (level && errno) + return NULL; + + stacktrace = ucv_array_new(vm); + + for (i = (lv < vm->callframes.count) ? vm->callframes.count - lv : 0; + i > 0; + i--) { + + frame = &vm->callframes.entries[i - 1]; + entry = ucv_object_new(vm); + + if (frame->closure) { + function = frame->closure->function; + source = uc_program_function_source(function); + + off = (frame->ip - function->chunk.entries) - 1; + srcpos = uc_program_function_srcpos(function, off); + + context = ucv_stringbuf_new(); + + uc_source_context_format(context, + uc_program_function_source(function), + srcpos, false); + + ucv_object_add(entry, "callee", ucv_get(&frame->closure->header)); + ucv_object_add(entry, "this", ucv_get(frame->ctx)); + ucv_object_add(entry, "mcall", ucv_boolean_new(frame->mcall)); + ucv_object_add(entry, "strict", ucv_boolean_new(frame->strict)); + ucv_object_add(entry, "filename", ucv_string_new(source->filename)); + ucv_object_add(entry, "line", ucv_int64_new(uc_source_get_line(source, &srcpos))); + ucv_object_add(entry, "byte", ucv_int64_new(srcpos)); + ucv_object_add(entry, "context", ucv_stringbuf_finish(context)); + } + else if (frame->cfunction) { + ucv_object_add(entry, "callee", ucv_get(&frame->cfunction->header)); + ucv_object_add(entry, "this", ucv_get(frame->ctx)); + ucv_object_add(entry, "mcall", ucv_boolean_new(frame->mcall)); + } + + ucv_array_push(stacktrace, entry); + } + + return stacktrace; +} + +/** + * Obtain information about the current source position. + * + * The `sourcepos()` function determines the source code position of the + * current instruction invoking this function. + * + * Returns a dictionary containing the filename, line number and line byte + * offset of the call site. + * + * Returns `null` if this function was invoked from C code. + * + * @function module:debug#sourcepos + * + * @return {module:debug.SourcePosition|null} + */ + +/** + * @typedef {Object} module:debug.SourcePosition + * + * @property {string} filename + * The name of the source file that called this function. + * + * @property {number} line + * The source line of the function call. + * + * @property {number} byte + * The source line offset of the function call. + */ + +static uc_value_t * +uc_sourcepos(uc_vm_t *vm, size_t nargs) +{ + uc_function_t *function; + uc_callframe_t *frame; + uc_source_t *source; + uc_value_t *rv; + size_t byte; + + if (vm->callframes.count < 2) + return NULL; + + frame = &vm->callframes.entries[vm->callframes.count - 2]; + + if (!frame->closure) + return NULL; + + function = frame->closure->function; + source = uc_program_function_source(function); + byte = uc_program_function_srcpos(function, + (frame->ip - function->chunk.entries) - 1); + + rv = ucv_object_new(vm); + + ucv_object_add(rv, "filename", ucv_string_new(source->filename)); + ucv_object_add(rv, "line", ucv_int64_new(uc_source_get_line(source, &byte))); + ucv_object_add(rv, "byte", ucv_int64_new(byte)); + + return rv; +} + +static uc_value_t * +uc_getinfo_fnargs(uc_vm_t *vm, uc_function_t *function) +{ + uc_value_t *rv = NULL, *name; + size_t i; + + for (i = 0; i < function->nargs; i++) { + name = uc_chunk_debug_get_variable(&function->chunk, i, i + 1, false); + + if (!name) + continue; + + if (!rv) + rv = ucv_array_new_length(vm, function->nargs); + + ucv_array_push(rv, name); + } + + return rv; +} + +/** + * @typedef {Object} module:debug.UpvalRef + * + * @property {string} name + * The name of the captured variable. + * + * @property {boolean} closed + * Indicates whether the captured variable (upvalue) is closed or not. A closed + * upvalue means that the function value outlived the declaration scope of the + * captured variable. + * + * @property {*} value + * The current value of the captured variable. + * + * @property {number} [slot] + * The stack slot of the captured variable. Only applicable to open (non-closed) + * captured variables. + */ +static uc_value_t * +uc_getinfo_upvals(uc_vm_t *vm, uc_closure_t *closure) +{ + uc_function_t *function = closure->function; + uc_upvalref_t **upvals = closure->upvals; + uc_value_t *rv = NULL, *up, *name; + size_t i; + + for (i = 0; i < function->nupvals; i++) { + up = ucv_object_new(vm); + name = uc_chunk_debug_get_variable(&function->chunk, 0, i, true); + + if (name) + ucv_object_add(up, "name", name); + + if (upvals[i]->closed) { + ucv_object_add(up, "closed", ucv_boolean_new(true)); + ucv_object_add(up, "value", ucv_get(upvals[i]->value)); + } + else { + ucv_object_add(up, "closed", ucv_boolean_new(false)); + ucv_object_add(up, "slot", ucv_uint64_new(upvals[i]->slot)); + ucv_object_add(up, "value", + ucv_get(vm->stack.entries[upvals[i]->slot])); + } + + if (!rv) + rv = ucv_array_new_length(vm, function->nupvals); + + ucv_array_push(rv, up); + } + + return rv; +} + +/** + * Obtain information about the given value. + * + * The `getinfo()` function allows querying internal information about the + * given ucode value, such as the current reference count, the mark bit state + * etc. + * + * Returns a dictionary with value type specific details. + * + * Returns `null` if a `null` value was provided. + * + * @function module:debug#getinfo + * + * @param {*} value + * The value to query information for. + * + * @return {module:debug.ValueInformation|null} + */ + +/** + * @typedef {Object} module:debug.ValueInformation + * + * @property {string} type + * The name of the value type, one of `integer`, `boolean`, `string`, `double`, + * `array`, `object`, `regexp`, `cfunction`, `closure`, `upvalue` or `resource`. + * + * @property {*} value + * The value itself. + * + * @property {boolean} tagged + * Indicates whether the given value is internally stored as tagged pointer + * without an additional heap allocation. + * + * @property {boolean} [mark] + * Indicates whether the value has it's mark bit set, which is used for loop + * detection during recursive object traversal on garbage collection cycles or + * complex value stringification. Only applicable to non-tagged values. + * + * @property {number} [refcount] + * The current reference count of the value. Note that the `getinfo()` function + * places a reference to the value into the `value` field of the resulting + * information dictionary, so the ref count will always be at least 2 - one + * reference for the function call argument and one for the value property in + * the result dictionary. Only applicable to non-tagged values. + * + * @property {boolean} [unsigned] + * Whether the number value is internally stored as unsigned integer. Only + * applicable to non-tagged integer values. + * + * @property {number} [address] + * The address of the underlying C heap memory. Only applicable to non-tagged + * `string`, `array`, `object`, `cfunction` or `resource` values. + * + * @property {number} [length] + * The length of the underlying string memory. Only applicable to non-tagged + * `string` values. + * + * @property {number} [count] + * The amount of elements in the underlying memory structure. Only applicable to + * `array` and `object` values. + * + * @property {boolean} [constant] + * Indicates whether the value is constant (immutable). Only applicable to + * `array` and `object` values. + * + * @property {*} [prototype] + * The associated prototype value, if any. Only applicable to `array`, `object` + * and `prototype` values. + * + * @property {string} [source] + * The original regex source pattern. Only applicable to `regexp` values. + * + * @property {boolean} [icase] + * Whether the compiled regex has the `i` (ignore case) flag set. Only + * applicable to `regexp` values. + * + * @property {boolean} [global] + * Whether the compiled regex has the `g` (global) flag set. Only applicable to + * `regexp` values. + * + * @property {boolean} [newline] + * Whether the compiled regex has the `s` (single line) flag set. Only + * applicable to `regexp` values. + * + * @property {number} [nsub] + * The amount of capture groups within the regular expression. Only applicable + * to `regexp` values. + * + * @property {string} [name] + * The name of the non-anonymous function. Only applicable to `cfunction` and + * `closure` values. Set to `null` for anonymous function values. + * + * @property {boolean} [arrow] + * Indicates whether the ucode function value is an arrow function. Only + * applicable to `closure` values. + * + * @property {boolean} [module] + * Indicates whether the ucode function value is a module entry point. Only + * applicable to `closure` values. + * + * @property {boolean} [strict] + * Indicates whether the function body will be executed in strict mode. Only + * applicable to `closure` values. + * + * @property {boolean} [vararg] + * Indicates whether the ucode function takes a variable number of arguments. + * Only applicable to `closure` values. + * + * @property {number} [nargs] + * The number of arguments expected by the ucode function, excluding a potential + * final variable argument ellipsis. Only applicable to `closure` values. + * + * @property {string[]} [argnames] + * The names of the function arguments in their declaration order. Only + * applicable to `closure` values. + * + * @property {number} [nupvals] + * The number of upvalues associated with the ucode function. Only applicable to + * `closure` values. + * + * @property {module:debug.UpvalRef[]} [upvals] + * An array of upvalue information objects. Only applicable to `closure` values. + * + * @property {string} [filename] + * The path of the source file the function was declared in. Only applicable to + * `closure` values. + * + * @property {number} [line] + * The source line number the function was declared at. Only applicable to + * `closure` values. + * + * @property {number} [byte] + * The source line offset the function was declared at. Only applicable to + * `closure` values. + * + * @property {string} [type] + * The resource type name. Only applicable to `resource` values. + */ + +static uc_value_t * +uc_getinfo(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *uv = uc_fn_arg(0), *rv; + uintptr_t pv = (uintptr_t)uv; + uc_cfunction_t *uvcfn; + uc_resource_t *uvres; + uc_closure_t *uvfun; + uc_source_t *source; + uc_regexp_t *uvreg; + uc_string_t *uvstr; + uc_object_t *uvobj; + uc_array_t *uvarr; + size_t byte; + + if (!uv) + return NULL; + + rv = ucv_object_new(vm); + + ucv_object_add(rv, "type", ucv_string_new(ucv_typename(uv))); + ucv_object_add(rv, "value", ucv_get(uv)); + + if (pv & 3) { + ucv_object_add(rv, "tagged", ucv_boolean_new(true)); + } + else { + ucv_object_add(rv, "tagged", ucv_boolean_new(false)); + ucv_object_add(rv, "mark", ucv_boolean_new(uv->mark)); + ucv_object_add(rv, "refcount", ucv_uint64_new(uv->refcount)); + } + + switch (ucv_type(uv)) { + case UC_INTEGER: + ucv_object_add(rv, "unsigned", + ucv_boolean_new(!(pv & 3) && uv->u64_or_constant)); + + break; + + case UC_STRING: + if (pv & 3) { + uvstr = (uc_string_t *)uv; + + ucv_object_add(rv, "address", + ucv_uint64_new((uintptr_t)uvstr->str)); + + ucv_object_add(rv, "length", ucv_uint64_new(uvstr->length)); + } + + break; + + case UC_ARRAY: + uvarr = (uc_array_t *)uv; + + ucv_object_add(rv, "address", + ucv_uint64_new((uintptr_t)uvarr->entries)); + + ucv_object_add(rv, "count", ucv_uint64_new(uvarr->count)); + ucv_object_add(rv, "constant", ucv_boolean_new(uv->u64_or_constant)); + ucv_object_add(rv, "prototype", ucv_get(uvarr->proto)); + + break; + + case UC_OBJECT: + uvobj = (uc_object_t *)uv; + + ucv_object_add(rv, "address", + ucv_uint64_new((uintptr_t)uvobj->table)); + + ucv_object_add(rv, "count", + ucv_uint64_new(lh_table_length(uvobj->table))); + + ucv_object_add(rv, "constant", ucv_boolean_new(uv->u64_or_constant)); + ucv_object_add(rv, "prototype", ucv_get(uvobj->proto)); + + break; + + case UC_REGEXP: + uvreg = (uc_regexp_t *)uv; + + ucv_object_add(rv, "source", ucv_string_new(uvreg->source)); + ucv_object_add(rv, "icase", ucv_boolean_new(uvreg->icase)); + ucv_object_add(rv, "global", ucv_boolean_new(uvreg->global)); + ucv_object_add(rv, "newline", ucv_boolean_new(uvreg->newline)); + ucv_object_add(rv, "nsub", ucv_uint64_new(uvreg->regexp.re_nsub)); + + break; + + case UC_CFUNCTION: + uvcfn = (uc_cfunction_t *)uv; + + ucv_object_add(rv, "name", ucv_string_new(uvcfn->name)); + ucv_object_add(rv, "address", ucv_uint64_new((uintptr_t)uvcfn->cfn)); + + break; + + case UC_CLOSURE: + uvfun = (uc_closure_t *)uv; + byte = uvfun->function->srcpos; + source = uc_program_function_source(uvfun->function); + + ucv_object_add(rv, "name", ucv_string_new(uvfun->function->name)); + ucv_object_add(rv, "arrow", ucv_boolean_new(uvfun->function->arrow)); + ucv_object_add(rv, "module", ucv_boolean_new(uvfun->function->module)); + ucv_object_add(rv, "strict", ucv_boolean_new(uvfun->function->strict)); + ucv_object_add(rv, "vararg", ucv_boolean_new(uvfun->function->vararg)); + ucv_object_add(rv, "nargs", ucv_uint64_new(uvfun->function->nargs)); + ucv_object_add(rv, "argnames", uc_getinfo_fnargs(vm, uvfun->function)); + ucv_object_add(rv, "nupvals", ucv_uint64_new(uvfun->function->nupvals)); + ucv_object_add(rv, "upvals", uc_getinfo_upvals(vm, uvfun)); + ucv_object_add(rv, "filename", ucv_string_new(source->filename)); + ucv_object_add(rv, "line", ucv_int64_new(uc_source_get_line(source, &byte))); + ucv_object_add(rv, "byte", ucv_int64_new(byte)); + + break; + + case UC_RESOURCE: + uvres = (uc_resource_t *)uv; + + ucv_object_add(rv, "address", ucv_uint64_new((uintptr_t)uvres->data)); + + if (uvres->type) { + ucv_object_add(rv, "type", ucv_string_new(uvres->type->name)); + ucv_object_add(rv, "prototype", ucv_get(uvres->type->proto)); + } + + break; + + default: + break; + } + + return rv; +} + +/** + * @typedef {Object} module:debug.LocalInfo + * + * @property {number} index + * The index of the local variable. + * + * @property {string} name + * The name of the local variable. + * + * @property {*} value + * The current value of the local variable. + * + * @property {number} linefrom + * The source line number of the local variable declaration. + * + * @property {number} bytefrom + * The source line offset of the local variable declaration. + * + * @property {number} lineto + * The source line number where the local variable goes out of scope. + * + * @property {number} byteto + * The source line offset where the local vatiable goes out of scope. + */ +static uc_value_t * +uc_xlocal(uc_vm_t *vm, uc_value_t *level, uc_value_t *var, uc_value_t **set) +{ + size_t lv, vn, vi, i, pos, slot = 0; + uc_value_t *vname = NULL, *rv; + uc_variables_t *variables; + uc_callframe_t *frame; + uc_source_t *source; + uc_chunk_t *chunk; + + lv = level ? ucv_uint64_get(level) : 1; + + if ((level && errno) || lv >= vm->callframes.count) + return NULL; + + frame = &vm->callframes.entries[vm->callframes.count - lv - 1]; + + if (!frame->closure) + return NULL; + + source = uc_program_function_source(frame->closure->function); + chunk = &frame->closure->function->chunk; + variables = &chunk->debuginfo.variables; + + if (ucv_type(var) == UC_INTEGER) { + vn = ucv_uint64_get(var); + var = NULL; + + if (errno || vn >= variables->count) + return NULL; + } + else if (ucv_type(var) == UC_STRING) { + vn = 0; + } + else { + return NULL; + } + + pos = frame->ip - chunk->entries; + + for (i = 0, vi = 0; i < variables->count; i++) { + slot = variables->entries[i].slot; + + if (slot >= (size_t)-1 / 2) + continue; + + if (variables->entries[i].from > pos || variables->entries[i].to < pos) + continue; + + vname = uc_chunk_debug_get_variable(chunk, pos, slot, false); + + if (var ? ucv_is_equal(var, vname) : (vi == vn)) + break; + + ucv_put(vname); + vname = NULL; + vi++; + } + + if (i == variables->count) + return NULL; + + if (set) { + ucv_put(vm->stack.entries[frame->stackframe + slot]); + vm->stack.entries[frame->stackframe + slot] = ucv_get(*set); + } + + rv = ucv_object_new(vm); + + ucv_object_add(rv, "index", ucv_uint64_new(vi)); + ucv_object_add(rv, "name", vname); + ucv_object_add(rv, "value", + ucv_get(vm->stack.entries[frame->stackframe + slot])); + + pos = uc_program_function_srcpos(frame->closure->function, + variables->entries[i].from); + + ucv_object_add(rv, "linefrom", + ucv_uint64_new(uc_source_get_line(source, &pos))); + + ucv_object_add(rv, "bytefrom", + ucv_uint64_new(pos)); + + pos = uc_program_function_srcpos(frame->closure->function, + variables->entries[i].to); + + ucv_object_add(rv, "lineto", + ucv_uint64_new(uc_source_get_line(source, &pos))); + + ucv_object_add(rv, "byteto", + ucv_uint64_new(pos)); + + return rv; +} + +/** + * Obtain local variable. + * + * The `getlocal()` function retrieves information about the specified local + * variable at the given call stack depth. + * + * The call stack depth specifies the amount of levels up local variables should + * be queried. A value of `0` refers to this `getlocal()` function call itself, + * `1` to the function calling `getlocal()` and so on. + * + * The variable to query might be either specified by name or by its index with + * index numbers following the source code declaration order. + * + * Returns a dictionary holding information about the given variable. + * + * Returns `null` if the stack depth exceeds the size of the current call stack. + * + * Returns `null` if the invocation at the given stack depth is a C call. + * + * Returns `null` if the given variable name is not found or the given variable + * index is invalid. + * + * @function module:debug#getlocal + * + * @param {number} [level=1] + * The amount of call stack levels up local variables should be queried. + * + * @param {string|number} variable + * The variable index or variable name to obtain information for. + * + * @returns {module:debug.LocalInfo|null} + */ +static uc_value_t * +uc_getlocal(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *level = uc_fn_arg(0); + uc_value_t *var = uc_fn_arg(1); + + return uc_xlocal(vm, level, var, NULL); +} + +/** + * Set local variable. + * + * The `setlocal()` function manipulates the value of the specified local + * variable at the given call stack depth. + * + * The call stack depth specifies the amount of levels up local variables should + * be updated. A value of `0` refers to this `setlocal()` function call itself, + * `1` to the function calling `setlocal()` and so on. + * + * The variable to update might be either specified by name or by its index with + * index numbers following the source code declaration order. + * + * Returns a dictionary holding information about the updated variable. + * + * Returns `null` if the stack depth exceeds the size of the current call stack. + * + * Returns `null` if the invocation at the given stack depth is a C call. + * + * Returns `null` if the given variable name is not found or the given variable + * index is invalid. + * + * @function module:debug#setlocal + * + * @param {number} [level=1] + * The amount of call stack levels up local variables should be updated. + * + * @param {string|number} variable + * The variable index or variable name to update. + * + * @param {*} [value=null] + * The value to set the local variable to. + * + * @returns {module:debug.LocalInfo|null} + */ +static uc_value_t * +uc_setlocal(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *level = uc_fn_arg(0); + uc_value_t *var = uc_fn_arg(1); + uc_value_t *val = uc_fn_arg(2); + + return uc_xlocal(vm, level, var, &val); +} + + +/** + * @typedef {Object} module:debug.UpvalInfo + * + * @property {number} index + * The index of the captured variable (upvalue). + * + * @property {string} name + * The name of the captured variable. + * + * @property {boolean} closed + * Indicates whether the captured variable is closed or not. A closed upvalue + * means that the function outlived the declaration scope of the captured + * variable. + * + * @property {*} value + * The current value of the captured variable. + */ +static uc_value_t * +uc_xupval(uc_vm_t *vm, uc_value_t *target, uc_value_t *var, uc_value_t **set) +{ + uc_value_t *vname = NULL, *rv; + uc_closure_t *closure = NULL; + uc_upvalref_t *uref = NULL; + uc_chunk_t *chunk; + size_t vn, depth; + + if (ucv_type(target) == UC_INTEGER) { + depth = ucv_uint64_get(target); + + if (errno || depth >= vm->callframes.count) + return NULL; + + depth = vm->callframes.count - depth - 1; + closure = vm->callframes.entries[depth].closure; + } + else if (ucv_type(target) == UC_CLOSURE) { + closure = (uc_closure_t *)target; + } + + if (!closure) + return NULL; + + chunk = &closure->function->chunk; + + if (ucv_type(var) == UC_INTEGER) { + vn = ucv_uint64_get(var); + var = NULL; + + if (errno || vn >= closure->function->nupvals) + return NULL; + + uref = closure->upvals[vn]; + vname = uc_chunk_debug_get_variable(chunk, 0, vn, true); + } + else if (ucv_type(var) == UC_STRING) { + for (vn = 0; vn < closure->function->nupvals; vn++) { + vname = uc_chunk_debug_get_variable(chunk, 0, vn, true); + + if (ucv_is_equal(vname, var)) { + uref = closure->upvals[vn]; + break; + } + + ucv_put(vname); + vname = NULL; + } + } + + if (!uref) + return NULL; + + rv = ucv_object_new(vm); + + ucv_object_add(rv, "index", ucv_uint64_new(vn)); + ucv_object_add(rv, "name", vname); + + if (uref->closed) { + if (set) { + ucv_put(uref->value); + uref->value = ucv_get(*set); + } + + ucv_object_add(rv, "closed", ucv_boolean_new(true)); + ucv_object_add(rv, "value", ucv_get(uref->value)); + } + else { + if (set) { + ucv_put(vm->stack.entries[uref->slot]); + vm->stack.entries[uref->slot] = ucv_get(*set); + } + + ucv_object_add(rv, "closed", ucv_boolean_new(false)); + ucv_object_add(rv, "value", ucv_get(vm->stack.entries[uref->slot])); + } + + return rv; +} + +/** + * Obtain captured variable (upvalue). + * + * The `getupval()` function retrieves information about the specified captured + * variable associated with the given function value or the invoked function at + * the given call stack depth. + * + * The call stack depth specifies the amount of levels up the function should be + * selected to query associated captured variables for. A value of `0` refers to + * this `getupval()` function call itself, `1` to the function calling + * `getupval()` and so on. + * + * The variable to query might be either specified by name or by its index with + * index numbers following the source code declaration order. + * + * Returns a dictionary holding information about the given variable. + * + * Returns `null` if the given function value is not a closure. + * + * Returns `null` if the stack depth exceeds the size of the current call stack. + * + * Returns `null` if the invocation at the given stack depth is not a closure. + * + * Returns `null` if the given variable name is not found or the given variable + * index is invalid. + * + * @function module:debug#getupval + * + * @param {function|number} target + * Either a function value referring to a closure to query upvalues for or a + * stack depth number selecting a closure that many levels up. + * + * @param {string|number} variable + * The variable index or variable name to obtain information for. + * + * @returns {module:debug.UpvalInfo|null} + */ +static uc_value_t * +uc_getupval(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *target = uc_fn_arg(0); + uc_value_t *var = uc_fn_arg(1); + + return uc_xupval(vm, target, var, NULL); +} + +/** + * Set upvalue. + * + * The `setupval()` function manipulates the value of the specified captured + * variable associated with the given function value or the invoked function at + * the given call stack depth. + * + * The call stack depth specifies the amount of levels up the function should be + * selected to update associated captured variables for. A value of `0` refers + * to this `setupval()` function call itself, `1` to the function calling + * `setupval()` and so on. + * + * The variable to update might be either specified by name or by its index with + * index numbers following the source code declaration order. + * + * Returns a dictionary holding information about the updated variable. + * + * Returns `null` if the given function value is not a closure. + * + * Returns `null` if the stack depth exceeds the size of the current call stack. + * + * Returns `null` if the invocation at the given stack depth is not a closure. + * + * Returns `null` if the given variable name is not found or the given variable + * index is invalid. + * + * @function module:debug#setupval + * + * @param {function|number} target + * Either a function value referring to a closure to update upvalues for or a + * stack depth number selecting a closure that many levels up. + * + * @param {string|number} variable + * The variable index or variable name to update. + * + * @param {*} value + * The value to set the variable to. + * + * @returns {module:debug.UpvalInfo|null} + */ +static uc_value_t * +uc_setupval(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *target = uc_fn_arg(0); + uc_value_t *var = uc_fn_arg(1); + uc_value_t *val = uc_fn_arg(2); + + return uc_xupval(vm, target, var, &val); +} + + +static const uc_function_list_t debug_fns[] = { + { "memdump", uc_memdump }, + { "traceback", uc_traceback }, + { "sourcepos", uc_sourcepos }, + { "getinfo", uc_getinfo }, + { "getlocal", uc_getlocal }, + { "setlocal", uc_setlocal }, + { "getupval", uc_getupval }, + { "setupval", uc_setupval }, +}; + +void uc_module_init(uc_vm_t *vm, uc_value_t *scope) +{ + uc_function_list_register(scope, debug_fns); + + debug_setup(vm); +} @@ -60,11 +60,8 @@ #include <limits.h> #include <fcntl.h> -#ifndef __APPLE__ -#include <sys/sysmacros.h> /* major(), minor() */ -#endif - #include "ucode/module.h" +#include "ucode/platform.h" #define err_return(err) do { last_error = err; return NULL; } while(0) diff --git a/lib/nl80211.c b/lib/nl80211.c index c7bd5fa..49aea32 100644 --- a/lib/nl80211.c +++ b/lib/nl80211.c @@ -24,7 +24,6 @@ limitations under the License. #include <limits.h> #include <math.h> #include <assert.h> -#include <endian.h> #include <fcntl.h> #include <poll.h> @@ -43,6 +42,7 @@ limitations under the License. #include <libubox/uloop.h> #include "ucode/module.h" +#include "ucode/platform.h" #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) @@ -24,7 +24,6 @@ limitations under the License. #include <limits.h> #include <math.h> #include <assert.h> -#include <endian.h> #include <netinet/ether.h> #include <arpa/inet.h> @@ -52,6 +51,7 @@ limitations under the License. #include <libubox/uloop.h> #include "ucode/module.h" +#include "ucode/platform.h" #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) diff --git a/lib/uloop.c b/lib/uloop.c index 99cd984..d8d702f 100644 --- a/lib/uloop.c +++ b/lib/uloop.c @@ -23,6 +23,7 @@ #include <libubox/uloop.h> #include "ucode/module.h" +#include "ucode/platform.h" #define err_return(err) do { last_error = err; return NULL; } while(0) @@ -535,13 +536,8 @@ uc_uloop_process(uc_vm_t *vm, size_t nargs) free(buf); } -#ifdef __APPLE__ - execve((const char *)ucv_string_get(executable), - (char * const *)argp, (char * const *)envp); -#else execvpe((const char *)ucv_string_get(executable), (char * const *)argp, (char * const *)envp); -#endif _exit(-1); } diff --git a/platform.c b/platform.c new file mode 100644 index 0000000..63a79d4 --- /dev/null +++ b/platform.c @@ -0,0 +1,242 @@ +/* + * Copyright (C) 2023 Jo-Philipp Wich <jo@mein.io> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <errno.h> + +#include "ucode/platform.h" + +const char *uc_system_signal_names[UC_SYSTEM_SIGNAL_COUNT] = { +#if defined(SIGINT) + [SIGINT] = "INT", +#endif +#if defined(SIGILL) + [SIGILL] = "ILL", +#endif +#if defined(SIGABRT) + [SIGABRT] = "ABRT", +#endif +#if defined(SIGFPE) + [SIGFPE] = "FPE", +#endif +#if defined(SIGSEGV) + [SIGSEGV] = "SEGV", +#endif +#if defined(SIGTERM) + [SIGTERM] = "TERM", +#endif +#if defined(SIGHUP) + [SIGHUP] = "HUP", +#endif +#if defined(SIGQUIT) + [SIGQUIT] = "QUIT", +#endif +#if defined(SIGTRAP) + [SIGTRAP] = "TRAP", +#endif +#if defined(SIGKILL) + [SIGKILL] = "KILL", +#endif +#if defined(SIGPIPE) + [SIGPIPE] = "PIPE", +#endif +#if defined(SIGALRM) + [SIGALRM] = "ALRM", +#endif +#if defined(SIGSTKFLT) + [SIGSTKFLT] = "STKFLT", +#endif +#if defined(SIGPWR) + [SIGPWR] = "PWR", +#endif +#if defined(SIGBUS) + [SIGBUS] = "BUS", +#endif +#if defined(SIGSYS) + [SIGSYS] = "SYS", +#endif +#if defined(SIGURG) + [SIGURG] = "URG", +#endif +#if defined(SIGSTOP) + [SIGSTOP] = "STOP", +#endif +#if defined(SIGTSTP) + [SIGTSTP] = "TSTP", +#endif +#if defined(SIGCONT) + [SIGCONT] = "CONT", +#endif +#if defined(SIGCHLD) + [SIGCHLD] = "CHLD", +#endif +#if defined(SIGTTIN) + [SIGTTIN] = "TTIN", +#endif +#if defined(SIGTTOU) + [SIGTTOU] = "TTOU", +#endif +#if defined(SIGPOLL) + [SIGPOLL] = "POLL", +#endif +#if defined(SIGXFSZ) + [SIGXFSZ] = "XFSZ", +#endif +#if defined(SIGXCPU) + [SIGXCPU] = "XCPU", +#endif +#if defined(SIGVTALRM) + [SIGVTALRM] = "VTALRM", +#endif +#if defined(SIGPROF) + [SIGPROF] = "PROF", +#endif +#if defined(SIGUSR1) + [SIGUSR1] = "USR1", +#endif +#if defined(SIGUSR2) + [SIGUSR2] = "USR2", +#endif +}; + + +#ifdef __APPLE__ +int +pipe2(int pipefd[2], int flags) +{ + if (pipe(pipefd) != 0) + return -1; + + if (flags & O_CLOEXEC) { + if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) != 0 || + fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) != 0) { + close(pipefd[0]); + close(pipefd[1]); + + return -1; + } + + flags &= ~O_CLOEXEC; + } + + if (fcntl(pipefd[0], F_SETFL, flags) != 0 || + fcntl(pipefd[1], F_SETFL, flags) != 0) { + close(pipefd[0]); + close(pipefd[1]); + + return -1; + } + + return 0; +} + +/* + * sigtimedwait() implementation based on + * https://comp.unix.programmer.narkive.com/rEDH0sPT/sigtimedwait-implementation + * and + * https://github.com/wahern/lunix/blob/master/src/unix.c + */ +static void +sigtimedwait_consume_signal(int signo) +{ +} + +int +sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout) +{ + struct timespec elapsed = { 0, 0 }, sleep, rem; + sigset_t pending, unblock, omask; + struct sigaction sa, osa; + int signo; + bool lt; + + while (true) { + sigemptyset(&pending); + sigpending(&pending); + + for (signo = 1; signo < NSIG; signo++) { + if (!sigismember(set, signo) || !sigismember(&pending, signo)) + continue; + + sa.sa_handler = sigtimedwait_consume_signal; + sa.sa_flags = 0; + sigfillset(&sa.sa_mask); + + sigaction(signo, &sa, &osa); + + sigemptyset(&unblock); + sigaddset(&unblock, signo); + sigprocmask(SIG_UNBLOCK, &unblock, &omask); + sigprocmask(SIG_SETMASK, &omask, NULL); + + sigaction(signo, &osa, NULL); + + if (info) { + memset(info, 0, sizeof(*info)); + info->si_signo = signo; + } + + return signo; + } + + sleep.tv_sec = 0; + sleep.tv_nsec = 200000000L; /* 2/10th second */ + rem = sleep; + + if (nanosleep(&sleep, &rem) == 0) { + elapsed.tv_sec += sleep.tv_sec; + elapsed.tv_nsec += sleep.tv_nsec; + + if (elapsed.tv_nsec > 1000000000) { + elapsed.tv_sec++; + elapsed.tv_nsec -= 1000000000; + } + } + else if (errno == EINTR) { + sleep.tv_sec -= rem.tv_sec; + sleep.tv_nsec -= rem.tv_nsec; + + if (sleep.tv_nsec < 0) { + sleep.tv_sec--; + sleep.tv_nsec += 1000000000; + } + + elapsed.tv_sec += sleep.tv_sec; + elapsed.tv_nsec += sleep.tv_nsec; + + if (elapsed.tv_nsec > 1000000000) { + elapsed.tv_sec++; + elapsed.tv_nsec -= 1000000000; + } + } + else { + return errno; + } + + lt = timeout + ? ((elapsed.tv_sec == timeout->tv_sec) + ? (elapsed.tv_nsec < timeout->tv_nsec) + : (elapsed.tv_sec < timeout->tv_sec)) + : true; + + if (!lt) + break; + } + + errno = EAGAIN; + + return -1; +} +#endif @@ -16,12 +16,12 @@ #include <assert.h> #include <errno.h> -#include <endian.h> #include "ucode/program.h" #include "ucode/source.h" #include "ucode/vallist.h" #include "ucode/chunk.h" +#include "ucode/platform.h" uc_program_t * @@ -16,9 +16,9 @@ #include <string.h> #include <errno.h> -#include <endian.h> #include "ucode/source.h" +#include "ucode/platform.h" uc_source_t * @@ -17,7 +17,6 @@ #include <stdarg.h> #include <stdlib.h> #include <assert.h> -#include <endian.h> #include <errno.h> #include <math.h> #include <ctype.h> @@ -15,7 +15,6 @@ */ #include <string.h> /* memcpy(), memset() */ -#include <endian.h> /* htobe64(), be64toh() */ #include <math.h> /* isnan(), INFINITY */ #include <ctype.h> /* isspace(), isdigit(), isxdigit() */ #include <assert.h> @@ -27,6 +26,7 @@ #include "ucode/program.h" #include "ucode/vallist.h" #include "ucode/vm.h" +#include "ucode/platform.h" #define TAG_TYPE uint64_t #define TAG_BITS 3 @@ -28,6 +28,7 @@ #include "ucode/compiler.h" #include "ucode/program.h" #include "ucode/lib.h" /* uc_error_context_format() */ +#include "ucode/platform.h" #undef __insn #define __insn(_name) #_name, @@ -154,36 +155,6 @@ uc_vm_signal_handler(int sig) uc_vm_signal_raise(signal_handler_vm, sig); } -#ifdef __APPLE__ -static int pipe2(int pipefd[2], int flags) -{ - if (pipe(pipefd) != 0) - return -1; - - if (flags & O_CLOEXEC) { - if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) != 0 || - fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) != 0) { - close(pipefd[0]); - close(pipefd[1]); - - return -1; - } - - flags &= ~O_CLOEXEC; - } - - if (fcntl(pipefd[0], F_SETFL, flags) != 0 || - fcntl(pipefd[1], F_SETFL, flags) != 0) { - close(pipefd[0]); - close(pipefd[1]); - - return -1; - } - - return 0; -} -#endif - static void uc_vm_signal_handlers_setup(uc_vm_t *vm) { @@ -200,7 +171,7 @@ uc_vm_signal_handlers_setup(uc_vm_t *vm) signal_handler_vm = vm; - vm->signal.handler = ucv_array_new_length(vm, NSIG - 1); + vm->signal.handler = ucv_array_new_length(vm, UC_SYSTEM_SIGNAL_COUNT); vm->signal.sa.sa_handler = uc_vm_signal_handler; vm->signal.sa.sa_flags = SA_RESTART | SA_ONSTACK; @@ -3182,7 +3153,7 @@ uc_vm_signal_raise(uc_vm_t *vm, int signo) { uint8_t signum = signo; - if (signo <= 0 || signo >= NSIG) + if (signo <= 0 || signo >= UC_SYSTEM_SIGNAL_COUNT) return; vm->signal.raised[signo / 64] |= (1ull << (signo % 64)); |