export LAUNCHABLE_SESSION_DIR=${builddir}

local github_ref="${GITHUB_REF//\//_}"

local build_name="${github_ref}"_"${GITHUB_PR_HEAD_SHA}"

launchable record build --name "${build_name}" || true

launchable record session \

--build "${build_name}" \

--flavor cppflags="${INPUT_CPPFLAGS}" \

--test-suite btest \

> "${builddir}"/${btest_session_file} \

if [ "$INPUT_CHECK" = "true" ]; then

launchable record session \

--build "${build_name}" \

--flavor test_task=test-all \

--flavor cppflags="${INPUT_CPPFLAGS}" \

--test-suite test-all \

> "${builddir}"/${test_all_session_file} \

mkdir "${builddir}"/"${test_spec_report_path}"

launchable record session \

--build "${build_name}" \

--flavor test_task=test-spec \

--flavor cppflags="${INPUT_CPPFLAGS}" \

--test-suite test-spec \

> "${builddir}"/${test_spec_session_file} \

fi

}

launchable_record_test() {

test_all_session_file='launchable_test_all_session.txt'

btest_session_file='launchable_btest_session.txt'

test_spec_session_file='launchable_test_spec_session.txt'

launchable_failed=false

kill "$sleep_pid" 2> /dev/null

echo "::endgroup::"

$launchable_failed || trap launchable_record_test EXIT

fi

post: |

rm -f "${test_all_session_file}"

rm -f "${btest_session_file}"

if: always() && steps.setup-launchable.outcome == 'success'

env:

test_all_session_file: ${{ steps.global.outputs.test_all_session_file }}

${{ steps.clean.outputs.distclean }}

${{ steps.clean.outputs.remained-files }}

${{ steps.clean.outputs.final }}

configure: '--enable-zjit=dev'

tests: '../src/test/ruby/test_zjit.rb'

env:

GITPULLOPTIONS: --no-tags origin ${{ github.ref }}

RUN_OPTS: ${{ matrix.zjit_opts }}

ruby -ne 'raise "Disassembly seems broken in dev build (output has too few lines)" unless $_.to_i > 10'

if: ${{ contains(matrix.configure, 'jit=dev') }}

- name: make ${{ matrix.test_task }}

run: >-

make -s ${{ matrix.test_task }} ${TESTS:+TESTS="$TESTS"}

PRECHECK_BUNDLED_GEMS: 'no'

TESTS: ${{ matrix.tests }}

continue-on-error: ${{ matrix.continue-on-test_task || false }}

result:

if: ${{ always() }}

configure: '--enable-zjit=dev'

tests: '../src/test/ruby/test_zjit.rb'

env:

GITPULLOPTIONS: --no-tags origin ${{ github.ref }}

RUN_OPTS: ${{ matrix.zjit_opts }}

run: ./miniruby --zjit -v | grep "+ZJIT"

if: ${{ matrix.configure != '--disable-zjit' }}

- name: make ${{ matrix.test_task }}

run: >-

make -s ${{ matrix.test_task }} ${TESTS:+TESTS="$TESTS"}

LIBCLANG_PATH: ${{ matrix.libclang_path }}

TESTS: ${{ matrix.tests }}

continue-on-error: ${{ matrix.continue-on-test_task || false }}

result:

if: ${{ always() }}

## Compatibility issues

* `Ractor.yield`

* `Ractor#take`

location_new(&RNODE_CLASS(node)->class_keyword_loc),

location_new(&RNODE_CLASS(node)->inheritance_operator_loc),

location_new(&RNODE_CLASS(node)->end_keyword_loc));

case NODE_DOT2:

return rb_ary_new_from_args(2,

location_new(nd_code_loc(node)),

call(Sub.new('o')).class

}

assert_equal '["str", "ivar"]', %q{

def str_dup(str) = str.dup

str = "str"

re.$(OBJEXT): {$(VPATH)}node.h

re.$(OBJEXT): {$(VPATH)}onigmo.h

re.$(OBJEXT): {$(VPATH)}oniguruma.h

re.$(OBJEXT): {$(VPATH)}re.c

re.$(OBJEXT): {$(VPATH)}re.h

re.$(OBJEXT): {$(VPATH)}regenc.h

re.$(OBJEXT): {$(VPATH)}thread_native.h

re.$(OBJEXT): {$(VPATH)}util.h

re.$(OBJEXT): {$(VPATH)}vm_core.h

re.$(OBJEXT): {$(VPATH)}vm_opts.h

regcomp.$(OBJEXT): $(hdrdir)/ruby.h

regcomp.$(OBJEXT): $(hdrdir)/ruby/ruby.h

if (simple_dat_p(x)) {

r = m_real_jd(x);

long ir = FIX2LONG(r);

ir = ir * 2 - 1;

return rb_rational_new2(LONG2FIX(ir), INT2FIX(2));

static VALUE

d_lite_hash(VALUE self)

{

get_d1(self);

v = rb_memhash(h, sizeof(h));

return ST2FIX(v);

}

m_of_in_day(dat),

DBL2NUM(m_sg(dat)));

return a;

}

INT2FIX(m_of(dat)),

DBL2NUM(m_sg(dat)));

return a;

}

HAVE_JD | HAVE_DF);

}

return self;

}

#

# [:resolv_timeout] Specifies the timeout in seconds from when the hostname resolution starts.

