datadog-ruby_core_source 3.3.6

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/eval_intern.h

@@ -0,0 +1,343 @@
+#ifndef RUBY_EVAL_INTERN_H
+#define RUBY_EVAL_INTERN_H
+
+#include "ruby/ruby.h"
+#include "vm_core.h"
+
+static inline void
+vm_passed_block_handler_set(rb_execution_context_t *ec, VALUE block_handler)
+{
+    vm_block_handler_verify(block_handler);
+    ec->passed_block_handler = block_handler;
+}
+
+static inline void
+pass_passed_block_handler(rb_execution_context_t *ec)
+{
+    VALUE block_handler = rb_vm_frame_block_handler(ec->cfp);
+    vm_passed_block_handler_set(ec, block_handler);
+    VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_PASSED);
+}
+
+#define PASS_PASSED_BLOCK_HANDLER_EC(ec) pass_passed_block_handler(ec)
+#define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_EC())
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+#include <stdio.h>
+#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
+# include "wasm/setjmp.h"
+#else
+# include <setjmp.h>
+#endif
+
+#ifdef __APPLE__
+# ifdef HAVE_CRT_EXTERNS_H
+#  include <crt_externs.h>
+# else
+#  include "missing/crt_externs.h"
+# endif
+#endif
+
+#ifndef HAVE_STRING_H
+char *strrchr(const char *, const char);
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_NET_SOCKET_H
+#include <net/socket.h>
+#endif
+
+#define ruby_setjmp(env) RUBY_SETJMP(env)
+#define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
+#ifdef __CYGWIN__
+# ifndef _setjmp
+int _setjmp(jmp_buf);
+# endif
+# ifndef _longjmp
+NORETURN(void _longjmp(jmp_buf, int));
+# endif
+#endif
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+/*
+  Solaris sys/select.h switches select to select_large_fdset to support larger
+  file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
+  But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
+  So following definition is required to use select_large_fdset.
+*/
+#ifdef HAVE_SELECT_LARGE_FDSET
+#define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
+extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#include <sys/stat.h>
+
+
+#define SAVE_ROOT_JMPBUF(th, stmt) do \
+  if (true) { \
+      stmt; \
+  } \
+  else if (th) { /* suppress unused-variable warning */ \
+  } while (0)
+
+#define EC_PUSH_TAG(ec) do { \
+  rb_execution_context_t * const _ec = (ec); \
+  struct rb_vm_tag _tag; \
+  _tag.state = TAG_NONE; \
+  _tag.tag = Qundef; \
+  _tag.prev = _ec->tag; \
+  _tag.lock_rec = rb_ec_vm_lock_rec(_ec); \
+  rb_vm_tag_jmpbuf_init(&_tag.buf); \
+
+#define EC_POP_TAG() \
+  _ec->tag = _tag.prev; \
+  rb_vm_tag_jmpbuf_deinit(&_tag.buf); \
+} while (0)
+
+#define EC_TMPPOP_TAG() \
+  _ec->tag = _tag.prev
+
+#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
+
+#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || defined __clang__
+/* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
+ * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
+ * (I confirmed Clang 4.0.1 and 5.0.0.)
+ */
+# define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
+# define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
+# define VAR_NOCLOBBERED(var) volatile var
+#else
+# define VAR_FROM_MEMORY(var) (var)
+# define VAR_INITIALIZED(var) ((void)&(var))
+# define VAR_NOCLOBBERED(var) var
+#endif
+
+static inline void
+rb_ec_vm_lock_rec_check(const rb_execution_context_t *ec, unsigned int recorded_lock_rec)
+{
+    unsigned int current_lock_rec = rb_ec_vm_lock_rec(ec);
+    if (current_lock_rec != recorded_lock_rec) {
+        rb_ec_vm_lock_rec_release(ec, recorded_lock_rec, current_lock_rec);
+    }
+}
+
+/* clear ec->tag->state, and return the value */
+static inline int
+rb_ec_tag_state(const rb_execution_context_t *ec)
+{
+    struct rb_vm_tag *tag = ec->tag;
+    enum ruby_tag_type state = tag->state;
+    tag->state = TAG_NONE;
+    rb_ec_vm_lock_rec_check(ec, tag->lock_rec);
+    RBIMPL_ASSUME(state != TAG_NONE);
+    return state;
+}
+
+NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
+static inline void
+rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
+{
+    RUBY_ASSERT(st != TAG_NONE);
+    ec->tag->state = st;
+    ruby_longjmp(RB_VM_TAG_JMPBUF_GET(ec->tag->buf), 1);
+}
+
+/*
+  setjmp() in assignment expression rhs is undefined behavior
+  [ISO/IEC 9899:1999] 7.13.1.1
+*/
+#define EC_EXEC_TAG() \
+    (UNLIKELY(ruby_setjmp(RB_VM_TAG_JMPBUF_GET(_tag.buf))) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
+
+#define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
+
+#define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
+
+/* CREF operators */
+
+#define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
+#define CREF_FL_OMOD_SHARED    IMEMO_FL_USER2
+#define CREF_FL_SINGLETON      IMEMO_FL_USER3
+
+static inline int CREF_SINGLETON(const rb_cref_t *cref);
+
+static inline VALUE
+CREF_CLASS(const rb_cref_t *cref)
+{
+    if (CREF_SINGLETON(cref)) {
+        return CLASS_OF(cref->klass_or_self);
+    }
+    else {
+        return cref->klass_or_self;
+    }
+}
+
+static inline VALUE
+CREF_CLASS_FOR_DEFINITION(const rb_cref_t *cref)
+{
+    if (CREF_SINGLETON(cref)) {
+        return rb_singleton_class(cref->klass_or_self);
+    }
+    else {
+        return cref->klass_or_self;
+    }
+}
+
+static inline rb_cref_t *
+CREF_NEXT(const rb_cref_t *cref)
+{
+    return cref->next;
+}
+
+static inline const rb_scope_visibility_t *
+CREF_SCOPE_VISI(const rb_cref_t *cref)
+{
+    return &cref->scope_visi;
+}
+
+static inline VALUE
+CREF_REFINEMENTS(const rb_cref_t *cref)
+{
+    return cref->refinements;
+}
+
+static inline void
+CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
+{
+    RB_OBJ_WRITE(cref, &cref->refinements, refs);
+}
+
+static inline int
+CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_PUSHED_BY_EVAL;
+}
+
+static inline void
+CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_PUSHED_BY_EVAL;
+}
+
+static inline int
+CREF_SINGLETON(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_SINGLETON;
+}
+
+static inline void
+CREF_SINGLETON_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_SINGLETON;
+}
+
+static inline int
+CREF_OMOD_SHARED(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_OMOD_SHARED;
+}
+
+static inline void
+CREF_OMOD_SHARED_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_OMOD_SHARED;
+}
+
+static inline void
+CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
+{
+    cref->flags &= ~CREF_FL_OMOD_SHARED;
+}
+
+enum {
+    RAISED_EXCEPTION = 1,
+    RAISED_STACKOVERFLOW = 2,
+    RAISED_NOMEMORY = 4
+};
+#define rb_ec_raised_set(ec, f)   ((ec)->raised_flag |= (f))
+#define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
+#define rb_ec_raised_p(ec, f)    (((ec)->raised_flag & (f)) != 0)
+#define rb_ec_raised_clear(ec)    ((ec)->raised_flag = 0)
+int rb_ec_set_raised(rb_execution_context_t *ec);
+int rb_ec_reset_raised(rb_execution_context_t *ec);
+int rb_ec_stack_check(rb_execution_context_t *ec);
+
+VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
+VALUE rb_make_exception(int argc, const VALUE *argv);
+
+NORETURN(void rb_method_name_error(VALUE, VALUE));
+
+NORETURN(void rb_fiber_start(rb_fiber_t*));
+
+NORETURN(void rb_print_undef(VALUE, ID, rb_method_visibility_t));
+NORETURN(void rb_print_undef_str(VALUE, VALUE));
+NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
+NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
+NORETURN(void rb_vm_jump_tag_but_local_jump(int));
+
+VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
+rb_cref_t *rb_vm_cref(void);
+rb_cref_t *rb_vm_cref_replace_with_duplicated_cref(void);
+VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename);
+void rb_vm_set_progname(VALUE filename);
+VALUE rb_vm_cbase(void);
+
+/* vm_backtrace.c */
+VALUE rb_ec_backtrace_object(const rb_execution_context_t *ec);
+VALUE rb_ec_backtrace_str_ary(const rb_execution_context_t *ec, long lev, long n);
+VALUE rb_ec_backtrace_location_ary(const rb_execution_context_t *ec, long lev, long n, bool skip_internal);
+
+#ifndef CharNext		/* defined as CharNext[AW] on Windows. */
+# ifdef HAVE_MBLEN
+#  define CharNext(p) rb_char_next(p)
+static inline char *
+rb_char_next(const char *p)
+{
+    if (p) {
+        int len = mblen(p, RUBY_MBCHAR_MAXSIZE);
+        p += len > 0 ? len : 1;
+    }
+    return (char *)p;
+}
+# else
+#  define CharNext(p) ((p) + 1)
+# endif
+#endif
+
+#if defined DOSISH || defined __CYGWIN__
+static inline void
+translit_char(char *p, int from, int to)
+{
+    while (*p) {
+        if ((unsigned char)*p == from)
+            *p = to;
+        p = CharNext(p);
+    }
+}
+#endif
+
+#endif /* RUBY_EVAL_INTERN_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/hrtime.h

