#include "moar.h"

/* Gets the statistics for a static frame, creating them if needed. */

MVMSpeshStats * stats_for(MVMThreadContext *tc, MVMStaticFrame *sf) {

    MVMStaticFrameSpesh *spesh = sf->body.spesh;

    if (!spesh->body.spesh_stats)

        spesh->body.spesh_stats = MVM_calloc(1, sizeof(MVMSpeshStats));

    return spesh->body.spesh_stats;

}

/* Gets the stats by callsite, adding it if it's missing. */

MVMuint32 by_callsite_idx(MVMThreadContext *tc, MVMSpeshStats *ss, MVMCallsite *cs) {

    /* See if we already have it. */

    MVMuint32 found;

    MVMuint32 n = ss->num_by_callsite;

    for (found = 0; found < n; found++)

        if (ss->by_callsite[found].cs == cs)

            return found;

    /* If not, we need a new record. */

    found = ss->num_by_callsite;

    ss->num_by_callsite++;

    ss->by_callsite = MVM_realloc(ss->by_callsite,

        ss->num_by_callsite * sizeof(MVMSpeshStatsByCallsite));

    memset(&(ss->by_callsite[found]), 0, sizeof(MVMSpeshStatsByCallsite));

    ss->by_callsite[found].cs = cs;

    return found;

}

/* Checks if a type tuple is incomplete (no types logged for some passed

 * objects, or no decont type logged for a container type). */

MVMint32 incomplete_type_tuple(MVMThreadContext *tc, MVMCallsite *cs,

                               MVMSpeshStatsType *arg_types) {

    MVMuint32 i;

    for (i = 0; i < cs->flag_count; i++) {

        if (cs->arg_flags[i] & MVM_CALLSITE_ARG_OBJ) {

            MVMObject *type = arg_types[i].type;

            if (!type)

                return 1;

            if (arg_types[i].type_concrete && type->st->container_spec)

                if (!arg_types[i].decont_type && REPR(type)->ID != MVM_REPR_ID_NativeRef)

                    return 1;

        }

    }

    return 0;

}

/* Returns true if the callsite has no object arguments, false otherwise. */

MVMint32 cs_without_object_args(MVMThreadContext *tc, MVMCallsite *cs) {

    MVMuint32 i;

    for (i = 0; i < cs->flag_count; i++)

        if (cs->arg_flags[i] & MVM_CALLSITE_ARG_OBJ)

            return 0;

    return 1;

}

/* Gets the stats by type, adding it if it's missing. Frees arg_types. Returns

 * the index in the by type array, or -1 if unresolved. */

MVMint32 by_type(MVMThreadContext *tc, MVMSpeshStats *ss, MVMuint32 callsite_idx,

                  MVMSpeshStatsType *arg_types) {

    /* Resolve type by callsite level info. If this is the no-callsite

     * specialization there is nothing further to do. */

    MVMSpeshStatsByCallsite *css = &(ss->by_callsite[callsite_idx]);

    MVMCallsite *cs = css->cs;

    if (!cs) {

        MVM_free(arg_types);

        return -1;

    }

    /* Otherwise if there's no object args, then we'll use a single "by type"

     * specialization, so we can have data tracked by offset at least. */

    else if (cs_without_object_args(tc, cs)) {

        if (css->num_by_type == 0) {

            css->num_by_type++;

            css->by_type = MVM_calloc(1, sizeof(MVMSpeshStatsByType));

            css->by_type[0].arg_types = arg_types;

        }

        else {

            MVM_free(arg_types);

        }

        return 0;

    }

    /* Maybe the type tuple is incomplete, maybe because the log buffer ended

     * prior to having all the type information. Discard. */

    else if (incomplete_type_tuple(tc, cs, arg_types)) {

        MVM_free(arg_types);

        return -1;

    }

    /* Can produce by-type stats. */

    else {

        /* See if we already have it. */

        size_t args_length = cs->flag_count * sizeof(MVMSpeshStatsType);

        MVMuint32 found;

        MVMuint32 n = css->num_by_type;

        for (found = 0; found < n; found++) {

            if (memcmp(css->by_type[found].arg_types, arg_types, args_length) == 0) {

                MVM_free(arg_types);

                return found;

            }

        }

        /* If not, we need a new record. */

        found = css->num_by_type;

        css->num_by_type++;

        css->by_type = MVM_realloc(css->by_type,

            css->num_by_type * sizeof(MVMSpeshStatsByType));

        memset(&(css->by_type[found]), 0, sizeof(MVMSpeshStatsByType));

        css->by_type[found].arg_types = arg_types;

        return found;

    }

}

