/**********************************************************************

compile.c - ruby node tree -> VM instruction sequence

$Author$

created at: 04/01/01 03:42:15 JST

Copyright (C) 2004-2007 Koichi Sasada

**********************************************************************/

#include "ruby/internal/config.h"

#include <math.h>

#ifdef HAVE_DLADDR

# include <dlfcn.h>

#endif

#include "encindex.h"

#include "id_table.h"

#include "internal.h"

#include "internal/array.h"

#include "internal/compile.h"

#include "internal/complex.h"

#include "internal/encoding.h"

#include "internal/error.h"

#include "internal/gc.h"

#include "internal/hash.h"

#include "internal/io.h"

#include "internal/numeric.h"

#include "internal/object.h"

#include "internal/rational.h"

#include "internal/re.h"

#include "internal/ruby_parser.h"

#include "internal/symbol.h"

#include "internal/thread.h"

#include "internal/variable.h"

#include "iseq.h"

#include "ruby/ractor.h"

#include "ruby/re.h"

#include "ruby/util.h"

#include "vm_core.h"

#include "vm_callinfo.h"

#include "vm_debug.h"

#include "yjit.h"

#include "builtin.h"

#include "insns.inc"

#include "insns_info.inc"

#define FIXNUM_INC(n, i) ((n) (INT2FIX(i)&~FIXNUM_FLAG))

#define FIXNUM_OR(n, i) ((n)|INT2FIX(i))

typedef struct iseq_link_element {

} LINK_ELEMENT;

typedef struct iseq_link_anchor {

LINK_ELEMENT anchor;

LINK_ELEMENT *last;

} LINK_ANCHOR;

typedef enum {

LABEL_RESCUE_NONE,

LABEL_RESCUE_BEG,

LABEL_RESCUE_END,

LABEL_RESCUE_TYPE_MAX

} LABEL_RESCUE_TYPE;

typedef struct iseq_label_data {

} LABEL;

typedef struct iseq_insn_data {

} INSN;

typedef struct iseq_adjust_data {

} ADJUST;

typedef struct iseq_trace_data {

} TRACE;

struct ensure_range {

};

struct iseq_compile_data_ensure_node_stack {

};

const ID rb_iseq_shared_exc_local_tbl[] = {idERROR_INFO};

/**

* debug function(macro) interface depend on CPDEBUG

* if it is less than 0, runtime option is in effect.

*

* debug level:

* 0: no debug output

* 1: show node type

* 2: show node important parameters

* ...

* 5: show other parameters

* 10: show every AST array

*/

#ifndef CPDEBUG

#define CPDEBUG 0

#endif

#if CPDEBUG >= 0

#define compile_debug CPDEBUG

#else

#define compile_debug ISEQ_COMPILE_DATA(iseq)->option->debug_level

#endif

#if CPDEBUG

#define compile_debug_print_indent(level) \

ruby_debug_print_indent((level), compile_debug, gl_node_level * 2)

#define debugp(header, value) (void) \

(compile_debug_print_indent(1) && \

ruby_debug_print_value(1, compile_debug, (header), (value)))

#define debugi(header, id) (void) \

(compile_debug_print_indent(1) && \

ruby_debug_print_id(1, compile_debug, (header), (id)))

#define debugp_param(header, value) (void) \

(compile_debug_print_indent(1) && \

ruby_debug_print_value(1, compile_debug, (header), (value)))

#define debugp_verbose(header, value) (void) \

(compile_debug_print_indent(2) && \

ruby_debug_print_value(2, compile_debug, (header), (value)))

#define debugp_verbose_node(header, value) (void) \

(compile_debug_print_indent(10) && \

ruby_debug_print_value(10, compile_debug, (header), (value)))

#define debug_node_start(node) ((void) \

(compile_debug_print_indent(1) && \

(ruby_debug_print_node(1, CPDEBUG, "", (const NODE *)(node)), gl_node_level)), \

gl_node_level )

#define debug_node_end() gl_node_level --

#else

#define debugi(header, id) ((void)0)

#define debugp(header, value) ((void)0)

#define debugp_verbose(header, value) ((void)0)

#define debugp_verbose_node(header, value) ((void)0)

#define debugp_param(header, value) ((void)0)

#define debug_node_start(node) ((void)0)

#define debug_node_end() ((void)0)

#endif

#if CPDEBUG > 1 || CPDEBUG < 0

#undef printf

#define printf ruby_debug_printf

