github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Revert https://github.com/ruby/ruby/pull/2486 

This reverts commits: 10d6a3aca7 8ba48c1b85 fba8627dc1 dd883de5ba
6c6a25feca 167e6b48f1 7cb96d41a5 3207979278 595b3c4fdd 1521f7cf89
c11c5e69ac cf33608203 3632a812c0 f56506be0d 86427a3219 .

The reason for the revert is that we observe ABA problem around
inline method cache.  When a cache misshits, we search for a
method entry.  And if the entry is identical to what was cached
before, we reuse the cache.  But the commits we are reverting here
introduced situations where a method entry is freed, then the
identical memory region is used for another method entry.  An
inline method cache cannot detect that ABA.

Here is a code that reproduce such situation:

```ruby
require 'prime'

class << Integer
  alias org_sqrt sqrt
  def sqrt(n)
    raise
  end

  GC.stress = true
  Prime.each(7*37){} rescue nil # <- Here we populate CC
  class << Object.new; end

  # These adjacent remove-then-alias maneuver
  # frees a method entry, then immediately
  # reuses it for another.
  remove_method :sqrt
  alias sqrt org_sqrt
end

Prime.each(7*37).to_a # <- SEGV
```
This commit is contained in:
卜部昌平 2019-10-03 12:26:41 +09:00
Родитель ef697388be
Коммит eb92159d72
14 изменённых файлов: 390 добавлений и 500 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

45
class.c
Просмотреть файл

@ -956,41 +956,25 @@ include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super)
return method_changed;
}
typedef struct tuple {
struct RClass *klass;
struct RClass *origin;
} tuple;
static enum rb_id_table_iterator_result
inject_refined_method(ID *key, VALUE *value, void *data, int _)
{
const tuple *ptr = data;
const rb_method_entry_t *me = *(const rb_method_entry_t **) value;
const rb_method_entry_t *orig_me = me->def->body.refined.orig_me;
const rb_method_entry_t *new_me =
rb_method_entry_from_template(
me, &(rb_method_refined_t) {
.orig_me = NULL,
.owner = me->def->body.refined.owner, });
rb_id_table_insert(RCLASS_M_TBL(ptr->klass), *key, (VALUE)new_me);
RB_OBJ_WRITTEN(ptr->klass, Qundef, new_me);
*value = (VALUE)rb_method_entry_clone(orig_me);
RB_OBJ_WRITTEN(ptr->origin, Qundef, orig_me);
return ID_TABLE_CONTINUE;
}
static enum rb_id_table_iterator_result
move_refined_method(ID key, VALUE value, void *data)
{
const tuple *ptr = data;
const rb_method_entry_t *me = (const rb_method_entry_t *) value;
rb_method_entry_t *me = (rb_method_entry_t *) value;
VALUE klass = (VALUE)data;
struct rb_id_table *tbl = RCLASS_M_TBL(klass);
if (me->def->type == VM_METHOD_TYPE_REFINED) {
if (me->def->body.refined.orig_me) {
return ID_TABLE_REPLACE;
const rb_method_entry_t *orig_me = me->def->body.refined.orig_me, *new_me;
RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL);
new_me = rb_method_entry_clone(me);
rb_id_table_insert(tbl, key, (VALUE)new_me);
RB_OBJ_WRITTEN(klass, Qundef, new_me);
rb_method_entry_copy(me, orig_me);
return ID_TABLE_CONTINUE;
}
else {
rb_id_table_insert(RCLASS_M_TBL(ptr->klass), key, (VALUE)me);
rb_id_table_insert(tbl, key, (VALUE)me);
return ID_TABLE_DELETE;
}
}
@ -1016,12 +1000,7 @@ rb_prepend_module(VALUE klass, VALUE module)
RCLASS_SET_ORIGIN(klass, origin);
RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);
RCLASS_M_TBL_INIT(klass);
rb_id_table_foreach_with_replace_with_key(
RCLASS_M_TBL(origin),
move_refined_method,
inject_refined_method,
&(tuple) { RCLASS(klass), RCLASS(origin), },
true);
rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (void *)klass);
}
changed = include_modules_at(klass, klass, module, FALSE);
if (changed < 0)

2
ext/coverage/coverage.c
Просмотреть файл