/* Get the stats by offset entry, adding it if it's missing. */

MVMSpeshStatsByOffset * by_offset(MVMThreadContext *tc, MVMSpeshStatsByType *tss,

                                  MVMuint32 bytecode_offset) {

    /* See if we already have it. */

    MVMuint32 found;

    MVMuint32 n = tss->num_by_offset;

    for (found = 0; found < n; found++)

        if (tss->by_offset[found].bytecode_offset == bytecode_offset)

            return &(tss->by_offset[found]);

    /* If not, we need a new record. */

    found = tss->num_by_offset;

    tss->num_by_offset++;

    tss->by_offset = MVM_realloc(tss->by_offset,

        tss->num_by_offset * sizeof(MVMSpeshStatsByOffset));

    memset(&(tss->by_offset[found]), 0, sizeof(MVMSpeshStatsByOffset));

    tss->by_offset[found].bytecode_offset = bytecode_offset;

    return &(tss->by_offset[found]);

}

/* Adds/increments the count of a certain type seen at the given offset. */

void add_type_at_offset(MVMThreadContext *tc, MVMSpeshStatsByOffset *oss,

                        MVMStaticFrame *sf, MVMObject *type, MVMuint8 concrete) {

    /* If we have it already, increment the count. */

    MVMuint32 found;

    MVMuint32 n = oss->num_types;

    for (found = 0; found < n; found++) {

        if (oss->types[found].type == type && oss->types[found].type_concrete == concrete) {

            oss->types[found].count++;

            return;

        }

    }

    /* Otherwise, add it to the list. */

    found = oss->num_types;

    oss->num_types++;

    oss->types = MVM_realloc(oss->types, oss->num_types * sizeof(MVMSpeshStatsTypeCount));

    MVM_ASSIGN_REF(tc, &(sf->body.spesh->common.header), oss->types[found].type, type);

    oss->types[found].type_concrete = concrete;

    oss->types[found].count = 1;

}

/* Adds/increments the count of a certain invocation target seen at the given

 * offset. */

void add_invoke_at_offset(MVMThreadContext *tc, MVMSpeshStatsByOffset *oss,

                          MVMStaticFrame *sf, MVMStaticFrame *target_sf,

                          MVMint16 caller_is_outer, MVMint16 was_multi) {

    /* If we have it already, increment the count. */

    MVMuint32 found;

    MVMuint32 n = oss->num_invokes;

    for (found = 0; found < n; found++) {

        if (oss->invokes[found].sf == target_sf) {

            oss->invokes[found].count++;

            if (caller_is_outer)

                oss->invokes[found].caller_is_outer_count++;

            if (was_multi)

                oss->invokes[found].was_multi_count++;

            return;

        }

    }

    /* Otherwise, add it to the list. */

    found = oss->num_invokes;

    oss->num_invokes++;

    oss->invokes = MVM_realloc(oss->invokes,

        oss->num_invokes * sizeof(MVMSpeshStatsInvokeCount));

    MVM_ASSIGN_REF(tc, &(sf->body.spesh->common.header), oss->invokes[found].sf, target_sf);

    oss->invokes[found].count = 1;

    oss->invokes[found].caller_is_outer_count = caller_is_outer ? 1 : 0;

    oss->invokes[found].was_multi_count = was_multi ? 1 : 0;

}

/* Adds/increments the count of a plugin guard index seen at the given offset. */

void add_plugin_guard_at_offset(MVMThreadContext *tc, MVMSpeshStatsByOffset *oss,

                                MVMuint32 guard_index) {

    /* If we have it already, increment the count. */

    MVMuint32 found;

    MVMuint32 n = oss->num_plugin_guards;

    for (found = 0; found < n; found++) {

        if (oss->plugin_guards[found].guard_index == guard_index) {

            oss->plugin_guards[found].count++;

            return;

        }

    }

    /* Otherwise, add it to the list. */

    found = oss->num_plugin_guards;

    oss->num_plugin_guards++;

    oss->plugin_guards = MVM_realloc(oss->plugin_guards,

            oss->num_plugin_guards * sizeof(MVMSpeshStatsPluginGuardCount));

    oss->plugin_guards[found].guard_index = guard_index;

    oss->plugin_guards[found].count = 1;

}

/* Adds/increments the count of a type tuple seen at the given offset. */