#define debugs if (compile_debug_print_indent(1)) ruby_debug_printf

#define debug_compile(msg, v) ((void)(compile_debug_print_indent(1) && fputs((msg), stderr)), (v))

#else

#define debugs if(0)printf

#define debug_compile(msg, v) (v)

#endif

#define LVAR_ERRINFO (1)

/* create new label */

#define NEW_LABEL(l) new_label_body(iseq, (l))

#define LABEL_FORMAT "<Ld>"

#define NEW_ISEQ(node, name, type, line_no) \

new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))

#define NEW_CHILD_ISEQ(node, name, type, line_no) \

new_child_iseq(iseq, (node), rb_fstring(name), iseq, (type), (line_no))

/* add instructions */

#define ADD_SEQ(seq1, seq2) \

APPEND_LIST((seq1), (seq2))

/* add an instruction */

#define ADD_INSN(seq, line_node, insn) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, nd_line(line_node), nd_node_id(line_node), BIN(insn), 0))

/* add an instruction with the given line number and node id */

#define ADD_SYNTHETIC_INSN(seq, line_no, node_id, insn) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (line_no), (node_id), BIN(insn), 0))

/* insert an instruction before next */

#define INSERT_BEFORE_INSN(next, line_no, node_id, insn) \

ELEM_INSERT_PREV(&(next)->link, (LINK_ELEMENT *) new_insn_body(iseq, line_no, node_id, BIN(insn), 0))

/* insert an instruction after prev */

#define INSERT_AFTER_INSN(prev, line_no, node_id, insn) \

ELEM_INSERT_NEXT(&(prev)->link, (LINK_ELEMENT *) new_insn_body(iseq, line_no, node_id, BIN(insn), 0))

/* add an instruction with some operands (1, 2, 3, 5) */

#define ADD_INSN1(seq, line_node, insn, op1) \

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, nd_line(line_node), nd_node_id(line_node), BIN(insn), 1, (VALUE)(op1)))

/* insert an instruction with some operands (1, 2, 3, 5) before next */

#define INSERT_BEFORE_INSN1(next, line_no, node_id, insn, op1) \

ELEM_INSERT_PREV(&(next)->link, (LINK_ELEMENT *) \

new_insn_body(iseq, line_no, node_id, BIN(insn), 1, (VALUE)(op1)))

/* insert an instruction with some operands (1, 2, 3, 5) after prev */

#define INSERT_AFTER_INSN1(prev, line_no, node_id, insn, op1) \

ELEM_INSERT_NEXT(&(prev)->link, (LINK_ELEMENT *) \

new_insn_body(iseq, line_no, node_id, BIN(insn), 1, (VALUE)(op1)))

#define LABEL_REF(label) ((label)->refcnt )

/* add an instruction with label operand (alias of ADD_INSN1) */

#define ADD_INSNL(seq, line_node, insn, label) (ADD_INSN1(seq, line_node, insn, label), LABEL_REF(label))

#define ADD_INSN2(seq, line_node, insn, op1, op2) \

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, nd_line(line_node), nd_node_id(line_node), BIN(insn), 2, (VALUE)(op1), (VALUE)(op2)))

#define ADD_INSN3(seq, line_node, insn, op1, op2, op3) \

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, nd_line(line_node), nd_node_id(line_node), BIN(insn), 3, (VALUE)(op1), (VALUE)(op2), (VALUE)(op3)))

/* Specific Insn factory */

#define ADD_SEND(seq, line_node, id, argc) \

ADD_SEND_R((seq), (line_node), (id), (argc), NULL, (VALUE)INT2FIX(0), NULL)

#define ADD_SEND_WITH_FLAG(seq, line_node, id, argc, flag) \

ADD_SEND_R((seq), (line_node), (id), (argc), NULL, (VALUE)(flag), NULL)

#define ADD_SEND_WITH_BLOCK(seq, line_node, id, argc, block) \

ADD_SEND_R((seq), (line_node), (id), (argc), (block), (VALUE)INT2FIX(0), NULL)

#define ADD_CALL_RECEIVER(seq, line_node) \

ADD_INSN((seq), (line_node), putself)

#define ADD_CALL(seq, line_node, id, argc) \

ADD_SEND_R((seq), (line_node), (id), (argc), NULL, (VALUE)INT2FIX(VM_CALL_FCALL), NULL)

#define ADD_CALL_WITH_BLOCK(seq, line_node, id, argc, block) \