@ -123,7 +123,7 @@ method_coverage_i(void *vstart, void *vend, size_t stride, void *data)
for (v = (VALUE)vstart; v != (VALUE)vend; v += stride) {
if (RB_TYPE_P(v, T_IMEMO) && imemo_type(v) == imemo_ment) {
const rb_method_entry_t *me = (const rb_method_entry_t *) v;
const rb_method_entry_t *me = (rb_method_entry_t *) v;
VALUE path, first_lineno, first_column, last_lineno, last_column;
VALUE data[5], ncoverage, methods;
VALUE methods_id = ID2SYM(rb_intern("methods"));

4
gc.c
Просмотреть файл

@ -7829,9 +7829,9 @@ void rb_update_st_references(struct st_table *ht)
}
static void
gc_ref_update_method_entry(rb_objspace_t *objspace, const rb_method_entry_t *me)
gc_ref_update_method_entry(rb_objspace_t *objspace, rb_method_entry_t *me)
{
const rb_method_definition_t *def = me->def;
rb_method_definition_t *def = me->def;
UPDATE_IF_MOVED(objspace, me->owner);
UPDATE_IF_MOVED(objspace, me->defined_class);

83
id_table.c
Просмотреть файл

@ -269,62 +269,57 @@ rb_id_table_delete(struct rb_id_table *tbl, ID id)
void
rb_id_table_foreach_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, rb_id_table_update_callback_func_t *replace, void *data)
{
rb_id_table_foreach_with_replace_with_key(tbl, func, replace, data, false);
int i, capa = tbl->capa;
for (i=0; i<capa; i++) {
if (ITEM_KEY_ISSET(tbl, i)) {
const id_key_t key = ITEM_GET_KEY(tbl, i);
enum rb_id_table_iterator_result ret = (*func)(Qundef, tbl->items[i].val, data);
assert(key != 0);
if (ret == ID_TABLE_REPLACE) {
VALUE val = tbl->items[i].val;
ret = (*replace)(NULL, &val, data, TRUE);
tbl->items[i].val = val;
}
else if (ret == ID_TABLE_STOP)
return;
}
}
}
void
rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data)
{
rb_id_table_foreach_with_replace_with_key(tbl, func, 0, data, true);
}
int i, capa = tbl->capa;
typedef struct tuple {
rb_id_table_foreach_values_func_t *const func;
void *const data;
} tuple;
for (i=0; i<capa; i++) {
if (ITEM_KEY_ISSET(tbl, i)) {
const id_key_t key = ITEM_GET_KEY(tbl, i);
enum rb_id_table_iterator_result ret = (*func)(key2id(key), tbl->items[i].val, data);
assert(key != 0);
static enum rb_id_table_iterator_result
cdr(ID car, VALUE cdr, void *data)
{
const tuple *ptr = data;
return ptr->func(cdr, ptr->data);
if (ret == ID_TABLE_DELETE)
hash_delete_index(tbl, i);
else if (ret == ID_TABLE_STOP)
return;
}
}
}
void
rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data)
{
rb_id_table_foreach_with_replace(
tbl, cdr, 0, &(tuple) { func, data, });
}
int i, capa = tbl->capa;
void
rb_id_table_foreach_with_replace_with_key(
struct rb_id_table *tbl,
rb_id_table_foreach_func_t *func,
rb_id_table_update_callback_func_t *replace,
void *data,
bool needkey)
{
for (int i = 0; i < tbl->capa; i++) {
if (ITEM_KEY_ISSET(tbl, i)) {
const id_key_t key = ITEM_GET_KEY(tbl, i);
assert(key != 0);
ID k = needkey ? key2id(key) : 0;
VALUE v = tbl->items[i].val;
switch (func(k, v, data)) {
case ID_TABLE_DELETE:
hash_delete_index(tbl, i);
/* FALLTHROUGH */
case ID_TABLE_CONTINUE:
continue;
case ID_TABLE_STOP:
return;
case ID_TABLE_REPLACE:
if (replace) {
replace(&k, &v, data, true);
tbl->items[i].val = v;
}
}
}
for (i=0; i<capa; i++) {
if (ITEM_KEY_ISSET(tbl, i)) {
enum rb_id_table_iterator_result ret = (*func)(tbl->items[i].val, data);
if (ret == ID_TABLE_DELETE)
hash_delete_index(tbl, i);
else if (ret == ID_TABLE_STOP)
return;
}
}
}

2
id_table.h
Просмотреть файл

@ -10,6 +10,7 @@ enum rb_id_table_iterator_result {
ID_TABLE_STOP = ST_STOP,
ID_TABLE_DELETE = ST_DELETE,
ID_TABLE_REPLACE = ST_REPLACE,
ID_TABLE_ITERATOR_RESULT_END
};
struct rb_id_table *rb_id_table_create(size_t size);
@ -28,7 +29,6 @@ typedef enum rb_id_table_iterator_result rb_id_table_foreach_func_t(ID id, VALUE
typedef enum rb_id_table_iterator_result rb_id_table_foreach_values_func_t(VALUE val, void *data);
void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data);
void rb_id_table_foreach_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, rb_id_table_update_callback_func_t *replace, void *data);
void rb_id_table_foreach_with_replace_with_key(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, rb_id_table_update_callback_func_t *replace, void *data, bool needkey);
void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);
#endif /* RUBY_ID_TABLE_H */

2
insns.def
Просмотреть файл

