/* Free all memory allocated to hold synthetic graphemes. These are global
* to a VM instance. */
void MVM_nfg_destroy(MVMThreadContext *tc) {
MVMNFGState *nfg = tc->instance->nfg;
MVMint32 i;
/* Free all synthetics. */
if (nfg->synthetics) {
size_t used_synths_in_block = nfg->num_synthetics % MVM_SYNTHETIC_GROW_ELEMS;
size_t synths_to_free = used_synths_in_block
? nfg->num_synthetics + (MVM_SYNTHETIC_GROW_ELEMS - used_synths_in_block)
: nfg->num_synthetics;
for (i = 0; i < nfg->num_synthetics; i++) {
MVM_fixed_size_free(tc, tc->instance->fsa,
nfg->synthetics[i].num_codes * sizeof(MVMCodepoint),
nfg->synthetics[i].codes);
if (nfg->synthetics[i].case_uc != CASE_UNCHANGED)
MVM_free(nfg->synthetics[i].case_uc);
if (nfg->synthetics[i].case_lc != CASE_UNCHANGED)
MVM_free(nfg->synthetics[i].case_lc);
if (nfg->synthetics[i].case_tc != CASE_UNCHANGED)
MVM_free(nfg->synthetics[i].case_tc);
if (nfg->synthetics[i].case_fc != CASE_UNCHANGED)
MVM_free(nfg->synthetics[i].case_fc);
}
MVM_fixed_size_free(tc, tc->instance->fsa,
synths_to_free * sizeof(MVMNFGSynthetic),
nfg->synthetics);
}
MVM_free(nfg);
}
/* Frees the memory associated with an argument guard. If `safe` is set to a
* non-zero value then the memory is freed at the next safepoint. If it is set
* to zero, the memory is freed immediately. */
void MVM_spesh_arg_guard_destroy(MVMThreadContext *tc, MVMSpeshArgGuard *ag, MVMuint32 safe) {
if (ag) {
size_t total_size = sizeof(MVMSpeshArgGuard) +
ag->num_nodes * sizeof(MVMSpeshArgGuardNode);
if (safe)
MVM_fixed_size_free_at_safepoint(tc, tc->instance->fsa, total_size, ag);
else
MVM_fixed_size_free(tc, tc->instance->fsa, total_size, ag);
}
}
/* Clean up an arguments processing context. */
void MVM_args_proc_cleanup(MVMThreadContext *tc, MVMArgProcContext *ctx) {
if (ctx->arg_flags) {
MVM_free(ctx->arg_flags);
MVM_free(ctx->args);
}
if (ctx->named_used_size > 64) {
MVM_fixed_size_free(tc, tc->instance->fsa, ctx->named_used_size,
ctx->named_used.byte_array);
ctx->named_used_size = 0;
}
}
/* Does the jump into the optimized code. */
void perform_osr(MVMThreadContext *tc, MVMSpeshCandidate *specialized) {
MVMJitCode *jit_code;
MVMint32 num_locals;
/* Work out the OSR deopt index, to locate the entry point. */
MVMint32 osr_index = get_osr_deopt_index(tc, specialized);
#if MVM_LOG_OSR
fprintf(stderr, "Performing OSR of frame '%s' (cuid: %s) at index %d\n",
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.name),
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.cuuid),
osr_index);
#endif
jit_code = specialized->jitcode;
num_locals = jit_code && jit_code->local_types ?
jit_code->num_locals : specialized->num_locals;
/* Resize work area if needed. */
if (specialized->work_size > tc->cur_frame->allocd_work) {
/* Resize work area. */
MVMRegister *new_work = MVM_fixed_size_alloc_zeroed(tc, tc->instance->fsa,
specialized->work_size);
MVMRegister *new_args = new_work + num_locals;
memcpy(new_work, tc->cur_frame->work,
tc->cur_frame->static_info->body.num_locals * sizeof(MVMRegister));
memcpy(new_args, tc->cur_frame->args,
tc->cur_frame->static_info->body.cu->body.max_callsite_size * sizeof(MVMRegister));
MVM_fixed_size_free(tc, tc->instance->fsa, tc->cur_frame->allocd_work,
tc->cur_frame->work);
tc->cur_frame->work = new_work;
tc->cur_frame->allocd_work = specialized->work_size;
tc->cur_frame->args = new_args;
#if MVM_LOG_OSR
fprintf(stderr, "OSR resized work area of frame '%s' (cuid: %s)\n",
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.name),
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.cuuid));
#endif
}
else if (specialized->work_size > tc->cur_frame->static_info->body.work_size) {
size_t keep_bytes = tc->cur_frame->static_info->body.num_locals * sizeof(MVMRegister);
size_t to_null = specialized->work_size - keep_bytes;
memset((char *)tc->cur_frame->work + keep_bytes, 0, to_null);
}
/* Resize environment if needed. */
if (specialized->num_lexicals > tc->cur_frame->static_info->body.num_lexicals) {
MVMRegister *new_env = MVM_fixed_size_alloc_zeroed(tc, tc->instance->fsa,
specialized->env_size);
if (tc->cur_frame->allocd_env) {
memcpy(new_env, tc->cur_frame->env,
tc->cur_frame->static_info->body.num_lexicals * sizeof(MVMRegister));
MVM_fixed_size_free(tc, tc->instance->fsa, tc->cur_frame->allocd_env,
tc->cur_frame->env);
}
tc->cur_frame->env = new_env;
tc->cur_frame->allocd_env = specialized->env_size;
#if MVM_LOG_OSR
fprintf(stderr, "OSR resized environment of frame '%s' (cuid: %s)\n",
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.name),
MVM_string_utf8_encode_C_string(tc, tc->cur_frame->static_info->body.cuuid));
#endif
}
else if (specialized->env_size > tc->cur_frame->static_info->body.env_size) {
size_t keep_bytes = tc->cur_frame->static_info->body.num_lexicals * sizeof(MVMRegister);
size_t to_null = specialized->env_size - keep_bytes;
memset((char *)tc->cur_frame->env + keep_bytes, 0, to_null);
}
/* Set up frame to point to spesh candidate/slots. */
tc->cur_frame->effective_spesh_slots = specialized->spesh_slots;
tc->cur_frame->spesh_cand = specialized;
/* Move into the optimized (and maybe JIT-compiled) code. */
if (jit_code && jit_code->num_deopts) {
MVMint32 i;
*(tc->interp_bytecode_start) = jit_code->bytecode;
*(tc->interp_cur_op) = jit_code->bytecode;
for (i = 0; i < jit_code->num_deopts; i++) {
if (jit_code->deopts[i].idx == osr_index) {
tc->cur_frame->jit_entry_label = jit_code->labels[jit_code->deopts[i].label];
break;
}
}
if (i == jit_code->num_deopts)
MVM_oops(tc, "JIT: Could not find OSR label");
if (tc->instance->profiling)
MVM_profiler_log_osr(tc, 1);
} else {
*(tc->interp_bytecode_start) = specialized->bytecode;
*(tc->interp_cur_op) = specialized->bytecode +
specialized->deopts[2 * osr_index + 1];
if (tc->instance->profiling)
MVM_profiler_log_osr(tc, 0);
}
*(tc->interp_reg_base) = tc->cur_frame->work;
}
/* Finalizes OSR. */
void MVM_spesh_osr_finalize(MVMThreadContext *tc) {
/* Find deopt index using existing deopt table, for entering the updated
* code later. */
MVMSpeshCandidate *specialized = tc->cur_frame->spesh_cand;
MVMint32 osr_index = get_osr_deopt_finalize_index(tc, specialized);
MVMJitCode *jc;
/* Finish up the specialization. */
MVM_spesh_candidate_specialize(tc, tc->cur_frame->static_info, specialized);
/* Resize work area if needed. */
if (specialized->num_locals > tc->cur_frame->static_info->body.num_locals) {
/* Resize work area. */
MVMRegister *new_work = MVM_fixed_size_alloc_zeroed(tc, tc->instance->fsa,
specialized->work_size);
memcpy(new_work, tc->cur_frame->work,
tc->cur_frame->static_info->body.num_locals * sizeof(MVMRegister));
MVM_fixed_size_free(tc, tc->instance->fsa, tc->cur_frame->allocd_work,
tc->cur_frame->work);
tc->cur_frame->work = new_work;
tc->cur_frame->allocd_work = specialized->work_size;
tc->cur_frame->args = tc->cur_frame->work + specialized->num_locals;
}
/* Resize environment if needed. */
if (specialized->num_lexicals > tc->cur_frame->static_info->body.num_lexicals) {
MVMRegister *new_env = MVM_fixed_size_alloc_zeroed(tc, tc->instance->fsa,
specialized->env_size);
if (tc->cur_frame->allocd_env) {
memcpy(new_env, tc->cur_frame->env,
tc->cur_frame->static_info->body.num_lexicals * sizeof(MVMRegister));
MVM_fixed_size_free(tc, tc->instance->fsa, tc->cur_frame->allocd_env,
tc->cur_frame->env);
}
tc->cur_frame->env = new_env;
tc->cur_frame->allocd_env = specialized->env_size;
}
/* Sync frame with updates. */
tc->cur_frame->effective_bytecode = specialized->bytecode;
tc->cur_frame->effective_handlers = specialized->handlers;
tc->cur_frame->effective_spesh_slots = specialized->spesh_slots;
tc->cur_frame->spesh_log_slots = NULL;
tc->cur_frame->spesh_log_idx = -1;
/* Sync interpreter with updates. */
jc = specialized->jitcode;
if (jc && jc->num_deopts) {
MVMint32 i;
*(tc->interp_bytecode_start) = specialized->jitcode->bytecode;
*(tc->interp_cur_op) = specialized->jitcode->bytecode;
for (i = 0; i < jc->num_deopts; i++) {
if (jc->deopts[i].idx == osr_index) {
tc->cur_frame->jit_entry_label = jc->labels[jc->deopts[i].label];
break;
}
}
if (i == jc->num_deopts)
MVM_oops(tc, "JIT: Could not find OSR label");
if (tc->instance->profiling)
MVM_profiler_log_osr(tc, 1);
} else {
*(tc->interp_bytecode_start) = specialized->bytecode;
*(tc->interp_cur_op) = specialized->bytecode +
specialized->deopts[2 * osr_index + 1];
if (tc->instance->profiling)
MVM_profiler_log_osr(tc, 0);
}
*(tc->interp_reg_base) = tc->cur_frame->work;
/* Tweak frame invocation count so future invocations will use the code
* produced by OSR. */
tc->cur_frame->static_info->body.invocations +=
tc->cur_frame->static_info->body.spesh_threshold;
}
