void
mono_cfg_dump_ir (MonoCompile *cfg, const char *phase_name)
{
if (cfg->gdump_ctx == NULL)
return;
cfg_debug ("=== DUMPING PASS \"%s\" ===", phase_name);
write_byte (cfg, BEGIN_GRAPH);
write_pool (cfg, create_cp_entry (cfg, (void *) phase_name, PT_STRING));
int instruction_count = label_instructions (cfg);
write_instructions (cfg, instruction_count);
write_blocks (cfg);
}
int create_cor(char *file)
{
int fd;
int fdwrite;
int error;
if ((fd = open(file, O_RDONLY)) == -1)
return (-5);
if ((fdwrite = open(my_strfusion(take_begin(file, '.'), ".cor"),
O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
return (-2);
if (create_header(fd, fdwrite) == -1)
return (-3);
if ((error = write_instructions(fd, fdwrite)) != 0)
return (error);
close(fd);
close(fdwrite);
return (0);
}
/* Generate bytecode from a spesh graph. */
MVMSpeshCode * MVM_spesh_codegen(MVMThreadContext *tc, MVMSpeshGraph *g) {
MVMSpeshCode *res;
MVMSpeshBB *bb;
MVMint32 i, hanlen;
/* Initialize writer state. */
SpeshWriterState *ws = MVM_malloc(sizeof(SpeshWriterState));
ws->bytecode_pos = 0;
ws->bytecode_alloc = 1024;
ws->bytecode = MVM_malloc(ws->bytecode_alloc);
ws->bb_offsets = MVM_malloc(g->num_bbs * sizeof(MVMint32));
ws->num_fixups = 0;
ws->alloc_fixups = 64;
ws->fixup_locations = MVM_malloc(ws->alloc_fixups * sizeof(MVMint32));
ws->fixup_bbs = MVM_malloc(ws->alloc_fixups * sizeof(MVMSpeshBB *));
for (i = 0; i < g->num_bbs; i++)
ws->bb_offsets[i] = -1;
/* Create copy of handlers, and -1 all offsets so we can catch missing
* updates. */
hanlen = g->num_handlers * sizeof(MVMFrameHandler);
if (hanlen) {
ws->handlers = MVM_malloc(hanlen);
memcpy(ws->handlers, g->handlers, hanlen);
for (i = 0; i < g->sf->body.num_handlers; i++) {
ws->handlers[i].start_offset = -1;
ws->handlers[i].end_offset = -1;
ws->handlers[i].goto_offset = -1;
}
}
else {
ws->handlers = NULL;
}
/* -1 all the deopt targets, so we'll easily catch those that don't get
* mapped if we try to use them. Same for inlines. */
for (i = 0; i < g->num_deopt_addrs; i++)
g->deopt_addrs[i * 2 + 1] = -1;
for (i = 0; i < g->num_inlines; i++) {
g->inlines[i].start = -1;
g->inlines[i].end = -1;
}
/* Write out each of the basic blocks, in linear order. Skip the first,
* dummy, block. */
bb = g->entry->linear_next;
while (bb) {
ws->bb_offsets[bb->idx] = ws->bytecode_pos;
write_instructions(tc, g, ws, bb);
bb = bb->linear_next;
}
/* Fixup labels we were too early for. */
for (i = 0; i < ws->num_fixups; i++)
*((MVMuint32 *)(ws->bytecode + ws->fixup_locations[i])) =
ws->bb_offsets[ws->fixup_bbs[i]->idx];
/* Ensure all handlers got fixed up. */
for (i = 0; i < g->sf->body.num_handlers; i++) {
if (ws->handlers[i].start_offset == -1 ||
ws->handlers[i].end_offset == -1 ||
ws->handlers[i].goto_offset == -1)
MVM_exception_throw_adhoc(tc, "Spesh: failed to fix up handlers (%d, %d, %d)",
(int)ws->handlers[i].start_offset,
(int)ws->handlers[i].end_offset,
(int)ws->handlers[i].goto_offset);
}
/* Ensure all inlines got fixed up. */
for (i = 0; i < g->num_inlines; i++)
if (g->inlines[i].start == -1 || g->inlines[i].end == -1)
MVM_exception_throw_adhoc(tc, "Spesh: failed to fix up inline %d", i);
/* Produce result data structure. */
res = MVM_malloc(sizeof(MVMSpeshCode));
res->bytecode = ws->bytecode;
res->bytecode_size = ws->bytecode_pos;
res->handlers = ws->handlers;
/* Cleanup. */
MVM_free(ws->bb_offsets);
MVM_free(ws->fixup_locations);
MVM_free(ws->fixup_bbs);
MVM_free(ws);
return res;
}