void add_type_tuple_at_offset(MVMThreadContext *tc, MVMSpeshStatsByOffset *oss,

                              MVMStaticFrame *sf, MVMSpeshSimCallType *info) {

    /* Compute type tuple size. */

    size_t tt_size = info->cs->flag_count * sizeof(MVMSpeshStatsType);

    /* If we have it already, increment the count. */

    MVMuint32 found, i;

    MVMuint32 n = oss->num_type_tuples;

    for (found = 0; found < n; found++) {

        if (oss->type_tuples[found].cs == info->cs) {

            if (memcmp(oss->type_tuples[found].arg_types, info->arg_types, tt_size) == 0) {

                oss->type_tuples[found].count++;

                return;

            }

        }

    }

    /* Otherwise, add it to the list; copy type tuple to ease memory

     * management, but also need to write barrier any types. */

    found = oss->num_type_tuples;

    oss->num_type_tuples++;

    oss->type_tuples = MVM_realloc(oss->type_tuples,

        oss->num_type_tuples * sizeof(MVMSpeshStatsTypeTupleCount));

    oss->type_tuples[found].cs = info->cs;

    oss->type_tuples[found].arg_types = MVM_malloc(tt_size);

    memcpy(oss->type_tuples[found].arg_types, info->arg_types, tt_size);

    for (i = 0; i < info->cs->flag_count; i++) {

        if (info->arg_types[i].type)

            MVM_gc_write_barrier(tc, &(sf->body.spesh->common.header),

                &(info->arg_types[i].type->header));

        if (info->arg_types[i].decont_type)

            MVM_gc_write_barrier(tc, &(sf->body.spesh->common.header),

                &(info->arg_types[i].decont_type->header));

    }

    oss->type_tuples[found].count = 1;

}

/* Initializes the stack simulation. */

void sim_stack_init(MVMThreadContext *tc, MVMSpeshSimStack *sims) {

    sims->used = 0;

    sims->limit = 32;

    sims->frames = MVM_malloc(sims->limit * sizeof(MVMSpeshSimStackFrame));

    sims->depth = 0;

}

/* Pushes an entry onto the stack frame model. */

void sim_stack_push(MVMThreadContext *tc, MVMSpeshSimStack *sims, MVMStaticFrame *sf,

                    MVMSpeshStats *ss, MVMuint32 cid, MVMuint32 callsite_idx) {

    MVMSpeshSimStackFrame *frame;

    MVMCallsite *cs;

    if (sims->used == sims->limit) {

        sims->limit *= 2;

        sims->frames = MVM_realloc(sims->frames, sims->limit * sizeof(MVMSpeshSimStackFrame));

    }

    frame = &(sims->frames[sims->used++]);

    frame->sf = sf;

    frame->ss = ss;

    frame->cid = cid;

    frame->callsite_idx = callsite_idx;

    frame->type_idx = -1;

    frame->arg_types = (cs = ss->by_callsite[callsite_idx].cs)

        ? MVM_calloc(cs->flag_count, sizeof(MVMSpeshStatsType))

        : NULL;

    frame->offset_logs = NULL;

    frame->offset_logs_used = frame->offset_logs_limit = 0;

    frame->osr_hits = 0;

    frame->call_type_info = NULL;

    frame->call_type_info_used = frame->call_type_info_limit = 0;

    frame->last_invoke_offset = 0;

    frame->last_invoke_sf = NULL;

    sims->depth++;

}

/* Adds an entry to a sim frame's callsite type info list, for later

 * inclusion in the callsite stats. */

void add_sim_call_type_info(MVMThreadContext *tc, MVMSpeshSimStackFrame *simf,

                            MVMuint32 bytecode_offset, MVMCallsite *cs,

                            MVMSpeshStatsType *arg_types) {

    MVMSpeshSimCallType *info;

    if (simf->call_type_info_used == simf->call_type_info_limit) {

        simf->call_type_info_limit += 32;

        simf->call_type_info = MVM_realloc(simf->call_type_info,

            simf->call_type_info_limit * sizeof(MVMSpeshSimCallType));

    }

    info = &(simf->call_type_info[simf->call_type_info_used++]);

    info->bytecode_offset = bytecode_offset;

    info->cs = cs;

    info->arg_types = arg_types;

}

/* Incorporate information collected into a sim stack frame. */