@@ -0,0 +1,227 @@
+#ifndef RB_HRTIME_H
+#define RB_HRTIME_H
+#include "ruby/ruby.h"
+#include <time.h>
+#if defined(HAVE_SYS_TIME_H)
+#  include <sys/time.h>
+#endif
+
+/*
+ * Hi-res monotonic clock.  It is currently nsec resolution, which has over
+ * 500 years of range (with an unsigned 64-bit integer).  Developers
+ * targeting small systems may try 32-bit and low-resolution (milliseconds).
+ *
+ * TBD: Is nsec even necessary? usec resolution seems enough for userspace
+ * and it'll be suitable for use with devices lasting over 500,000 years
+ * (maybe some devices designed for long-term space travel)
+ *
+ * Current API:
+ *
+ *	* rb_hrtime_now      - current clock value (monotonic if available)
+ *	* rb_hrtime_mul      - multiply with overflow check
+ *	* rb_hrtime_add      - add with overflow check
+ *	* rb_timeval2hrtime  - convert from timeval
+ *	* rb_timespec2hrtime - convert from timespec
+ *	* rb_msec2hrtime     - convert from millisecond
+ *	* rb_sec2hrtime      - convert from time_t (seconds)
+ *	* rb_hrtime2timeval  - convert to timeval
+ *	* rb_hrtime2timespec - convert to timespec
+ *
+ * Note: no conversion to milliseconds is provided here because different
+ * functions have different limits (e.g. epoll_wait vs w32_wait_events).
+ * So we provide RB_HRTIME_PER_MSEC and similar macros for implementing
+ * this for each use case.
+ */
+#define RB_HRTIME_PER_USEC ((rb_hrtime_t)1000)
+#define RB_HRTIME_PER_MSEC (RB_HRTIME_PER_USEC * (rb_hrtime_t)1000)
+#define RB_HRTIME_PER_SEC  (RB_HRTIME_PER_MSEC * (rb_hrtime_t)1000)
+#define RB_HRTIME_MAX      UINT64_MAX
+#define RB_HRTIME_MIN      ((rb_hrtime_t)0)
+
+/*
+ * Lets try to support time travelers.  Lets assume anybody with a time machine
+ * also has access to a modern gcc or clang with 128-bit int support
+ */
+#ifdef MY_RUBY_BUILD_MAY_TIME_TRAVEL
+typedef int128_t rb_hrtime_t;
+#else
+typedef uint64_t rb_hrtime_t;
+#endif
+
+/* thread.c */
+/* returns the value of the monotonic clock (if available) */
+rb_hrtime_t rb_hrtime_now(void);
+
+/*
+ * multiply @a and @b with overflow check and return the
+ * (clamped to RB_HRTIME_MAX) result.
+ */
+static inline rb_hrtime_t
+rb_hrtime_mul(rb_hrtime_t a, rb_hrtime_t b)
+{
+    rb_hrtime_t c;
+
+#ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW
+    if (__builtin_mul_overflow(a, b, &c))
+        return RB_HRTIME_MAX;
+#else
+    if (b != 0 && a > RB_HRTIME_MAX / b) /* overflow */
+        return RB_HRTIME_MAX;
+    c = a * b;
+#endif
+    return c;
+}
+
+/*
+ * add @a and @b with overflow check and return the
+ * (clamped to RB_HRTIME_MAX) result.
+ */
+static inline rb_hrtime_t
+rb_hrtime_add(rb_hrtime_t a, rb_hrtime_t b)
+{
+    rb_hrtime_t c;
+
+#ifdef HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW
+    if (__builtin_add_overflow(a, b, &c))
+        return RB_HRTIME_MAX;
+#else
+    c = a + b;
+    if (c < a) /* overflow */
+        return RB_HRTIME_MAX;
+#endif
+    return c;
+}
+
+static inline rb_hrtime_t
+rb_hrtime_sub(rb_hrtime_t a, rb_hrtime_t b)
+{
+    if (a < b) {
+        return RB_HRTIME_MIN;
+    }
+    return a - b;
+}
+
+/*
+ * convert a timeval struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_timeval2hrtime(const struct timeval *tv)
+{
+    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)tv->tv_sec, RB_HRTIME_PER_SEC);
+    rb_hrtime_t u = rb_hrtime_mul((rb_hrtime_t)tv->tv_usec, RB_HRTIME_PER_USEC);
+
+    return rb_hrtime_add(s, u);
+}
+
+/*
+ * convert a timespec struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_timespec2hrtime(const struct timespec *ts)
+{
+    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)ts->tv_sec, RB_HRTIME_PER_SEC);
+
+    return rb_hrtime_add(s, (rb_hrtime_t)ts->tv_nsec);
+}
+
+/*
+ * convert a millisecond value to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ */
+static inline rb_hrtime_t
+rb_msec2hrtime(unsigned long msec)
+{
+    return rb_hrtime_mul((rb_hrtime_t)msec, RB_HRTIME_PER_MSEC);
+}
+
+/*
+ * convert a time_t value to rb_hrtime_t, clamping at RB_HRTIME_MAX
+ * Negative values will be clamped at 0.
+ */
+static inline rb_hrtime_t
+rb_sec2hrtime(time_t sec)
+{
+    if (sec <= 0) return 0;
+
+    return rb_hrtime_mul((rb_hrtime_t)sec, RB_HRTIME_PER_SEC);
+}
+
+/*
+ * convert a rb_hrtime_t value to a timespec, suitable for calling
+ * functions like ppoll(2) or kevent(2)
+ */
+static inline struct timespec *
+rb_hrtime2timespec(struct timespec *ts, const rb_hrtime_t *hrt)
+{
+    if (hrt) {
+        ts->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
+        ts->tv_nsec = (int32_t)(*hrt % RB_HRTIME_PER_SEC);
+        return ts;
+    }
+    return 0;
+}
+
+/*
+ * convert a rb_hrtime_t value to a timeval, suitable for calling
+ * functions like select(2)
+ */
+static inline struct timeval *
+rb_hrtime2timeval(struct timeval *tv, const rb_hrtime_t *hrt)
+{
+    if (hrt) {
+        tv->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
+        tv->tv_usec = (int32_t)((*hrt % RB_HRTIME_PER_SEC)/RB_HRTIME_PER_USEC);
+
+        return tv;
+    }
+    return 0;
+}
+
+#include "internal/warnings.h"
+#include "internal/time.h"
+
+/*
+ * Back when we used "struct timeval", not all platforms implemented
+ * tv_sec as time_t.  Nowadays we use "struct timespec" and tv_sec
+ * seems to be implemented more consistently across platforms.
+ * At least other parts of our code hasn't had to deal with non-time_t
+ * tv_sec in timespec...
+ */
+#define TIMESPEC_SEC_MAX TIMET_MAX
+#define TIMESPEC_SEC_MIN TIMET_MIN
+
+COMPILER_WARNING_PUSH
+#if __has_warning("-Wimplicit-int-float-conversion")
+COMPILER_WARNING_IGNORED(-Wimplicit-int-float-conversion)
+#elif defined(_MSC_VER)
+/* C4305: 'initializing': truncation from '__int64' to 'const double' */
+COMPILER_WARNING_IGNORED(4305)
+#endif
+static const double TIMESPEC_SEC_MAX_as_double = TIMESPEC_SEC_MAX;
+COMPILER_WARNING_POP
+
+static inline rb_hrtime_t *
+double2hrtime(rb_hrtime_t *hrt, double d)
+{
+    /* assume timespec.tv_sec has same signedness as time_t */
+    const double TIMESPEC_SEC_MAX_PLUS_ONE = 2.0 * (TIMESPEC_SEC_MAX_as_double / 2.0 + 1.0);
+
+    if (TIMESPEC_SEC_MAX_PLUS_ONE <= d) {
+        *hrt = RB_HRTIME_MAX;
+        return NULL;
+    }
+    else if (d <= 0) {
+        *hrt = 0;
+    }
+    else {
+        *hrt = (rb_hrtime_t)(d * (double)RB_HRTIME_PER_SEC);
+    }
+    return hrt;
+}
+
+static inline double
+hrtime2double(rb_hrtime_t hrt)
+{
+    return (double)hrt / (double)RB_HRTIME_PER_SEC;
+}
+
+#endif /* RB_HRTIME_H */