@ -911,7 +911,7 @@ invokeblock
// attr rb_snum_t sp_inc = sp_inc_of_invokeblock(ci);
{
static struct rb_call_cache cc = {
0, 0, NULL, vm_invokeblock_i,
0, 0, NULL, NULL, vm_invokeblock_i,
};
VALUE bh = VM_BLOCK_HANDLER_NONE;

2
internal.h
Просмотреть файл

@ -2330,6 +2330,7 @@ enum method_missing_reason {
MISSING_NONE = 0x40
};
struct rb_callable_method_entry_struct;
struct rb_method_definition_struct;
struct rb_execution_context_struct;
struct rb_control_frame_struct;
struct rb_calling_info;
@ -2341,6 +2342,7 @@ struct rb_call_cache {
/* inline cache: values */
const struct rb_callable_method_entry_struct *me;
const struct rb_method_definition_struct *def;
VALUE (*call)(struct rb_execution_context_struct *ec,
struct rb_control_frame_struct *cfp,

89
method.h
Просмотреть файл

@ -49,23 +49,54 @@ typedef struct rb_cref_struct {
/* method data type */
typedef struct rb_method_entry_struct {
const VALUE flags;
const VALUE defined_class;
VALUE flags;
VALUE defined_class;
struct rb_method_definition_struct * const def;
const ID called_id;
const VALUE owner;
ID called_id;
VALUE owner;
} rb_method_entry_t;
typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_entry_t */
const VALUE flags;
VALUE flags;
const VALUE defined_class;
struct rb_method_definition_struct * const def;
const ID called_id;
ID called_id;
const VALUE owner;
} rb_callable_method_entry_t;
#define METHOD_ENTRY_VISI(me) (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))
#define METHOD_ENTRY_BASIC(me) (int) (((me)->flags & (IMEMO_FL_USER2 )) >> (IMEMO_FL_USHIFT+2))
#define METHOD_ENTRY_COMPLEMENTED(me) ((me)->flags & IMEMO_FL_USER3)
#define METHOD_ENTRY_COMPLEMENTED_SET(me) ((me)->flags = (me)->flags | IMEMO_FL_USER3)
static inline void
METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
{
VM_ASSERT((int)visi >= 0 && visi <= 3);
me->flags = (me->flags & ~(IMEMO_FL_USER0 | IMEMO_FL_USER1)) | (visi << (IMEMO_FL_USHIFT+0));
}
static inline void
METHOD_ENTRY_BASIC_SET(rb_method_entry_t *me, unsigned int basic)
{
VM_ASSERT(basic <= 1);
me->flags = (me->flags & ~(IMEMO_FL_USER2 )) | (basic << (IMEMO_FL_USHIFT+2));
}
static inline void
METHOD_ENTRY_FLAGS_SET(rb_method_entry_t *me, rb_method_visibility_t visi, unsigned int basic)
{
VM_ASSERT((int)visi >= 0 && visi <= 3);
VM_ASSERT(basic <= 1);
me->flags =
(me->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
((visi << (IMEMO_FL_USHIFT+0)) | (basic << (IMEMO_FL_USHIFT+2)));
}
static inline void
METHOD_ENTRY_FLAGS_COPY(rb_method_entry_t *dst, const rb_method_entry_t *src)
{
dst->flags =
(dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
(src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2));
}
typedef enum {
VM_METHOD_TYPE_ISEQ, /*!< Ruby method */
@ -93,32 +124,32 @@ typedef struct rb_iseq_struct rb_iseq_t;
#endif
typedef struct rb_method_iseq_struct {
const rb_iseq_t *const iseqptr; /*!< iseq pointer, should be separated from iseqval */
rb_cref_t *const cref; /*!< class reference, should be marked */
} rb_method_iseq_t;
rb_iseq_t * iseqptr; /*!< iseq pointer, should be separated from iseqval */
rb_cref_t * cref; /*!< class reference, should be marked */
} rb_method_iseq_t; /* check rb_add_method_iseq() when modify the fields */
typedef struct rb_method_cfunc_struct {
VALUE (*const func)(ANYARGS);
VALUE (*const invoker)(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS));
const int argc;
VALUE (*func)(ANYARGS);
VALUE (*invoker)(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS));
int argc;
} rb_method_cfunc_t;
typedef struct rb_method_attr_struct {
const ID id;
const VALUE location; /* should be marked */
ID id;
VALUE location; /* should be marked */
} rb_method_attr_t;
typedef struct rb_method_alias_struct {
const struct rb_method_entry_struct *const original_me; /* original_me->klass is original owner */
struct rb_method_entry_struct * original_me; /* original_me->klass is original owner */
} rb_method_alias_t;
typedef struct rb_method_refined_struct {
const struct rb_method_entry_struct *const orig_me;
const VALUE owner;
struct rb_method_entry_struct * orig_me;
VALUE owner;
} rb_method_refined_t;
typedef struct rb_method_bmethod_struct {
const VALUE proc; /* should be marked */
VALUE proc; /* should be marked */
struct rb_hook_list_struct *hooks;
} rb_method_bmethod_t;
@ -130,22 +161,22 @@ enum method_optimized_type {
};
struct rb_method_definition_struct {
BITFIELD(rb_method_type_t, const type, VM_METHOD_TYPE_MINIMUM_BITS);
BITFIELD(rb_method_type_t, type, VM_METHOD_TYPE_MINIMUM_BITS);
int alias_count : 28;
int complemented_count : 28;
union {
const rb_method_iseq_t iseq;
const rb_method_cfunc_t cfunc;
const rb_method_attr_t attr;
const rb_method_alias_t alias;
const rb_method_refined_t refined;
rb_method_iseq_t iseq;
rb_method_cfunc_t cfunc;
rb_method_attr_t attr;
rb_method_alias_t alias;
rb_method_refined_t refined;
rb_method_bmethod_t bmethod;
const enum method_optimized_type optimize_type;
enum method_optimized_type optimize_type;
} body;
const ID original_id;
ID original_id;
};
typedef struct rb_method_definition_struct rb_method_definition_t;
@ -161,9 +192,8 @@ void rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *c
void rb_add_refined_method_entry(VALUE refined_class, ID mid);
void rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi);
const rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex);
const rb_method_entry_t *rb_method_entry_from_template(const rb_method_entry_t *template, const void *opts);
const rb_method_entry_t *rb_method_entry_for_missing(ID mid, VALUE klass);
rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex);
rb_method_entry_t *rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, const rb_method_definition_t *def);
const rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
@ -193,6 +223,7 @@ void rb_sweep_method_entry(void *vm);
const rb_method_entry_t *rb_method_entry_clone(const rb_method_entry_t *me);
const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class);
void rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src);
void rb_scope_visibility_set(rb_method_visibility_t);

20
proc.c
Просмотреть файл

@ -1426,7 +1426,7 @@ bm_compact(void *ptr)
UPDATE_REFERENCE(data->recv);
UPDATE_REFERENCE(data->klass);
UPDATE_REFERENCE(data->iclass);
UPDATE_TYPED_REFERENCE(const rb_method_entry_t *, data->me);
UPDATE_TYPED_REFERENCE(rb_method_entry_t *, data->me);
}
static size_t
@ -1474,9 +1474,19 @@ mnew_missing(VALUE klass, VALUE obj, ID id, VALUE mclass)
{
struct METHOD *data;
VALUE method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
rb_method_entry_t *me;
rb_method_definition_t *def;
RB_OBJ_WRITE(method, &data->recv, obj);
RB_OBJ_WRITE(method, &data->klass, klass);
RB_OBJ_WRITE(method, &data->me, rb_method_entry_for_missing(id, klass));
def = ZALLOC(rb_method_definition_t);
def->type = VM_METHOD_TYPE_MISSING;
def->original_id = id;
me = rb_method_entry_create(id, klass, METHOD_VISI_UNDEF, def);
RB_OBJ_WRITE(method, &data->me, me);
OBJ_INFECT(method, klass);
@ -1519,7 +1529,7 @@ mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
if (me->defined_class) {
VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->defined_class));
id = me->def->original_id;
me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
}
else {
VALUE klass = RCLASS_SUPER(me->owner);
@ -1557,7 +1567,7 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
me = rb_method_entry_with_refinements(klass, id, &iclass);
}
else {
me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
}
return mnew_from_me(me, klass, iclass, obj, id, mclass, scope);
}
@ -2947,7 +2957,7 @@ method_super_method(VALUE method)
super_class = RCLASS_SUPER(RCLASS_ORIGIN(iclass));
mid = data->me->called_id;
if (!super_class) return Qnil;
me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(super_class, mid, &iclass);
me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(super_class, mid, &iclass);
if (!me) return Qnil;
return mnew_internal(me, me->owner, iclass, data->recv, mid, rb_obj_class(method), FALSE, FALSE);
}

13
vm.c
Просмотреть файл