void incorporate_stats(MVMThreadContext *tc, MVMSpeshSimStackFrame *simf,

                       MVMuint32 frame_depth, MVMSpeshSimStackFrame *caller,

                       MVMObject *sf_updated) {

    MVMSpeshStatsByType *tss;

    MVMint32 first_type_hit = 0;

    /* Bump version if needed. */

    if (simf->ss->last_update != tc->instance->spesh_stats_version) {

        simf->ss->last_update = tc->instance->spesh_stats_version;

        MVM_repr_push_o(tc, sf_updated, (MVMObject *)simf->sf);

    }

    /* Add OSR hits at callsite level and update depth. */

    if (simf->osr_hits) {

        simf->ss->osr_hits += simf->osr_hits;

        simf->ss->by_callsite[simf->callsite_idx].osr_hits += simf->osr_hits;

    }

    if (frame_depth > simf->ss->by_callsite[simf->callsite_idx].max_depth)

        simf->ss->by_callsite[simf->callsite_idx].max_depth = frame_depth;

    /* See if there's a type tuple to attach type-based stats to. */

    if (simf->type_idx < 0 && simf->arg_types) {

        simf->type_idx = by_type(tc, simf->ss, simf->callsite_idx, simf->arg_types);

        simf->arg_types = NULL;

        first_type_hit = 1;

    }

    tss = simf->type_idx >= 0

        ? &(simf->ss->by_callsite[simf->callsite_idx].by_type[simf->type_idx])

        : NULL;

    if (tss) {

        /* Incorporate data logged at offsets. */

        MVMuint32 i;

        for (i = 0; i < simf->offset_logs_used; i++) {

            MVMSpeshLogEntry *e = simf->offset_logs[i];

            switch (e->kind) {

                case MVM_SPESH_LOG_TYPE:

                case MVM_SPESH_LOG_RETURN: {

                    MVMSpeshStatsByOffset *oss = by_offset(tc, tss,

                        e->type.bytecode_offset);

                    add_type_at_offset(tc, oss, simf->sf, e->type.type,

                        e->type.flags & MVM_SPESH_LOG_TYPE_FLAG_CONCRETE);

                    break;

                }

                case MVM_SPESH_LOG_INVOKE: {

                    MVMSpeshStatsByOffset *oss = by_offset(tc, tss,

                        e->invoke.bytecode_offset);

                    add_invoke_at_offset(tc, oss, simf->sf, e->invoke.sf,

                        e->invoke.caller_is_outer, e->invoke.was_multi);

                    break;

                }

                case MVM_SPESH_LOG_PLUGIN_RESOLUTION: {

                    MVMSpeshStatsByOffset *oss = by_offset(tc, tss,

                        e->plugin.bytecode_offset);

                    add_plugin_guard_at_offset(tc, oss, e->plugin.guard_index);

                    break;

                }

            }

        }

        /* Incorporate callsite type stats (what type tuples did we make a

         * call with). */

        for (i = 0; i < simf->call_type_info_used; i++) {

            MVMSpeshSimCallType *info = &(simf->call_type_info[i]);

            MVMSpeshStatsByOffset *oss = by_offset(tc, tss, info->bytecode_offset);

            add_type_tuple_at_offset(tc, oss, simf->sf, info);

        }

        /* Incorporate OSR hits and bump max depth. */

        if (first_type_hit)

            tss->hits++;

        tss->osr_hits += simf->osr_hits;

        if (frame_depth > tss->max_depth)

            tss->max_depth = frame_depth;

        /* If the callee's last incovation matches the frame just invoked,

         * then log the type tuple against the callsite. */

        if (caller && caller->last_invoke_sf == simf->sf)

            add_sim_call_type_info(tc, caller, caller->last_invoke_offset,

                simf->ss->by_callsite[simf->callsite_idx].cs,

                tss->arg_types);

    }

    /* Clear up offset logs and call type info; they're either incorproated or

     * to be tossed. Also zero OSR hits, so we don't over-inflate them if this

     * frame entry survives. */

    MVM_free(simf->offset_logs);

    simf->offset_logs = NULL;

    simf->offset_logs_used = simf->offset_logs_limit = 0;

    MVM_free(simf->call_type_info);

    simf->call_type_info = NULL;

    simf->call_type_info_used = simf->call_type_info_limit = 0;

    simf->osr_hits = 0;

}

/* Pops the top frame from the sim stack. */

void sim_stack_pop(MVMThreadContext *tc, MVMSpeshSimStack *sims, MVMObject *sf_updated) {

    MVMSpeshSimStackFrame *simf;

    MVMuint32 frame_depth;

    /* Pop off the simulated frame and incorporate logged data into the spesh

     * stats model. */

    if (sims->used == 0)

        MVM_panic(1, "Spesh stats: cannot pop an empty simulation stack");

    sims->used--;

    simf = &(sims->frames[sims->used]);

    frame_depth = sims->depth--;

    /* Incorporate logged data into the statistics model. */

    incorporate_stats(tc, simf, frame_depth,

        sims->used > 0 ? &(sims->frames[sims->used - 1]) : NULL,

        sf_updated);

}

