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

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/ruby.h"

#include "internal.h"

#include <math.h>

#define USE_INSN_STACK_INCREASE 1

#include "vm_core.h"

#include "iseq.h"

#include "insns.inc"

#include "insns_info.inc"

#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))

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

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

typedef struct iseq_link_element {

enum {

ISEQ_ELEMENT_NONE,

ISEQ_ELEMENT_LABEL,

ISEQ_ELEMENT_INSN,

ISEQ_ELEMENT_ADJUST

} type;

struct iseq_link_element *next;

struct iseq_link_element *prev;

} LINK_ELEMENT;

typedef struct iseq_link_anchor {

LINK_ELEMENT anchor;

LINK_ELEMENT *last;

} LINK_ANCHOR;

typedef struct iseq_label_data {

LINK_ELEMENT link;

int label_no;

int position;

int sc_state;

int set;

int sp;

} LABEL;

typedef struct iseq_insn_data {

LINK_ELEMENT link;

enum ruby_vminsn_type insn_id;

unsigned int line_no;

int operand_size;

int sc_state;

VALUE *operands;

} INSN;

typedef struct iseq_adjust_data {

LINK_ELEMENT link;

LABEL *label;

int line_no;

} ADJUST;

struct ensure_range {

LABEL *begin;

LABEL *end;

struct ensure_range *next;

};

struct iseq_compile_data_ensure_node_stack {

NODE *ensure_node;

struct iseq_compile_data_ensure_node_stack *prev;

struct ensure_range *erange;

};

/**

* 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->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, "", (NODE *)(node)), gl_node_level)), \

gl_node_level++)

#define debug_node_end() gl_node_level --

#else

static inline ID

r_id(ID id)

{

return id;

}

static inline VALUE

r_value(VALUE value)

{

return value;

}

#define debugi(header, id) r_id(id)

#define debugp(header, value) r_value(value)

#define debugp_verbose(header, value) r_value(value)

#define debugp_verbose_node(header, value) r_value(value)

#define debugp_param(header, value) r_value(value)

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

#define debug_node_end() ((void)0)

#endif

#if CPDEBUG > 1 || CPDEBUG < 0

#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

/* create new label */

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

#define iseq_path(iseq) \

(((rb_iseq_t*)DATA_PTR(iseq))->location.path)

#define iseq_absolute_path(iseq) \

(((rb_iseq_t*)DATA_PTR(iseq))->location.absolute_path)

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

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

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

new_child_iseq(iseq, (node), (name), iseq->self, (type), (line_no))

/* add instructions */

#define ADD_SEQ(seq1, seq2) \

APPEND_LIST((seq1), (seq2))

/* add an instruction */

#define ADD_INSN(seq, line, insn) \

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

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

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

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, (line), BIN(insn), 1, (VALUE)(op1)))

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

#define ADD_INSNL(seq, line, insn, label) ADD_INSN1(seq, line, insn, label)

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

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, (line), BIN(insn), 2, (VALUE)(op1), (VALUE)(op2)))

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

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_body(iseq, (line), BIN(insn), 3, (VALUE)(op1), (VALUE)(op2), (VALUE)(op3)))

/* Specific Insn factory */

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

ADD_SEND_R((seq), (line), (id), (argc), (VALUE)Qfalse, (VALUE)INT2FIX(0))

#define ADD_CALL_RECEIVER(seq, line) \

ADD_INSN((seq), (line), putself)

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

ADD_SEND_R((seq), (line), (id), (argc), (VALUE)Qfalse, (VALUE)INT2FIX(VM_CALL_FCALL))

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

ADD_SEND_R((seq), (line), (id), (argc), (block), (VALUE)INT2FIX(VM_CALL_FCALL))

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

ADD_ELEM((seq), (LINK_ELEMENT *) \

new_insn_send(iseq, (line), \

(VALUE)(id), (VALUE)(argc), (VALUE)(block), (VALUE)(flag)))

#define ADD_TRACE(seq, line, event) \

do { \

if ((event) == RUBY_EVENT_LINE && iseq->coverage && \

(line) != iseq->compile_data->last_coverable_line) { \

RARRAY_PTR(iseq->coverage)[(line) - 1] = INT2FIX(0); \

iseq->compile_data->last_coverable_line = (line); \

ADD_INSN1((seq), (line), trace, INT2FIX(RUBY_EVENT_COVERAGE)); \

} \

if (iseq->compile_data->option->trace_instruction) { \

ADD_INSN1((seq), (line), trace, INT2FIX(event)); \

} \

} while (0)

