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"

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

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

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 {

if (rb_shape_too_complex_p(shape_id)) {

clone = rb_imemo_class_fields_new_complex(CLASS_OF(fields_obj), 0);

st_table *src_table = rb_imemo_class_fields_complex_tbl(fields_obj);

st_replace(rb_imemo_class_fields_complex_tbl(clone), src_table);

}

else {

clone = imemo_class_fields_new(CLASS_OF(fields_obj), RSHAPE_CAPACITY(shape_id));

MEMCPY(rb_imemo_class_fields_ptr(clone), rb_imemo_class_fields_ptr(fields_obj), VALUE, RSHAPE_LEN(shape_id));

}

= 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

if (ext)

return ext;

RB_VM_LOCKING() {

// re-check the classext is not created to avoid the multi-thread race

ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);

}

static inline VALUE

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

if (!ext->fields_obj) {

RB_OBJ_WRITE(obj, &ext->fields_obj, rb_imemo_class_fields_new(obj, 1));

}

RCLASSEXT_SET_FIELDS_OBJ(VALUE obj, rb_classext_t *ext, VALUE fields_obj)

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

static inline void

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

static inline uint32_t

RCLASS_FIELDS_COUNT(VALUE obj)

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

if (fields_obj) {

if (rb_shape_obj_too_complex_p(fields_obj)) {

return (uint32_t)rb_st_table_size(rb_imemo_class_fields_complex_tbl(fields_obj));

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

// If a code in the namespace adds a constant, the constant will be visible even from root/main.

RCLASS_SET_PRIME_CLASSEXT_WRITABLE(namespace, true);

// Get a clean constant table of Object even by writable one

// because ns was just created, so it has not touched any constants yet.

object_classext = RCLASS_EXT_WRITABLE_IN_NS(rb_cObject, ns);

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

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 {

}

}

RUBY_DEBUG_LOG("closed:%u@r%u", (unsigned int)ractor_port_id(rp), rb_ractor_id(rp->r));

if (raise_on_error) {

rb_raise(rb_eRactorClosedError, "The port was already closed");

}

}

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

#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

return LEAF;

}

else {

return left;

}

}

return LEAF;

}

else {

return right;

}

}

return 0;

}

else {

redblack_id_t id = (redblack_id_t)(node - redblack_nodes);

return id + 1;

}

static redblack_node_t *

redblack_new(char color, ID key, rb_shape_t *value, redblack_node_t *left, redblack_node_t *right)

{

// We're out of cache, just quit

return LEAF;

}

RUBY_ASSERT(left == LEAF || left->key < key);

RUBY_ASSERT(right == LEAF || right->key > key);

node->key = key;

node->value = (rb_shape_t *)((uintptr_t)value | color);

node->l = redblack_id_for(left);

}

#endif

static VALUE shape_tree_obj = Qfalse;

rb_shape_t *

rb_shape_get_root_shape(void)

{

}

static void

shape_tree_mark(void *data)