ADD_SEND_R((seq), (line_node), (id), (argc), (block), (VALUE)INT2FIX(VM_CALL_FCALL), NULL)

#define ADD_SEND_R(seq, line_node, id, argc, block, flag, keywords) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_send(iseq, nd_line(line_node), nd_node_id(line_node), (id), (VALUE)(argc), (block), (VALUE)(flag), (keywords)))

#define ADD_TRACE(seq, event) \

ADD_ELEM((seq), (LINK_ELEMENT *)new_trace_body(iseq, (event), 0))

#define ADD_TRACE_WITH_DATA(seq, event, data) \

ADD_ELEM((seq), (LINK_ELEMENT *)new_trace_body(iseq, (event), (data)))

static void iseq_add_getlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, const NODE *const line_node, int idx, int level);

static void iseq_add_setlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, const NODE *const line_node, int idx, int level);

#define ADD_GETLOCAL(seq, line_node, idx, level) iseq_add_getlocal(iseq, (seq), (line_node), (idx), (level))

#define ADD_SETLOCAL(seq, line_node, idx, level) iseq_add_setlocal(iseq, (seq), (line_node), (idx), (level))

/* add label */

#define ADD_LABEL(seq, label) \

ADD_ELEM((seq), (LINK_ELEMENT *) (label))

#define APPEND_LABEL(seq, before, label) \

APPEND_ELEM((seq), (before), (LINK_ELEMENT *) (label))

#define ADD_ADJUST(seq, line_node, label) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), nd_line(line_node)))

#define ADD_ADJUST_RESTORE(seq, label) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), -1))

#define LABEL_UNREMOVABLE(label) \

((label) ? (LABEL_REF(label), (label)->unremovable=1) : 0)

#define ADD_CATCH_ENTRY(type, ls, le, iseqv, lc) do { \

VALUE _e = rb_ary_new3(5, (type), \

(VALUE)(ls) | 1, (VALUE)(le) | 1, \

(VALUE)(iseqv), (VALUE)(lc) | 1); \

LABEL_UNREMOVABLE(ls); \

LABEL_REF(le); \

LABEL_REF(lc); \

if (NIL_P(ISEQ_COMPILE_DATA(iseq)->catch_table_ary)) \

RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->catch_table_ary, rb_ary_hidden_new(3)); \

rb_ary_push(ISEQ_COMPILE_DATA(iseq)->catch_table_ary, freeze_hide_obj(_e)); \

} while (0)

/* compile node */

#define COMPILE(anchor, desc, node) \

(debug_compile("== " desc "\n", \

iseq_compile_each(iseq, (anchor), (node), 0)))

/* compile node, this node's value will be popped */

#define COMPILE_POPPED(anchor, desc, node) \

(debug_compile("== " desc "\n", \

iseq_compile_each(iseq, (anchor), (node), 1)))

/* compile node, which is popped when 'popped' is true */

#define COMPILE_(anchor, desc, node, popped) \

(debug_compile("== " desc "\n", \

iseq_compile_each(iseq, (anchor), (node), (popped))))

#define COMPILE_RECV(anchor, desc, node, recv) \

(private_recv_p(node) ? \

(ADD_INSN(anchor, node, putself), VM_CALL_FCALL) : \

COMPILE(anchor, desc, recv) ? 0 : -1)

#define OPERAND_AT(insn, idx) \

(((INSN*)(insn))->operands[(idx)])

#define INSN_OF(insn) \

(((INSN*)(insn))->insn_id)

#define IS_INSN(link) ((link)->type == ISEQ_ELEMENT_INSN)

#define IS_LABEL(link) ((link)->type == ISEQ_ELEMENT_LABEL)

#define IS_ADJUST(link) ((link)->type == ISEQ_ELEMENT_ADJUST)

#define IS_TRACE(link) ((link)->type == ISEQ_ELEMENT_TRACE)

#define IS_INSN_ID(iobj, insn) (INSN_OF(iobj) == BIN(insn))

#define IS_NEXT_INSN_ID(link, insn) \

((link)->next && IS_INSN((link)->next) && IS_INSN_ID((link)->next, insn))

/* error */

#if CPDEBUG > 0

RBIMPL_ATTR_NORETURN()

#endif

RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 4)

static void

append_compile_error(const rb_iseq_t *iseq, int line, const char *fmt, ...)