# [:connect_timeout] This method sequentially attempts connecting to all candidate destination addresses.<br>The +connect_timeout+ specifies the timeout in seconds from the start of the connection attempt to the last candidate.<br>By default, all connection attempts continue until the timeout occurs.<br>When +fast_fallback:false+ is explicitly specified,<br>a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.

# [:fast_fallback] Enables the Happy Eyeballs Version 2 algorithm (enabled by default).

#

# If a block is given, the block is called with the socket.

# sock.close_write

# puts sock.read

# }

sock = if fast_fallback && !(host && ip_address?(host))

else

end

if block_given?

end

end

if local_host || local_port

local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: resolv_timeout)

resolving_family_names = local_addrinfos.map { |lai| ADDRESS_FAMILIES.key(lai.afamily) }.uniq

resolution_delay_expires_at = nil

connection_attempt_delay_expires_at = nil

user_specified_connect_timeout_at = nil

last_error = nil

last_error_from_thread = false

ends_at =

if resolution_store.any_addrinfos?

else

[user_specified_resolv_timeout_at, user_specified_connect_timeout_at].compact.max

end

end

end

if resolution_store.empty_addrinfos?

if connecting_sockets.empty? && resolution_store.resolved_all_families?

if last_error_from_thread

end

end

last_error = nil

ret = nil

local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)

end

if local_addr_list

local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }

next unless local_addr

local_addr = nil

end

begin

sock = local_addr ?

rescue SystemCallError

last_error = $!

next

#if RUBY_USE_STATX

unsigned int m = get_stat(self)->stx_dev_major;

unsigned int n = get_stat(self)->stx_dev_minor;

#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_DEV_T

return DEVT2NUM(get_stat(self)->st_dev);

#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_LONG

#if RUBY_USE_STATX

unsigned int m = get_stat(self)->stx_rdev_major;

unsigned int n = get_stat(self)->stx_rdev_minor;

#elif !defined(HAVE_STRUCT_STAT_ST_RDEV)

return Qnil;

#elif SIZEOF_STRUCT_STAT_ST_RDEV <= SIZEOF_DEV_T

{

obj_free_object_id(obj);

rb_free_generic_ivar((VALUE)obj);

}

switch (BUILTIN_TYPE(obj)) {

return 0;

}

size += rb_generic_ivar_memsize(obj);

}

{

struct gc_mark_classext_foreach_arg foreach_args;

rb_mark_generic_ivar(obj);

}

case ST_DELETE:

free_gen_fields_tbl((VALUE)key, (struct gen_fields_tbl *)value);

return ST_DELETE;

case ST_REPLACE: {

break;

}

case RB_GC_VM_WEAK_TABLE_COUNT:

default:

rb_bug("rb_gc_vm_weak_table_foreach: unknown table %d", table);

}

const HIDDEN_SIZE_MASK: usize = 0x0000FFFFFFFFFFFF;

// An opaque type for the C counterpart.

#[allow(non_camel_case_types)]

pub struct st_table;

unsafe { self.flags_field().load::<usize>() }

}

pub fn prefix_size() -> usize {

// Currently, a hidden size field of word size is placed before each object.

OBJREF_OFFSET

rb_hash_dup(VALUE hash)

{

const VALUE flags = RBASIC(hash)->flags;

rb_copy_generic_ivar(ret, hash);

return ret;

}

VALUE

rb_hash_key_str(VALUE key)

{

return rb_fstring(key);

}

else {

= 0,

/**

* This flag has something to do with Ractor. Multiple Ractors run without

* protecting each other. Sharing an object among Ractors are basically

* dangerous, disabled by default. This flag is used to bypass that

*/

RUBY_FL_UNUSED9 = (1<<9),

/**

* This flag has something to do with data immutability. When this flag is

# pragma deprecated(RUBY_FL_DUPPED)

#endif

};

#undef RBIMPL_HAVE_ENUM_ATTRIBUTE

#endif

/* string.c */

VALUE rb_fstring(VALUE);

VALUE rb_fstring_cstr(const char *str);

VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);

int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);

bool rb_thread_mn_schedulable(VALUE thread);

// interrupt exec

typedef VALUE (rb_interrupt_exec_func_t)(void *data);

enum rb_interrupt_exec_flag {

rb_interrupt_exec_flag_none = 0x00,

rb_interrupt_exec_flag_value_data = 0x01,

};

// interrupt the target_th and run func.

if man_pages.include?(command)

man_page = man_pages[command]

Kernel.exec("man", man_page)

else

puts File.read("#{man_path}/#{File.basename(man_page)}.ronn")

flags = [

"RUBY_FL_WB_PROTECTED", "RUBY_FL_PROMOTED", "RUBY_FL_FINALIZE",

"RUBY_FL_USER0", "RUBY_FL_USER1", "RUBY_FL_USER2", "RUBY_FL_USER3", "RUBY_FL_USER4",

"RUBY_FL_USER5", "RUBY_FL_USER6", "RUBY_FL_USER7", "RUBY_FL_USER8", "RUBY_FL_USER9",

"RUBY_FL_USER10", "RUBY_FL_USER11", "RUBY_FL_USER12", "RUBY_FL_USER13", "RUBY_FL_USER14",

ANN("format: [nd_head]::[nd_mid]");

ANN("example: M::C");

F_ID(nd_mid, RNODE_COLON2, "constant name");

F_NODE(nd_head, RNODE_COLON2, "receiver");

return;

case NODE_COLON3:

ANN("format: ::[nd_mid]");

ANN("example: ::Object");

F_ID(nd_mid, RNODE_COLON3, "constant name");

return;

case NODE_DOT2:

if (OBJ_FROZEN(dest)) {

rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest));

}