/* 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, label) \

ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), (line)))

#define ADD_ADJUST_RESTORE(seq, label) \

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

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

(rb_ary_push(iseq->compile_data->catch_table_ary, \

rb_ary_new3(5, (type), \

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

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

/* 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_POPED(anchor, desc, node) \

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

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

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

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

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

iseq_compile_each(iseq, (anchor), (node), (poped))))

#define OPERAND_AT(insn, idx) \

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

#define INSN_OF(insn) \

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

/* error */

#define COMPILE_ERROR(strs) \

{ \

VALUE tmp = GET_THREAD()->errinfo; \

if (compile_debug) rb_compile_bug strs; \

GET_THREAD()->errinfo = iseq->compile_data->err_info; \

rb_compile_error strs; \

iseq->compile_data->err_info = GET_THREAD()->errinfo; \

GET_THREAD()->errinfo = tmp; \

ret = 0; \

break; \

}

#define ERROR_ARGS ruby_sourcefile, nd_line(node),

#define COMPILE_OK 1

#define COMPILE_NG 0

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

* missing */

#define DECL_ANCHOR(name) \

LINK_ANCHOR *name, name##_body__ = {{0,},}

#define INIT_ANCHOR(name) \

(name##_body__.last = &name##_body__.anchor, name = &name##_body__)

#define hide_obj(obj) do {OBJ_FREEZE(obj); RBASIC(obj)->klass = 0;} while (0)

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

#if 0

static void debug_list(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor);

#endif

#endif

static void dump_disasm_list(LINK_ELEMENT *elem);

static int insn_data_length(INSN *iobj);

static int insn_data_line_no(INSN *iobj);

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

static INSN *new_insn_body(rb_iseq_t *iseq, int line_no, int 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 int iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * n, int);

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

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

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

static int iseq_set_local_table(rb_iseq_t *iseq, ID *tbl);

static int iseq_set_exception_local_table(rb_iseq_t *iseq);

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

static int iseq_set_sequence_stackcaching(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

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

static int iseq_set_exception_table(rb_iseq_t *iseq);

static int iseq_set_optargs_table(rb_iseq_t *iseq);

/*

* To make Array to LinkedList, use link_anchor

*/

static void

verify_list(ISEQ_ARG_DECLARE const char *info, LINK_ANCHOR *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: %08x (%s)", flag, info);

}

#endif

}

#if CPDEBUG < 0

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

#endif

/*

* elem1, elem2 => elem1, elem2, elem

*/

static void

ADD_ELEM(ISEQ_ARG_DECLARE LINK_ANCHOR *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 *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) ADD_ELEM(iseq, (anchor), (before), (elem))

#endif

static int

iseq_add_mark_object(rb_iseq_t *iseq, VALUE v)

{

if (!SPECIAL_CONST_P(v)) {

rb_ary_push(iseq->mark_ary, v);

}

return COMPILE_OK;

}

#define ruby_sourcefile RSTRING_PTR(iseq->location.path)

static int

iseq_add_mark_object_compile_time(rb_iseq_t *iseq, VALUE v)

{

if (!SPECIAL_CONST_P(v)) {

rb_ary_push(iseq->compile_data->mark_ary, v);

}

return COMPILE_OK;

}

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 {

int ret;

COMPILE_ERROR((ruby_sourcefile, lobj->position,

"%s: undefined label", rb_id2name((ID)name)));

if (ret) break;

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

if (!NIL_P(iseq->compile_data->err_info)) {

rb_exc_raise(iseq->compile_data->err_info);

}

}

VALUE

rb_iseq_compile_node(VALUE self, NODE *node)

{

DECL_ANCHOR(ret);

rb_iseq_t *iseq;

INIT_ANCHOR(ret);

GetISeqPtr(self, iseq);

if (node == 0) {

COMPILE(ret, "nil", node);

iseq_set_local_table(iseq, 0);

}

else if (nd_type(node) == NODE_SCOPE) {

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

iseq_set_local_table(iseq, node->nd_tbl);

iseq_set_arguments(iseq, ret, node->nd_args);

switch (iseq->type) {

case ISEQ_TYPE_BLOCK:

{

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

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

ADD_LABEL(ret, start);

ADD_TRACE(ret, FIX2INT(iseq->location.first_lineno), RUBY_EVENT_B_CALL);

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

ADD_TRACE(ret, nd_line(node), RUBY_EVENT_B_RETURN);

ADD_LABEL(ret, end);

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

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

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

break;

}

case ISEQ_TYPE_CLASS:

{

ADD_TRACE(ret, FIX2INT(iseq->location.first_lineno), RUBY_EVENT_CLASS);

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

ADD_TRACE(ret, nd_line(node), RUBY_EVENT_END);

break;

}

case ISEQ_TYPE_METHOD:

{

ADD_TRACE(ret, FIX2INT(iseq->location.first_lineno), RUBY_EVENT_CALL);

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

ADD_TRACE(ret, nd_line(node), RUBY_EVENT_RETURN);

break;

}

default: {

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

break;

}

}

}

else {

switch (iseq->type) {

case ISEQ_TYPE_METHOD:

case ISEQ_TYPE_CLASS:

case ISEQ_TYPE_BLOCK:

case ISEQ_TYPE_EVAL:

case ISEQ_TYPE_MAIN:

case ISEQ_TYPE_TOP:

rb_compile_error(ERROR_ARGS "compile/should not be reached: %s:%d",

__FILE__, __LINE__);

break;

case ISEQ_TYPE_RESCUE:

iseq_set_exception_local_table(iseq);

COMPILE(ret, "rescue", node);

break;

case ISEQ_TYPE_ENSURE:

iseq_set_exception_local_table(iseq);

COMPILE_POPED(ret, "ensure", node);

break;

case ISEQ_TYPE_DEFINED_GUARD:

iseq_set_local_table(iseq, 0);

COMPILE(ret, "defined guard", node);

break;

default:

rb_bug("unknown scope");

}

}

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

ADD_INSN2(ret, 0, getlocal, INT2FIX(2), INT2FIX(0));

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

}

else {

ADD_INSN(ret, iseq->compile_data->last_line, leave);

}

#if SUPPORT_JOKE

if (iseq->compile_data->labels_table) {

validate_labels(iseq, iseq->compile_data->labels_table);

}

#endif

return iseq_setup(iseq, ret);

}

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 long i;