{

VALUE err_info = ISEQ_COMPILE_DATA(iseq)->err_info;

VALUE file = rb_iseq_path(iseq);

VALUE err = err_info == Qtrue ? Qfalse : err_info;

va_list args;

va_start(args, fmt);

err = rb_syntax_error_append(err, file, line, -1, NULL, fmt, args);

va_end(args);

if (NIL_P(err_info)) {

RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->err_info, err);

rb_set_errinfo(err);

}

else if (!err_info) {

RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->err_info, Qtrue);

}

if (compile_debug) {

if (SPECIAL_CONST_P(err)) err = rb_eSyntaxError;

rb_exc_fatal(err);

}

}

#if 0

static void

compile_bug(rb_iseq_t *iseq, int line, const char *fmt, ...)

{

va_list args;

va_start(args, fmt);

rb_report_bug_valist(rb_iseq_path(iseq), line, fmt, args);

va_end(args);

abort();

}

#endif

#define COMPILE_ERROR append_compile_error

#define ERROR_ARGS_AT(n) iseq, nd_line(n),

#define ERROR_ARGS ERROR_ARGS_AT(node)

#define EXPECT_NODE(prefix, node, ndtype, errval) \

do { \

const NODE *error_node = (node); \

enum node_type error_type = nd_type(error_node); \

if (error_type != (ndtype)) { \

COMPILE_ERROR(ERROR_ARGS_AT(error_node) \

prefix ": " #ndtype " is expected, but %s", \

ruby_node_name(error_type)); \

return errval; \

} \

} while (0)

#define EXPECT_NODE_NONULL(prefix, parent, ndtype, errval) \

do { \

COMPILE_ERROR(ERROR_ARGS_AT(parent) \

prefix ": must be " #ndtype ", but 0"); \

return errval; \

} while (0)

#define UNKNOWN_NODE(prefix, node, errval) \

do { \

const NODE *error_node = (node); \

COMPILE_ERROR(ERROR_ARGS_AT(error_node) prefix ": unknown node (%s)", \

ruby_node_name(nd_type(error_node))); \

return errval; \

} while (0)

#define COMPILE_OK 1

#define COMPILE_NG 0

#define CHECK(sub) if (!(sub)) {BEFORE_RETURN;return COMPILE_NG;}

#define NO_CHECK(sub) (void)(sub)

#define BEFORE_RETURN

/* leave name uninitialized so that compiler warn if INIT_ANCHOR is

* missing */

#define DECL_ANCHOR(name) \

LINK_ANCHOR name[1] = {{{ISEQ_ELEMENT_ANCHOR,},}}

#define INIT_ANCHOR(name) \

(name->last = &name->anchor)

static inline VALUE

freeze_hide_obj(VALUE obj)

{

OBJ_FREEZE(obj);

RBASIC_CLEAR_CLASS(obj);

return obj;

}

#include "optinsn.inc"

#if OPT_INSTRUCTIONS_UNIFICATION

#include "optunifs.inc"

#endif

/* for debug */

#if CPDEBUG < 0

#define ISEQ_ARG iseq,

#define ISEQ_ARG_DECLARE rb_iseq_t *iseq,

#else

#define ISEQ_ARG

#define ISEQ_ARG_DECLARE

#endif

#if CPDEBUG

#define gl_node_level ISEQ_COMPILE_DATA(iseq)->node_level

#endif

static void dump_disasm_list_with_cursor(const LINK_ELEMENT *link, const LINK_ELEMENT *curr, const LABEL *dest);

static void dump_disasm_list(const LINK_ELEMENT *elem);

static int insn_data_length(INSN *iobj);

static int calc_sp_depth(int depth, INSN *iobj);

static INSN *new_insn_body(rb_iseq_t *iseq, int line_no, int node_id, enum ruby_vminsn_type insn_id, int argc, ...);

static LABEL *new_label_body(rb_iseq_t *iseq, long line);

static ADJUST *new_adjust_body(rb_iseq_t *iseq, LABEL *label, int line);

static TRACE *new_trace_body(rb_iseq_t *iseq, rb_event_flag_t event, long data);

static int iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *anchor, const NODE *n, int);

static int iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *const anchor);

static int iseq_setup_insn(rb_iseq_t *iseq, LINK_ANCHOR *const anchor);

static int iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *const anchor);

static int iseq_insns_unification(rb_iseq_t *iseq, LINK_ANCHOR *const anchor);

static int iseq_set_local_table(rb_iseq_t *iseq, const rb_ast_id_table_t *tbl, const NODE *const node_args);

