/* Creates a new serialization context with the specified handle. If any
* compilation units are waiting for an SC with this handle, removes it from
* their to-resolve list after installing itself in the appropriate slot. */
MVMObject * MVM_sc_create(MVMThreadContext *tc, MVMString *handle) {
MVMSerializationContext *sc;
MVMSerializationContextBody *scb;
/* Allocate. */
MVMROOT(tc, handle, {
sc = (MVMSerializationContext *)REPR(tc->instance->SCRef)->allocate(tc, STABLE(tc->instance->SCRef));
MVMROOT(tc, sc, {
/* Add to weak lookup hash. */
uv_mutex_lock(&tc->instance->mutex_sc_weakhash);
MVM_string_flatten(tc, handle);
MVM_HASH_GET(tc, tc->instance->sc_weakhash, handle, scb);
if (!scb) {
sc->body = scb = calloc(1, sizeof(MVMSerializationContextBody));
MVM_ASSIGN_REF(tc, (MVMObject *)sc, scb->handle, handle);
MVM_HASH_BIND(tc, tc->instance->sc_weakhash, handle, scb);
/* Calling repr_init will allocate, BUT if it does so, and we
* get unlucky, the GC will try to acquire mutex_sc_weakhash.
* This deadlocks. Thus, we force allocation in gen2, which
* can never trigger GC. Note that releasing the mutex early
* is not a good way to fix this, as it leaves a race to
* test/set scb->sc (between the line doing it in this block,
* and in the else clauses beneath it). */
MVM_gc_allocate_gen2_default_set(tc);
MVM_repr_init(tc, (MVMObject *)sc);
MVM_gc_allocate_gen2_default_clear(tc);
scb->sc = sc;
}
else if (scb->sc) {
/* we lost a race to create it! */
sc = scb->sc;
}
else {
scb->sc = sc;
sc->body = scb;
MVM_ASSIGN_REF(tc, sc, scb->handle, handle);
MVM_repr_init(tc, (MVMObject *)sc);
}
uv_mutex_unlock(&tc->instance->mutex_sc_weakhash);
});
});
/* Composes the meta-object. */
static void compose(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMObject *self, *type_obj, *method_table, *attributes, *BOOTArray, *BOOTHash,
*repr_info_hash, *repr_info, *type_info, *attr_info_list, *parent_info;
MVMuint64 num_attrs, i;
MVMInstance *instance = tc->instance;
/* Get arguments. */
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
MVM_args_checkarity(tc, &arg_ctx, 2, 2);
self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
type_obj = MVM_args_get_pos_obj(tc, &arg_ctx, 1, MVM_ARG_REQUIRED).arg.o;
MVM_args_proc_cleanup(tc, &arg_ctx);
if (!self || !IS_CONCRETE(self) || REPR(self)->ID != MVM_REPR_ID_KnowHOWREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW methods must be called on object instance with REPR KnowHOWREPR");
/* Fill out STable. */
method_table = ((MVMKnowHOWREPR *)self)->body.methods;
MVM_ASSIGN_REF(tc, &(STABLE(type_obj)->header), STABLE(type_obj)->method_cache, method_table);
STABLE(type_obj)->mode_flags = MVM_METHOD_CACHE_AUTHORITATIVE;
STABLE(type_obj)->type_check_cache_length = 1;
STABLE(type_obj)->type_check_cache = MVM_malloc(sizeof(MVMObject *));
MVM_ASSIGN_REF(tc, &(STABLE(type_obj)->header), STABLE(type_obj)->type_check_cache[0], type_obj);
attributes = ((MVMKnowHOWREPR *)self)->body.attributes;
/* Next steps will allocate, so make sure we keep hold of the type
* object and ourself. */
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attributes);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&type_obj);
/* Use any attribute information to produce attribute protocol
* data. The protocol consists of an array... */
BOOTArray = instance->boot_types.BOOTArray;
BOOTHash = instance->boot_types.BOOTHash;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&BOOTArray);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&BOOTHash);
repr_info = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&repr_info);
/* ...which contains an array per MRO entry (just us)... */
type_info = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&type_info);
MVM_repr_push_o(tc, repr_info, type_info);
/* ...which in turn contains this type... */
MVM_repr_push_o(tc, type_info, type_obj);
/* ...then an array of hashes per attribute... */
attr_info_list = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_info_list);
MVM_repr_push_o(tc, type_info, attr_info_list);
num_attrs = REPR(attributes)->elems(tc, STABLE(attributes),
attributes, OBJECT_BODY(attributes));
for (i = 0; i < num_attrs; i++) {
MVMObject *attr_info = REPR(BOOTHash)->allocate(tc, STABLE(BOOTHash));
MVMKnowHOWAttributeREPR *attribute = (MVMKnowHOWAttributeREPR *)
MVM_repr_at_pos_o(tc, attributes, i);
MVMROOT(tc, attr_info, {
MVMROOT(tc, attribute, {
if (REPR((MVMObject *)attribute)->ID != MVM_REPR_ID_KnowHOWAttributeREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW attributes must use KnowHOWAttributeREPR");
MVM_repr_init(tc, attr_info);
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.name, (MVMObject *)attribute->body.name);
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.type, attribute->body.type);
if (attribute->body.box_target) {
/* Merely having the key serves as a "yes". */
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.box_target, attr_info);
}
MVM_repr_push_o(tc, attr_info_list, attr_info);
});
});