iseq->iseq_encoded = ALLOC_N(VALUE, iseq->iseq_size);

MEMCPY(iseq->iseq_encoded, iseq->iseq, VALUE, iseq->iseq_size);

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

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

int len = insn_len(insn);

iseq->iseq_encoded[i] = (VALUE)table[insn];

i += len;

}

#else

iseq->iseq_encoded = iseq->iseq;

#endif

return COMPILE_OK;

}

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

/* definition of data structure for compiler */

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

static void *

compile_data_alloc(rb_iseq_t *iseq, size_t size)

{

void *ptr = 0;

struct iseq_compile_data_storage *storage =

iseq->compile_data->storage_current;

if (storage->pos + size > storage->size) {

unsigned long alloc_size = storage->size * 2;

retry:

if (alloc_size < size) {

alloc_size *= 2;

goto retry;

}

storage->next = (void *)ALLOC_N(char, alloc_size +

sizeof(struct

iseq_compile_data_storage));

storage = iseq->compile_data->storage_current = storage->next;

storage->next = 0;

storage->pos = 0;

storage->size = alloc_size;

storage->buff = (char *)(&storage->buff + 1);

}

ptr = (void *)&storage->buff[storage->pos];

storage->pos += size;

return ptr;

}

static INSN *

compile_data_alloc_insn(rb_iseq_t *iseq)

{

return (INSN *)compile_data_alloc(iseq, sizeof(INSN));

}

static LABEL *

compile_data_alloc_label(rb_iseq_t *iseq)

{

return (LABEL *)compile_data_alloc(iseq, sizeof(LABEL));

}

static ADJUST *

compile_data_alloc_adjust(rb_iseq_t *iseq)

{

return (ADJUST *)compile_data_alloc(iseq, sizeof(ADJUST));

}

/*

* elem1, elemX => elem1, elem2, elemX

*/

static void