static int iseq_set_exception_local_table(rb_iseq_t *iseq);

static int iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *const anchor, const NODE *const node);

static int iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *const anchor);

static int iseq_set_exception_table(rb_iseq_t *iseq);

static int iseq_set_optargs_table(rb_iseq_t *iseq);

static int compile_defined_expr(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node, VALUE needstr);

static int compile_hash(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *node, int method_call_keywords, int popped);

/*

* To make Array to LinkedList, use link_anchor

*/

static void

verify_list(ISEQ_ARG_DECLARE const char *info, LINK_ANCHOR *const anchor)

{

#if CPDEBUG

int flag = 0;

LINK_ELEMENT *list, *plist;

if (!compile_debug) return;

list = anchor->anchor.next;

plist = &anchor->anchor;

while (list) {

if (plist != list->prev) {

flag = 1;

}

plist = list;

list = list->next;

}

if (anchor->last != plist && anchor->last != 0) {

flag |= 0x70000;

}

if (flag != 0) {

rb_bug("list verify error: x (%s)", flag, info);

}

#endif

}

#if CPDEBUG < 0

#define verify_list(info, anchor) verify_list(iseq, (info), (anchor))

#endif

static void

verify_call_cache(rb_iseq_t *iseq)

{

#if CPDEBUG

VALUE *original = rb_iseq_original_iseq(iseq);

size_t i = 0;

while (i < ISEQ_BODY(iseq)->iseq_size) {

VALUE insn = original[i];

const char *types = insn_op_types(insn);

for (int j=0; types[j]; j ) {

if (types[j] == TS_CALLDATA) {

struct rb_call_data *cd = (struct rb_call_data *)original[i j 1];

const struct rb_callinfo *ci = cd->ci;

const struct rb_callcache *cc = cd->cc;

if (cc != vm_cc_empty()) {

vm_ci_dump(ci);

rb_bug("call cache is not initialized by vm_cc_empty()");

}

}

}

i = insn_len(insn);

}

for (unsigned int i=0; i<ISEQ_BODY(iseq)->ci_size; i ) {

struct rb_call_data *cd = &ISEQ_BODY(iseq)->call_data[i];

const struct rb_callinfo *ci = cd->ci;

const struct rb_callcache *cc = cd->cc;

if (cc != NULL && cc != vm_cc_empty()) {

vm_ci_dump(ci);

rb_bug("call cache is not initialized by vm_cc_empty()");

}

}

#endif

}

/*

* elem1, elem2 => elem1, elem2, elem

*/

static void

ADD_ELEM(ISEQ_ARG_DECLARE LINK_ANCHOR *const anchor, LINK_ELEMENT *elem)

{

elem->prev = anchor->last;

anchor->last->next = elem;

anchor->last = elem;

verify_list("add", anchor);

}

/*

* elem1, before, elem2 => elem1, before, elem, elem2

*/

static void

APPEND_ELEM(ISEQ_ARG_DECLARE LINK_ANCHOR *const anchor, LINK_ELEMENT *before, LINK_ELEMENT *elem)

{

elem->prev = before;

elem->next = before->next;

elem->next->prev = elem;

before->next = elem;

if (before == anchor->last) anchor->last = elem;

verify_list("add", anchor);

}

#if CPDEBUG < 0

#define ADD_ELEM(anchor, elem) ADD_ELEM(iseq, (anchor), (elem))

#define APPEND_ELEM(anchor, before, elem) APPEND_ELEM(iseq, (anchor), (before), (elem))

#endif

static int

branch_coverage_valid_p(rb_iseq_t *iseq, int first_line)

{

if (!ISEQ_COVERAGE(iseq)) return 0;

if (!ISEQ_BRANCH_COVERAGE(iseq)) return 0;

if (first_line <= 0) return 0;

return 1;

}

#define PTR2NUM(x) (rb_int2inum((intptr_t)(void *)(x)))

static VALUE

decl_branch_base(rb_iseq_t *iseq, VALUE key, const rb_code_location_t *loc, const char *type)