/* Gets the simulation stack frame for the specified correlation ID. If it is

 * not on the top, searches to see if it's further down. If it is, then pops

 * off the top to reach it. If it's not found at all, returns NULL and does

 * nothing to the simulation stack. */

MVMSpeshSimStackFrame * sim_stack_find(MVMThreadContext *tc, MVMSpeshSimStack *sims,

                                       MVMuint32 cid, MVMObject *sf_updated) {

    MVMuint32 found_at = sims->used;

    while (found_at != 0) {

        found_at--;

        if (sims->frames[found_at].cid == cid) {

            MVMint32 pop = (sims->used - found_at) - 1;

            MVMint32 i;

            for (i = 0; i < pop; i++)

                sim_stack_pop(tc, sims, sf_updated);

            return &(sims->frames[found_at]);

        }

    }

    return NULL;

}

/* Pops all the frames in the stack simulation and frees the frames storage. */

void sim_stack_teardown(MVMThreadContext *tc, MVMSpeshSimStack *sims, MVMObject *sf_updated) {

    while (sims->used)

        sim_stack_pop(tc, sims, sf_updated);

    MVM_free(sims->frames);

}

/* Gets the parameter type slot from a simulation frame. */

MVMSpeshStatsType * param_type(MVMThreadContext *tc, MVMSpeshSimStackFrame *simf, MVMSpeshLogEntry *e) {

    if (simf->arg_types) {

        MVMuint16 idx = e->param.arg_idx;

        MVMCallsite *cs = simf->ss->by_callsite[simf->callsite_idx].cs;

        if (cs) {

            MVMint32 flag_idx = idx < cs->num_pos

                ? idx

                : cs->num_pos + (((idx - 1) - cs->num_pos) / 2);

            if (flag_idx >= cs->flag_count)

                MVM_panic(1, "Spesh stats: argument flag index out of bounds");

            if (cs->arg_flags[flag_idx] & MVM_CALLSITE_ARG_OBJ)

                return &(simf->arg_types[flag_idx]);

        }

    }

    return NULL;

}

/* Records a static value for a frame, unless it's already in the log. */

void add_static_value(MVMThreadContext *tc, MVMSpeshSimStackFrame *simf, MVMint32 bytecode_offset,

                      MVMObject *value) {

    MVMSpeshStats *ss = simf->ss;

    MVMuint32 i, id;

    for (i = 0; i < ss->num_static_values; i++)

        if (ss->static_values[i].bytecode_offset == bytecode_offset)

            return;

    id = ss->num_static_values++;

    ss->static_values = MVM_realloc(ss->static_values,

        ss->num_static_values * sizeof(MVMSpeshStatsStatic));

    ss->static_values[id].bytecode_offset = bytecode_offset;

    MVM_ASSIGN_REF(tc, &(simf->sf->body.spesh->common.header), ss->static_values[id].value, value);

}

/* Decides whether to save or free the simulation stack. */

static void save_or_free_sim_stack(MVMThreadContext *tc, MVMSpeshSimStack *sims,

                                   MVMThreadContext *save_on_tc, MVMObject *sf_updated) {

    MVMint32 first_survivor = -1;

    MVMint32 i;

    if (save_on_tc) {

        for (i = 0; i < sims->used; i++) {

            MVMSpeshSimStackFrame *simf = &(sims->frames[i]);

            MVMuint32 age = tc->instance->spesh_stats_version - simf->ss->last_update;

            if (age < MVM_SPESH_STATS_MAX_AGE - 1) {

                first_survivor = i;

                break;

            }

        }

    }

    if (first_survivor >= 0) {

        /* Move survivors to the start. */

        if (first_survivor > 0) {

            sims->used -= first_survivor;

            memmove(sims->frames, sims->frames + first_survivor,

                sims->used * sizeof(MVMSpeshSimStackFrame));

        }

        /* Incorporate data from the rest into the stats model, clearing it

         * away. */

        i = sims->used - 1;

        while (i >= 0) {

            incorporate_stats(tc, &(sims->frames[i]), first_survivor + i,

                i > 0 ? &(sims->frames[i - 1]) : NULL,

                sf_updated);

            i--;

        }

        /* Save frames for next time. */

        save_on_tc->spesh_sim_stack = sims;

    }

    else {

        /* Everything on the simulated stack is too old; throw it away. */

        sim_stack_teardown(tc, sims, sf_updated);

        MVM_free(sims);

    }

}