// Copies the shape id from obj to dest

switch (BUILTIN_TYPE(obj)) {

case T_IMEMO:

break;

case T_CLASS:

case T_MODULE:

static rb_node_class_t *rb_node_class_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, NODE *nd_super, const YYLTYPE *loc, const YYLTYPE *class_keyword_loc, const YYLTYPE *inheritance_operator_loc, const YYLTYPE *end_keyword_loc);

static rb_node_module_t *rb_node_module_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, const YYLTYPE *loc);

static rb_node_sclass_t *rb_node_sclass_new(struct parser_params *p, NODE *nd_recv, NODE *nd_body, const YYLTYPE *loc);

static rb_node_dot2_t *rb_node_dot2_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);

static rb_node_dot3_t *rb_node_dot3_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);

static rb_node_self_t *rb_node_self_new(struct parser_params *p, const YYLTYPE *loc);

#define NEW_CLASS(n,b,s,loc,ck_loc,io_loc,ek_loc) (NODE *)rb_node_class_new(p,n,b,s,loc,ck_loc,io_loc,ek_loc)

#define NEW_MODULE(n,b,loc) (NODE *)rb_node_module_new(p,n,b,loc)

#define NEW_SCLASS(r,b,loc) (NODE *)rb_node_sclass_new(p,r,b,loc)

#define NEW_DOT2(b,e,loc,op_loc) (NODE *)rb_node_dot2_new(p,b,e,loc,op_loc)

#define NEW_DOT3(b,e,loc,op_loc) (NODE *)rb_node_dot3_new(p,b,e,loc,op_loc)

#define NEW_SELF(loc) (NODE *)rb_node_self_new(p,loc)

| primary_value tCOLON2 tCONSTANT tOP_ASGN lex_ctxt rhs

{

YYLTYPE loc = code_loc_gen(&@primary_value, &@tCONSTANT);

/*% ripper: opassign!(const_path_field!($:1, $:3), $:4, $:6) %*/

}

| tCOLON3 tCONSTANT tOP_ASGN lex_ctxt rhs

{

YYLTYPE loc = code_loc_gen(&@tCOLON3, &@tCONSTANT);

/*% ripper: opassign!(top_const_field!($:2), $:3, $:5) %*/

}

| backref tOP_ASGN lex_ctxt rhs

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_field!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_field!($:2) %*/

}

| backref

{

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_field!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_field!($:2) %*/

}

| backref

{

cpath : tCOLON3 cname

{

/*% ripper: top_const_ref!($:2) %*/

}

| cname

{

/*% ripper: const_ref!($:1) %*/

}

| primary_value tCOLON2 cname

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

;

}

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_ref!($:2) %*/

}

| tLBRACK aref_args ']'

p_const : tCOLON3 cname

{

/*% ripper: top_const_ref!($:2) %*/

}

| p_const tCOLON2 cname

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

| tCONSTANT

}

static rb_node_colon2_t *

{

rb_node_colon2_t *n = NODE_NEWNODE(NODE_COLON2, rb_node_colon2_t, loc);

n->nd_head = nd_head;

n->nd_mid = nd_mid;

return n;

}

static rb_node_colon3_t *

{

rb_node_colon3_t *n = NODE_NEWNODE(NODE_COLON3, rb_node_colon3_t, loc);

n->nd_mid = nd_mid;

return n;

}

break;

}

default:

rb_bug("Unexpected node type: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));

break;

case PM_INSTANCE_VARIABLE_TARGET_NODE:

case PM_CONSTANT_PATH_TARGET_NODE:

case PM_CALL_TARGET_NODE:

// For other targets, we need to potentially compile the parent or

// owning expression of this target, then retrieve the value, expand it,

// and then compile the necessary writes.

}

}

return traverse_skip;

}

if (!RB_OBJ_FROZEN_RAW(obj)) {

else if (data->replacement != _val) { RB_OBJ_WRITE(obj, &v, data->replacement); } \

} while (0)

struct gen_fields_tbl *fields_tbl;

rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);

rb_gc_obj_id_moved(data->replacement);

rb_replace_generic_ivar(data->replacement, obj);

}

ID name;

};

static VALUE

require_body(VALUE data)

{

}

static VALUE

{

// catch any error

rb_rescue2(func, (VALUE)crr,

require_rescue, (VALUE)crr, rb_eException, 0);

require_result_copy_resuce, (VALUE)crr, rb_eException, 0);

ractor_port_send(GET_EC(), crr->port, Qtrue, Qfalse);

return Qnil;

}

static VALUE

{

}

VALUE

rb_ractor_require(VALUE feature)

{

rb_execution_context_t *ec = GET_EC();

rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;

// wait for require done

}

else {

}

}

}

static VALUE

{

}

VALUE

rb_ractor_autoload_load(VALUE module, ID name)

{

rb_execution_context_t *ec = GET_EC();

rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;

// wait for require done

}

else {

}

}

#include "ruby/encoding.h"

#include "ruby/re.h"

#include "ruby/util.h"

VALUE rb_eRegexpError, rb_eRegexpTimeoutError;