{

const int first_lineno = loc->beg_pos.lineno, first_column = loc->beg_pos.column;

const int last_lineno = loc->end_pos.lineno, last_column = loc->end_pos.column;

if (!branch_coverage_valid_p(iseq, first_lineno)) return Qundef;

/*

* if !structure[node]

* structure[node] = [type, first_lineno, first_column, last_lineno, last_column, branches = {}]

* else

* branches = structure[node][5]

* end

*/

VALUE structure = RARRAY_AREF(ISEQ_BRANCH_COVERAGE(iseq), 0);

VALUE branch_base = rb_hash_aref(structure, key);

VALUE branches;

if (NIL_P(branch_base)) {

branch_base = rb_ary_hidden_new(6);

rb_hash_aset(structure, key, branch_base);

rb_ary_push(branch_base, ID2SYM(rb_intern(type)));

rb_ary_push(branch_base, INT2FIX(first_lineno));

rb_ary_push(branch_base, INT2FIX(first_column));

rb_ary_push(branch_base, INT2FIX(last_lineno));

rb_ary_push(branch_base, INT2FIX(last_column));

branches = rb_hash_new();

rb_obj_hide(branches);

rb_ary_push(branch_base, branches);

}

else {

branches = RARRAY_AREF(branch_base, 5);

}

return branches;

}

static NODE

generate_dummy_line_node(int lineno, int node_id)

{

NODE dummy = { 0 };

nd_set_line(&dummy, lineno);

nd_set_node_id(&dummy, node_id);

return dummy;

}

static void

add_trace_branch_coverage(rb_iseq_t *iseq, LINK_ANCHOR *const seq, const rb_code_location_t *loc, int node_id, int branch_id, const char *type, VALUE branches)

{

const int first_lineno = loc->beg_pos.lineno, first_column = loc->beg_pos.column;

const int last_lineno = loc->end_pos.lineno, last_column = loc->end_pos.column;

if (!branch_coverage_valid_p(iseq, first_lineno)) return;

/*

* if !branches[branch_id]

* branches[branch_id] = [type, first_lineno, first_column, last_lineno, last_column, counter_idx]

* else

* counter_idx= branches[branch_id][5]

* end

*/

VALUE key = INT2FIX(branch_id);

VALUE branch = rb_hash_aref(branches, key);

long counter_idx;

if (NIL_P(branch)) {

branch = rb_ary_hidden_new(6);

rb_hash_aset(branches, key, branch);

rb_ary_push(branch, ID2SYM(rb_intern(type)));

rb_ary_push(branch, INT2FIX(first_lineno));

rb_ary_push(branch, INT2FIX(first_column));

rb_ary_push(branch, INT2FIX(last_lineno));

rb_ary_push(branch, INT2FIX(last_column));

VALUE counters = RARRAY_AREF(ISEQ_BRANCH_COVERAGE(iseq), 1);

counter_idx = RARRAY_LEN(counters);

rb_ary_push(branch, LONG2FIX(counter_idx));

rb_ary_push(counters, INT2FIX(0));

}

else {

counter_idx = FIX2LONG(RARRAY_AREF(branch, 5));

}

ADD_TRACE_WITH_DATA(seq, RUBY_EVENT_COVERAGE_BRANCH, counter_idx);

ADD_SYNTHETIC_INSN(seq, last_lineno, node_id, nop);

}

#define ISEQ_LAST_LINE(iseq) (ISEQ_COMPILE_DATA(iseq)->last_line)

static int

validate_label(st_data_t name, st_data_t label, st_data_t arg)

{

rb_iseq_t *iseq = (rb_iseq_t *)arg;

LABEL *lobj = (LABEL *)label;

if (!lobj->link.next) {

do {

COMPILE_ERROR(iseq, lobj->position,

"%"PRIsVALUE": undefined label",

rb_sym2str((VALUE)name));

} while (0);

}

return ST_CONTINUE;

}

static void

validate_labels(rb_iseq_t *iseq, st_table *labels_table)

{

st_foreach(labels_table, validate_label, (st_data_t)iseq);

st_free_table(labels_table);

}

static NODE *

get_nd_recv(const NODE *node)

