vm.h

/*
 * MacRuby VM.
 *
 * This file is covered by the Ruby license. See COPYING for more details.
 * 
 * Copyright (C) 2008-2011, Apple Inc. All rights reserved.
 */

#ifndef __VM_H_
#define __VM_H_

#if defined(__cplusplus)
extern "C" {
#endif

typedef struct {
    short min;		// min number of args that we accept
    short max;		// max number of args that we accept (-1 if rest)
    short left_req;	// number of args required on the left side
    short real;		// number of args of the low level function
} rb_vm_arity_t;

typedef struct rb_vm_local {
    ID name;
    VALUE *value;
    struct rb_vm_local *next;
} rb_vm_local_t;

#define VM_BLOCK_PROC	(1<<0)	// block is a Proc object
#define VM_BLOCK_LAMBDA (1<<1)	// block is a lambda
#define VM_BLOCK_ACTIVE (1<<2)	// block is active (being executed)
#define VM_BLOCK_METHOD (1<<3)	// block is created from Method
#define VM_BLOCK_IFUNC  (1<<4)  // block is created from rb_vm_create_block()
#define VM_BLOCK_EMPTY  (1<<5)	// block has an empty body
#define VM_BLOCK_THREAD (1<<6)	// block is being executed as a Thread
#define VM_BLOCK_AOT	(1<<10) // block is created by the AOT compiler
				// (temporary)

typedef struct rb_vm_block {
    // IMPORTANT: the flags field should always be at the beginning.
    // Look at how rb_vm_take_ownership() is called in compiler.cpp.
    int flags;
    VALUE proc; // a reference to a Proc object, or nil.
    VALUE self;
    VALUE klass;
    VALUE userdata; // if VM_BLOCK_IFUNC, contains the user data, otherwise
		    // contains the key used in the blocks cache.
    rb_vm_arity_t arity;
    IMP imp;
    rb_vm_local_t *locals;
    struct rb_vm_var_uses **parent_var_uses;
    struct rb_vm_block *parent_block;
    int dvars_size;
    // IMPORTANT: do not add fields after dvars, because it would mess with
    // the way the structure is allocated.
    VALUE *dvars[1];
} rb_vm_block_t;

typedef struct rb_vm_binding {
    VALUE self;
    rb_vm_block_t *block;
    rb_vm_local_t *locals;
    struct rb_vm_binding *next;
} rb_vm_binding_t;

#define VM_METHOD_EMPTY		1 // method has an empty body (compilation)
#define VM_METHOD_PRIVATE	2 // method is private (runtime)
#define VM_METHOD_PROTECTED	4 // method is protected (runtime)
#define VM_METHOD_FBODY		8 // method has a MRI C prototype (compilation) 

static inline int
rb_vm_noex_flag(const int noex)
{
    switch (noex) {
	case NOEX_PRIVATE:
	    return VM_METHOD_PRIVATE;
	case NOEX_PROTECTED:
	    return VM_METHOD_PROTECTED;
	default:
	case NOEX_PUBLIC:
	    return 0;
    }
}

static inline int
rb_vm_node_flags(NODE *node)
{
    int flags = 0;
    if (nd_type(node) == NODE_FBODY) {
	flags |= VM_METHOD_FBODY;
	if (nd_type(node->nd_body) == NODE_METHOD) {
	    flags |= rb_vm_noex_flag(node->nd_body->nd_noex);
	}
    }
    if (node->nd_body == NULL) {
	flags |= VM_METHOD_EMPTY;
    }
    return flags;
}

static inline SEL
rb_vm_name_to_sel(const char *name, int arity)
{
    SEL sel;
    if (arity > 0 && name[strlen(name) - 1] != ':') {
	char buf[100];
	snprintf(buf, sizeof buf, "%s:", name);
	sel = sel_registerName(buf);
    }
    else {
	sel = sel_registerName(name);
    }
    return sel;
}

static inline SEL
rb_vm_id_to_sel(ID mid, int arity)
{
    return rb_vm_name_to_sel(rb_id2name(mid), arity);
}

typedef struct rb_vm_method_node {
    rb_vm_arity_t arity;
    Class klass;
    SEL sel;
    IMP objc_imp;
    IMP ruby_imp;
    int flags;
} rb_vm_method_node_t;

typedef struct {
    VALUE oclass;
    VALUE rclass;
    VALUE recv;
    SEL sel;
    int arity;
    rb_vm_method_node_t *node;	// NULL in case the method is ObjC
    void *cache;
} rb_vm_method_t;

#define GetThreadPtr(obj) ((rb_vm_thread_t *)DATA_PTR(obj))

typedef enum {
    THREAD_ALIVE,  // this thread was born to be alive
    THREAD_SLEEP,  // this thread is sleeping
    THREAD_KILLED, // this thread is being killed!
    THREAD_DEAD    // this thread is dead, sigh
} rb_vm_thread_status_t;

#include <pthread.h>

#define pthread_assert(cmd) \
    do { \
	const int code = cmd; \
	if (code != 0) { \
	    printf("pthread command `%s' failed: %s (%d)\n", \
		#cmd, strerror(code), code); \
	    abort(); \
	} \
    } \
    while (0)

typedef struct rb_vm_thread {
    pthread_t thread;
    rb_vm_block_t *body;
    int argc;
    const VALUE *argv;
    void *vm;		// a C++ instance of RoxorVM
    VALUE value;
    pthread_mutex_t sleep_mutex;
    pthread_cond_t sleep_cond;
    rb_vm_thread_status_t status;
    bool in_cond_wait;
    bool abort_on_exception;	// per-local state, global one is in RoxorCore
    bool joined_on_exception;
    VALUE locals;	// a Hash object or Qnil
    VALUE exception;	// killed-by exception or Qnil 
    VALUE group;	// always a ThreadGroup object
    VALUE mutexes;	// an Array object or Qnil
} rb_vm_thread_t;

typedef struct rb_vm_outer {
    Class klass;
    struct rb_vm_outer *outer;
} rb_vm_outer_t;

typedef struct {
    jmp_buf buf;
    VALUE throw_value;
    int nested;
} rb_vm_catch_t;

static inline rb_vm_arity_t
rb_vm_arity(int argc)
{
    rb_vm_arity_t arity;
    arity.left_req = arity.min = arity.max = arity.real = argc;
    return arity;
}

static inline int
rb_vm_arity_n(rb_vm_arity_t arity)
{
    int n = arity.min;
    if (arity.min != arity.max) {
	n = -n - 1;
    }
    return n;
}

static inline rb_vm_arity_t
rb_vm_node_arity(NODE *node)
{
    const int type = nd_type(node);
    rb_vm_arity_t arity;

    if (type == NODE_SCOPE) {
	NODE *n = node->nd_args;
	short opt_args = 0, req_args = 0;
	bool has_rest = false;
	if (n == NULL) {
	    arity.left_req = 0;
	}
	else {
	    req_args = n->nd_frml;
	    arity.left_req = req_args;
	    NODE *n_opt = n->nd_opt;
	    if (n_opt != NULL) {
		NODE *ni = n_opt;
		while (ni != NULL) {
		    opt_args++;
		    ni = ni->nd_next;
		}
	    }
	    if (n->nd_next != NULL) {
		NODE *rest_node = n->nd_next;
		if (rest_node->nd_rest) {
		    has_rest = true;
		}
		if (rest_node->nd_next) {
		    req_args += rest_node->nd_next->nd_frml;
		}
	    }
	}
	arity.min = req_args;
	if (has_rest) {
	    arity.max = -1;
	    arity.real = req_args + opt_args + 1;
	}
	else {
	    arity.max = arity.real = req_args + opt_args;
	}
	return arity;
    }

    if (type == NODE_FBODY) {
	assert(node->nd_body != NULL);
	assert(node->nd_body->nd_body != NULL);
	int argc = node->nd_body->nd_body->nd_argc;
	if (argc >= 0) {
	    arity.left_req = arity.real = arity.min = arity.max = argc;
	}
	else {
	    arity.left_req = arity.min = 0;
	    arity.max = -1;
	    if (argc == -1) {
		arity.real = 2;
	    }
	    else if (argc == -2) {
		arity.real = 1;
	    }
	    else if (argc == -3) {
		arity.real = 3;
	    }
	    else {
		printf("invalid FBODY arity: %d\n", argc);
		abort();
	    }
	}
	return arity; 
    }

    printf("invalid node %p type %d\n", node, type);
    abort();
}

static inline NODE *
rb_vm_cfunc_node_from_imp(Class klass, int arity, IMP imp, int noex)
{
    NODE *node = NEW_CFUNC(imp, arity);
    return NEW_FBODY(NEW_METHOD(node, klass, noex), 0);
}

VALUE rb_vm_eval_string(VALUE self, VALUE klass, VALUE src,
	rb_vm_binding_t *binding, const char *file, const int line);
VALUE rb_vm_run(const char *fname, NODE *node, rb_vm_binding_t *binding,
	bool inside_eval);
VALUE rb_vm_run_under(VALUE klass, VALUE self, const char *fname, NODE *node,
	rb_vm_binding_t *binding, bool inside_eval);
void rb_vm_aot_compile(NODE *node);

void rb_vm_init_compiler(void);
void rb_vm_init_jit(void);

bool rb_vm_running(void);
void rb_vm_set_running(bool flag);
VALUE rb_vm_default_random(void);
void rb_vm_set_default_random(VALUE rand);
bool rb_vm_parse_in_eval(void);
void rb_vm_set_parse_in_eval(bool flag);
VALUE rb_vm_load_path(void);
VALUE rb_vm_loaded_features(void);
VALUE rb_vm_trap_cmd_for_signal(int signal);
int rb_vm_trap_level_for_signal(int signal);
void rb_vm_set_trap_for_signal(VALUE trap, int level, int signal);
int rb_vm_safe_level(void);
void rb_vm_set_safe_level(int level);
int rb_vm_thread_safe_level(rb_vm_thread_t *thread);
VALUE rb_vm_top_self(void);
void rb_vm_const_is_defined(ID path);
VALUE rb_vm_resolve_const_value(VALUE val, VALUE klass, ID name);

VALUE rb_vm_const_lookup_level(VALUE outer, uint64_t outer_mask, ID path,
	bool lexical, bool defined);
static inline VALUE
rb_vm_const_lookup(VALUE outer, ID path, bool lexical, bool defined)
{
    return rb_vm_const_lookup_level(outer, 0, path, lexical, defined);
}

bool rb_vm_lookup_method(Class klass, SEL sel, IMP *pimp,
	rb_vm_method_node_t **pnode);
bool rb_vm_lookup_method2(Class klass, ID mid, SEL *psel, IMP *pimp,
	rb_vm_method_node_t **pnode);
bool rb_vm_is_ruby_method(Method m);
rb_vm_method_node_t *rb_vm_define_method(Class klass, SEL sel, IMP imp,
	NODE *node, bool direct);
rb_vm_method_node_t *rb_vm_define_method2(Class klass, SEL sel,
	rb_vm_method_node_t *node, long flags, bool direct);
void rb_vm_define_method3(Class klass, ID mid, rb_vm_block_t *node);
bool rb_vm_resolve_method(Class klass, SEL sel);
void *rb_vm_undefined_imp(void *rcv, SEL sel);
void *rb_vm_removed_imp(void *rcv, SEL sel);
#define UNAVAILABLE_IMP(imp) \
    (imp == NULL || imp == (IMP)rb_vm_undefined_imp \
     || imp == (IMP)rb_vm_removed_imp)
void rb_vm_define_attr(Class klass, const char *name, bool read, bool write);
void rb_vm_undef_method(Class klass, ID name, bool must_exist);
void rb_vm_remove_method(Class klass, ID name);
void rb_vm_alias(VALUE klass, ID name, ID def);
bool rb_vm_copy_method(Class klass, Method method);
void rb_vm_copy_methods(Class from_class, Class to_class);
VALUE rb_vm_yield_under(VALUE klass, VALUE self, int argc, const VALUE *argv);
bool rb_vm_respond_to(VALUE obj, SEL sel, bool priv);
bool rb_vm_respond_to2(VALUE obj, VALUE klass, SEL sel, bool priv, bool check_override);
VALUE rb_vm_method_missing(VALUE obj, int argc, const VALUE *argv);
void rb_vm_push_methods(VALUE ary, VALUE mod, bool include_objc_methods,
	int (*filter) (VALUE, ID, VALUE));
void rb_vm_set_outer(VALUE klass, VALUE under);
VALUE rb_vm_get_outer(VALUE klass);
VALUE rb_vm_module_nesting(VALUE mod);
VALUE rb_vm_catch(VALUE tag);
VALUE rb_vm_throw(VALUE tag, VALUE value);

typedef struct {
    ID name;
    VALUE value; 
} rb_object_ivar_slot_t;

#define SLOT_CACHE_VIRGIN	-2
#define SLOT_CACHE_CANNOT	-1

#define RB_OBJECT_DEFAULT_NUM_SLOTS	4

typedef struct {
    struct RBasic basic;
    rb_object_ivar_slot_t *slots;
    unsigned int num_slots;
} rb_object_t;

#define ROBJECT(o) ((rb_object_t *)o)

static inline void
rb_vm_regrow_robject_slots(rb_object_t *obj, unsigned int new_num_slot)
{
    rb_object_ivar_slot_t *new_slots =
	(rb_object_ivar_slot_t *)xrealloc(obj->slots,
		sizeof(rb_object_ivar_slot_t) * (new_num_slot + 1));
    if (new_slots != obj->slots) {
	GC_WB(&obj->slots, new_slots);
    }

    unsigned int i;
    for (i = obj->num_slots; i <= new_num_slot; i++) {
	obj->slots[i].name = 0;
	obj->slots[i].value = Qundef;
    }
    obj->num_slots = new_num_slot + 1;
}

int rb_vm_get_ivar_slot(VALUE obj, ID name, bool create);

static inline VALUE
rb_vm_get_ivar_from_slot(VALUE obj, int slot) 
{
    rb_object_t *robj = ROBJECT(obj);
    return robj->slots[slot].value;
}

static inline void
rb_vm_set_ivar_from_slot(VALUE obj, VALUE val, int slot) 
{
    rb_object_t *robj = ROBJECT(obj);
    GC_WB(&robj->slots[slot].value, val);
}

static inline VALUE
rb_vm_new_rb_object(VALUE klass)
{
    const int num_slots = RB_OBJECT_DEFAULT_NUM_SLOTS;

    rb_object_t *obj = (rb_object_t *)rb_objc_newobj(sizeof(rb_object_t));
    GC_WB(&obj->slots, xmalloc(sizeof(rb_object_ivar_slot_t) * num_slots));

    OBJSETUP(obj, klass, T_OBJECT);
    obj->num_slots = num_slots;

    int i;
    for (i = 0; i < num_slots; i++) {
	obj->slots[i].name = 0;
	obj->slots[i].value = Qundef;
    }
    return (VALUE)obj;
}

// Defined in proc.c
VALUE rb_proc_alloc_with_block(VALUE klass, rb_vm_block_t *proc);

rb_vm_method_t *rb_vm_get_method(VALUE klass, VALUE obj, ID mid, int scope);
rb_vm_block_t *rb_vm_create_block_from_method(rb_vm_method_t *method);
rb_vm_block_t *rb_vm_create_block_calling_mid(ID mid);
VALUE rb_vm_make_curry_proc(VALUE proc, VALUE passed, VALUE arity);

static inline rb_vm_block_t *
rb_proc_get_block(VALUE proc)
{
    return (rb_vm_block_t *)DATA_PTR(proc);
}

void rb_vm_add_block_lvar_use(rb_vm_block_t *block);
rb_vm_block_t *rb_vm_create_block(IMP imp, VALUE self, VALUE userdata);
rb_vm_block_t *rb_vm_current_block(void);
rb_vm_block_t *rb_vm_first_block(void);
bool rb_vm_block_saved(void);
VALUE rb_vm_block_eval(rb_vm_block_t *block, int argc, const VALUE *argv);

rb_vm_block_t *rb_vm_uncache_or_dup_block(rb_vm_block_t *b);
rb_vm_block_t *rb_vm_dup_block(rb_vm_block_t *b);

static inline void
rb_vm_block_make_detachable_proc(rb_vm_block_t *b)
{
    if (!(b->flags & VM_BLOCK_PROC)) {
	b->flags |= VM_BLOCK_PROC;
	if (!(b->flags & VM_BLOCK_METHOD)) {
	    rb_vm_add_block_lvar_use(b);
	}
    }
}

rb_vm_binding_t *rb_vm_create_binding(VALUE self, rb_vm_block_t *current_block,
	rb_vm_binding_t *top_binding, int lvars_size, va_list lvars,
	bool vm_push);
rb_vm_binding_t *rb_vm_current_binding(void);
void rb_vm_add_binding(rb_vm_binding_t *binding);
void rb_vm_pop_binding();
VALUE rb_binding_new_from_binding(rb_vm_binding_t *binding);

void rb_vm_thread_pre_init(rb_vm_thread_t *t, rb_vm_block_t *body, int argc,
	const VALUE *argv, void *vm);
void *rb_vm_create_vm(void);
void rb_vm_register_thread(VALUE thread);
void *rb_vm_thread_run(VALUE thread);
VALUE rb_vm_current_thread(void);
VALUE rb_vm_main_thread(void);
VALUE rb_vm_threads(void);
VALUE rb_vm_thread_locals(VALUE thread, bool create_storage);
void rb_vm_thread_wakeup(rb_vm_thread_t *t);
void rb_vm_thread_cancel(rb_vm_thread_t *t);
void rb_vm_thread_raise(rb_vm_thread_t *t, VALUE exc);

void rb_vm_register_current_alien_thread(void);
void rb_vm_unregister_current_alien_thread(void);

bool rb_vm_abort_on_exception(void);
void rb_vm_set_abort_on_exception(bool flag);

Class rb_vm_set_current_class(Class klass);
Class rb_vm_get_current_class(void);

bool rb_vm_aot_feature_load(const char *name);

bool rb_vm_generate_objc_class_name(const char *name, char *buf,
	size_t buflen);

void rb_vm_raise(VALUE exception);
void rb_vm_raise_current_exception(void);
VALUE rb_vm_current_exception(void);
void rb_vm_set_current_exception(VALUE exception);
VALUE rb_vm_backtrace(int skip);
void rb_vm_print_exception(VALUE exc);
void rb_vm_print_current_exception(void);

#define TEST_THREAD_CANCEL() (pthread_testcancel())

VALUE rb_vm_get_broken_value(void *vm);
VALUE rb_vm_returned_from_block(void *_vm, int id);

#define BROKEN_VALUE() (rb_vm_get_broken_value(rb_vm_current_vm()))

#define ST_STOP_IF_BROKEN() \
    do { \
	VALUE __v = BROKEN_VALUE(); \
	if (__v != Qundef) { \
	    return ST_STOP; \
	} \
    } \
    while (0)

VALUE rb_vm_pop_broken_value(void);
#define RETURN_IF_BROKEN() \
    do { \
	VALUE __v = rb_vm_pop_broken_value(); \
	if (__v != Qundef) { \
	    return __v; \
	} \
    } \
    while (0)

#define ENSURE_AND_RETURN_IF_BROKEN(code) \
    do { \
        VALUE __v = rb_vm_pop_broken_value(); \
        if (__v != Qundef) { \
	    code; \
            return __v; \
        } \
    } \
    while (0)

static inline void
rb_vm_release_ownership(VALUE obj)
{
    if (!SPECIAL_CONST_P(obj)) {
	// This function allows the given object's ownership to be transfered
	// to the current thread. It is used when objects are allocated from a
	// thread but assigned into another thread's stack, which is prohibited
	// by the thread-local collector.
	GC_RETAIN(obj);
	GC_RELEASE(obj);
    }
}

void rb_vm_finalize(void);

void rb_vm_load_bridge_support(const char *path, const char *framework_path,
	int options);

typedef struct {
    VALUE klass;
    VALUE objid;
    VALUE finalizers;
} rb_vm_finalizer_t;

void rb_vm_register_finalizer(rb_vm_finalizer_t *finalizer);
void rb_vm_unregister_finalizer(rb_vm_finalizer_t *finalizer);
void rb_vm_call_finalizer(rb_vm_finalizer_t *finalizer);

struct icache {
    VALUE klass;
    int slot;
};

struct icache *rb_vm_ivar_slot_allocate(void);

struct ccache {
    VALUE outer;
    uint64_t outer_mask;
    VALUE val;
};

typedef VALUE rb_vm_objc_stub_t(IMP imp, id self, SEL sel, int argc,
	const VALUE *argv);
typedef VALUE rb_vm_c_stub_t(IMP imp, int argc, const VALUE *argv);

#include "bridgesupport.h"
#include "compiler.h"

struct mcache {
#define MCACHE_RCALL 0x1 // Ruby call
#define MCACHE_OCALL 0x2 // Objective-C call
#define MCACHE_FCALL 0x4 // C call
#define MCACHE_SUPER 0x8 // Super call (only applied with RCALL or OCALL)
    uint8_t flag;
    SEL sel;
    Class klass;
    union {
	struct {
	    rb_vm_method_node_t *node;
	} rcall;
	struct {
	    IMP imp;
	    int argc;
	    bs_element_method_t *bs_method;	
	    rb_vm_objc_stub_t *stub;
	} ocall;
	struct {
	    IMP imp;
	    bs_element_function_t *bs_function;
	    rb_vm_c_stub_t *stub;
	} fcall;
    } as;
};

#define VM_MCACHE_SIZE	0x1000

VALUE rb_vm_dispatch(void *_vm, struct mcache *cache, VALUE top, VALUE self,
	Class klass, SEL sel, rb_vm_block_t *block, unsigned char opt,
	int argc, const VALUE *argv);

void *rb_vm_current_vm(void) __attribute__((const));
struct mcache *rb_vm_get_mcache(void *vm) __attribute__((const));

static inline int
rb_vm_mcache_hash(Class klass, SEL sel)
{
    return (((unsigned long)klass >> 3) ^ (unsigned long)sel)
	& (VM_MCACHE_SIZE - 1);
}

static inline VALUE
rb_vm_call0(void *vm, VALUE top, VALUE self, Class klass, SEL sel,
	rb_vm_block_t *block, unsigned char opt, int argc, const VALUE *argv)
{
    int hash = rb_vm_mcache_hash(klass, sel);
    if (opt & DISPATCH_SUPER) {
	hash++;
    }
    struct mcache *cache = &rb_vm_get_mcache(vm)[hash];
    return rb_vm_dispatch(vm, cache, top, self, klass, sel, block, opt,
	    argc, argv);
}

static inline VALUE
rb_vm_call(VALUE self, SEL sel, int argc, const VALUE *argv)
{
    return rb_vm_call0(rb_vm_current_vm(), 0, self, (Class)CLASS_OF(self), sel,
	    NULL, DISPATCH_FCALL, argc, argv);
}

static inline VALUE
rb_vm_call_super(VALUE self, SEL sel, int argc, const VALUE *argv)
{
    return rb_vm_call0(rb_vm_current_vm(), 0, self, (Class)CLASS_OF(self), sel,
	    NULL, DISPATCH_SUPER, argc, argv);
}

static inline VALUE
rb_vm_call2(rb_vm_block_t *block, VALUE self, VALUE klass, SEL sel, int argc,
	const VALUE *argv)
{
    if (klass == 0) {
	klass = CLASS_OF(self);
    }
    return rb_vm_call0(rb_vm_current_vm(), 0, self, (Class)klass, sel, block,
	    DISPATCH_FCALL, argc, argv);
}

static inline VALUE
rb_vm_method_call(rb_vm_method_t *m, rb_vm_block_t *block, int argc,
	const VALUE *argv)
{
    return rb_vm_dispatch(rb_vm_current_vm(), (struct mcache *)m->cache, 0,
	    m->recv, (Class)m->oclass, m->sel, block, DISPATCH_FCALL,
	    argc, argv);
}

VALUE rb_vm_yield_args(void *vm, int argc, const VALUE *argv);

static inline VALUE
rb_vm_yield(int argc, const VALUE *argv)
{
    return rb_vm_yield_args(rb_vm_current_vm(), argc, argv);
}

#if defined(__cplusplus)
}

#if !defined(MACRUBY_STATIC)
typedef struct {
    Function *func;
    rb_vm_arity_t arity;
    int flags;
} rb_vm_method_source_t;
#endif

#define rb_vm_long_arity_stub_t rb_vm_objc_stub_t
typedef VALUE rb_vm_long_arity_bstub_t(IMP imp, id self, SEL sel,
	VALUE dvars, rb_vm_block_t *b, int argc, const VALUE *argv);

// For rb_vm_define_class()
#define DEFINE_MODULE		0x1
#define DEFINE_OUTER 		0x2
#define DEFINE_SUB_OUTER	0x4

class RoxorCompiler;
class RoxorJITManager;

#define READER(name, type) \
    type get_##name(void) { return name; }

#define WRITER(name, type) \
    void set_##name(type v) { name = v; }

#define ACCESSOR(name, type) \
    READER(name, type) \
    WRITER(name, type)

// The Core class is a singleton, it's only created once and it's used by the
// VMs. All calls to the Core are thread-safe, they acquire a shared lock.
class RoxorCore {
    public:
	static RoxorCore *shared;

    private:
	// LLVM objects.
#if !defined(MACRUBY_STATIC)
	RoxorJITManager *jmm;
	ExecutionEngine *ee;
	FunctionPassManager *fpm;
#endif

	// Running threads.
	VALUE threads;

	// Finalizers. They are automatically called during garbage collection
	// but we still need to keep a list of them, because the list may not
	// be empty when we exit and we need to call the remaining finalizers.
	std::vector<rb_vm_finalizer_t *> finalizers;

	// The global lock.
	pthread_mutex_t gl;

	// State.
	bool interpreter_enabled;
	bool inlining_enabled;
	bool optims_enabled;
	bool running;
	bool abort_on_exception;
	VALUE loaded_features;
	VALUE load_path;
	VALUE default_random;

	// Signals.
	std::map<int, VALUE> trap_cmd;
	std::map<int, int> trap_level;

#if !defined(MACRUBY_STATIC)
	// Cache to avoid compiling the same Function twice.
	std::map<Function *, IMP> JITcache;
#endif

	// Cache to identify pure Ruby implementations / methods.
	std::map<IMP, rb_vm_method_node_t *> ruby_imps;
	std::map<Method, rb_vm_method_node_t *> ruby_methods;

	// Constants cache.
	std::map<ID, struct ccache *> ccache;

	// Outers map (where a class is actually defined).
	std::map<Class, struct rb_vm_outer *> outers;

#if !defined(MACRUBY_STATIC)
	// Optimized selectors redefinition cache.
	std::map<SEL, GlobalVariable *> redefined_ops_gvars;

	// Caches for the lazy JIT.
	std::map<SEL, std::map<Class, rb_vm_method_source_t *> *>
	    method_sources;
	std::multimap<Class, SEL> method_source_sels;
#endif

	// Maps to cache compiled stubs for a given Objective-C runtime type.
	std::map<std::string, void *> c_stubs, objc_stubs,
	    to_rval_convertors, to_ocval_convertors;
#if !defined(MACRUBY_STATIC)
	std::map<IMP, IMP> objc_to_ruby_stubs;
#endif
	std::map<int, void *> rb_large_arity_rstubs; // Large arity Ruby calls
	std::map<int, void *> rb_large_arity_bstubs; // Large arity block calls

	// BridgeSupport caches.
	bs_parser_t *bs_parser;
	std::map<std::string, rb_vm_bs_boxed_t *> bs_boxed;
	std::map<std::string, bs_element_function_t *> bs_funcs;
	std::map<ID, bs_element_constant_t *> bs_consts;
	std::map<std::string, std::map<SEL, bs_element_method_t *> *>
	    bs_classes_class_methods, bs_classes_instance_methods;
	std::map<std::string, bs_element_cftype_t *> bs_cftypes;
	std::map<SEL, std::string *> bs_informal_protocol_imethods,
	    bs_informal_protocol_cmethods;

	// respond_to? cache.
#define RESPOND_TO_NOT_EXIST	0
#define RESPOND_TO_PUBLIC 	1
#define RESPOND_TO_PRIVATE 	2
	std::map<long, int> respond_to_cache;

#if ROXOR_VM_DEBUG
	long functions_compiled;
#endif

    public:
	RoxorCore(void);
	~RoxorCore(void);

	void prepare_jit(void);

	ACCESSOR(running, bool);
	ACCESSOR(abort_on_exception, bool);
	ACCESSOR(default_random, VALUE);
	READER(interpreter_enabled, bool);
	READER(loaded_features, VALUE);
	READER(load_path, VALUE);
	READER(threads, VALUE);

#if ROXOR_VM_DEBUG
	READER(functions_compiled, long);
#endif

	// signals
	void set_trap_for_signal(VALUE trap, int level, int signal);
	VALUE trap_cmd_for_signal(int signal);
	int trap_level_for_signal(int signal);

	void lock(void) { 
	    assert(pthread_mutex_lock(&gl) == 0);
	}
	void unlock(void) {
	    assert(pthread_mutex_unlock(&gl) == 0);
	}

	void register_thread(VALUE thread);
	void unregister_thread(VALUE thread);

#if !defined(MACRUBY_STATIC)
	void optimize(Function *func);
	IMP compile(Function *func, bool optimize=true);
	void delenda(Function *func);

	void load_bridge_support(const char *path, const char *framework_path,
		int options);
#endif

	bs_element_constant_t *find_bs_const(ID name);
	bs_element_method_t *find_bs_method(Class klass, SEL sel);
	rb_vm_bs_boxed_t *find_bs_boxed(std::string type);
	rb_vm_bs_boxed_t *find_bs_struct(std::string type);
	rb_vm_bs_boxed_t *find_bs_opaque(std::string type);
	bs_element_cftype_t *find_bs_cftype(std::string type);
	std::string *find_bs_informal_protocol_method(SEL sel,
		bool class_method);
	bs_element_function_t *find_bs_function(std::string &name);

	// This callback is public for the only reason it's called by C.
	void bs_parse_cb(bs_element_type_t type, void *value, void *ctx);

	void insert_stub(const char *types, void *stub, bool is_objc) {
	    std::map<std::string, void *> &m =
		is_objc ? objc_stubs : c_stubs;
	    m.insert(std::make_pair(types, stub));
	}

	void *gen_large_arity_stub(int argc, bool is_block=false);
	void *gen_stub(std::string types, bool variadic, int min_argc,
		bool is_objc);
	void *gen_to_rval_convertor(std::string type);
	void *gen_to_ocval_convertor(std::string type);

#if !defined(MACRUBY_STATIC)
	std::map<Class, rb_vm_method_source_t *> *
	method_sources_for_sel(SEL sel, bool create) {
	    std::map<SEL, std::map<Class, rb_vm_method_source_t *> *>::iterator
		iter = method_sources.find(sel);
		
	    std::map<Class, rb_vm_method_source_t *> *map = NULL;
	    if (iter == method_sources.end()) {
		if (!create) {
		    return NULL;
		}
		map = new std::map<Class, rb_vm_method_source_t *>();
		method_sources[sel] = map;
	    }
	    else {
		map = iter->second;
	    }
	    return map;
	}
#endif

	bool symbolize_call_address(void *addr, char *path, size_t path_len,
		unsigned long *ln, char *name, size_t name_len,
		unsigned int *interpreter_frame_idx);

	void symbolize_backtrace_entry(int index, char *path, size_t path_len, 
		unsigned long *ln, char *name, size_t name_len);

	void invalidate_method_cache(SEL sel);
	rb_vm_method_node_t *method_node_get(IMP imp, bool create=false);
	rb_vm_method_node_t *method_node_get(Method m, bool create=false);

#if !defined(MACRUBY_STATIC)
	rb_vm_method_source_t *method_source_get(Class klass, SEL sel);

	void prepare_method(Class klass, SEL sel, Function *func,
		const rb_vm_arity_t &arity, int flag);
	bool resolve_methods(std::map<Class, rb_vm_method_source_t *> *map,
		Class klass, SEL sel);
#endif
	rb_vm_method_node_t *resolve_method(Class klass, SEL sel,
		void *func, const rb_vm_arity_t &arity, int flags,
		IMP imp, Method m, void *objc_imp_types);
	rb_vm_method_node_t *add_method(Class klass, SEL sel, IMP imp,
		IMP ruby_imp, const rb_vm_arity_t &arity, int flags,
		const char *types);
	rb_vm_method_node_t *retype_method(Class klass,
		rb_vm_method_node_t *node, const char *old_types,
		const char *new_types);
	void undef_method(Class klass, SEL sel);
	void remove_method(Class klass, SEL sel);
	bool copy_method(Class klass, Method m);
	void copy_methods(Class from_class, Class to_class);
	void get_methods(VALUE ary, Class klass, bool include_objc_methods,
		int (*filter) (VALUE, ID, VALUE));
	void method_added(Class klass, SEL sel);

#if !defined(MACRUBY_STATIC)
	GlobalVariable *redefined_op_gvar(SEL sel, bool create);
#endif
	bool should_invalidate_inline_op(SEL sel, Class klass);

	struct ccache *constant_cache_get(ID path);
	void const_defined(ID path);
	
	struct rb_vm_outer *get_outer(Class klass);
	void set_outer(Class klass, Class mod);

#if !defined(MACRUBY_STATIC)
	size_t get_sizeof(const Type *type);
	size_t get_sizeof(const char *type);
	bool is_large_struct_type(const Type *type);
#endif

	void register_finalizer(rb_vm_finalizer_t *finalizer);
	void unregister_finalizer(rb_vm_finalizer_t *finalizer);
	void call_all_finalizers(void);

	long respond_to_key(Class klass, SEL sel) {
	    return (long)klass + (long)sel;
	}
	void invalidate_respond_to_cache(void) {
	    respond_to_cache.clear();
	}
	bool respond_to(VALUE obj, VALUE klass, SEL sel, bool priv,
		bool check_override);

	void debug_outers(Class k);

    private:
	bool register_bs_boxed(bs_element_type_t type, void *value);
	void register_bs_class(bs_element_class_t *bs_class);
	rb_vm_bs_boxed_t *register_anonymous_bs_struct(const char *type);
};

#define GET_CORE() (RoxorCore::shared)

typedef enum {
    METHOD_MISSING_DEFAULT = 0,
    METHOD_MISSING_PRIVATE,
    METHOD_MISSING_PROTECTED,
    METHOD_MISSING_VCALL,
    METHOD_MISSING_SUPER
} rb_vm_method_missing_reason_t;

// MacRuby doesn't compile with rtti so we make our own.
#define CATCH_THROW_EXCEPTION		1
#define RETURN_FROM_BLOCK_EXCEPTION	2
#define THREAD_RAISE_EXCEPTION		3

class RoxorSpecialException {
    public:
	int type;

	RoxorSpecialException(int _type) { type = _type; }
};

// Custom C++ exception class used to implement catch/throw.
class RoxorCatchThrowException : public RoxorSpecialException {
    public:
	VALUE throw_symbol;
	VALUE throw_value;

	RoxorCatchThrowException()
	    : RoxorSpecialException(CATCH_THROW_EXCEPTION) {}
};

// Custom C++ exception class used to implement "return-from-block".
class RoxorReturnFromBlockException : public RoxorSpecialException {
    public:
	VALUE val;
	int id;

	RoxorReturnFromBlockException()
	    : RoxorSpecialException(RETURN_FROM_BLOCK_EXCEPTION) {}
};

// Custom C++ exception class used to implement thread cancelation.
class RoxorThreadRaiseException : public RoxorSpecialException {
    public:
	RoxorThreadRaiseException()
	    : RoxorSpecialException(THREAD_RAISE_EXCEPTION) {}
};

// The VM class is instantiated per thread. There is always at least one
// instance. The VM class is purely thread-safe and concurrent, it does not
// acquire any lock, except when it calls the Core.
class RoxorVM {
    public:
	// The main VM object.
	static RoxorVM *main;

	// The pthread specific key to retrieve the current VM thread.
	static pthread_key_t vm_thread_key;

	static force_inline RoxorVM *current(void) {
	    void *vm = pthread_getspecific(vm_thread_key);
	    if (vm == NULL) {
		// The value does not exist yet, which means we are called
		// from a thread that was not created by MacRuby directly
		// (potentially the GC thread or Cocoa). In this case, we
		// create a new VM object just for this thread.
		RoxorVM *new_vm = new RoxorVM();
		new_vm->setup_from_current_thread();
		return new_vm;
	    }
	    return (RoxorVM *)vm;
	}

    private:
	// Cache to avoid allocating the same block twice.
	std::map<void *, rb_vm_block_t *> blocks;

	// Keeps track of the current VM state (blocks, exceptions, bindings).
	std::vector<rb_vm_block_t *> current_blocks;
	std::vector<VALUE> current_exceptions;
	std::vector<rb_vm_binding_t *> bindings;
	std::map<VALUE, int *> catch_nesting;
	std::vector<VALUE> recursive_objects;

	// Method cache.
	struct mcache *mcache;

	VALUE thread;
	Class current_class;
	VALUE current_top_object;
	VALUE backref;
	VALUE broken_with;
	VALUE last_line;
	VALUE last_status;
	VALUE errinfo;
	int safe_level;
	rb_vm_method_missing_reason_t method_missing_reason;
	bool parse_in_eval;
	bool has_ensure;
	int return_from_block;
	Class current_super_class;
	SEL current_super_sel;
	VALUE current_mri_method_self;
	SEL current_mri_method_sel;

	RoxorSpecialException *special_exc;

	void increase_nesting_for_tag(VALUE tag);
	void decrease_nesting_for_tag(VALUE tag);

    public:
	RoxorVM(void);
	RoxorVM(const RoxorVM &vm);
	~RoxorVM(void);

	ACCESSOR(thread, VALUE);
	ACCESSOR(current_class, Class);
	ACCESSOR(current_top_object, VALUE);
	ACCESSOR(backref, VALUE);
	ACCESSOR(broken_with, VALUE);
	ACCESSOR(last_line, VALUE);
	ACCESSOR(last_status, VALUE);
	ACCESSOR(errinfo, VALUE);
	ACCESSOR(safe_level, int);
	ACCESSOR(method_missing_reason, rb_vm_method_missing_reason_t);
	ACCESSOR(parse_in_eval, bool);
	ACCESSOR(has_ensure, bool);
	ACCESSOR(return_from_block, int);
	ACCESSOR(special_exc, RoxorSpecialException *);
	ACCESSOR(current_super_class, Class);
	ACCESSOR(current_super_sel, SEL);
	READER(mcache, struct mcache *);
	ACCESSOR(current_mri_method_self, VALUE);
	ACCESSOR(current_mri_method_sel, SEL);

	void debug_blocks(void);

	bool is_block_current(rb_vm_block_t *b) {
	    return b == NULL
		? false
		: current_blocks.empty()
		? false
		: current_blocks.back() == b;
	}

	void add_current_block(rb_vm_block_t *b) {
	    current_blocks.push_back(b);
	}

	void pop_current_block(void) {
	    assert(!current_blocks.empty());
	    current_blocks.pop_back();
	}

	rb_vm_block_t *current_block(void) {
	    return current_blocks.empty()
		? NULL : current_blocks.back();
	}

	rb_vm_block_t *previous_block(void) {
	    if (current_blocks.size() > 1) {
		return current_blocks[current_blocks.size() - 2];
	    }
	    return NULL;
	}

	rb_vm_block_t *first_block(void) {
	    rb_vm_block_t *b = current_block();
	    if (b == NULL) {
		b = previous_block();
	    }
	    return b;
	}

	rb_vm_block_t *uncache_or_create_block(void *key, bool *cached,
		int dvars_size);
	rb_vm_block_t *uncache_or_dup_block(rb_vm_block_t *b);

	rb_vm_binding_t *current_binding(void) {
	    return bindings.empty()
		? NULL : bindings.back();
	}

	rb_vm_binding_t *get_binding(unsigned int index) {
	    if (!bindings.empty()) {
		if (index < bindings.size()) {
		    return bindings[index];
		}
	    }
	    return NULL;
	}

	void push_current_binding(rb_vm_binding_t *binding) {
	    GC_RETAIN(binding);
	    bindings.push_back(binding);
	}

	void pop_current_binding() {
	    if (!bindings.empty()) {
		GC_RELEASE(bindings.back());
		bindings.pop_back();
	    }
	}

	void debug_exceptions(void);

	VALUE current_exception(void) {
	    return current_exceptions.empty()
		? Qnil : current_exceptions.back();
	}

	void push_current_exception(VALUE exc);
	void pop_current_exception(int pos=0);

	VALUE *get_binding_lvar(ID name, bool create);

	VALUE ruby_catch(VALUE tag);
	VALUE ruby_throw(VALUE tag, VALUE value);

	VALUE pop_broken_with(void) {
	    VALUE val = broken_with;
	    if (return_from_block == -1) {
		GC_RELEASE(val);
		broken_with = Qundef;
	    }
	    return val;
	}

	void setup_from_current_thread(void);

	VALUE exec_recursive(VALUE (*func) (VALUE, VALUE, int), VALUE obj,
		VALUE arg);
};

#define GET_VM() (RoxorVM::current())
#define GET_THREAD() (GetThreadPtr(GET_VM()->get_thread()))

#endif /* __cplusplus */

#define not_implemented_in_static(s) \
    rb_raise(rb_eRuntimeError, "%s: not supported in static compilation", sel_getName(s))

#endif /* __VM_H_ */