VALUE

rb_reg_regcomp(VALUE str)

{

}

static st_index_t reg_hash(VALUE re);

}

#define ATOMIC_LOAD_RELAXED(var) rbimpl_atomic_load_relaxed(&(var))

static inline uint64_t

{

#if defined(HAVE_GCC_ATOMIC_BUILTINS_64)

return __atomic_load_n(value, __ATOMIC_RELAXED);

#define ATOMIC_U64_LOAD_RELAXED(var) rbimpl_atomic_u64_load_relaxed(&(var))

static inline void

{

#if defined(HAVE_GCC_ATOMIC_BUILTINS_64)

__atomic_store_n(address, value, __ATOMIC_RELAXED);

struct RNode *nd_head;

ID nd_mid;

} rb_node_colon2_t;

typedef struct RNode_COLON3 {

NODE node;

ID nd_mid;

} rb_node_colon3_t;

/* NODE_DOT2, NODE_DOT3, NODE_FLIP2, NODE_FLIP3 */

#define RNODE_FILE(node) ((rb_node_file_t *)(node))

#define RNODE_ENCODING(node) ((rb_node_encoding_t *)(node))

/* NODE_FL: 0..4: UNUSED, 5: UNUSED, 6: UNUSED, 7: NODE_FL_NEWLINE,

* 8..14: nd_type,

* 15..: nd_line

struct rb_fiber_scheduler_blocking_operation {

void *(*function)(void *);

void *data;

rb_unblock_function_t *unblock_function;

void *data2;

int flags;

struct rb_fiber_scheduler_blocking_operation_state *state;

return -1; // Invalid blocking operation

}

rb_atomic_t expected = RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_QUEUED;

if (RUBY_ATOMIC_CAS(blocking_operation->status, expected, RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_EXECUTING) != expected) {

// Already cancelled or in wrong state

rb_atomic_t current_state = RUBY_ATOMIC_LOAD(blocking_operation->status);

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_QUEUED:

if (RUBY_ATOMIC_CAS(blocking_operation->status, current_state, RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_CANCELLED) == current_state) {

}

// Fall through if state changed between load and CAS

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_EXECUTING:

// Work is running - mark cancelled AND call unblock function

blocking_operation->unblock_function(blocking_operation->data2);

}

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_COMPLETED:

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_CANCELLED:

return 0;

}

#define MAX_SHAPE_ID (SHAPE_BUFFER_SIZE - 1)

#define ANCESTOR_SEARCH_MAX_DEPTH 2

#define LEAF 0

#define BLACK 0x0

RUBY_ASSERT(!rb_shape_has_object_id(original_shape_id));

bool dont_care;

if (!shape) {

shape = RSHAPE(ROOT_SHAPE_WITH_OBJ_ID);

}

// obj is TOO_COMPLEX so we can copy its iv_hash

st_table *table = st_copy(fields_table);

if (rb_shape_has_object_id(src_shape_id)) {

st_delete(table, &id, NULL);

}

rb_obj_init_too_complex(dest, table);

}

}

uint8_t flags_heap_index = rb_shape_heap_index(shape_id);

if (RB_TYPE_P(obj, T_OBJECT)) {

size_t shape_id_slot_size = rb_shape_tree.capacities[flags_heap_index - 1] * sizeof(VALUE) + sizeof(struct RBasic);

}

else {

if (flags_heap_index) {

}

}

rb_memerror();

}

#ifdef HAVE_MMAP

size_t shape_cache_mmap_size = rb_size_mul_or_raise(REDBLACK_CACHE_SIZE, sizeof(redblack_node_t), rb_eRuntimeError);

root->type = SHAPE_ROOT;

rb_shape_tree.root_shape = root;

RUBY_ASSERT(raw_shape_id(rb_shape_tree.root_shape) == ROOT_SHAPE_ID);

RUBY_ASSERT(raw_shape_id(root_with_obj_id) == ROOT_SHAPE_WITH_OBJ_ID);

}

void

#define SHAPE_ID_HEAP_INDEX_MAX ((1 << SHAPE_ID_HEAP_INDEX_BITS) - 1)

#define SHAPE_ID_HEAP_INDEX_MASK (SHAPE_ID_HEAP_INDEX_MAX << SHAPE_ID_HEAP_INDEX_OFFSET)

// The interpreter doesn't care about frozen status or slot size when reading ivars.

// So we normalize shape_id by clearing these bits to improve cache hits.

// JITs however might care about it.

#define ROOT_TOO_COMPLEX_WITH_OBJ_ID (ROOT_SHAPE_WITH_OBJ_ID | SHAPE_ID_FL_TOO_COMPLEX | SHAPE_ID_FL_HAS_OBJECT_ID)

#define SPECIAL_CONST_SHAPE_ID (ROOT_SHAPE_ID | SHAPE_ID_FL_FROZEN)

typedef struct redblack_node redblack_node_t;

struct rb_shape {

{

RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));

RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO) || IMEMO_TYPE_P(obj, imemo_class_fields));

#if RBASIC_SHAPE_ID_FIELD

RBASIC(obj)->shape_id = (VALUE)shape_id;

#else

RBASIC(obj)->flags &= SHAPE_FLAG_MASK;

RBASIC(obj)->flags |= ((VALUE)(shape_id) << SHAPE_FLAG_SHIFT);

#endif

}

static inline rb_shape_t *

return rb_shape_has_object_id(RBASIC_SHAPE_ID(obj));

}

// For ext/objspace

RUBY_SYMBOL_EXPORT_BEGIN

typedef void each_shape_callback(shape_id_t shape_id, void *data);

require "bundler"

require "bundler/friendly_errors"

RSpec.describe Bundler, "friendly errors" do

context "with invalid YAML in .gemrc" do

require_relative 'spec_helper'

load_extension('digest')

value = entry->record;

}

old_key = key;

retval = (*func)(&key, &value, arg, existing);

switch (retval) {

case ST_CONTINUE:

if (! existing) {

static inline bool

BARE_STRING_P(VALUE str)

{

}

static inline st_index_t

RUBY_ASSERT(RB_TYPE_P(str, T_STRING));

RUBY_ASSERT(OBJ_FROZEN(str));

RUBY_ASSERT(!FL_TEST_RAW(str, STR_FAKESTR));

RUBY_ASSERT(RBASIC_CLASS(str) == rb_cString);

RUBY_ASSERT(!rb_objspace_garbage_object_p(str));

rb_str_dup_m(VALUE str)

{

if (LIKELY(BARE_STRING_P(str))) {

}

else {

return rb_obj_dup(str);

RUBY_ASSERT(RB_TYPE_P(c, T_CLASS));

ivar = rb_attr_get(c, id);

if (!NIL_P(ivar)) {

}

}

}

assert_equal(9, h[DateTime.new(1999,5,25)])

h = {}

h[DateTime.new(1999,5,23)] = 0

h[DateTime.new(1999,5,24)] = 1

h[DateTime.new(1999,5,25)] = 2

[d.year, d.mon, d.mday, d.hour, d.min, d.sec, d.offset])

end

def test_ordinal

d = Date.ordinal

assert_equal([-4712, 1], [d.year, d.yday])

assert_locations(node.children[-1].locations, [[1, 0, 1, 16], [1, 0, 1, 5], [1, 8, 1, 9], [1, 13, 1, 16]])

end

def test_dot2_locations

node = ast_parse("1..2")

assert_locations(node.children[-1].locations, [[1, 0, 1, 4], [1, 1, 1, 3]])

assert_prism_eval("for foo, in [1,2,3] do end")

assert_prism_eval("for i, j in {a: 'b'} do; i; j; end")

end

############################################################################

assert_not_same(test, loaded)

assert_predicate(loaded, :frozen?)

end

end

# Create some objects and place it in a WeakMap

wmap = ObjectSpace::WeakMap.new

obj = Object.new

wmap[obj] = nil

end

# Run full GC to collect stats about weak references

GC.start

# Sometimes the WeakMap has a few elements, which might be held on by registers.

assert_operator(GC.latest_gc_info(:weak_references_count), :<=, before_weak_references_count - count + error_tolerance)

assert_operator(GC.latest_gc_info(:retained_weak_references_count), :<=, before_retained_weak_references_count - count + error_tolerance)

end

end

end

RUBY

end

def assert_make_shareable(obj)

refute Ractor.shareable?(obj), "object was already shareable"

Ractor.make_shareable(obj)

CODE

end

class TopStruct < Test::Unit::TestCase

include TestStruct

}

end

def test_local_variables_with_kwarg

bug11674 = '[ruby-core:71437] [Bug #11674]'

v = with_kwargs_11(v1:1,v2:2,v3:3,v4:4,v5:5,v6:6,v7:7,v8:8,v9:9,v10:10,v11:11)

}, call_threshold: 2

end

def test_opt_plus_type_guard_nested_exit

def side_exit(n) = 1 + n

def jit_frame(n) = 1 + side_exit(n)

def entry(n) = jit_frame(n)

[entry(2), entry(2.0)]

}, call_threshold: 2

end

end

def test_opt_mult_overflow

assert_compiles '[6, -6, 9671406556917033397649408, -9671406556917033397649408, 21267647932558653966460912964485513216]', %q{

def test(a, b)

a * b

}

end

# tool/ruby_vm/views/*.erb relies on the zjit instructions a) being contiguous and

# b) being reliably ordered after all the other instructions.

def test_instruction_order

pipe_fd = 3

script = <<~RUBY

result = {

ret_val:,

#{ unless insns.empty?

RUBY

end

def test_tcp_socket_one_hostname_resolution_succeeded_at_least

opts = %w[-rsocket -W1]

assert_separately opts, <<~RUBY

th->locking_mutex = Qfalse;

thread_cleanup_func_before_exec(th_ptr);

if (atfork) {

th->nt = NULL;

return;

}

#endif

}

void *

rb_nogvl(void *(*func)(void *), void *data1,

rb_unblock_function_t *ubf, void *data2,

bool is_main_thread = vm->ractor.main_thread == th;

int saved_errno = 0;

if (flags & RB_NOGVL_UBF_ASYNC_SAFE) {

vm->ubf_async_safe = 1;

}

RUBY_DEBUG_LOG("task:%p", task);

if (task) {

ruby_xfree(task);

}

else {

rb_native_mutex_unlock(&th->interrupt_lock);

}

// native thread safe

// func/data should be native thread safe

void

rb_ractor_interrupt_exec(struct rb_ractor_struct *target_r,

rb_interrupt_exec_func_t *func, void *data, enum rb_interrupt_exec_flag flags)

{

RUBY_DEBUG_LOG("flags:%d", (int)flags);

rb_thread_t *main_th = target_r->threads.main;

}

{

}

static int

native_thread_init_stack(rb_thread_t *th, void *local_in_parent_frame)

{

}

static void

native_thread_destroy(struct rb_native_thread *nt)

{

if (nt) {

rb_native_cond_destroy(&nt->cond.intr);

}

}

}

th->ec->machine.stack_maxsize = size - space;

}

#ifndef InterlockedExchangePointer

#define InterlockedExchangePointer(t, v) \

(void *)InterlockedExchange((long *)(t), (long)(v))

# define FIXWV2WINT(w) FIX2LONG(WIDEVAL_GET(w))

#endif

#define POSFIXWVABLE(wi) ((wi) < FIXWV_MAX+1)

#define NEGFIXWVABLE(wi) ((wi) >= FIXWV_MIN)

#define FIXWV_P(w) FIXWINT_P(WIDEVAL_GET(w))

{

struct time_object *tobj = ptr;

if (!FIXWV_P(tobj->timew)) {

}

rb_gc_mark_movable(tobj->vtm.year);

rb_gc_mark_movable(tobj->vtm.subsecx);

{

struct time_object *tobj = ptr;

if (!FIXWV_P(tobj->timew)) {

}

tobj->vtm.year = rb_gc_location(tobj->vtm.year);

}

static wideval_t

{

wideval_t timew;

if (nsec)

timew = wadd(timew, wmulquoll(WINT2WV(nsec), TIME_SCALE, 1000000000));

return timew;

}

static void

{

long subsec = *subsecp;

long sec2;

if (UNLIKELY(subsec >= maxsubsec)) { /* subsec positive overflow */

sec2 = subsec / maxsubsec;

rb_raise(rb_eRangeError, "out of Time range");

}