{

switch (nd_type(node)) {

case NODE_CALL:

return RNODE_CALL(node)->nd_recv;

case NODE_OPCALL:

return RNODE_OPCALL(node)->nd_recv;

case NODE_FCALL:

return 0;

case NODE_QCALL:

return RNODE_QCALL(node)->nd_recv;

case NODE_VCALL:

return 0;

case NODE_ATTRASGN:

return RNODE_ATTRASGN(node)->nd_recv;

case NODE_OP_ASGN1:

return RNODE_OP_ASGN1(node)->nd_recv;

case NODE_OP_ASGN2:

return RNODE_OP_ASGN2(node)->nd_recv;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static ID

get_node_call_nd_mid(const NODE *node)

{

switch (nd_type(node)) {

case NODE_CALL:

return RNODE_CALL(node)->nd_mid;

case NODE_OPCALL:

return RNODE_OPCALL(node)->nd_mid;

case NODE_FCALL:

return RNODE_FCALL(node)->nd_mid;

case NODE_QCALL:

return RNODE_QCALL(node)->nd_mid;

case NODE_VCALL:

return RNODE_VCALL(node)->nd_mid;

case NODE_ATTRASGN:

return RNODE_ATTRASGN(node)->nd_mid;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static NODE *

get_nd_args(const NODE *node)

{

switch (nd_type(node)) {

case NODE_CALL:

return RNODE_CALL(node)->nd_args;

case NODE_OPCALL:

return RNODE_OPCALL(node)->nd_args;

case NODE_FCALL:

return RNODE_FCALL(node)->nd_args;

case NODE_QCALL:

return RNODE_QCALL(node)->nd_args;

case NODE_VCALL:

return 0;

case NODE_ATTRASGN:

return RNODE_ATTRASGN(node)->nd_args;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static ID

get_node_colon_nd_mid(const NODE *node)

{

switch (nd_type(node)) {

case NODE_COLON2:

return RNODE_COLON2(node)->nd_mid;

case NODE_COLON3:

return RNODE_COLON3(node)->nd_mid;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static ID

get_nd_vid(const NODE *node)

{

switch (nd_type(node)) {

case NODE_LASGN:

return RNODE_LASGN(node)->nd_vid;

case NODE_DASGN:

return RNODE_DASGN(node)->nd_vid;

case NODE_IASGN:

return RNODE_IASGN(node)->nd_vid;

case NODE_CVASGN:

return RNODE_CVASGN(node)->nd_vid;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static NODE *

get_nd_value(const NODE *node)

{

switch (nd_type(node)) {

case NODE_LASGN:

return RNODE_LASGN(node)->nd_value;

case NODE_DASGN:

return RNODE_DASGN(node)->nd_value;

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

static VALUE

get_string_value(const NODE *node)

{

switch (nd_type(node)) {

case NODE_STR:

return rb_node_str_string_val(node);

case NODE_FILE:

return rb_node_file_path_val(node);

default:

rb_bug("unexpected node: %s", ruby_node_name(nd_type(node)));

}

}

VALUE

rb_iseq_compile_callback(rb_iseq_t *iseq, const struct rb_iseq_new_with_callback_callback_func * ifunc)

{

DECL_ANCHOR(ret);

INIT_ANCHOR(ret);

(*ifunc->func)(iseq, ret, ifunc->data);

ADD_SYNTHETIC_INSN(ret, ISEQ_COMPILE_DATA(iseq)->last_line, -1, leave);

CHECK(iseq_setup_insn(iseq, ret));

return iseq_setup(iseq, ret);

}

static bool drop_unreachable_return(LINK_ANCHOR *ret);

VALUE

rb_iseq_compile_node(rb_iseq_t *iseq, const NODE *node)

{

DECL_ANCHOR(ret);

INIT_ANCHOR(ret);

if (node == 0) {

NO_CHECK(COMPILE(ret, "nil", node));

iseq_set_local_table(iseq, 0, 0);

}

/* assume node is T_NODE */

else if (nd_type_p(node, NODE_SCOPE)) {

/* iseq type of top, method, class, block */

iseq_set_local_table(iseq, RNODE_SCOPE(node)->nd_tbl, (NODE *)RNODE_SCOPE(node)->nd_args);

iseq_set_arguments(iseq, ret, (NODE *)RNODE_SCOPE(node)->nd_args);

switch (ISEQ_BODY(iseq)->type) {

case ISEQ_TYPE_BLOCK:

{

LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);

LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);

start->rescued = LABEL_RESCUE_BEG;

end->rescued = LABEL_RESCUE_END;

ADD_TRACE(ret, RUBY_EVENT_B_CALL);

ADD_SYNTHETIC_INSN(ret, ISEQ_BODY(iseq)->location.first_lineno, -1, nop);

ADD_LABEL(ret, start);

CHECK(COMPILE(ret, "block body", RNODE_SCOPE(node)->nd_body));

ADD_LABEL(ret, end);

ADD_TRACE(ret, RUBY_EVENT_B_RETURN);

ISEQ_COMPILE_DATA(iseq)->last_line = ISEQ_BODY(iseq)->location.code_location.end_pos.lineno;

/* wide range catch handler must put at last */

ADD_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);

ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);

break;

}

case ISEQ_TYPE_CLASS:

{

ADD_TRACE(ret, RUBY_EVENT_CLASS);

CHECK(COMPILE(ret, "scoped node", RNODE_SCOPE(node)->nd_body));

ADD_TRACE(ret, RUBY_EVENT_END);

ISEQ_COMPILE_DATA(iseq)->last_line = nd_line(node);

break;

}

case ISEQ_TYPE_METHOD:

{

ISEQ_COMPILE_DATA(iseq)->root_node = RNODE_SCOPE(node)->nd_body;

ADD_TRACE(ret, RUBY_EVENT_CALL);

CHECK(COMPILE(ret, "scoped node", RNODE_SCOPE(node)->nd_body));

ISEQ_COMPILE_DATA(iseq)->root_node = RNODE_SCOPE(node)->nd_body;

ADD_TRACE(ret, RUBY_EVENT_RETURN);

ISEQ_COMPILE_DATA(iseq)->last_line = nd_line(node);

break;

}

default: {

CHECK(COMPILE(ret, "scoped node", RNODE_SCOPE(node)->nd_body));

break;

}

}

}

else {

const char *m;

#define INVALID_ISEQ_TYPE(type) \

ISEQ_TYPE_##type: m = #type; goto invalid_iseq_type

switch (ISEQ_BODY(iseq)->type) {

case INVALID_ISEQ_TYPE(METHOD);

case INVALID_ISEQ_TYPE(CLASS);

case INVALID_ISEQ_TYPE(BLOCK);

case INVALID_ISEQ_TYPE(EVAL);

case INVALID_ISEQ_TYPE(MAIN);

case INVALID_ISEQ_TYPE(TOP);

#undef INVALID_ISEQ_TYPE /* invalid iseq types end */

case ISEQ_TYPE_RESCUE:

iseq_set_exception_local_table(iseq);

CHECK(COMPILE(ret, "rescue", node));

break;

case ISEQ_TYPE_ENSURE:

iseq_set_exception_local_table(iseq);

CHECK(COMPILE_POPPED(ret, "ensure", node));

break;

case ISEQ_TYPE_PLAIN:

CHECK(COMPILE(ret, "ensure", node));

break;

default:

COMPILE_ERROR(ERROR_ARGS "unknown scope: %d", ISEQ_BODY(iseq)->type);

return COMPILE_NG;

invalid_iseq_type:

COMPILE_ERROR(ERROR_ARGS "compile/ISEQ_TYPE_%s should not be reached", m);

return COMPILE_NG;

}

}

if (ISEQ_BODY(iseq)->type == ISEQ_TYPE_RESCUE || ISEQ_BODY(iseq)->type == ISEQ_TYPE_ENSURE) {

NODE dummy_line_node = generate_dummy_line_node(0, -1);

ADD_GETLOCAL(ret, &dummy_line_node, LVAR_ERRINFO, 0);

ADD_INSN1(ret, &dummy_line_node, throw, INT2FIX(0) /* continue throw */ );

}

else if (!drop_unreachable_return(ret)) {

ADD_SYNTHETIC_INSN(ret, ISEQ_COMPILE_DATA(iseq)->last_line, -1, leave);

}

#if OPT_SUPPORT_JOKE

if (ISEQ_COMPILE_DATA(iseq)->labels_table) {

st_table *labels_table = ISEQ_COMPILE_DATA(iseq)->labels_table;

ISEQ_COMPILE_DATA(iseq)->labels_table = 0;

validate_labels(iseq, labels_table);

}

#endif

CHECK(iseq_setup_insn(iseq, ret));

return iseq_setup(iseq, ret);

}

static int

rb_iseq_translate_threaded_code(rb_iseq_t *iseq)

{

#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE

const void * const *table = rb_vm_get_insns_address_table();

unsigned int i;

VALUE *encoded = (VALUE *)ISEQ_BODY(iseq)->iseq_encoded;

for (i = 0; i < ISEQ_BODY(iseq)->iseq_size; /* */ ) {

int insn = (int)ISEQ_BODY(iseq)->iseq_encoded[i];

int len = insn_len(insn);

encoded[i] = (VALUE)table[insn];

i = len;

}

FL_SET((VALUE)iseq, ISEQ_TRANSLATED);

#endif

#if USE_YJIT

rb_yjit_live_iseq_count ;

rb_yjit_iseq_alloc_count ;

#endif