/* Receives a spesh log and updates static frame statistics. Each static frame

 * that is updated is pushed once into sf_updated. */

void MVM_spesh_stats_update(MVMThreadContext *tc, MVMSpeshLog *sl, MVMObject *sf_updated) {

    MVMuint32 i;

    MVMuint32 n = sl->body.used;

    MVMSpeshSimStack *sims;

    MVMThreadContext *log_from_tc = sl->body.thread->body.tc;

#if MVM_GC_DEBUG

    tc->in_spesh = 1;

#endif

    /* See if we have a simulation stack left over from before; create a new

     * one if not. */

    if (log_from_tc && log_from_tc->spesh_sim_stack) {

        /* Filter out those whose stats pointer is outdated. */

        MVMuint32 insert_pos = 0;

        sims = log_from_tc->spesh_sim_stack;

        for (i = 0; i < sims->used; i++) {

            MVMSpeshStats *cur_stats = sims->frames[i].sf->body.spesh->body.spesh_stats;

            if (cur_stats == sims->frames[i].ss) {

                if (i != insert_pos)

                    sims->frames[insert_pos] = sims->frames[i];

                insert_pos++;

            }

        }

        sims->used = insert_pos;

        log_from_tc->spesh_sim_stack = NULL;

    }

    else {

        sims = MVM_malloc(sizeof(MVMSpeshSimStack));

        sim_stack_init(tc, sims);

    }

    /* Process the log entries. */

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

        MVMSpeshLogEntry *e = &(sl->body.entries[i]);

        switch (e->kind) {

            case MVM_SPESH_LOG_ENTRY: {

                MVMSpeshStats *ss = stats_for(tc, e->entry.sf);

                MVMuint32 callsite_idx;

                if (ss->last_update != tc->instance->spesh_stats_version) {

                    ss->last_update = tc->instance->spesh_stats_version;

                    MVM_repr_push_o(tc, sf_updated, (MVMObject *)e->entry.sf);

                }

                ss->hits++;

                callsite_idx = by_callsite_idx(tc, ss, e->entry.cs);

                ss->by_callsite[callsite_idx].hits++;

                sim_stack_push(tc, sims, e->entry.sf, ss, e->id, callsite_idx);

                break;

            }

            case MVM_SPESH_LOG_PARAMETER: {

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf) {

                    MVMSpeshStatsType *type_slot = param_type(tc, simf, e);

                    if (type_slot) {

                        MVM_ASSIGN_REF(tc, &(simf->sf->body.spesh->common.header),

                            type_slot->type, e->param.type);

                        type_slot->type_concrete =

                            e->param.flags & MVM_SPESH_LOG_TYPE_FLAG_CONCRETE ? 1 : 0;

                        type_slot->rw_cont =

                            e->param.flags & MVM_SPESH_LOG_TYPE_FLAG_RW_CONT ? 1 : 0;

                    }

                }

                break;

            }

            case MVM_SPESH_LOG_PARAMETER_DECONT: {

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf) {

                    MVMSpeshStatsType *type_slot = param_type(tc, simf, e);

                    if (type_slot) {

                        MVM_ASSIGN_REF(tc, &(simf->sf->body.spesh->common.header),

                            type_slot->decont_type, e->param.type);

                        type_slot->decont_type_concrete =

                            e->param.flags & MVM_SPESH_LOG_TYPE_FLAG_CONCRETE;

                    }

                }

                break;

            }

            case MVM_SPESH_LOG_TYPE:

            case MVM_SPESH_LOG_INVOKE:

            case MVM_SPESH_LOG_PLUGIN_RESOLUTION: {

                /* We only incorporate these into the model later, and only

                 * then if we need to. For now, just keep references to

                 * them. */

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf) {

                    if (simf->offset_logs_used == simf->offset_logs_limit) {

                        simf->offset_logs_limit += 32;

                        simf->offset_logs = MVM_realloc(simf->offset_logs,

                            simf->offset_logs_limit * sizeof(MVMSpeshLogEntry *));

                    }

                    simf->offset_logs[simf->offset_logs_used++] = e;

                    if (e->kind == MVM_SPESH_LOG_INVOKE) {

                        simf->last_invoke_offset = e->invoke.bytecode_offset;

                        simf->last_invoke_sf = e->invoke.sf;

                    }

                }

                break;

            }

            case MVM_SPESH_LOG_OSR: {

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf)

                    simf->osr_hits++;

                break;

            }

            case MVM_SPESH_LOG_STATIC: {

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf)

                    add_static_value(tc, simf, e->value.bytecode_offset, e->value.value);

                break;

            }

            case MVM_SPESH_LOG_RETURN: {

                MVMSpeshSimStackFrame *simf = sim_stack_find(tc, sims, e->id, sf_updated);

                if (simf) {

                    MVMStaticFrame *called_sf = simf->sf;

                    sim_stack_pop(tc, sims, sf_updated);

                    if (e->type.type && sims->used) {

                        MVMSpeshSimStackFrame *caller = &(sims->frames[sims->used - 1]);

                        if (called_sf == caller->last_invoke_sf) {

                            if (caller->offset_logs_used == caller->offset_logs_limit) {

                                caller->offset_logs_limit += 32;

                                caller->offset_logs = MVM_realloc(caller->offset_logs,

                                    caller->offset_logs_limit * sizeof(MVMSpeshLogEntry *));

                            }

                            e->type.bytecode_offset = caller->last_invoke_offset;

                            caller->offset_logs[caller->offset_logs_used++] = e;

                        }

                    }

                }

                break;

            }

        }

    }

    save_or_free_sim_stack(tc, sims, log_from_tc, sf_updated);