subsec -= sec2 * maxsubsec;

}

else if (UNLIKELY(subsec < 0)) { /* subsec negative overflow */

sec2 = NDIV(subsec, maxsubsec); /* negative div */

rb_raise(rb_eRangeError, "out of Time range");

}

subsec -= sec2 * maxsubsec;

sec += sec2;

}

*secp = sec;

*subsecp = subsec;

}

#define time_usec_normalize(secp, usecp) subsec_normalize(secp, usecp, 1000000)

#define time_nsec_normalize(secp, nsecp) subsec_normalize(secp, nsecp, 1000000000)

static VALUE

time_new_timew(VALUE klass, wideval_t timew)

{

return time;

}

VALUE

rb_time_new(time_t sec, long usec)

{

}

/* returns localtime time object */

VALUE

rb_time_nano_new(time_t sec, long nsec)

{

}

VALUE

rb_time_timespec_new(const struct timespec *ts, int offset)

{

struct time_object *tobj;

if (-86400 < offset && offset < 86400) { /* fixoff */

GetTimeval(time, tobj);

end

module_function :timeout

def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)

reprieve = apply_timeout_scale(reprieve) if reprieve

pgroup = pid

end

while signal = signals.shift

end

begin

end

def kill

signal = RUBY_PLATFORM =~ /mswin|mingw/ ? :KILL : :SEGV

Process.kill(signal, @pid)

warn "worker #{to_s} does not respond; #{signal} is sent"

parser.on '--repeat-count=NUM', "Number of times to repeat", Integer do |n|

options[:repeat_count] = n

end

end

def _run_anything(type)

@repeat_count = @options[:repeat_count]

super

end

end

[(@repeat_count ? "(#{@@current_repeat_count}/#{@repeat_count}) " : ""), type,

t, @test_count.fdiv(t), @assertion_count.fdiv(t)]

end while @repeat_count && @@current_repeat_count < @repeat_count &&

output.sync = old_sync if sync

void

rb_free_generic_ivar(VALUE obj)

{

}

}

}