INSERT_ELEM_NEXT(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

{

elem2->next = elem1->next;

elem2->prev = elem1;

elem1->next = elem2;

if (elem2->next) {

elem2->next->prev = elem2;

}

}

#if 0 /* unused */

/*

* elemX, elem1 => elemX, elem2, elem1

*/

static void

INSERT_ELEM_PREV(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

{

elem2->prev = elem1->prev;

elem2->next = elem1;

elem1->prev = elem2;

if (elem2->prev) {

elem2->prev->next = elem2;

}

}

#endif

/*

* elemX, elem1, elemY => elemX, elem2, elemY

*/

static void

REPLACE_ELEM(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

{

elem2->prev = elem1->prev;

elem2->next = elem1->next;

if (elem1->prev) {

elem1->prev->next = elem2;

}

if (elem1->next) {

elem1->next->prev = elem2;

}

}

static void

REMOVE_ELEM(LINK_ELEMENT *elem)

{

elem->prev->next = elem->next;

if (elem->next) {

elem->next->prev = elem->prev;

}

}

static LINK_ELEMENT *

FIRST_ELEMENT(LINK_ANCHOR *anchor)

{

return anchor->anchor.next;

}

#if 0 /* unused */

static LINK_ELEMENT *

LAST_ELEMENT(LINK_ANCHOR *anchor)

{

return anchor->last;

}

#endif

static LINK_ELEMENT *

POP_ELEMENT(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor)

{

LINK_ELEMENT *elem = anchor->last;

anchor->last = anchor->last->prev;

anchor->last->next = 0;

verify_list("pop", anchor);

return elem;

}

#if CPDEBUG < 0

#define POP_ELEMENT(anchor) POP_ELEMENT(iseq, (anchor))

#endif

#if 0 /* unused */

static LINK_ELEMENT *

SHIFT_ELEMENT(LINK_ANCHOR *anchor)

{

LINK_ELEMENT *elem = anchor->anchor.next;

if (elem) {

anchor->anchor.next = elem->next;

}

return elem;

}

#endif

#if 0 /* unused */

static int

LIST_SIZE(LINK_ANCHOR *anchor)

{

LINK_ELEMENT *elem = anchor->anchor.next;

int size = 0;

while (elem) {

size += 1;

elem = elem->next;

}

return size;

}

#endif

static int

LIST_SIZE_ZERO(LINK_ANCHOR *anchor)

{

if (anchor->anchor.next == 0) {

return 1;

}

else {

return 0;

}

}

/*

* anc1: e1, e2, e3

* anc2: e4, e5

*#=>

* anc1: e1, e2, e3, e4, e5

* anc2: e4, e5 (broken)

*/

static void

APPEND_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

{

if (anc2->anchor.next) {

anc1->last->next = anc2->anchor.next;

anc2->anchor.next->prev = anc1->last;

anc1->last = anc2->last;

}

verify_list("append", anc1);

}

#if CPDEBUG < 0

#define APPEND_LIST(anc1, anc2) APPEND_LIST(iseq, (anc1), (anc2))

#endif

/*

* anc1: e1, e2, e3

* anc2: e4, e5

*#=>

* anc1: e4, e5, e1, e2, e3

* anc2: e4, e5 (broken)

*/

static void

INSERT_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

{

if (anc2->anchor.next) {

LINK_ELEMENT *first = anc1->anchor.next;

anc1->anchor.next = anc2->anchor.next;

anc1->anchor.next->prev = &anc1->anchor;

anc2->last->next = first;

if (first) {

first->prev = anc2->last;

}

else {

anc1->last = anc2->last;

}

}

verify_list("append", anc1);

}

#if CPDEBUG < 0

#define INSERT_LIST(anc1, anc2) INSERT_LIST(iseq, (anc1), (anc2))

#endif

#if 0 /* unused */

/*

* anc1: e1, e2, e3

* anc2: e4, e5

*#=>

* anc1: e4, e5

* anc2: e1, e2, e3

*/

static void

SWAP_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

{

LINK_ANCHOR tmp = *anc2;

/* it has bug */

*anc2 = *anc1;

*anc1 = tmp;

verify_list("swap1", anc1);

verify_list("swap2", anc2);

}

#if CPDEBUG < 0

#define SWAP_LIST(anc1, anc2) SWAP_LIST(iseq, (anc1), (anc2))

#endif

static LINK_ANCHOR *

REVERSE_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc)

{

LINK_ELEMENT *first, *last, *elem, *e;

first = &anc->anchor;

elem = first->next;

last = anc->last;

if (elem != 0) {

anc->anchor.next = last;

anc->last = elem;

}

else {

/* null list */

return anc;

}

while (elem) {

e = elem->next;

elem->next = elem->prev;

elem->prev = e;

elem = e;

}

first->next = last;

last->prev = first;

anc->last->next = 0;

verify_list("reverse", anc);

return anc;

}

#if CPDEBUG < 0

#define REVERSE_LIST(anc) REVERSE_LIST(iseq, (anc))

#endif

#endif

#if CPDEBUG && 0

static void

debug_list(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor)

{

LINK_ELEMENT *list = FIRST_ELEMENT(anchor);

printf("----\n");

printf("anch: %p, frst: %p, last: %p\n", &anchor->anchor,

anchor->anchor.next, anchor->last);

while (list) {

printf("curr: %p, next: %p, prev: %p, type: %d\n", list, list->next,

list->prev, FIX2INT(list->type));

list = list->next;

}

printf("----\n");

dump_disasm_list(anchor->anchor.next);

verify_list("debug list", anchor);

}

#if CPDEBUG < 0

#define debug_list(anc) debug_list(iseq, (anc))

#endif

#endif

static LABEL *

new_label_body(rb_iseq_t *iseq, long line)

{

LABEL *labelobj = compile_data_alloc_label(iseq);

labelobj->link.type = ISEQ_ELEMENT_LABEL;

labelobj->link.next = 0;

labelobj->label_no = iseq->compile_data->label_no++;

labelobj->sc_state = 0;

labelobj->sp = -1;

return labelobj;

}

static ADJUST *

new_adjust_body(rb_iseq_t *iseq, LABEL *label, int line)

{

ADJUST *adjust = compile_data_alloc_adjust(iseq);

adjust->link.type = ISEQ_ELEMENT_ADJUST;

adjust->link.next = 0;

adjust->label = label;

adjust->line_no = line;

return adjust;

}

static INSN *

new_insn_core(rb_iseq_t *iseq, int line_no,

int insn_id, int argc, VALUE *argv)

{

INSN *iobj = compile_data_alloc_insn(iseq);

/* printf("insn_id: %d, line: %d\n", insn_id, line_no); */

iobj->link.type = ISEQ_ELEMENT_INSN;

iobj->link.next = 0;

iobj->insn_id = insn_id;

iobj->line_no = line_no;

iobj->operands = argv;

iobj->operand_size = argc;

iobj->sc_state = 0;

return iobj;

}

static INSN *

new_insn_body(rb_iseq_t *iseq, int line_no, int insn_id, int argc, ...)

{

VALUE *operands = 0;

va_list argv;

if (argc > 0) {

int i;

va_init_list(argv, argc);

operands = (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * argc);

for (i = 0; i < argc; i++) {

VALUE v = va_arg(argv, VALUE);

operands[i] = v;

}

va_end(argv);

}

return new_insn_core(iseq, line_no, insn_id, argc, operands);

}

static rb_call_info_t *

new_callinfo(rb_iseq_t *iseq, ID mid, int argc, VALUE block, unsigned long flag)

{

rb_call_info_t *ci = (rb_call_info_t *)compile_data_alloc(iseq, sizeof(rb_call_info_t));

ci->mid = mid;

ci->flag = flag;

ci->orig_argc = argc;

ci->argc = argc;

if (block) {

GetISeqPtr(block, ci->blockiseq);

}

else {

ci->blockiseq = 0;

if (!(ci->flag & (VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_BLOCKARG))) {

ci->flag |= VM_CALL_ARGS_SKIP_SETUP;

}

}

ci->vmstat = 0;

ci->blockptr = 0;

ci->recv = Qundef;

ci->call = 0; /* TODO: should set default function? */

ci->aux.index = iseq->callinfo_size++;

return ci;

}

static INSN *

new_insn_send(rb_iseq_t *iseq, int line_no, VALUE id, VALUE argc, VALUE block, VALUE flag)

{

VALUE *operands = (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * 1);

operands[0] = (VALUE)new_callinfo(iseq, SYM2ID(id), FIX2INT(argc), block, FIX2INT(flag));

return new_insn_core(iseq, line_no, BIN(send), 1, operands);

}

static VALUE

new_child_iseq(rb_iseq_t *iseq, NODE *node,

VALUE name, VALUE parent, enum iseq_type type, int line_no)

{

VALUE ret;

debugs("[new_child_iseq]> ---------------------------------------\n");

ret = rb_iseq_new_with_opt(node, name,

iseq_path(iseq->self), iseq_absolute_path(iseq->self),

INT2FIX(line_no), parent, type, iseq->compile_data->option);

debugs("[new_child_iseq]< ---------------------------------------\n");

iseq_add_mark_object(iseq, ret);

return ret;

}

static int

iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

{

/* debugs("[compile step 2] (iseq_array_to_linkedlist)\n"); */

if (compile_debug > 5)

dump_disasm_list(FIRST_ELEMENT(anchor));