#if MVM_GC_DEBUG

    tc->in_spesh = 0;

#endif

}

/* Takes an array of frames we recently updated the stats in. If they weren't

 * updated in a while, clears them out. */

void MVM_spesh_stats_cleanup(MVMThreadContext *tc, MVMObject *check_frames) {

    MVMint64 elems = MVM_repr_elems(tc, check_frames);

    MVMint64 insert_pos = 0;

    MVMint64 i;

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

        MVMStaticFrame *sf = (MVMStaticFrame *)MVM_repr_at_pos_o(tc, check_frames, i);

        MVMStaticFrameSpesh *spesh = sf->body.spesh;

        MVMSpeshStats *ss = spesh->body.spesh_stats;

        if (!ss) {

            /* No stats; already destroyed, don't keep this frame under

             * consideration. */

        }

        else if (tc->instance->spesh_stats_version - ss->last_update > MVM_SPESH_STATS_MAX_AGE) {

            MVM_spesh_stats_destroy(tc, ss);

            MVM_free(spesh->body.spesh_stats);

            spesh->body.spesh_stats = NULL;

        }

        else {

            MVM_repr_bind_pos_o(tc, check_frames, insert_pos++, (MVMObject *)sf);

        }

    }

    MVM_repr_pos_set_elems(tc, check_frames, insert_pos);

}

void MVM_spesh_stats_gc_mark(MVMThreadContext *tc, MVMSpeshStats *ss, MVMGCWorklist *worklist) {

    if (ss) {

        MVMuint32 i, j, k, l, m;

        for (i = 0; i < ss->num_by_callsite; i++) {

            MVMSpeshStatsByCallsite *by_cs = &(ss->by_callsite[i]);

            for (j = 0; j < by_cs->num_by_type; j++) {

                MVMSpeshStatsByType *by_type = &(by_cs->by_type[j]);

                MVMuint32 num_types = by_cs->cs->flag_count;

                for (k = 0; k < num_types; k++) {

                    MVM_gc_worklist_add(tc, worklist, &(by_type->arg_types[k].type));

                    MVM_gc_worklist_add(tc, worklist, &(by_type->arg_types[k].decont_type));

                }

                for (k = 0; k < by_type->num_by_offset; k++) {

                    MVMSpeshStatsByOffset *by_offset = &(by_type->by_offset[k]);

                    for (l = 0; l < by_offset->num_types; l++)

                        MVM_gc_worklist_add(tc, worklist, &(by_offset->types[l].type));

                    for (l = 0; l < by_offset->num_invokes; l++)

                        MVM_gc_worklist_add(tc, worklist, &(by_offset->invokes[l].sf));

                    for (l = 0; l < by_offset->num_type_tuples; l++) {

                        MVMSpeshStatsType *off_types = by_offset->type_tuples[l].arg_types;

                        MVMuint32 num_off_types = by_offset->type_tuples[l].cs->flag_count;

                        for (m = 0; m < num_off_types; m++) {

                            MVM_gc_worklist_add(tc, worklist, &(off_types[m].type));

                            MVM_gc_worklist_add(tc, worklist, &(off_types[m].decont_type));

                        }

                    }

                }

            }

        }

        for (i = 0; i < ss->num_static_values; i++)

            MVM_gc_worklist_add(tc, worklist, &(ss->static_values[i].value));

    }

}

