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

${{ 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() }}

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

}

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

def str_dup(str) = str.dup

str = "str"

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

{

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: {

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);

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",

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:

rb_bug("Unreacheable");

}

}

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);

}

#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;

}

}

}

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);

root->type = SHAPE_ROOT;

rb_shape_tree.root_shape = root;

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

bool dontcare;

rb_shape_t *root_with_obj_id = get_next_shape_internal(root, id_object_id, SHAPE_OBJ_ID, &dontcare, true);

RUBY_ASSERT(root_with_obj_id->type == SHAPE_OBJ_ID);

RUBY_ASSERT(root_with_obj_id->edge_name == id_object_id);

RUBY_ASSERT(root_with_obj_id->next_field_index == 1);

}

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.

{

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);

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);

end

end

end

require "tempfile"

require "pathname"

f = Tempfile.new(["file_to_require_from_ractor", ".rb"])

f.flush

result = Ractor.new(f.path) do |path|

require Pathname.new(path)

}

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)

RUBY

end

def test_tcp_socket_one_hostname_resolution_succeeded_at_least

opts = %w[-rsocket -W1]

assert_separately opts, <<~RUBY

#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;

}

# 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))

}

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);

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)) {

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,

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));

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;