mbed I/F binding for mruby
Dependents: mruby_mbed_web mirb_mbed
mbed-mruby
How to use
Class
src/dump.c
- Committer:
- mzta
- Date:
- 2015-03-25
- Revision:
- 0:158c61bb030f
File content as of revision 0:158c61bb030f:
/* ** dump.c - mruby binary dumper (mrbc binary format) ** ** See Copyright Notice in mruby.h */ #include <ctype.h> #include <string.h> #include <limits.h> #include "mruby/dump.h" #include "mruby/string.h" #include "mruby/irep.h" #include "mruby/numeric.h" #include "mruby/debug.h" #define FLAG_BYTEORDER_NATIVE 2 #define FLAG_BYTEORDER_NONATIVE 0 #ifdef ENABLE_STDIO static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep); #if UINT32_MAX > SIZE_MAX # error This code cannot be built on your environment. #endif static size_t write_padding(uint8_t *buf) { const size_t align = MRB_DUMP_ALIGNMENT; size_t pad_len = -(intptr_t)buf & (align-1); if (pad_len > 0) { memset(buf, 0, pad_len); } return pad_len; } static size_t get_irep_header_size(mrb_state *mrb) { size_t size = 0; size += sizeof(uint32_t) * 1; size += sizeof(uint16_t) * 3; return size; } static ptrdiff_t write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) { uint8_t *cur = buf; cur += uint32_to_bin(get_irep_record_size_1(mrb, irep), cur); /* record size */ cur += uint16_to_bin((uint16_t)irep->nlocals, cur); /* number of local variable */ cur += uint16_to_bin((uint16_t)irep->nregs, cur); /* number of register variable */ cur += uint16_to_bin((uint16_t)irep->rlen, cur); /* number of child irep */ return cur - buf; } static size_t get_iseq_block_size(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; size += sizeof(uint32_t); /* ilen */ size += sizeof(uint32_t); /* max padding */ size += sizeof(uint32_t) * irep->ilen; /* iseq(n) */ return size; } static ptrdiff_t write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags) { uint8_t *cur = buf; uint32_t iseq_no; cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */ cur += write_padding(cur); if (flags & FLAG_BYTEORDER_NATIVE) { memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code)); cur += irep->ilen * sizeof(mrb_code); } else { for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */ } } return cur - buf; } static size_t get_pool_block_size(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; size_t pool_no; mrb_value str; char buf[32]; size += sizeof(uint32_t); /* plen */ size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */ for (pool_no = 0; pool_no < irep->plen; pool_no++) { int ai = mrb_gc_arena_save(mrb); switch (mrb_type(irep->pool[pool_no])) { case MRB_TT_FIXNUM: str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10); { mrb_int len = RSTRING_LEN(str); mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); size += (size_t)len; } break; case MRB_TT_FLOAT: { int len; len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no])); mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); size += (size_t)len; } break; case MRB_TT_STRING: { mrb_int len = RSTRING_LEN(irep->pool[pool_no]); mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); size += (size_t)len; } break; default: break; } mrb_gc_arena_restore(mrb, ai); } return size; } static ptrdiff_t write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) { size_t pool_no; uint8_t *cur = buf; uint16_t len; mrb_value str; const char *char_ptr; char char_buf[30]; cur += uint32_to_bin(irep->plen, cur); /* number of pool */ for (pool_no = 0; pool_no < irep->plen; pool_no++) { int ai = mrb_gc_arena_save(mrb); switch (mrb_type(irep->pool[pool_no])) { case MRB_TT_FIXNUM: cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */ str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10); char_ptr = RSTRING_PTR(str); { mrb_int tlen; tlen = RSTRING_LEN(str); mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX); len = (uint16_t)tlen; } break; case MRB_TT_FLOAT: cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ { int tlen; tlen = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no])); mrb_assert_int_fit(int, tlen, uint16_t, UINT16_MAX); len = (uint16_t)tlen; } char_ptr = &char_buf[0]; break; case MRB_TT_STRING: cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */ char_ptr = RSTRING_PTR(irep->pool[pool_no]); { mrb_int tlen; tlen = RSTRING_LEN(irep->pool[pool_no]); mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX); len = (uint16_t)tlen; } break; default: continue; } cur += uint16_to_bin(len, cur); /* data length */ memcpy(cur, char_ptr, (size_t)len); cur += len; mrb_gc_arena_restore(mrb, ai); } return cur - buf; } static size_t get_syms_block_size(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; uint32_t sym_no; mrb_int len; size += sizeof(uint32_t); /* slen */ for (sym_no = 0; sym_no < irep->slen; sym_no++) { size += sizeof(uint16_t); /* snl(n) */ if (irep->syms[sym_no] != 0) { mrb_sym2name_len(mrb, irep->syms[sym_no], &len); size += len + 1; /* sn(n) + null char */ } } return size; } static ptrdiff_t write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) { uint32_t sym_no; uint8_t *cur = buf; const char *name; cur += uint32_to_bin(irep->slen, cur); /* number of symbol */ for (sym_no = 0; sym_no < irep->slen; sym_no++) { if (irep->syms[sym_no] != 0) { mrb_int len; name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len); mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX); cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */ memcpy(cur, name, len); /* symbol name */ cur += (uint16_t)len; *cur++ = '\0'; } else { cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */ } } return cur - buf; } static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; size += get_irep_header_size(mrb); size += get_iseq_block_size(mrb, irep); size += get_pool_block_size(mrb, irep); size += get_syms_block_size(mrb, irep); return size; } static size_t get_irep_record_size(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; size_t irep_no; size = get_irep_record_size_1(mrb, irep); for (irep_no = 0; irep_no < irep->rlen; irep_no++) { size += get_irep_record_size(mrb, irep->reps[irep_no]); } return size; } static int write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags) { uint32_t i; uint8_t *src = bin; if (irep == NULL) { return MRB_DUMP_INVALID_IREP; } *irep_record_size = get_irep_record_size_1(mrb, irep); if (*irep_record_size == 0) { return MRB_DUMP_GENERAL_FAILURE; } bin += write_irep_header(mrb, irep, bin); bin += write_iseq_block(mrb, irep, bin, flags); bin += write_pool_block(mrb, irep, bin); bin += write_syms_block(mrb, irep, bin); for (i = 0; i < irep->rlen; i++) { int result; size_t rsize; result = write_irep_record(mrb, irep->reps[i], bin, &rsize, flags); if (result != MRB_DUMP_OK) { return result; } bin += rsize; } *irep_record_size = bin - src; return MRB_DUMP_OK; } static uint32_t write_footer(mrb_state *mrb, uint8_t *bin) { struct rite_binary_footer footer; memcpy(footer.section_identify, RITE_BINARY_EOF, sizeof(footer.section_identify)); uint32_to_bin(sizeof(struct rite_binary_footer), footer.section_size); memcpy(bin, &footer, sizeof(struct rite_binary_footer)); return sizeof(struct rite_binary_footer); } static int write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin) { struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin; memcpy(header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(header->section_identify)); mrb_assert_int_fit(size_t, section_size, uint32_t, UINT32_MAX); uint32_to_bin((uint32_t)section_size, header->section_size); memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version)); return MRB_DUMP_OK; } static int write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags) { int result; size_t rsize = 0; uint8_t *cur = bin; if (mrb == NULL || bin == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } cur += sizeof(struct rite_section_irep_header); result = write_irep_record(mrb, irep, cur, &rsize, flags); if (result != MRB_DUMP_OK) { return result; } *len_p = cur - bin + rsize; write_section_irep_header(mrb, *len_p, bin); return MRB_DUMP_OK; } static int write_section_lineno_header(mrb_state *mrb, size_t section_size, uint8_t *bin) { struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin; memcpy(header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(header->section_identify)); uint32_to_bin((uint32_t)section_size, header->section_size); return MRB_DUMP_OK; } static size_t get_lineno_record_size(mrb_state *mrb, mrb_irep *irep) { size_t size = 0; size += sizeof(uint32_t); /* record size */ size += sizeof(uint16_t); /* filename size */ if (irep->filename) { size += strlen(irep->filename); /* filename */ } size += sizeof(uint32_t); /* niseq */ if (irep->lines) { size += sizeof(uint16_t) * irep->ilen; /* lineno */ } return size; } static size_t write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin) { uint8_t *cur = bin; size_t iseq_no; size_t filename_len; ptrdiff_t diff; cur += sizeof(uint32_t); /* record size */ if (irep->filename) { filename_len = strlen(irep->filename); } else { filename_len = 0; } mrb_assert_int_fit(size_t, filename_len, uint16_t, UINT16_MAX); cur += uint16_to_bin((uint16_t)filename_len, cur); /* filename size */ if (filename_len) { memcpy(cur, irep->filename, filename_len); cur += filename_len; /* filename */ } if (irep->lines) { mrb_assert_int_fit(size_t, irep->ilen, uint32_t, UINT32_MAX); cur += uint32_to_bin((uint32_t)(irep->ilen), cur); /* niseq */ for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */ } } else { cur += uint32_to_bin(0, cur); /* niseq */ } diff = cur - bin; mrb_assert_int_fit(ptrdiff_t, diff, uint32_t, UINT32_MAX); uint32_to_bin((uint32_t)diff, bin); /* record size */ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); return (size_t)diff; } static size_t write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin) { size_t i; size_t rlen, size = 0; rlen = write_lineno_record_1(mrb, irep, bin); bin += rlen; size += rlen; for (i=0; i<irep->rlen; i++) { rlen = write_lineno_record(mrb, irep, bin); bin += rlen; size += rlen; } return size; } static int write_section_lineno(mrb_state *mrb, mrb_irep *irep, uint8_t *bin) { size_t section_size = 0; size_t rlen = 0; /* size of irep record */ uint8_t *cur = bin; if (mrb == NULL || bin == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } cur += sizeof(struct rite_section_lineno_header); section_size += sizeof(struct rite_section_lineno_header); rlen = write_lineno_record(mrb, irep, cur); section_size += rlen; write_section_lineno_header(mrb, section_size, bin); return MRB_DUMP_OK; } static size_t get_debug_record_size(mrb_state *mrb, mrb_irep *irep) { size_t ret = 0; uint16_t f_idx; size_t i; ret += sizeof(uint32_t); /* record size */ ret += sizeof(uint16_t); /* file count */ for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { mrb_irep_debug_info_file const* file = irep->debug_info->files[f_idx]; ret += sizeof(uint32_t); /* position */ ret += sizeof(uint16_t); /* filename index */ /* lines */ ret += sizeof(uint32_t); /* entry count */ ret += sizeof(uint8_t); /* line type */ switch (file->line_type) { case mrb_debug_line_ary: ret += sizeof(uint16_t) * (size_t)(file->line_entry_count); break; case mrb_debug_line_flat_map: ret += (sizeof(uint32_t) + sizeof(uint16_t)) * (size_t)(file->line_entry_count); break; default: mrb_assert(0); break; } } for (i=0; i<irep->rlen; i++) { ret += get_debug_record_size(mrb, irep->reps[i]); } return ret; } static int find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s) { int i; for (i = 0; i < ary_len; ++i) { if (ary[i] == s) { return i; } } return -1; } static size_t get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp) { mrb_sym *filenames = *fp; size_t i, size = 0; mrb_irep_debug_info *di = irep->debug_info; mrb_assert(lp); for (i = 0; i < di->flen; ++i) { mrb_irep_debug_info_file *file; mrb_int filename_len; file = di->files[i]; if (find_filename_index(filenames, *lp, file->filename_sym) == -1) { /* register filename */ *lp += 1; *fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp)); filenames[*lp - 1] = file->filename_sym; /* filename */ mrb_sym2name_len(mrb, file->filename_sym, &filename_len); size += sizeof(uint16_t) + (size_t)filename_len; } } for (i=0; i<irep->rlen; i++) { size += get_filename_table_size(mrb, irep->reps[i], fp, lp); } return size; } static size_t write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) { uint8_t *cur; uint16_t f_idx; ptrdiff_t ret; cur = bin + sizeof(uint32_t); /* skip record size */ cur += uint16_to_bin(irep->debug_info->flen, cur); /* file count */ for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { int filename_idx; const mrb_irep_debug_info_file *file = irep->debug_info->files[f_idx]; /* position */ cur += uint32_to_bin(file->start_pos, cur); /* filename index */ filename_idx = find_filename_index(filenames, filenames_len, file->filename_sym); mrb_assert_int_fit(int, filename_idx, uint16_t, UINT16_MAX); cur += uint16_to_bin((uint16_t)filename_idx, cur); /* lines */ cur += uint32_to_bin(file->line_entry_count, cur); cur += uint8_to_bin(file->line_type, cur); switch (file->line_type) { case mrb_debug_line_ary: { uint32_t l; for (l = 0; l < file->line_entry_count; ++l) { cur += uint16_to_bin(file->lines.ary[l], cur); } } break; case mrb_debug_line_flat_map: { uint32_t line; for (line = 0; line < file->line_entry_count; ++line) { cur += uint32_to_bin(file->lines.flat_map[line].start_pos, cur); cur += uint16_to_bin(file->lines.flat_map[line].line, cur); } } break; default: mrb_assert(0); break; } } ret = cur - bin; mrb_assert_int_fit(ptrdiff_t, ret, uint32_t, UINT32_MAX); uint32_to_bin(ret, bin); mrb_assert_int_fit(ptrdiff_t, ret, size_t, SIZE_MAX); return (size_t)ret; } static size_t write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) { size_t size, len; size_t irep_no; size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len); bin += len; for (irep_no = 0; irep_no < irep->rlen; irep_no++) { len = write_debug_record(mrb, irep->reps[irep_no], bin, filenames, filenames_len); bin += len; size += len; } mrb_assert(size == get_debug_record_size(mrb, irep)); return size; } static int write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len) { size_t section_size = 0; const uint8_t *bin = cur; struct rite_section_debug_header *header; size_t dlen; uint16_t i; char const *sym; mrb_int sym_len; if (mrb == NULL || cur == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } header = (struct rite_section_debug_header *)bin; cur += sizeof(struct rite_section_debug_header); section_size += sizeof(struct rite_section_debug_header); /* filename table */ cur += uint16_to_bin(filenames_len, cur); section_size += sizeof(uint16_t); for (i = 0; i < filenames_len; ++i) { sym = mrb_sym2name_len(mrb, filenames[i], &sym_len); mrb_assert(sym); cur += uint16_to_bin(sym_len, cur); memcpy(cur, sym, sym_len); cur += sym_len; section_size += sizeof(uint16_t) + sym_len; } /* debug records */ dlen = write_debug_record(mrb, irep, cur, filenames, filenames_len); section_size += dlen; memcpy(header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(header->section_identify)); mrb_assert(section_size <= INT32_MAX); uint32_to_bin(section_size, header->section_size); return MRB_DUMP_OK; } static void create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len) { size_t i; if (*syms == NULL) { *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1); } for (i = 0; i + 1 < irep->nlocals; ++i) { mrb_sym const name = irep->lv[i].name; if (name == 0) continue; if (find_filename_index(*syms, *syms_len, name) != -1) continue; ++(*syms_len); *syms = (mrb_sym*)mrb_realloc(mrb, *syms, sizeof(mrb_sym) * (*syms_len)); (*syms)[*syms_len - 1] = name; } for (i = 0; i < irep->rlen; ++i) { create_lv_sym_table(mrb, irep->reps[i], syms, syms_len); } } static int write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_t syms_len) { uint8_t *cur = *start; uint32_t i; const char *str; mrb_int str_len; cur += uint32_to_bin(syms_len, cur); for (i = 0; i < syms_len; ++i) { str = mrb_sym2name_len(mrb, syms[i], &str_len); cur += uint16_to_bin(str_len, cur); memcpy(cur, str, str_len); cur += str_len; } *start = cur; return MRB_DUMP_OK; } static int write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len) { uint8_t *cur = *start; size_t i; for (i = 0; i + 1 < irep->nlocals; ++i) { if (irep->lv[i].name == 0) { cur += uint16_to_bin(RITE_LV_NULL_MARK, cur); cur += uint16_to_bin(0, cur); } else { int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name); mrb_assert(sym_idx != -1); /* local variable name must be in syms */ cur += uint16_to_bin(sym_idx, cur); cur += uint16_to_bin(irep->lv[i].r, cur); } } for (i = 0; i < irep->rlen; ++i) { write_lv_record(mrb, irep->reps[i], &cur, syms, syms_len); } *start = cur; return MRB_DUMP_OK; } static size_t get_lv_record_size(mrb_state *mrb, mrb_irep *irep) { size_t ret = 0, i; ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1); for (i = 0; i < irep->rlen; ++i) { ret += get_lv_record_size(mrb, irep->reps[i]); } return ret; } static size_t get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len) { size_t ret = 0, i; ret += sizeof(uint32_t); /* syms_len */ ret += sizeof(uint16_t) * syms_len; /* symbol name lengths */ for (i = 0; i < syms_len; ++i) { mrb_int str_len; mrb_sym2name_len(mrb, syms[i], &str_len); ret += str_len; } ret += get_lv_record_size(mrb, irep); return ret; } static int write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len) { uint8_t *cur = start; struct rite_section_lv_header *header; ptrdiff_t diff; int result = MRB_DUMP_OK; if (mrb == NULL || cur == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } header = (struct rite_section_lv_header*)cur; cur += sizeof(struct rite_section_lv_header); result = write_lv_sym_table(mrb, &cur, syms, syms_len); if (result != MRB_DUMP_OK) { goto lv_section_exit; } result = write_lv_record(mrb, irep, &cur, syms, syms_len); if (result != MRB_DUMP_OK) { goto lv_section_exit; } memcpy(header->section_identify, RITE_SECTION_LV_IDENTIFIER, sizeof(header->section_identify)); diff = cur - start; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); uint32_to_bin(diff, header->section_size); lv_section_exit: return result; } static int write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8_t flags) { struct rite_binary_header *header = (struct rite_binary_header *)bin; uint16_t crc; uint32_t offset; if (flags & FLAG_BYTEORDER_NATIVE) { uint32_t ident = 0; size_t i; for(i=0; i<sizeof(ident); i++) { ident<<=8; ident|=RITE_BINARY_IDENTIFIER[i]; } memcpy(header->binary_identify, (char*)&ident, sizeof(uint32_t)); } else { memcpy(header->binary_identify, RITE_BINARY_IDENTIFIER, sizeof(header->binary_identify)); } memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)); memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name)); memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version)); mrb_assert(binary_size <= UINT32_MAX); uint32_to_bin((uint32_t)binary_size, header->binary_size); offset = (&(header->binary_crc[0]) - bin) + sizeof(uint16_t); crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0); uint16_to_bin(crc, header->binary_crc); return MRB_DUMP_OK; } static mrb_bool is_debug_info_defined(mrb_irep *irep) { size_t i; if (!irep->debug_info) return FALSE; for (i=0; i<irep->rlen; i++) { if (!is_debug_info_defined(irep->reps[i])) return FALSE; } return TRUE; } static mrb_bool is_lv_defined(mrb_irep *irep) { size_t i; if (irep->lv) { return TRUE; } for (i = 0; i < irep->rlen; ++i) { if (is_lv_defined(irep->reps[i])) { return TRUE; } } return FALSE; } static int dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size, uint8_t flags) { int result = MRB_DUMP_GENERAL_FAILURE; size_t malloc_size; size_t section_irep_size; size_t section_lineno_size = 0, section_lv_size = 0; uint8_t *cur = NULL; mrb_bool const debug_info_defined = is_debug_info_defined(irep), lv_defined = is_lv_defined(irep); mrb_sym *lv_syms = NULL; uint32_t lv_syms_len = 0; mrb_sym *filenames = NULL; uint16_t filenames_len = 0; if (mrb == NULL) { *bin = NULL; return MRB_DUMP_GENERAL_FAILURE; } section_irep_size = sizeof(struct rite_section_irep_header); section_irep_size += get_irep_record_size(mrb, irep); /* DEBUG section size */ if (debug_info) { if (debug_info_defined) { section_lineno_size += sizeof(struct rite_section_debug_header); /* filename table */ filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) + 1); /* filename table size */ section_lineno_size += sizeof(uint16_t); section_lineno_size += get_filename_table_size(mrb, irep, &filenames, &filenames_len); section_lineno_size += get_debug_record_size(mrb, irep); } else { section_lineno_size += sizeof(struct rite_section_lineno_header); section_lineno_size += get_lineno_record_size(mrb, irep); } } if (lv_defined) { section_lv_size += sizeof(struct rite_section_lv_header); create_lv_sym_table(mrb, irep, &lv_syms, &lv_syms_len); section_lv_size += get_lv_section_size(mrb, irep, lv_syms, lv_syms_len); } malloc_size = sizeof(struct rite_binary_header) + section_irep_size + section_lineno_size + section_lv_size + sizeof(struct rite_binary_footer); cur = *bin = (uint8_t*)mrb_malloc(mrb, malloc_size); cur += sizeof(struct rite_binary_header); result = write_section_irep(mrb, irep, cur, §ion_irep_size, flags); if (result != MRB_DUMP_OK) { goto error_exit; } cur += section_irep_size; *bin_size = sizeof(struct rite_binary_header) + section_irep_size + section_lineno_size + section_lv_size + sizeof(struct rite_binary_footer); /* write DEBUG section */ if (debug_info) { if (debug_info_defined) { result = write_section_debug(mrb, irep, cur, filenames, filenames_len); } else { result = write_section_lineno(mrb, irep, cur); } if (result != MRB_DUMP_OK) { goto error_exit; } cur += section_lineno_size; } if (lv_defined) { result = write_section_lv(mrb, irep, cur, lv_syms, lv_syms_len); if (result != MRB_DUMP_OK) { goto error_exit; } cur += section_lv_size; } write_footer(mrb, cur); write_rite_binary_header(mrb, *bin_size, *bin, flags); error_exit: if (result != MRB_DUMP_OK) { mrb_free(mrb, *bin); *bin = NULL; } if (lv_syms) { mrb_free(mrb, lv_syms); } if (filenames) { mrb_free(mrb, filenames); } return result; } int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size) { return dump_irep(mrb, irep, debug_info, bin, bin_size, FLAG_BYTEORDER_NONATIVE); } int mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE* fp) { uint8_t *bin = NULL; size_t bin_size = 0; int result; if (fp == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } result = dump_irep(mrb, irep, debug_info, &bin, &bin_size, FLAG_BYTEORDER_NONATIVE); if (result == MRB_DUMP_OK) { if (fwrite(bin, sizeof(bin[0]), bin_size, fp) != bin_size) { result = MRB_DUMP_WRITE_FAULT; } } mrb_free(mrb, bin); return result; } static mrb_bool is_valid_c_symbol_name(const char *name) { const char *c = NULL; if (name == NULL || name[0] == '\0') return FALSE; if (!ISALPHA(name[0]) && name[0] != '_') return FALSE; c = &name[1]; for (; *c != '\0'; ++c) { if (!ISALNUM(*c) && *c != '_') return FALSE; } return TRUE; } int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE *fp, const char *initname) { uint8_t *bin = NULL; size_t bin_size = 0, bin_idx = 0; int result; if (fp == NULL || initname == NULL || !is_valid_c_symbol_name(initname)) { return MRB_DUMP_INVALID_ARGUMENT; } result = dump_irep(mrb, irep, debug_info, &bin, &bin_size, FLAG_BYTEORDER_NATIVE); if (result == MRB_DUMP_OK) { if (fprintf(fp, "#include <stdint.h>\n") < 0) { /* for uint8_t under at least Darwin */ mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; } if (fprintf(fp, "const uint8_t\n" "#if defined __GNUC__\n" "__attribute__((aligned(%u)))\n" "#elif defined _MSC_VER\n" "__declspec(align(%u))\n" "#endif\n" "%s[] = {", (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) { mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; } while (bin_idx < bin_size) { if (bin_idx % 16 == 0) { if (fputs("\n", fp) == EOF) { mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; } } if (fprintf(fp, "0x%02x,", bin[bin_idx++]) < 0) { mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; } } if (fputs("\n};\n", fp) == EOF) { mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; } } mrb_free(mrb, bin); return result; } #endif /* ENABLE_STDIO */