fields_hash = ROBJECT_FIELDS_HASH(obj);

break;

default:

struct gen_fields_tbl *fields_tbl = NULL;

rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);

RUBY_ASSERT(fields_tbl);

fields = ROBJECT_FIELDS(obj);

break;

default:

struct gen_fields_tbl *fields_tbl = NULL;

rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);

RUBY_ASSERT(fields_tbl);

}

default:

shape_id = RBASIC_SHAPE_ID(obj);

struct gen_fields_tbl *fields_tbl;

rb_gen_fields_tbl_get(obj, id, &fields_tbl);

RUBY_ASSERT(removed_shape_id != INVALID_SHAPE_ID);

attr_index_t removed_index = RSHAPE_INDEX(removed_shape_id);

val = fields[removed_index];

if (RB_TYPE_P(obj, T_OBJECT) &&

!RB_FL_TEST_RAW(obj, ROBJECT_EMBED) &&

struct gen_fields_lookup_ensure_size {

VALUE obj;

ID id;

shape_id_t shape_id;

bool resize;

};

static VALUE *

generic_ivar_set_shape_fields(VALUE obj, void *data)

{

RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));

struct gen_fields_lookup_ensure_size *fields_lookup = data;

RB_VM_LOCKING() {

}

static void

generic_ivar_set_transition_too_complex(VALUE obj, void *_data)

{

shape_id_t new_shape_id = rb_evict_fields_to_hash(obj);

return new_shape_id;

}

RB_VM_LOCKING() {

st_insert(generic_fields_tbl(obj, fields_lookup->id, false), (st_data_t)obj, (st_data_t)fields_tbl);

}

}

RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));

rb_check_frozen(dest);

}

unsigned long src_num_ivs = rb_ivar_count(obj);

if (gen_fields_tbl_count(obj, obj_fields_tbl) == 0)

goto clear;

if (rb_shape_too_complex_p(src_shape_id)) {

rb_shape_copy_complex_ivars(dest, obj, src_shape_id, obj_fields_tbl->as.complex.table);

return;

if (!RSHAPE_LEN(dest_shape_id)) {

rb_obj_set_shape_id(dest, dest_shape_id);

return;

}

return;

clear:

}

void

rb_replace_generic_ivar(VALUE clone, VALUE obj)

{

RB_VM_LOCKING() {

st_data_t fields_tbl, obj_data = (st_data_t)obj;

if (st_delete(generic_fields_tbl_, &obj_data, &fields_tbl)) {

st_insert(generic_fields_tbl_, (st_data_t)clone, fields_tbl);

}

else {

rb_bug("unreachable");

}

break;

default:

gen_fields_each(obj, func, arg, ivar_only);

}

break;

return RBASIC_FIELDS_COUNT(fields_obj);

}

default:

struct gen_fields_tbl *fields_tbl;

if (rb_gen_fields_tbl_get(obj, 0, &fields_tbl)) {

} aux_;

};

/* VM_CALLCACHE_IVAR used for IVAR/ATTRSET/STRUCT_AREF/STRUCT_ASET methods */

#define VM_CALLCACHE_IVAR IMEMO_FL_USER0

#define VM_CALLCACHE_BF IMEMO_FL_USER1

#define VM_CALLCACHE_SUPER IMEMO_FL_USER2

#define VM_CALLCACHE_REFINEMENT IMEMO_FL_USER3

enum vm_cc_type {

cc_type_normal, // chained from ccs

break;

}

default:

struct gen_fields_tbl *fields_tbl;

rb_gen_fields_tbl_get(obj, id, &fields_tbl);

ivar_list = fields_tbl->as.shape.fields;

.allowlist_function("rb_obj_as_string_result")

.allowlist_function("rb_str_byte_substr")

.allowlist_function("rb_str_substr_two_fixnums")

// From include/ruby/internal/intern/parse.h

.allowlist_function("rb_backref_get")

jit_prepare_call_with_gc(jit, asm);

let recv_opnd = asm.stack_pop(1);

let recv_opnd = asm.load(recv_opnd);

// Call rb_str_dup

let stack_ret = asm.stack_push(Type::CString);

asm.mov(stack_ret, ret_opnd);

true

pub const RUBY_FL_UNUSED6: ruby_fl_type = 64;

pub const RUBY_FL_FINALIZE: ruby_fl_type = 128;

pub const RUBY_FL_TAINT: ruby_fl_type = 0;

pub const RUBY_FL_SHAREABLE: ruby_fl_type = 256;

pub const RUBY_FL_UNTRUSTED: ruby_fl_type = 0;

pub const RUBY_FL_UNUSED9: ruby_fl_type = 512;

pub const RUBY_FL_FREEZE: ruby_fl_type = 2048;

pub const RUBY_FL_USER0: ruby_fl_type = 4096;

pub const RUBY_FL_USER1: ruby_fl_type = 8192;

pub fn rb_gvar_set(arg1: ID, arg2: VALUE) -> VALUE;

pub fn rb_ensure_iv_list_size(obj: VALUE, current_len: u32, newsize: u32);

pub fn rb_vm_barrier();

pub fn rb_str_byte_substr(str_: VALUE, beg: VALUE, len: VALUE) -> VALUE;

pub fn rb_str_substr_two_fixnums(

str_: VALUE,

vec![X1_REG, X9_REG, X10_REG, X11_REG, X12_REG, X13_REG, X14_REG, X15_REG]

}

/// Split platform-specific instructions

/// The transformations done here are meant to make our lives simpler in later

/// stages of the compilation pipeline.

use std::collections::HashMap;

use std::fmt;

use std::mem::take;

use crate::{cruby::VALUE};

use crate::backend::current::*;

use crate::virtualmem::CodePtr;

asm_comment!(self, "write locals: {locals:?}");

for (idx, &opnd) in locals.iter().enumerate() {

let opnd = split_store_source(self, opnd);

}

asm_comment!(self, "save cfp->pc");

let cfp_sp = Opnd::mem(64, CFP, RUBY_OFFSET_CFP_SP);

self.store(cfp_sp, Opnd::Reg(Assembler::SCRATCH_REG));

asm_comment!(self, "exit to the interpreter");

self.frame_teardown();

self.mov(C_RET_OPND, Opnd::UImm(Qundef.as_u64()));

}

Some(())

}

}

impl fmt::Debug for Assembler {

vec![RAX_REG, RCX_REG, RDX_REG, RSI_REG, RDI_REG, R8_REG, R9_REG, R10_REG, R11_REG]

}

// These are the callee-saved registers in the x86-64 SysV ABI

// RBX, RSP, RBP, and R12–R15

Insn::IfTrue { val, target } => return gen_if_true(jit, asm, opnd!(val), target),

Insn::IfFalse { val, target } => return gen_if_false(jit, asm, opnd!(val), target),

Insn::SendWithoutBlock { call_info, cd, state, self_val, args, .. } => gen_send_without_block(jit, asm, call_info, *cd, &function.frame_state(*state), self_val, args)?,