@ -298,6 +298,17 @@ rb_vm_cref_new_toplevel(void)
return vm_cref_new_toplevel(GET_EC());
}
static void
vm_cref_dump(const char *mesg, const rb_cref_t *cref)
{
fprintf(stderr, "vm_cref_dump: %s (%p)\n", mesg, (void *)cref);
while (cref) {
fprintf(stderr, "= cref| klass: %s\n", RSTRING_PTR(rb_class_path(CREF_CLASS(cref))));
cref = CREF_NEXT(cref);
}
}
void
rb_vm_block_ep_update(VALUE obj, const struct rb_block *dst, const VALUE *ep)
{
@ -1595,7 +1606,7 @@ static enum rb_id_table_iterator_result
check_redefined_method(ID mid, VALUE value, void *data)
{
VALUE klass = (VALUE)data;
const rb_method_entry_t *me = (const rb_method_entry_t *)value;
const rb_method_entry_t *me = (rb_method_entry_t *)value;
const rb_method_entry_t *newme = rb_method_entry(klass, mid);
if (newme != me) rb_vm_check_redefinition_opt_method(me, me->owner);

4
vm_backtrace.c
Просмотреть файл

@ -1349,7 +1349,7 @@ frame2iseq(VALUE frame)
return (const rb_iseq_t *)frame;
case imemo_ment:
{
const rb_callable_method_entry_t *cme = (const rb_callable_method_entry_t *)frame;
const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
switch (cme->def->type) {
case VM_METHOD_TYPE_ISEQ:
return cme->def->body.iseq.iseqptr;
@ -1405,7 +1405,7 @@ frame2klass(VALUE frame)
if (frame == Qnil) return Qnil;
if (RB_TYPE_P(frame, T_IMEMO)) {
const rb_callable_method_entry_t *cme = (const rb_callable_method_entry_t *)frame;
const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
if (imemo_type(frame) == imemo_ment) {
return cme->defined_class;

2
vm_core.h
Просмотреть файл

@ -491,7 +491,7 @@ rb_iseq_check(const rb_iseq_t *iseq)
}
static inline const rb_iseq_t *
def_iseq_ptr(const rb_method_definition_t *def)
def_iseq_ptr(rb_method_definition_t *def)
{
#if VM_CHECK_MODE > 0
if (def->type != VM_METHOD_TYPE_ISEQ) rb_bug("def_iseq_ptr: not iseq (%d)", def->type);

54
vm_insnhelper.c
Просмотреть файл

@ -19,7 +19,8 @@
#include "ruby/config.h"
#include "debug_counter.h"
extern void rb_method_entry_spoof(const rb_method_entry_t *me);
extern rb_method_definition_t *rb_method_definition_create(rb_method_type_t type, ID mid);
extern void rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts);
extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
extern VALUE rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
int argc, const VALUE *argv, int priv);
@ -578,8 +579,8 @@ vm_getspecial(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key,
return val;
}
PUREFUNC(static const rb_callable_method_entry_t *check_method_entry(VALUE obj, int can_be_svar));
static const rb_callable_method_entry_t *
PUREFUNC(static rb_callable_method_entry_t *check_method_entry(VALUE obj, int can_be_svar));
static rb_callable_method_entry_t *
check_method_entry(VALUE obj, int can_be_svar)
{
if (obj == Qfalse) return NULL;
@ -590,7 +591,7 @@ check_method_entry(VALUE obj, int can_be_svar)
switch (imemo_type(obj)) {
case imemo_ment:
return (const rb_callable_method_entry_t *)obj;
return (rb_callable_method_entry_t *)obj;
case imemo_cref:
return NULL;
case imemo_svar:
@ -609,7 +610,7 @@ MJIT_STATIC const rb_callable_method_entry_t *
rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
{
const VALUE *ep = cfp->ep;
const rb_callable_method_entry_t *me;
rb_callable_method_entry_t *me;
while (!VM_ENV_LOCAL_P(ep)) {
if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
@ -620,7 +621,7 @@ rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
}
static rb_cref_t *
method_entry_cref(const rb_callable_method_entry_t *me)
method_entry_cref(rb_callable_method_entry_t *me)
{
switch (me->def->type) {
case VM_METHOD_TYPE_ISEQ:
@ -644,7 +645,7 @@ check_cref(VALUE obj, int can_be_svar)
switch (imemo_type(obj)) {
case imemo_ment:
return method_entry_cref((const rb_callable_method_entry_t *)obj);
return method_entry_cref((rb_callable_method_entry_t *)obj);
case imemo_cref:
return (rb_cref_t *)obj;
case imemo_svar:
@ -1390,6 +1391,9 @@ calccall(const struct rb_call_info *ci, const struct rb_call_cache *cc, const rb
else if (LIKELY(cc->me != me)) {
return vm_call_general; /* normal cases */
}
else if (UNLIKELY(cc->def != me->def)) {
return vm_call_general; /* cc->me was refined elsewhere */
}
/* "Calling a formerly-public method, which is now privatised, with an
* explicit receiver" is the only situation we have to check here. A
* formerly-private method now publicised is an absolutely safe thing.
@ -1412,6 +1416,7 @@ rb_vm_search_method_slowpath(const struct rb_call_info *ci, struct rb_call_cache
GET_GLOBAL_METHOD_STATE(),
RCLASS_SERIAL(klass),
me,
me ? me->def : NULL,
calccall(ci, cc, me),
};
VM_ASSERT(callable_method_entry_p(cc->me));
@ -2573,31 +2578,32 @@ find_defined_class_by_owner(VALUE current_class, VALUE target_owner)
return current_class; /* maybe module function */
}
static const void*
aliased_callable_method_entry0(const rb_method_entry_t *me)
static const rb_callable_method_entry_t *
aliased_callable_method_entry(const rb_callable_method_entry_t *me)
{
const rb_method_entry_t *orig_me = me->def->body.alias.original_me;
const rb_callable_method_entry_t *cme;
if (orig_me->defined_class != 0) {
VM_ASSERT(callable_class_p(orig_me->defined_class));
return orig_me;
}
else {
if (orig_me->defined_class == 0) {
VALUE defined_class = find_defined_class_by_owner(me->defined_class, orig_me->owner);
VM_ASSERT(RB_TYPE_P(orig_me->owner, T_MODULE));
cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
const rb_method_entry_t *ret =
rb_method_entry_from_template((const rb_method_entry_t*)me, cme);
rb_method_entry_spoof(ret);
return ret;
}
}
static const rb_callable_method_entry_t*
aliased_callable_method_entry(const rb_callable_method_entry_t *me)
{
return aliased_callable_method_entry0((const void*)me);
if (me->def->alias_count + me->def->complemented_count == 0) {
RB_OBJ_WRITE(me, &me->def->body.alias.original_me, cme);
}
else {
rb_method_definition_t *def =
rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
rb_method_definition_set((rb_method_entry_t *)me, def, (void *)cme);
}
}
else {
cme = (const rb_callable_method_entry_t *)orig_me;
}
VM_ASSERT(callable_method_entry_p(cme));
return cme;
}
static const rb_callable_method_entry_t *

568
vm_method.c
Просмотреть файл

@ -41,7 +41,7 @@ struct cache_entry {
rb_serial_t method_state;
rb_serial_t class_serial;
ID mid;
const rb_method_entry_t* me;
rb_method_entry_t* me;
VALUE defined_class;
};
@ -132,7 +132,9 @@ rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_me
{
if (argc < -2 || 15 < argc) rb_raise(rb_eArgError, "arity out of range: %d for -2..15", argc);
if (func != rb_f_notimplement) {
rb_method_cfunc_t opt = { func, 0, argc, };
rb_method_cfunc_t opt;
opt.func = func;
opt.argc = argc;
rb_add_method(klass, mid, VM_METHOD_TYPE_CFUNC, &opt, visi);
}
else {
@ -140,11 +142,9 @@ rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_me
}
}
void
rb_free_method_entry(const rb_method_entry_t *me)
static void
rb_method_definition_release(rb_method_definition_t *def, int complemented)
{
rb_method_definition_t *def = me->def;
if (def != NULL) {
const int alias_count = def->alias_count;
const int complemented_count = def->complemented_count;
@ -158,7 +158,7 @@ rb_free_method_entry(const rb_method_entry_t *me)
xfree(def);
}
else {
if (def->complemented_count > 0) def->complemented_count--;
if (complemented) def->complemented_count--;
else if (def->alias_count > 0) def->alias_count--;
if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:%d->%d,%d->%d (dec)\n", (void *)def, rb_id2name(def->original_id),
@ -167,17 +167,23 @@ rb_free_method_entry(const rb_method_entry_t *me)
}
}
static inline const rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);
void
rb_free_method_entry(const rb_method_entry_t *me)
{
rb_method_definition_release(me->def, METHOD_ENTRY_COMPLEMENTED(me));
}
static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);
extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
static inline const rb_method_entry_t *
static inline rb_method_entry_t *
lookup_method_table(VALUE klass, ID id)
{
st_data_t body;
struct rb_id_table *m_tbl = RCLASS_M_TBL(klass);
if (rb_id_table_lookup(m_tbl, id, &body)) {
return (const rb_method_entry_t *) body;
return (rb_method_entry_t *) body;
}
else {
return 0;
@ -211,10 +217,98 @@ static VALUE
}
}
static void
setup_method_cfunc_struct(rb_method_cfunc_t *cfunc, VALUE (*func)(), int argc)
{
cfunc->func = func;
cfunc->argc = argc;
cfunc->invoker = call_cfunc_invoker_func(argc);
}
MJIT_FUNC_EXPORTED void
rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts)
{
*(rb_method_definition_t **)&me->def = def;
if (opts != NULL) {
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
{
rb_method_iseq_t *iseq_body = (rb_method_iseq_t *)opts;
rb_cref_t *method_cref, *cref = iseq_body->cref;
/* setup iseq first (before invoking GC) */
RB_OBJ_WRITE(me, &def->body.iseq.iseqptr, iseq_body->iseqptr);
if (0) vm_cref_dump("rb_method_definition_create", cref);
if (cref) {
method_cref = cref;
}
else {
method_cref = vm_cref_new_toplevel(GET_EC()); /* TODO: can we reuse? */
}
RB_OBJ_WRITE(me, &def->body.iseq.cref, method_cref);
return;
}
case VM_METHOD_TYPE_CFUNC:
{
rb_method_cfunc_t *cfunc = (rb_method_cfunc_t *)opts;
setup_method_cfunc_struct(UNALIGNED_MEMBER_PTR(def, body.cfunc), cfunc->func, cfunc->argc);
return;
}
case VM_METHOD_TYPE_ATTRSET:
case VM_METHOD_TYPE_IVAR:
{
const rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp;
int line;
def->body.attr.id = (ID)(VALUE)opts;
cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
if (cfp && (line = rb_vm_get_sourceline(cfp))) {
VALUE location = rb_ary_new3(2, rb_iseq_path(cfp->iseq), INT2FIX(line));
RB_OBJ_WRITE(me, &def->body.attr.location, rb_ary_freeze(location));
}
else {
VM_ASSERT(def->body.attr.location == 0);
}
return;
}
case VM_METHOD_TYPE_BMETHOD:
RB_OBJ_WRITE(me, &def->body.bmethod.proc, (VALUE)opts);
return;
case VM_METHOD_TYPE_NOTIMPLEMENTED:
setup_method_cfunc_struct(UNALIGNED_MEMBER_PTR(def, body.cfunc), rb_f_notimplement, -1);
return;
case VM_METHOD_TYPE_OPTIMIZED:
def->body.optimize_type = (enum method_optimized_type)opts;
return;
case VM_METHOD_TYPE_REFINED:
{
const rb_method_refined_t *refined = (rb_method_refined_t *)opts;
RB_OBJ_WRITE(me, &def->body.refined.orig_me, refined->orig_me);
RB_OBJ_WRITE(me, &def->body.refined.owner, refined->owner);
return;
}
case VM_METHOD_TYPE_ALIAS:
RB_OBJ_WRITE(me, &def->body.alias.original_me, (rb_method_entry_t *)opts);
return;
case VM_METHOD_TYPE_ZSUPER:
case VM_METHOD_TYPE_UNDEF:
case VM_METHOD_TYPE_MISSING:
return;
}
}
}
static void
method_definition_reset(const rb_method_entry_t *me)
{
const rb_method_definition_t *def = me->def;
rb_method_definition_t *def = me->def;
switch(def->type) {
case VM_METHOD_TYPE_ISEQ:
@ -247,218 +341,14 @@ method_definition_reset(const rb_method_entry_t *me)
}
}
static rb_cref_t*
the_top_cref(void)
MJIT_FUNC_EXPORTED rb_method_definition_t *
rb_method_definition_create(rb_method_type_t type, ID mid)
{
static rb_cref_t *top = NULL;
if (!top) {
top = vm_cref_new_toplevel(GET_EC());
rb_gc_register_mark_object((VALUE)top); // cref is an IMEMO.
}
return top;
}
static rb_method_iseq_t
the_method_iseq(const rb_method_iseq_t *p)
{
return (rb_method_iseq_t) {
.iseqptr = p->iseqptr,
.cref = p->cref ? p->cref : the_top_cref(),
};
}
static rb_method_cfunc_t
the_method_cfunc(const rb_method_cfunc_t *p)
{
return (rb_method_cfunc_t) {
.func = p->func,
.invoker = call_cfunc_invoker_func(p->argc),
.argc = p->argc,
};
}
static VALUE
the_location(void)
{
const rb_execution_context_t *ec = GET_EC();
const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
int line;
if (!cfp) {
return Qfalse;
}
else if (! (line = rb_vm_get_sourceline(cfp))) {
return Qfalse;
}
else {
VALUE loc = rb_ary_new3(2, rb_iseq_path(cfp->iseq), INT2FIX(line));
rb_ary_freeze(loc);
return loc;
}
}
static rb_method_attr_t
the_method_attr(const void *p)
{
return (rb_method_attr_t) {
.id = (ID)(VALUE)p,
.location = the_location(),
};
}
static rb_method_bmethod_t
the_method_bmethod(const void *p)
{
return (rb_method_bmethod_t) {
.proc = (VALUE)p,
.hooks = NULL,
};
}
static rb_method_cfunc_t
the_method_notimplemented(void)
{
return (rb_method_cfunc_t) {
.func = rb_f_notimplement,
.invoker = call_cfunc_m1,
.argc = -1,
};
}
static enum method_optimized_type
the_method_optimized(const void *p)
{
return (enum method_optimized_type)p;
}
static rb_method_refined_t
the_method_refined(const rb_method_refined_t *p)
{
if (!p) {
return (rb_method_refined_t) { 0, };
}
else {
return (rb_method_refined_t) {
.orig_me = p->orig_me,
.owner = p->owner,
};
}
}
static rb_method_alias_t
the_method_alias(const rb_method_entry_t *p)
{
return (rb_method_alias_t) {
.original_me = p,
};
}
static rb_method_definition_t
rb_method_definition_new(rb_method_type_t type, ID mid, const void *opts)
{
switch (type) {
case VM_METHOD_TYPE_ISEQ:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.iseq = the_method_iseq(opts),
}
};
case VM_METHOD_TYPE_CFUNC:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.cfunc = the_method_cfunc(opts),
}
};
case VM_METHOD_TYPE_ATTRSET:
case VM_METHOD_TYPE_IVAR:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.attr = the_method_attr(opts),
}
};
case VM_METHOD_TYPE_BMETHOD:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.bmethod = the_method_bmethod(opts),
}
};
case VM_METHOD_TYPE_NOTIMPLEMENTED:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.cfunc = the_method_notimplemented(),
}
};
case VM_METHOD_TYPE_OPTIMIZED:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.optimize_type = the_method_optimized(opts),
}
};
case VM_METHOD_TYPE_REFINED:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.refined = the_method_refined(opts),
}
};
case VM_METHOD_TYPE_ALIAS:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
.body = {
.alias = the_method_alias(opts),
}
};
case VM_METHOD_TYPE_ZSUPER:
case VM_METHOD_TYPE_UNDEF:
case VM_METHOD_TYPE_MISSING:
return (rb_method_definition_t) {
.type = type,
.original_id = mid,
};
}
UNREACHABLE_RETURN((rb_method_definition_t){0});
}
MJIT_FUNC_EXPORTED void
rb_method_entry_spoof(const rb_method_entry_t *me)
{
VALUE v = (VALUE)me;
VALUE o = me->owner;
rb_id_table_insert(RCLASS_M_TBL(o), me->called_id, v);
RB_OBJ_WRITTEN(o, Qundef, v);
rb_clear_method_cache_by_class(o);
}
static const rb_method_definition_t *
rb_method_definition_create(rb_method_type_t type, ID mid, const void *opts)
{
rb_method_definition_t template = rb_method_definition_new(type, mid, opts);
void *ptr = ALLOC(rb_method_definition_t);
memcpy(ptr, &template, sizeof template);
return ptr;
rb_method_definition_t *def;
def = ZALLOC(rb_method_definition_t);
def->type = type;
def->original_id = mid;
return def;
}
static rb_method_definition_t *
@ -477,15 +367,10 @@ method_definition_addref_complement(rb_method_definition_t *def)
return def;
}
static const rb_method_entry_t *
rb_method_entry_alloc(VALUE flags, ID called_id, VALUE owner, VALUE defined_class, const rb_method_definition_t *def)
static rb_method_entry_t *
rb_method_entry_alloc(ID called_id, VALUE owner, VALUE defined_class, const rb_method_definition_t *def)
{
VALUE v = rb_imemo_new(imemo_ment, (VALUE)def, (VALUE)called_id, owner, defined_class);
RBASIC(v)->flags =
(RBASIC(v)->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
(flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2));
const rb_method_entry_t *me = (void *)v;
method_definition_reset(me);
rb_method_entry_t *me = (rb_method_entry_t *)rb_imemo_new(imemo_ment, (VALUE)def, (VALUE)called_id, owner, defined_class);
return me;
}
@ -503,58 +388,33 @@ filter_defined_class(VALUE klass)
rb_bug("filter_defined_class: %s", rb_obj_info(klass));
}
static inline VALUE
method_entry_flags(rb_method_visibility_t visi)
rb_method_entry_t *
rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, const rb_method_definition_t *def)
{
return (visi << (IMEMO_FL_USHIFT+0)) |
((!ruby_running) << (IMEMO_FL_USHIFT+2));
}
MJIT_FUNC_EXPORTED const rb_method_entry_t *
rb_method_entry_from_template(
const rb_method_entry_t *me,
const void *body)
{
return rb_method_entry_alloc(
me->flags,
me->called_id,
me->owner,
me->defined_class,
rb_method_definition_create(
me->def->type,
me->def->original_id,
body));
}
const rb_method_entry_t *
rb_method_entry_for_missing(ID mid, VALUE klass)
{
return rb_method_entry_alloc(
method_entry_flags(METHOD_VISI_UNDEF),
mid,
klass,
filter_defined_class(klass),
rb_method_definition_create(
VM_METHOD_TYPE_MISSING,
mid,
NULL));
rb_method_entry_t *me = rb_method_entry_alloc(called_id, klass, filter_defined_class(klass), def);
METHOD_ENTRY_FLAGS_SET(me, visi, ruby_running ? FALSE : TRUE);
if (def != NULL) method_definition_reset(me);
return me;
}
const rb_method_entry_t *
rb_method_entry_clone(const rb_method_entry_t *src_me)
{
return rb_method_entry_alloc(
src_me->flags,
src_me->called_id,
src_me->owner,
src_me->defined_class,
method_definition_addref(src_me->def));
rb_method_entry_t *me = rb_method_entry_alloc(src_me->called_id, src_me->owner, src_me->defined_class,
method_definition_addref(src_me->def));
METHOD_ENTRY_FLAGS_COPY(me, src_me);
return me;
}
MJIT_FUNC_EXPORTED const rb_callable_method_entry_t *
rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class)
{
const rb_method_definition_t *def = src_me->def;
rb_method_definition_t *def = src_me->def;
rb_method_entry_t *me;
struct {
const struct rb_method_entry_struct *orig_me;
VALUE owner;
} refined = {0};
if (!src_me->defined_class &&
def->type == VM_METHOD_TYPE_REFINED &&
@ -562,69 +422,73 @@ rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID cal
const rb_method_entry_t *orig_me =
rb_method_entry_clone(def->body.refined.orig_me);
RB_OBJ_WRITE((VALUE)orig_me, &orig_me->defined_class, defined_class);
def = rb_method_definition_create(
VM_METHOD_TYPE_REFINED,
called_id,
&(rb_method_refined_t) {
.orig_me = orig_me,
.owner = orig_me->owner});
refined.orig_me = orig_me;
refined.owner = orig_me->owner;
def = NULL;
}
else {
def = method_definition_addref_complement((rb_method_definition_t *)def);
def = method_definition_addref_complement(def);
}
me = rb_method_entry_alloc(called_id, src_me->owner, defined_class, def);
METHOD_ENTRY_FLAGS_COPY(me, src_me);
METHOD_ENTRY_COMPLEMENTED_SET(me);
if (!def) {
def = rb_method_definition_create(VM_METHOD_TYPE_REFINED, called_id);
rb_method_definition_set(me, def, &refined);
}
const rb_method_entry_t *me =
rb_method_entry_alloc(
src_me->flags,
called_id,
src_me->owner,
defined_class,
def);
VM_ASSERT(RB_TYPE_P(me->owner, T_MODULE));
return (const rb_callable_method_entry_t *)me;
return (rb_callable_method_entry_t *)me;
}
static const rb_method_entry_t*
make_method_entry_refined(VALUE owner, const rb_method_entry_t *me)
void
rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src)
{
*(rb_method_definition_t **)&dst->def = method_definition_addref(src->def);
method_definition_reset(dst);
dst->called_id = src->called_id;
RB_OBJ_WRITE((VALUE)dst, &dst->owner, src->owner);
RB_OBJ_WRITE((VALUE)dst, &dst->defined_class, src->defined_class);
METHOD_ENTRY_FLAGS_COPY(dst, src);
}
static void
make_method_entry_refined(VALUE owner, rb_method_entry_t *me)
{
if (me->def->type == VM_METHOD_TYPE_REFINED) {
return me;
return;
}
else {
struct {
struct rb_method_entry_struct *orig_me;
VALUE owner;
} refined;
rb_method_definition_t *def;
rb_vm_check_redefinition_opt_method(me, me->owner);
/* :FIXME: can rb_method_entry_from_template be tweaked to also be
* applicable here? */
return rb_method_entry_alloc(
method_entry_flags(METHOD_VISI_PUBLIC),
me->called_id,
me->owner,
me->defined_class,
rb_method_definition_create(
VM_METHOD_TYPE_REFINED,
me->called_id,
&(rb_method_refined_t) {
.owner = owner,
.orig_me =
rb_method_entry_alloc(
me->flags,
me->called_id,
me->owner,
me->defined_class ?
me->defined_class : owner,
method_definition_addref(me->def))}));
refined.orig_me =
rb_method_entry_alloc(me->called_id, me->owner,
me->defined_class ?
me->defined_class : owner,
method_definition_addref(me->def));
METHOD_ENTRY_FLAGS_COPY(refined.orig_me, me);
refined.owner = owner;
def = rb_method_definition_create(VM_METHOD_TYPE_REFINED, me->called_id);
rb_method_definition_set(me, def, (void *)&refined);
METHOD_ENTRY_VISI_SET(me, METHOD_VISI_PUBLIC);
}
}
void
rb_add_refined_method_entry(VALUE refined_class, ID mid)
{
const rb_method_entry_t *me = lookup_method_table(refined_class, mid);
rb_method_entry_t *me = lookup_method_table(refined_class, mid);
if (me) {
me = make_method_entry_refined(refined_class, me);
rb_method_entry_spoof(me);
make_method_entry_refined(refined_class, me);
rb_clear_method_cache_by_class(refined_class);
}
else {
@ -654,10 +518,11 @@ check_override_opt_method(VALUE klass, VALUE arg)
* If def is given (!= NULL), then just use it and ignore original_id and otps.
* If not given, then make a new def with original_id and opts.
*/
static const rb_method_entry_t *
static rb_method_entry_t *
rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibility_t visi,
rb_method_type_t type, const rb_method_definition_t *def, ID original_id, void *opts)
rb_method_type_t type, rb_method_definition_t *def, ID original_id, void *opts)
{
rb_method_entry_t *me;
struct rb_id_table *mtbl;
st_data_t data;
int make_refined = 0;
@ -685,7 +550,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
rb_add_refined_method_entry(refined_class, mid);
}
if (type == VM_METHOD_TYPE_REFINED) {
const rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid);
rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid);
if (old_me) rb_vm_check_redefinition_opt_method(old_me, klass);
}
else {
@ -695,8 +560,8 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
/* check re-definition */
if (rb_id_table_lookup(mtbl, mid, &data)) {
const rb_method_entry_t *old_me = (const rb_method_entry_t *)data;
const rb_method_definition_t *old_def = old_me->def;
rb_method_entry_t *old_me = (rb_method_entry_t *)data;
rb_method_definition_t *old_def = old_me->def;
if (rb_method_definition_eq(old_def, def)) return old_me;
rb_vm_check_redefinition_opt_method(old_me, klass);
@ -733,16 +598,9 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
}
/* create method entry */
if (!def) {
def = rb_method_definition_create(type, original_id, opts);
}
const rb_method_entry_t *me =
rb_method_entry_alloc(
method_entry_flags(visi),
mid,
defined_class,
filter_defined_class(defined_class),
def);
me = rb_method_entry_create(mid, defined_class, visi, NULL);
if (def == NULL) def = rb_method_definition_create(type, original_id);
rb_method_definition_set(me, def, opts);
rb_clear_method_cache_by_class(klass);
@ -764,7 +622,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
}
if (make_refined) {
me = make_method_entry_refined(klass, me);
make_method_entry_refined(klass, me);
}
rb_id_table_insert(mtbl, mid, (VALUE)me);
@ -812,21 +670,27 @@ rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_
MJIT_FUNC_EXPORTED void
rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_method_visibility_t visi)
{
rb_method_iseq_t iseq_body = { iseq, cref };
struct { /* should be same fields with rb_method_iseq_struct */
const rb_iseq_t *iseqptr;
rb_cref_t *cref;
} iseq_body;
iseq_body.iseqptr = iseq;
iseq_body.cref = cref;
rb_add_method(klass, mid, VM_METHOD_TYPE_ISEQ, &iseq_body, visi);
}
static const rb_method_entry_t *
static rb_method_entry_t *
method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me,
rb_method_visibility_t visi, VALUE defined_class)
{
const rb_method_entry_t *newme = rb_method_entry_make(klass, mid, defined_class, visi,
rb_method_entry_t *newme = rb_method_entry_make(klass, mid, defined_class, visi,
me->def->type, method_definition_addref(me->def), 0, NULL);
method_added(klass, mid);
return newme;
}
const rb_method_entry_t *
rb_method_entry_t *
rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me, rb_method_visibility_t visi)
{
return method_entry_set(klass, mid, me, visi, klass);
@ -860,10 +724,10 @@ rb_get_alloc_func(VALUE klass)
return 0;
}
static inline const rb_method_entry_t*
static inline rb_method_entry_t*
search_method(VALUE klass, ID id, VALUE *defined_class_ptr)
{
const rb_method_entry_t *me;
rb_method_entry_t *me;
for (; klass; klass = RCLASS_SUPER(klass)) {
RB_DEBUG_COUNTER_INC(mc_search_super);
@ -887,12 +751,12 @@ rb_method_entry_at(VALUE klass, ID id)
* if you need method entry with method cache (normal case), use
* rb_method_entry() simply.
*/
static const rb_method_entry_t *
static rb_method_entry_t *
method_entry_get_without_cache(VALUE klass, ID id,
VALUE *defined_class_ptr)
{
VALUE defined_class;
const rb_method_entry_t *me = search_method(klass, id, &defined_class);
rb_method_entry_t *me = search_method(klass, id, &defined_class);
if (ruby_running) {
if (OPT_GLOBAL_METHOD_CACHE) {
@ -924,11 +788,11 @@ method_entry_get_without_cache(VALUE klass, ID id,
}
static void
verify_method_cache(VALUE klass, ID id, VALUE defined_class, const rb_method_entry_t *me)
verify_method_cache(VALUE klass, ID id, VALUE defined_class, rb_method_entry_t *me)
{
if (!VM_DEBUG_VERIFY_METHOD_CACHE) return;
VALUE actual_defined_class;
const rb_method_entry_t *actual_me =
rb_method_entry_t *actual_me =
method_entry_get_without_cache(klass, id, &actual_defined_class);
if (me != actual_me || defined_class != actual_defined_class) {
@ -936,7 +800,7 @@ verify_method_cache(VALUE klass, ID id, VALUE defined_class, const rb_method_ent
}
}
static const rb_method_entry_t *
static rb_method_entry_t *
method_entry_get(VALUE klass, ID id, VALUE *defined_class_ptr)
{
struct cache_entry *ent;
@ -977,7 +841,7 @@ prepare_callable_method_entry(VALUE defined_class, ID id, const rb_method_entry_
if (mtbl && rb_id_table_lookup(mtbl, id, (VALUE *)&me)) {
RB_DEBUG_COUNTER_INC(mc_cme_complement_hit);
cme = (const rb_callable_method_entry_t *)me;
cme = (rb_callable_method_entry_t *)me;
VM_ASSERT(callable_method_entry_p(cme));
}
else {
@ -1001,7 +865,7 @@ MJIT_FUNC_EXPORTED const rb_callable_method_entry_t *
rb_callable_method_entry(VALUE klass, ID id)
{
VALUE defined_class;
const rb_method_entry_t *me = method_entry_get(klass, id, &defined_class);
rb_method_entry_t *me = method_entry_get(klass, id, &defined_class);
return prepare_callable_method_entry(defined_class, id, me);
}
@ -1115,7 +979,7 @@ static void
remove_method(VALUE klass, ID mid)
{
VALUE data;
const rb_method_entry_t *me = NULL;
rb_method_entry_t *me = 0;
VALUE self = klass;
klass = RCLASS_ORIGIN(klass);
@ -1125,7 +989,7 @@ remove_method(VALUE klass, ID mid)
}
if (!rb_id_table_lookup(RCLASS_M_TBL(klass), mid, &data) ||
!(me = (const rb_method_entry_t *)data) ||
!(me = (rb_method_entry_t *)data) ||
(!me->def || me->def->type == VM_METHOD_TYPE_UNDEF) ||
UNDEFINED_REFINED_METHOD_P(me->def)) {
rb_name_err_raise("method `%1$s' not defined in %2$s",
@ -1183,18 +1047,10 @@ rb_mod_remove_method(int argc, VALUE *argv, VALUE mod)
return mod;
}
static inline void
METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
{
VM_ASSERT((int)visi >= 0 && visi <= 3);
VALUE flags = (me->flags & ~(IMEMO_FL_USER0 | IMEMO_FL_USER1)) | (visi << (IMEMO_FL_USHIFT+0));
memcpy((void *)&me->flags, &flags, sizeof flags);
}
static void
rb_export_method(VALUE klass, ID name, rb_method_visibility_t visi)
{
const rb_method_entry_t *me;
rb_method_entry_t *me;
VALUE defined_class;
VALUE origin_class = RCLASS_ORIGIN(klass);
@ -1212,7 +1068,7 @@ rb_export_method(VALUE klass, ID name, rb_method_visibility_t visi)
rb_vm_check_redefinition_opt_method(me, klass);
if (klass == defined_class || origin_class == defined_class) {
METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me, visi);
METHOD_ENTRY_VISI_SET(me, visi);
if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) {
METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me->def->body.refined.orig_me, visi);
@ -1740,7 +1596,7 @@ rb_alias(VALUE klass, ID alias_name, ID original_name)
method_added(target_klass, alias_name);
}
else {
const rb_method_entry_t *alias_me;
rb_method_entry_t *alias_me;
alias_me = method_entry_set(target_klass, alias_name, orig_me, visi, orig_me->owner);
RB_OBJ_WRITE(alias_me, &alias_me->owner, target_klass);
@ -1931,7 +1787,7 @@ rb_mod_ruby2_keywords(int argc, VALUE *argv, VALUE module)
for (i = 0; i < argc; i++) {
VALUE v = argv[i];
ID name = rb_check_id(&v);
const rb_method_entry_t *me;
rb_method_entry_t *me;
VALUE defined_class;
if (!name) {