void MVM_spesh_stats_gc_describe(MVMThreadContext *tc, MVMHeapSnapshotState *snapshot, MVMSpeshStats *ss) {

    if (ss) {

        MVMuint32 i, j, k, l, m;

        for (i = 0; i < ss->num_by_callsite; i++) {

            MVMSpeshStatsByCallsite *by_cs = &(ss->by_callsite[i]);

            for (j = 0; j < by_cs->num_by_type; j++) {

                MVMSpeshStatsByType *by_type = &(by_cs->by_type[j]);

                MVMuint32 num_types = by_cs->cs->flag_count;

                for (k = 0; k < num_types; k++) {

                    MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                        (MVMCollectable*)(by_type->arg_types[k].type), "type");

                    MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                        (MVMCollectable*)(by_type->arg_types[k].decont_type), "decont type");

                }

                for (k = 0; k < by_type->num_by_offset; k++) {

                    MVMSpeshStatsByOffset *by_offset = &(by_type->by_offset[k]);

                    for (l = 0; l < by_offset->num_types; l++)

                        MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                            (MVMCollectable*)(by_offset->types[l].type), "type at offset");

                    for (l = 0; l < by_offset->num_invokes; l++)

                        MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                            (MVMCollectable*)(by_offset->invokes[l].sf), "invoke");

                    for (l = 0; l < by_offset->num_type_tuples; l++) {

                        MVMSpeshStatsType *off_types = by_offset->type_tuples[l].arg_types;

                        MVMuint32 num_off_types = by_offset->type_tuples[l].cs->flag_count;

                        for (m = 0; m < num_off_types; m++) {

                            MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                                (MVMCollectable*)(off_types[m].type), "type tuple type");

                            MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                                (MVMCollectable*)(off_types[m].decont_type), "type tuple deconted type");

                        }

                    }

                }

            }

        }

        for (i = 0; i < ss->num_static_values; i++)

            MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,

                (MVMCollectable*)(ss->static_values[i].value), "static value");

    }

}

void MVM_spesh_stats_destroy(MVMThreadContext *tc, MVMSpeshStats *ss) {

    if (ss) {

        MVMuint32 i, j, k, l;

        for (i = 0; i < ss->num_by_callsite; i++) {

            MVMSpeshStatsByCallsite *by_cs = &(ss->by_callsite[i]);

            for (j = 0; j < by_cs->num_by_type; j++) {

                MVMSpeshStatsByType *by_type = &(by_cs->by_type[j]);

                for (k = 0; k < by_type->num_by_offset; k++) {

                    MVMSpeshStatsByOffset *by_offset = &(by_type->by_offset[k]);

                    MVM_free(by_offset->types);

                    MVM_free(by_offset->invokes);

                    for (l = 0; l < by_offset->num_type_tuples; l++)

                        MVM_free(by_offset->type_tuples[l].arg_types);

                    MVM_free(by_offset->type_tuples);

                    MVM_free(by_offset->plugin_guards);

                }

                MVM_free(by_type->by_offset);

                MVM_free(by_type->arg_types);

            }

            MVM_free(by_cs->by_type);

        }

        MVM_free(ss->by_callsite);

        MVM_free(ss->static_values);

    }

}

void MVM_spesh_sim_stack_gc_mark(MVMThreadContext *tc, MVMSpeshSimStack *sims,

                                 MVMGCWorklist *worklist) {

    MVMuint32 n = sims ? sims->used : 0;

    MVMuint32 i;

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

        MVMSpeshSimStackFrame *simf = &(sims->frames[i]);

        MVM_gc_worklist_add(tc, worklist, &(simf->sf));

        MVM_gc_worklist_add(tc, worklist, &(simf->last_invoke_sf));

    }

}

void MVM_spesh_sim_stack_gc_describe(MVMThreadContext *tc, MVMHeapSnapshotState *ss, MVMSpeshSimStack *sims) {

    MVMuint32 n = sims ? sims->used : 0;

    MVMuint32 i;

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

        MVMSpeshSimStackFrame *simf = &(sims->frames[i]);

        MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,

            (MVMCollectable*)(simf->sf), "staticframe");

        MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,

            (MVMCollectable*)(simf->last_invoke_sf), "last invoked staticframe");

    }

}

void MVM_spesh_sim_stack_destroy(MVMThreadContext *tc, MVMSpeshSimStack *sims) {

    if (sims) {

        MVM_free(sims->frames);

        MVM_free(sims);

    }

}