Insn::Return { val } => return Some(gen_return(asm, opnd!(val))?),

Insn::FixnumAdd { left, right, state } => gen_fixnum_add(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,

Insn::FixnumSub { left, right, state } => gen_fixnum_sub(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,

Insn::GetIvar { self_val, id, state: _ } => gen_getivar(asm, opnd!(self_val), *id),

Insn::SetGlobal { id, val, state: _ } => gen_setglobal(asm, *id, opnd!(val)),

Insn::GetGlobal { id, state: _ } => gen_getglobal(asm, *id),

_ => {

debug!("ZJIT: gen_function: unexpected insn {:?}", insn);

return None;

}

};

// If the instruction has an output, remember it in jit.opnds

jit.opnds[insn_id.0] = Some(out_opnd);

}

/// Emit an uncached instance variable store

asm_comment!(asm, "call rb_ivar_set");

asm.ccall(

rb_ivar_set as *const u8,

vec![recv, Opnd::UImm(id.0), val],

}

/// Look up global variables

)

}

/// Compile an interpreter entry block to be inserted into an ISEQ

fn gen_entry_prologue(asm: &mut Assembler, iseq: IseqPtr) {

asm_comment!(asm, "ZJIT entry point: {}", iseq_get_location(iseq, 0));

self_val: &InsnId,

args: &Vec<InsnId>,

) -> Option<lir::Opnd> {

// TODO: Avoid spilling operands that have been spilled before.

for (idx, &insn_id) in [*self_val].iter().chain(args.iter()).enumerate() {

// Currently, we don't move the SP register. So it's equal to the base pointer.

let stack_opnd = Opnd::mem(64, SP, idx as i32 * SIZEOF_VALUE_I32);

cb: &mut CodeBlock,

jit: &mut JITState,

asm: &mut Assembler,

iseq: IseqPtr,

recv: Opnd,

args: &Vec<InsnId>,

) -> Option<lir::Opnd> {

asm_comment!(asm, "switch to new CFP");

let new_cfp = asm.sub(CFP, RUBY_SIZEOF_CONTROL_FRAME.into());

asm.mov(CFP, new_cfp);

jit.branch_iseqs.push((branch.clone(), iseq));

// TODO(max): Add a PatchPoint here that can side-exit the function if the callee messed with

// the frame's locals

}

/// Compile an array duplication instruction

asm.mov(cfp_sp, sp_addr);

}

/// Return a register we use for the basic block argument at a given index

fn param_reg(idx: usize) -> Reg {

// To simplify the implementation, allocate a fixed register for each basic block argument for now.

/// Inverse of ep_offset_to_local_idx(). See ep_offset_to_local_idx() for details.

fn local_idx_to_ep_offset(iseq: IseqPtr, local_idx: usize) -> i32 {

}

/// Convert ISEQ into High-level IR

move |code_ptr, _| {

start_branch.start_addr.set(Some(code_ptr));

},

end_branch.end_addr.set(Some(code_ptr));

},

)

}

pub const RUBY_FL_UNUSED6: ruby_fl_type = 64;

pub const RUBY_FL_FINALIZE: ruby_fl_type = 128;

pub const RUBY_FL_TAINT: ruby_fl_type = 0;

pub const RUBY_FL_SHAREABLE: ruby_fl_type = 256;

pub const RUBY_FL_UNTRUSTED: ruby_fl_type = 0;

pub const RUBY_FL_UNUSED9: ruby_fl_type = 512;

pub const RUBY_FL_FREEZE: ruby_fl_type = 2048;

pub const RUBY_FL_USER0: ruby_fl_type = 4096;

pub const RUBY_FL_USER1: ruby_fl_type = 8192;

/// Ignoring keyword arguments etc for now

SendWithoutBlock { self_val: InsnId, call_info: CallInfo, cd: *const rb_call_data, args: Vec<InsnId>, state: InsnId },

Send { self_val: InsnId, call_info: CallInfo, cd: *const rb_call_data, blockiseq: IseqPtr, args: Vec<InsnId>, state: InsnId },

/// Control flow instructions

Return { val: InsnId },

args: args.iter().map(|arg| find!(*arg)).collect(),

state: *state,

},

self_val: find!(*self_val),

call_info: call_info.clone(),

cd: *cd,

iseq: *iseq,

args: args.iter().map(|arg| find!(*arg)).collect(),

state: *state,

if let Some(expected) = guard_equal_to {

self_val = self.push_insn(block, Insn::GuardBitEquals { val: self_val, expected, state });

}

self.make_equal_to(insn_id, send_direct);

}

Insn::GetConstantPath { ic } => {

use crate::cruby::{self, rb_bug_panic_hook, EcPtr, Qnil, VALUE};

use crate::cruby_methods;

use crate::invariants::Invariants;

use crate::options::Options;

use crate::asm::CodeBlock;

#[allow(non_upper_case_globals)]

#[unsafe(no_mangle)]

/// Properties of core library methods

method_annotations: cruby_methods::Annotations,

}

/// Private singleton instance of the codegen globals

invariants: Invariants::default(),

assert_compiles: false,

method_annotations: cruby_methods::init(),

};

unsafe { ZJIT_STATE = Some(zjit_state); }

}

/// Return true if zjit_state has been initialized

instance.assert_compiles = true;

}

}

}

}