{

rb_shape_t *cursor = rb_shape_get_root_shape();

while (cursor < end) {

if (cursor->edges && !SINGLE_CHILD_P(cursor->edges)) {

rb_gc_mark_movable(cursor->edges);

shape_tree_compact(void *data)

{

rb_shape_t *cursor = rb_shape_get_root_shape();

while (cursor < end) {

if (cursor->edges && !SINGLE_CHILD_P(cursor->edges)) {

cursor->edges = rb_gc_location(cursor->edges);

static size_t

shape_tree_memsize(const void *data)

{

}

static const rb_data_type_t shape_tree_type = {

raw_shape_id(rb_shape_t *shape)

{

RUBY_ASSERT(shape);

}

static inline shape_id_t

shape_id(rb_shape_t *shape, shape_id_t previous_shape_id)

{

RUBY_ASSERT(shape);

return raw_id | (previous_shape_id & SHAPE_ID_FLAGS_MASK);

}

{

rb_shape_t *start = rb_shape_get_root_shape();

rb_shape_t *cursor = start;

while (cursor < end) {

callback((shape_id_t)(cursor - start), data);

cursor += 1;

}

}

RUBY_FUNC_EXPORTED shape_id_t

rb_obj_shape_id(VALUE obj)

{

}

if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {

if (fields_obj) {

return RBASIC_SHAPE_ID(fields_obj);

}

static rb_shape_t *

shape_alloc(void)

{

if (shape_id == (MAX_SHAPE_ID + 1)) {

// TODO: Make an OutOfShapesError ??

rb_bug("Out of shapes");

}

}

static rb_shape_t *

static attr_index_t

shape_grow_capa(attr_index_t current_capa)

{

// First try to use the next size that will be embeddable in a larger object slot.

attr_index_t capa;

if (!res) {

// If we're not allowed to create a new variation, of if we're out of shapes

// we return TOO_COMPLEX_SHAPE.

res = NULL;

}

else {

if (!res) {

// If we're not allowed to create a new variation, of if we're out of shapes

// we return TOO_COMPLEX_SHAPE.

res = NULL;

}

else {

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 actual_slot_size = rb_gc_obj_slot_size(obj);

if (shape_id_slot_size != actual_slot_size) {

static VALUE

rb_shape_shapes_available(VALUE self)

{

}

static VALUE

{

rb_check_arity(argc, 0, 1);

int offset = argc == 1 ? NUM2INT(argv[0]) : 0;

return Qnil;

}

rb_shape_find_by_id(VALUE mod, VALUE id)

{

shape_id_t shape_id = NUM2UINT(id);

rb_raise(rb_eArgError, "Shape ID %d is out of bounds\n", shape_id);

}

return shape_id_t_to_rb_cShape(shape_id);

void

Init_default_shapes(void)

{

size_t *heap_sizes = rb_gc_heap_sizes();

size_t heaps_count = 0;

while (heap_sizes[heaps_count]) {

for (index = 0; index < heaps_count; index++) {

capacities[index] = (heap_sizes[index] - sizeof(struct RBasic)) / sizeof(VALUE);

}

#ifdef HAVE_MMAP

size_t shape_list_mmap_size = rb_size_mul_or_raise(SHAPE_BUFFER_SIZE, sizeof(rb_shape_t), rb_eRuntimeError);

PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

}

else {

}

#else

#endif

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

PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

// If mmap fails, then give up on the redblack tree cache.

// We set the cache size such that the redblack node allocators think

// the cache is full.

}

else {

}

#endif

rb_shape_t *root = rb_shape_alloc_with_parent_id(0, INVALID_SHAPE_ID);

root->capacity = 0;

root->type = SHAPE_ROOT;

RUBY_ASSERT(raw_shape_id(root_with_obj_id) == ROOT_SHAPE_WITH_OBJ_ID);

}

void

rb_shape_free_all(void)

{

}

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 {

redblack_node_t *shape_cache;

unsigned int cache_size;

} rb_shape_tree_t;

union rb_attr_index_cache {

uint64_t pack;

} unpack;

};

static inline shape_id_t

RBASIC_SHAPE_ID(VALUE obj)

{

{

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

}

int32_t rb_shape_id_offset(void);

RUBY_FUNC_EXPORTED shape_id_t rb_obj_shape_id(VALUE obj);

shape_id_t rb_shape_get_next_iv_shape(shape_id_t shape_id, ID id);

bool rb_shape_get_iv_index(shape_id_t shape_id, ID id, attr_index_t *value);

{

uint8_t heap_index = rb_shape_heap_index(shape_id);

if (heap_index) {

}

return 0;

}

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

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_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

end;

end

def test_methods_added_in_namespace_are_invisible_globally

pend unless Namespace.enabled?

end

end

end

end;

end

def test_require_raises_and_no_ractor_belonging_issue

assert_ractor(<<~'RUBY')

require "tempfile"

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

void

rb_free_generic_ivar(VALUE obj)

{

}

}

}

if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {

ASSERT_vm_locking();

if (field_obj) {

return rb_obj_field_get(field_obj, target_shape_id);

}

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

{

if (SPECIAL_CONST_P(obj)) return undef;

shape_id_t shape_id;

switch (BUILTIN_TYPE(obj)) {

case T_CLASS:

case T_MODULE:

{

}

case T_IMEMO:

// Handled like T_OBJECT

{

RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_class_fields));

if (rb_shape_too_complex_p(shape_id)) {

VALUE val;

if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {

return val;

}

case T_OBJECT:

{

if (rb_shape_too_complex_p(shape_id)) {

VALUE val;

if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {

return val;

break;

}

default:

struct gen_fields_tbl *fields_tbl;

rb_gen_fields_tbl_get(obj, id, &fields_tbl);

if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {

IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(id);

if (fields_obj) {

val = rb_ivar_delete(fields_obj, id, undef);

}

}

}

shape_id_t old_shape_id = rb_obj_shape_id(obj);

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

obj_transition_too_complex(VALUE obj, st_table *table)

{

if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {

}

RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));

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

if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {

// Avoid creating the fields_obj just to freeze the class

if (!(shape_id == SPECIAL_CONST_SHAPE_ID && old_shape_id == ROOT_SHAPE_ID)) {

}

}

// FIXME: How to do multi-shape?

ivar_set(obj, id, val);

}

void

rb_obj_field_set(VALUE obj, shape_id_t target_shape_id, VALUE val)

{

break;

case T_CLASS:

case T_MODULE:

break;

default:

generic_field_set(obj, target_shape_id, val);

switch (BUILTIN_TYPE(obj)) {

case T_CLASS:

case T_MODULE:

if (fields_obj) {

defined = ivar_defined0(fields_obj, id);

}

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;

case T_CLASS:

case T_MODULE:

if (fields_obj) {

class_fields_each(fields_obj, func, arg, ivar_only);

}

}

break;

default:

gen_fields_each(obj, func, arg, ivar_only);

}

break;

case T_CLASS:

case T_MODULE:

{

if (!fields_obj) {

return 0;

}

return RBASIC_FIELDS_COUNT(fields_obj);

}

default:

struct gen_fields_tbl *fields_tbl;

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

return rb_ivar_set(obj, id, val);

}

{

bool existing = true;

shape_id_t current_shape_id = RBASIC_SHAPE_ID(fields_obj);

if (UNLIKELY(rb_shape_too_complex_p(current_shape_id))) {

goto too_complex;

}

next_shape_id = rb_shape_transition_add_ivar(fields_obj, id);

if (UNLIKELY(rb_shape_too_complex_p(next_shape_id))) {

attr_index_t current_len = RSHAPE_LEN(current_shape_id);

if (current_len) {

rb_obj_copy_fields_to_hash_table(original_fields_obj, rb_imemo_class_fields_complex_tbl(fields_obj));

RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id);

attr_index_t next_capacity = RSHAPE_CAPACITY(next_shape_id);

attr_index_t current_capacity = RSHAPE_CAPACITY(current_shape_id);

if (original_fields_obj) {

MEMCPY(rb_imemo_class_fields_ptr(fields_obj), rb_imemo_class_fields_ptr(original_fields_obj), VALUE, RSHAPE_LEN(current_shape_id));

}

VALUE *fields = rb_imemo_class_fields_ptr(fields_obj);

RB_OBJ_WRITE(fields_obj, &fields[index], val);

if (!existing) {

RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id);

}

return existing;

too_complex:

if (fields_obj != original_fields_obj) {

RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id);

}

}

return existing;

}

rb_class_ivar_set(VALUE obj, ID id, VALUE val)

{

RUBY_ASSERT(RB_TYPE_P(obj, T_CLASS) || RB_TYPE_P(obj, T_MODULE));

rb_check_frozen(obj);

rb_class_ensure_writable(obj);

}

static int

SET(constant_cache_invalidations, ruby_vm_constant_cache_invalidations);

SET(constant_cache_misses, ruby_vm_constant_cache_misses);

SET(global_cvar_state, ruby_vm_global_cvar_state);

#undef SET

#if USE_DEBUG_COUNTER

} 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

}

}

if (!fields_obj) {

return default_value;

}

break;

}

default:

struct gen_fields_tbl *fields_tbl;

rb_gen_fields_tbl_get(obj, id, &fields_tbl);

ivar_list = fields_tbl->as.shape.fields;

rb_object_shape_count(void)

{

// next_shape_id starts from 0, so it's the same as the count

}

bool

return RSHAPE_CAPACITY(shape_id);

}

// Assert that we have the VM lock. Relevant mostly for multi ractor situations.

// The GC takes the lock before calling us, and this asserts that it indeed happens.

void

// From shape.h

.allowlist_function("rb_obj_shape_id")

.allowlist_function("rb_shape_id_offset")

.allowlist_function("rb_shape_get_iv_index")

.allowlist_function("rb_shape_transition_add_ivar_no_warnings")

.allowlist_function("rb_yjit_shape_obj_too_complex_p")

.allowlist_function("rb_yjit_shape_too_complex_p")

.allowlist_function("rb_yjit_shape_capacity")

.allowlist_var("SHAPE_ID_NUM_BITS")

// From ruby/internal/intern/object.h

.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")

if new_shape_too_complex {

Some((next_shape_id, None, 0_usize))

} else {

let current_capacity = unsafe { rb_yjit_shape_capacity(current_shape_id) };

let next_capacity = unsafe { rb_yjit_shape_capacity(next_shape_id) };

let needs_extension = next_capacity != current_capacity;

// We can write to the object, but we need to transition the shape

let needs_extension = if needs_extension {

Some((current_capacity, next_capacity))

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

unsafe { rb_obj_shape_id(self) }

}

pub fn embedded_p(self) -> bool {

unsafe {

FL_TEST_RAW(self, VALUE(ROBJECT_EMBED as usize)) != VALUE(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;

pub type vm_frame_env_flags = u32;

pub type attr_index_t = u16;

pub type shape_id_t = u32;

#[repr(C)]

pub struct rb_cvar_class_tbl_entry {

pub index: u32,

pub fn rb_obj_info(obj: VALUE) -> *const ::std::os::raw::c_char;

pub fn rb_ec_stack_check(ec: *mut rb_execution_context_struct) -> ::std::os::raw::c_int;

pub fn rb_shape_id_offset() -> i32;

pub fn rb_obj_shape_id(obj: VALUE) -> shape_id_t;

pub fn rb_shape_get_iv_index(shape_id: shape_id_t, id: ID, value: *mut attr_index_t) -> bool;

pub fn rb_shape_transition_add_ivar_no_warnings(obj: VALUE, id: ID) -> shape_id_t;

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,

pub fn rb_yjit_shape_too_complex_p(shape_id: shape_id_t) -> bool;

pub fn rb_yjit_shape_obj_too_complex_p(obj: VALUE) -> bool;

pub fn rb_yjit_shape_capacity(shape_id: shape_id_t) -> attr_index_t;

pub fn rb_yjit_assert_holding_vm_lock();

pub fn rb_yjit_sendish_sp_pops(ci: *const rb_callinfo) -> usize;

pub fn rb_yjit_invokeblock_sp_pops(ci: *const rb_callinfo) -> usize;

// From shape.h

.allowlist_function("rb_obj_shape_id")

.allowlist_function("rb_shape_id_offset")

.allowlist_function("rb_shape_get_iv_index")

.allowlist_function("rb_shape_transition_add_ivar_no_warnings")

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

},

)

}

unsafe { rb_obj_shape_id(self) }

}

pub fn embedded_p(self) -> bool {

unsafe {

FL_TEST_RAW(self, VALUE(ROBJECT_EMBED as usize)) != VALUE(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;

pub type vm_frame_env_flags = u32;

pub type attr_index_t = u16;

pub type shape_id_t = u32;

#[repr(C)]

pub struct rb_cvar_class_tbl_entry {

pub index: u32,

pub fn rb_obj_info(obj: VALUE) -> *const ::std::os::raw::c_char;

pub fn rb_ec_stack_check(ec: *mut rb_execution_context_struct) -> ::std::os::raw::c_int;

pub fn rb_shape_id_offset() -> i32;

pub fn rb_obj_shape_id(obj: VALUE) -> shape_id_t;

pub fn rb_shape_get_iv_index(shape_id: shape_id_t, id: ID, value: *mut attr_index_t) -> bool;

pub fn rb_shape_transition_add_ivar_no_warnings(obj: VALUE, id: ID) -> shape_id_t;

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

}

}

}

}