static int read_rite_section_lineno(mrb_state *mrb, const uint8_t *bin, size_t sirep) { int result; size_t i; uint32_t len; uint16_t nirep; uint16_t n; const struct rite_section_lineno_header *header; len = 0; header = (const struct rite_section_lineno_header*)bin; bin += sizeof(struct rite_section_lineno_header); nirep = bin_to_uint16(header->nirep); //Read Binary Data Section for (n = 0, i = sirep; n < nirep; n++, i++) { result = read_rite_lineno_record(mrb, bin, i, &len); if (result != MRB_DUMP_OK) goto error_exit; bin += len; } result = sirep + bin_to_uint16(header->sirep); error_exit: return result; }
static int read_rite_section_irep(mrb_state *mrb, const uint8_t *bin) { int result; size_t sirep; size_t i; uint32_t len; uint16_t nirep; uint16_t n; const struct rite_section_irep_header *header; header = (const struct rite_section_irep_header*)bin; bin += sizeof(struct rite_section_irep_header); sirep = mrb->irep_len; nirep = bin_to_uint16(header->nirep); //Read Binary Data Section for (n = 0, i = sirep; n < nirep; n++, i++) { result = read_rite_irep_record(mrb, bin, &len); if (result != MRB_DUMP_OK) goto error_exit; bin += len; } result = sirep + bin_to_uint16(header->sirep); error_exit: if (result < MRB_DUMP_OK) { irep_free(sirep, mrb); } return result; }
static int read_rite_lineno_record(mrb_state *mrb, const uint8_t *bin, size_t irepno, uint32_t *len) { int ret; size_t i, fname_len, niseq; char *fname; uint16_t *lines; ret = MRB_DUMP_OK; *len = 0; bin += sizeof(uint32_t); // record size *len += sizeof(uint32_t); fname_len = bin_to_uint16(bin); bin += sizeof(uint16_t); *len += sizeof(uint16_t); if (SIZE_ERROR(fname_len + 1)) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } fname = (char *)mrb_malloc(mrb, fname_len + 1); if (fname == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } memcpy(fname, bin, fname_len); fname[fname_len] = '\0'; bin += fname_len; *len += fname_len; niseq = bin_to_uint32(bin); bin += sizeof(uint32_t); // niseq *len += sizeof(uint32_t); if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } lines = (uint16_t *)mrb_malloc(mrb, niseq * sizeof(uint16_t)); if (lines == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i = 0; i < niseq; i++) { lines[i] = bin_to_uint16(bin); bin += sizeof(uint16_t); // niseq *len += sizeof(uint16_t); } mrb->irep[irepno]->filename = fname; mrb->irep[irepno]->lines = lines; error_exit: return ret; }
static int read_lineno_record_1(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, uint32_t *len) { int ret; size_t i, fname_len, niseq; char *fname; uint16_t *lines; ret = MRB_DUMP_OK; *len = 0; bin += sizeof(uint32_t); /* record size */ *len += sizeof(uint32_t); fname_len = bin_to_uint16(bin); bin += sizeof(uint16_t); *len += sizeof(uint16_t); if (SIZE_ERROR(fname_len + 1)) { return MRB_DUMP_GENERAL_FAILURE; } fname = (char *)mrb_malloc(mrb, fname_len + 1); if (fname == NULL) { return MRB_DUMP_GENERAL_FAILURE; } memcpy(fname, bin, fname_len); fname[fname_len] = '\0'; bin += fname_len; *len += fname_len; niseq = bin_to_uint32(bin); bin += sizeof(uint32_t); /* niseq */ *len += sizeof(uint32_t); if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) { return MRB_DUMP_GENERAL_FAILURE; } lines = (uint16_t *)mrb_malloc(mrb, niseq * sizeof(uint16_t)); if (lines == NULL) { return MRB_DUMP_GENERAL_FAILURE; } for (i = 0; i < niseq; i++) { lines[i] = bin_to_uint16(bin); bin += sizeof(uint16_t); /* niseq */ *len += sizeof(uint16_t); } irep->filename = fname; irep->lines = lines; return ret; }
static int32_t read_rite_section_irep_file(mrb_state *mrb, FILE *fp) { int32_t result; size_t sirep; size_t i; uint16_t nirep; uint16_t n; uint32_t len, buf_size; uint8_t *buf = NULL; const size_t record_header_size = 1 + 4; struct rite_section_irep_header header; if (fread(&header, sizeof(struct rite_section_irep_header), 1, fp) == 0) { return MRB_DUMP_READ_FAULT; } sirep = mrb->irep_len; nirep = bin_to_uint16(header.nirep); buf_size = record_header_size; buf = (uint8_t *)mrb_malloc(mrb, buf_size); //Read Binary Data Section for (n = 0, i = sirep; n < nirep; n++, i++) { if (fread(buf, record_header_size, 1, fp) == 0) { result = MRB_DUMP_READ_FAULT; goto error_exit; } buf_size = bin_to_uint32(&buf[0]); buf = (uint8_t *)mrb_realloc(mrb, buf, buf_size); if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) { result = MRB_DUMP_READ_FAULT; goto error_exit; } result = read_rite_irep_record(mrb, buf, &len); if (result != MRB_DUMP_OK) goto error_exit; } result = sirep + bin_to_uint16(header.sirep); error_exit: mrb_free(mrb, buf); if (result < MRB_DUMP_OK) { irep_free(sirep, mrb); } return result; }
static int read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc, uint8_t *flags) { const struct rite_binary_header *header = (const struct rite_binary_header *)bin; if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) == 0) { if (bigendian_p()) *flags |= FLAG_BYTEORDER_NATIVE; else *flags |= FLAG_BYTEORDER_BIG; } else if (memcmp(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)) == 0) { if (bigendian_p()) *flags |= FLAG_BYTEORDER_LIL; else *flags |= FLAG_BYTEORDER_NATIVE; } else { return MRB_DUMP_INVALID_FILE_HEADER; } if (crc) { *crc = bin_to_uint16(header->binary_crc); } *bin_size = (size_t)bin_to_uint32(header->binary_size); return MRB_DUMP_OK; }
/* ignore lineno record */ static int read_lineno_record_1(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *len) { size_t i, fname_len, niseq; *len = 0; bin += sizeof(uint32_t); /* record size */ *len += sizeof(uint32_t); fname_len = bin_to_uint16(bin); bin += sizeof(uint16_t); *len += sizeof(uint16_t); bin += fname_len; *len += fname_len; niseq = (size_t)bin_to_uint32(bin); bin += sizeof(uint32_t); /* niseq */ *len += sizeof(uint32_t); if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) { return MRB_DUMP_GENERAL_FAILURE; } for (i = 0; i < niseq; i++) { bin += sizeof(uint16_t); /* niseq */ *len += sizeof(uint16_t); } return MRB_DUMP_OK; }
static int read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc) { const uint8_t *bin; ptrdiff_t diff; struct rite_section_debug_header *header; uint16_t i; size_t len = 0; int result; uint16_t filenames_len; mrb_sym *filenames; bin = start; header = (struct rite_section_debug_header *)bin; bin += sizeof(struct rite_section_debug_header); filenames_len = bin_to_uint16(bin); bin += sizeof(uint16_t); filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)filenames_len); for (i = 0; i < filenames_len; ++i) { uint16_t f_len = bin_to_uint16(bin); bin += sizeof(uint16_t); if (alloc) { filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len); } else { filenames[i] = mrb_intern_static(mrb, (const char *)bin, (size_t)f_len); } bin += f_len; } result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len); if (result != MRB_DUMP_OK) goto debug_exit; bin += len; diff = bin - start; mrb_assert(diff >= 0); mrb_assert(diff <= UINT32_MAX); if ((uint32_t)diff != bin_to_uint32(header->section_size)) { result = MRB_DUMP_GENERAL_FAILURE; } debug_exit: mrb_free(mrb, filenames); return result; }
int mrb_read_irep_file(mrb_state *mrb, FILE* fp) { int ret, i; uint32_t len, rlen = 0; unsigned char hex8[8], hcrc[4]; unsigned char *dst, *rite_dst = NULL; rite_binary_header bin_header; RiteFILE ritefp = { 0 }; RiteFILE *rfp; if ((mrb == NULL) || (fp == NULL)) { return MRB_DUMP_INVALID_ARGUMENT; } ritefp.fp = fp; rfp = &ritefp; //Read File Header Section ret = load_rite_header(fp, &bin_header, hcrc); if (ret != MRB_DUMP_OK) return ret; len = sizeof(rite_binary_header) + bin_to_uint32(bin_header.rbds); rite_dst = (unsigned char *)mrb_malloc(mrb, len); if (rite_dst == NULL) return MRB_DUMP_GENERAL_FAILURE; dst = rite_dst; memset(dst, 0x00, len); *(rite_binary_header *)dst = bin_header; dst += sizeof(rite_binary_header); dst += hex_to_bin16(dst, hcrc); //Read Binary Data Section len = bin_to_uint16(bin_header.nirep); for (i=0; i<len; i++) { rite_fgets(rfp, hex8, sizeof(hex8), TRUE); //record len dst += hex_to_bin32(dst, hex8); ret = load_rite_irep_record(mrb, rfp, dst, &rlen); if (ret != MRB_DUMP_OK) //irep info goto error_exit; dst += rlen; } rite_fgets(rfp, hex8, sizeof(hex8), TRUE); //dummy record len hex_to_bin32(dst, hex8); /* dst += hex_to_bin32(dst, hex8); */ if (0 != hex_to_uint32(hex8)) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } if (ret == MRB_DUMP_OK) ret = mrb_read_irep(mrb, (char*)rite_dst); error_exit: mrb_free(mrb, rite_dst); return ret; }
static int read_rite_section_debug(mrb_state *mrb, const uint8_t *start, size_t sirep) { const uint8_t *bin; struct rite_section_debug_header *header; uint16_t i; int result; uint16_t nirep; size_t filenames_len; mrb_sym *filenames; bin = start; header = (struct rite_section_debug_header *)bin; bin += sizeof(struct rite_section_debug_header); nirep = bin_to_uint16(header->nirep); filenames_len = bin_to_uint16(bin); bin += sizeof(uint16_t); filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym*) * filenames_len); for(i = 0; i < filenames_len; ++i) { uint16_t f_len = bin_to_uint16(bin); bin += sizeof(uint16_t); filenames[i] = mrb_intern2(mrb, (const char *)bin, f_len); bin += f_len; } for(i = sirep; i < (sirep + nirep); ++i) { uint32_t len = 0; result = read_rite_debug_record(mrb, bin, i, &len, filenames, filenames_len); if (result != MRB_DUMP_OK) { goto debug_exit; } bin += len; } if ((bin - start) != bin_to_uint32(header->section_size)) { return MRB_DUMP_GENERAL_FAILURE; } result = sirep + bin_to_uint16(header->sirep); debug_exit: mrb_free(mrb, filenames); return result; }
static int read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len) { const uint8_t *bin = start; ptrdiff_t diff; int i; irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1)); for (i = 0; i + 1< irep->nlocals; ++i) { uint16_t const sym_idx = bin_to_uint16(bin); bin += sizeof(uint16_t); if (sym_idx == RITE_LV_NULL_MARK) { irep->lv[i].name = 0; irep->lv[i].r = 0; } else { if (sym_idx >= syms_len) { return MRB_DUMP_GENERAL_FAILURE; } irep->lv[i].name = syms[sym_idx]; irep->lv[i].r = bin_to_uint16(bin); } bin += sizeof(uint16_t); } for (i = 0; i < irep->rlen; ++i) { size_t len; int ret; ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len); if (ret != MRB_DUMP_OK) return ret; bin += len; } diff = bin - start; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); *record_len = (size_t)diff; return MRB_DUMP_OK; }
static int read_rite_header(mrb_state *mrb, unsigned char *bin, rite_binary_header* bin_header) { uint16_t crc; *bin_header = *(rite_binary_header *)bin; bin += sizeof(rite_binary_header); if (memcmp(bin_header->rbfi, RITE_FILE_IDENFIFIER, sizeof(bin_header->rbfi)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File identifier error } if (memcmp(bin_header->risv, RITE_VM_VER, sizeof(bin_header->risv)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //Instruction set version check } crc = calc_crc_16_ccitt((unsigned char*)bin_header, sizeof(*bin_header)); //Calculate CRC if (crc != bin_to_uint16(bin)) { return MRB_DUMP_INVALID_FILE_HEADER; //CRC error } return bin_to_uint16(bin_header->nirep); }
static int read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags) { const uint8_t *bin; ptrdiff_t diff; struct rite_section_lv_header const *header; uint32_t i; size_t len = 0; int result; uint32_t syms_len; mrb_sym *syms; mrb_sym (*intern_func)(mrb_state*, const char*, size_t) = (flags & FLAG_SRC_MALLOC)? mrb_intern : mrb_intern_static; bin = start; header = (struct rite_section_lv_header const*)bin; bin += sizeof(struct rite_section_lv_header); syms_len = bin_to_uint32(bin); bin += sizeof(uint32_t); syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)syms_len); for (i = 0; i < syms_len; ++i) { uint16_t const str_len = bin_to_uint16(bin); bin += sizeof(uint16_t); syms[i] = intern_func(mrb, (const char*)bin, str_len); bin += str_len; } result = read_lv_record(mrb, bin, irep, &len, syms, syms_len); if (result != MRB_DUMP_OK) goto lv_exit; bin += len; diff = bin - start; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); if ((uint32_t)diff != bin_to_uint32(header->section_size)) { result = MRB_DUMP_GENERAL_FAILURE; } lv_exit: mrb_free(mrb, syms); return result; }
static int read_rite_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc) { const struct rite_binary_header *header = (const struct rite_binary_header *)bin; if (memcmp(header->binary_identify, RITE_BINARY_IDENFIFIER, sizeof(header->binary_identify)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; } if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; } *crc = bin_to_uint16(header->binary_crc); if (bin_size) { *bin_size = bin_to_uint32(header->binary_size); } return MRB_DUMP_OK; }
static mrb_irep* read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags) { int i; const uint8_t *src = bin; ptrdiff_t diff; uint16_t tt, pool_data_len, snl; int plen; int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = mrb_add_irep(mrb); /* skip record size */ src += sizeof(uint32_t); /* number of local variable */ irep->nlocals = bin_to_uint16(src); src += sizeof(uint16_t); /* number of register variable */ irep->nregs = bin_to_uint16(src); src += sizeof(uint16_t); /* number of child irep */ irep->rlen = (size_t)bin_to_uint16(src); src += sizeof(uint16_t); /* Binary Data Section */ /* ISEQ BLOCK */ irep->ilen = (uint16_t)bin_to_uint32(src); src += sizeof(uint32_t); src += skip_padding(src); if (irep->ilen > 0) { if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) { return NULL; } if ((flags & FLAG_SRC_MALLOC) == 0 && (flags & FLAG_BYTEORDER_NATIVE)) { irep->iseq = (mrb_code*)src; src += sizeof(mrb_code) * irep->ilen; irep->flags |= MRB_ISEQ_NO_FREE; } else { size_t data_len = sizeof(mrb_code) * irep->ilen; irep->iseq = (mrb_code *)mrb_malloc(mrb, data_len); memcpy(irep->iseq, src, data_len); src += data_len; } } /* POOL BLOCK */ plen = bin_to_uint32(src); /* number of pool */ src += sizeof(uint32_t); if (plen > 0) { if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) { return NULL; } irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen); for (i = 0; i < plen; i++) { mrb_value s; tt = *src++; /* pool TT */ pool_data_len = bin_to_uint16(src); /* pool data length */ src += sizeof(uint16_t); if (flags & FLAG_SRC_MALLOC) { s = mrb_str_new(mrb, (char *)src, pool_data_len); } else { s = mrb_str_new_static(mrb, (char *)src, pool_data_len); } src += pool_data_len; switch (tt) { /* pool data */ case IREP_TT_FIXNUM: { mrb_value num = mrb_str_to_inum(mrb, s, 10, FALSE); #ifdef MRB_WITHOUT_FLOAT irep->pool[i] = num; #else irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num; #endif } break; #ifndef MRB_WITHOUT_FLOAT case IREP_TT_FLOAT: irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE)); break; #endif case IREP_TT_STRING: irep->pool[i] = mrb_str_pool(mrb, s); break; default: /* should not happen */ irep->pool[i] = mrb_nil_value(); break; } irep->plen++; mrb_gc_arena_restore(mrb, ai); } } /* SYMS BLOCK */ irep->slen = (uint16_t)bin_to_uint32(src); /* syms length */ src += sizeof(uint32_t); if (irep->slen > 0) { if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) { return NULL; } irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen); for (i = 0; i < irep->slen; i++) { snl = bin_to_uint16(src); /* symbol name length */ src += sizeof(uint16_t); if (snl == MRB_DUMP_NULL_SYM_LEN) { irep->syms[i] = 0; continue; } if (flags & FLAG_SRC_MALLOC) { irep->syms[i] = mrb_intern(mrb, (char *)src, snl); } else { irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl); } src += snl + 1; mrb_gc_arena_restore(mrb, ai); } } irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen); diff = src - bin; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); *len = (size_t)diff; return irep; }
static int read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *record_len, const mrb_sym *filenames, size_t filenames_len) { const uint8_t *bin = start; ptrdiff_t diff; size_t record_size; uint16_t f_idx; int i; if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; } irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info)); irep->debug_info->pc_count = (uint32_t)irep->ilen; record_size = (size_t)bin_to_uint32(bin); bin += sizeof(uint32_t); irep->debug_info->flen = bin_to_uint16(bin); irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_malloc(mrb, sizeof(mrb_irep_debug_info*) * irep->debug_info->flen); bin += sizeof(uint16_t); for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { mrb_irep_debug_info_file *file; uint16_t filename_idx; mrb_int len; file = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*file)); irep->debug_info->files[f_idx] = file; file->start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); /* filename */ filename_idx = bin_to_uint16(bin); bin += sizeof(uint16_t); mrb_assert(filename_idx < filenames_len); file->filename_sym = filenames[filename_idx]; len = 0; file->filename = mrb_sym2name_len(mrb, file->filename_sym, &len); file->line_entry_count = bin_to_uint32(bin); bin += sizeof(uint32_t); file->line_type = (mrb_debug_line_type)bin_to_uint8(bin); bin += sizeof(uint8_t); switch (file->line_type) { case mrb_debug_line_ary: { uint32_t l; file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count)); for (l = 0; l < file->line_entry_count; ++l) { file->lines.ary[l] = bin_to_uint16(bin); bin += sizeof(uint16_t); } } break; case mrb_debug_line_flat_map: { uint32_t l; file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc( mrb, sizeof(mrb_irep_debug_info_line) * (size_t)(file->line_entry_count)); for (l = 0; l < file->line_entry_count; ++l) { file->lines.flat_map[l].start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); file->lines.flat_map[l].line = bin_to_uint16(bin); bin += sizeof(uint16_t); } } break; default: return MRB_DUMP_GENERAL_FAILURE; } } diff = bin - start; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); if (record_size != (size_t)diff) { return MRB_DUMP_GENERAL_FAILURE; } for (i = 0; i < irep->rlen; i++) { size_t len; int ret; ret = read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len); if (ret != MRB_DUMP_OK) return ret; bin += len; } diff = bin - start; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); *record_len = (size_t)diff; return MRB_DUMP_OK; }
static int read_rite_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len) { int ret; size_t i; const uint8_t *src = bin; uint16_t tt, pool_data_len, snl; size_t plen; int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = mrb_add_irep(mrb); // skip record size src += sizeof(uint32_t); // number of local variable irep->nlocals = bin_to_uint16(src); src += sizeof(uint16_t); // number of register variable irep->nregs = bin_to_uint16(src); src += sizeof(uint16_t); // Binary Data Section // ISEQ BLOCK irep->ilen = bin_to_uint32(src); src += sizeof(uint32_t); if (irep->ilen > 0) { irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen); if (irep->iseq == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i = 0; i < irep->ilen; i++) { irep->iseq[i] = bin_to_uint32(src); //iseq src += sizeof(uint32_t); } } //POOL BLOCK plen = bin_to_uint32(src); /* number of pool */ src += sizeof(uint32_t); if (plen > 0) { irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * plen); if (irep->pool == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i = 0; i < plen; i++) { mrb_value s; tt = *src++; //pool TT pool_data_len = bin_to_uint16(src); //pool data length src += sizeof(uint16_t); s = mrb_str_new(mrb, (char *)src, pool_data_len); src += pool_data_len; switch (tt) { //pool data case MRB_TT_FIXNUM: irep->pool[i] = mrb_str_to_inum(mrb, s, 10, FALSE); break; case MRB_TT_FLOAT: irep->pool[i] = mrb_float_value(mrb_str_to_dbl(mrb, s, FALSE)); break; case MRB_TT_STRING: irep->pool[i] = s; break; default: irep->pool[i] = mrb_nil_value(); break; } irep->plen++; mrb_gc_arena_restore(mrb, ai); } } //SYMS BLOCK irep->slen = bin_to_uint32(src); //syms length src += sizeof(uint32_t); if (irep->slen > 0) { irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen); if (irep->syms == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i = 0; i < irep->slen; i++) { snl = bin_to_uint16(src); //symbol name length src += sizeof(uint16_t); if (snl == MRB_DUMP_NULL_SYM_LEN) { irep->syms[i] = 0; continue; } irep->syms[i] = mrb_intern2(mrb, (char *)src, snl); src += snl + 1; mrb_gc_arena_restore(mrb, ai); } } *len = src - bin; ret = MRB_DUMP_OK; error_exit: return ret; }
static int read_rite_irep_record(mrb_state *mrb, unsigned char *src, uint32_t* len) { int i, ret = MRB_DUMP_OK; char *buf; unsigned char *recordStart, *pStart; uint16_t crc, tt, pdl, snl, offset, bufsize=MRB_DUMP_DEFAULT_STR_LEN; mrb_int fix_num; mrb_float f; int plen; int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = mrb_add_irep(mrb); recordStart = src; buf = (char *)mrb_malloc(mrb, bufsize); if (buf == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } //Header Section pStart = src; if (*src != RITE_IREP_IDENFIFIER) return MRB_DUMP_INVALID_IREP; src += (sizeof(unsigned char) * 2); irep->nlocals = bin_to_uint16(src); //number of local variable src += MRB_DUMP_SIZE_OF_SHORT; irep->nregs = bin_to_uint16(src); //number of register variable src += MRB_DUMP_SIZE_OF_SHORT; offset = bin_to_uint16(src); //offset of isec block src += MRB_DUMP_SIZE_OF_SHORT; crc = calc_crc_16_ccitt(pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) //header CRC return MRB_DUMP_INVALID_IREP; src += offset; //Binary Data Section //ISEQ BLOCK pStart = src; irep->ilen = bin_to_uint32(src); //iseq length src += MRB_DUMP_SIZE_OF_LONG; if (irep->ilen > 0) { if ((irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } for (i=0; i<irep->ilen; i++) { irep->iseq[i] = bin_to_uint32(src); //iseq src += MRB_DUMP_SIZE_OF_LONG; } } crc = calc_crc_16_ccitt((unsigned char*)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //iseq CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; //POOL BLOCK pStart = src; plen = bin_to_uint32(src); //pool length src += MRB_DUMP_SIZE_OF_LONG; if (plen > 0) { irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * plen); if (irep->pool == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } for (i=0; i<plen; i++) { tt = *src; //pool TT src += sizeof(unsigned char); pdl = bin_to_uint16(src); //pool data length src += MRB_DUMP_SIZE_OF_SHORT; if (pdl > bufsize - 1) { mrb_free(mrb, buf); bufsize = pdl + 1; if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } } memcpy(buf, src, pdl); src += pdl; buf[pdl] = '\0'; switch (tt) { //pool data case MRB_TT_FIXNUM: fix_num = str_to_mrb_int(buf); irep->pool[i] = mrb_fixnum_value(fix_num); break; case MRB_TT_FLOAT: f = str_to_mrb_float(buf); irep->pool[i] = mrb_float_value(f); break; case MRB_TT_STRING: irep->pool[i] = mrb_str_new(mrb, buf, pdl); break; #ifdef ENABLE_REGEXP case MRB_TT_REGEX: str = mrb_str_new(mrb, buf, pdl); irep->pool[i] = mrb_reg_quote(mrb, str); break; #endif default: irep->pool[i] = mrb_nil_value(); break; } irep->plen++; mrb_gc_arena_restore(mrb, ai); } } crc = calc_crc_16_ccitt((unsigned char*)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //pool CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; //SYMS BLOCK pStart = src; irep->slen = bin_to_uint32(src); //syms length src += MRB_DUMP_SIZE_OF_LONG; if (irep->slen > 0) { if ((irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } for (i = 0; i < irep->slen; i++) { static const mrb_sym mrb_sym_zero = { 0 }; *irep->syms = mrb_sym_zero; } for (i=0; i<irep->slen; i++) { snl = bin_to_uint16(src); //symbol name length src += MRB_DUMP_SIZE_OF_SHORT; if (snl == MRB_DUMP_NULL_SYM_LEN) { irep->syms[i] = 0; continue; } if (snl > bufsize - 1) { mrb_free(mrb, buf); bufsize = snl + 1; if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } } memcpy(buf, src, snl); //symbol name src += snl; buf[snl] = '\0'; irep->syms[i] = mrb_intern2(mrb, buf, snl); } } crc = calc_crc_16_ccitt((unsigned char*)pStart, src - pStart); //Calculate CRC if (crc != bin_to_uint16(src)) { //syms CRC ret = MRB_DUMP_INVALID_IREP; goto error_exit; } src += MRB_DUMP_SIZE_OF_SHORT; *len = src - recordStart; error_exit: if (buf) mrb_free(mrb, buf); return ret; }
static mrb_irep* read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool alloc) { size_t i; const uint8_t *src = bin; ptrdiff_t diff; uint16_t tt, pool_data_len, snl; size_t plen; int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = mrb_add_irep(mrb); /* skip record size */ src += sizeof(uint32_t); /* number of local variable */ irep->nlocals = bin_to_uint16(src); src += sizeof(uint16_t); /* number of register variable */ irep->nregs = bin_to_uint16(src); src += sizeof(uint16_t); /* number of child irep */ irep->rlen = (size_t)bin_to_uint16(src); src += sizeof(uint16_t); /* Binary Data Section */ /* ISEQ BLOCK */ irep->ilen = (size_t)bin_to_uint32(src); src += sizeof(uint32_t); if (irep->ilen > 0) { if (SIZE_ERROR_MUL(sizeof(mrb_code), irep->ilen)) { return NULL; } irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen); for (i = 0; i < irep->ilen; i++) { irep->iseq[i] = (size_t)bin_to_uint32(src); /* iseq */ src += sizeof(uint32_t); } } /* POOL BLOCK */ plen = (size_t)bin_to_uint32(src); /* number of pool */ src += sizeof(uint32_t); if (plen > 0) { if (SIZE_ERROR_MUL(sizeof(mrb_value), plen)) { return NULL; } irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen); for (i = 0; i < plen; i++) { mrb_value s; tt = *src++; /* pool TT */ pool_data_len = bin_to_uint16(src); /* pool data length */ src += sizeof(uint16_t); if (alloc) { s = mrb_str_new(mrb, (char *)src, pool_data_len); } else { s = mrb_str_new_static(mrb, (char *)src, pool_data_len); } src += pool_data_len; switch (tt) { /* pool data */ case IREP_TT_FIXNUM: irep->pool[i] = mrb_str_to_inum(mrb, s, 10, FALSE); break; case IREP_TT_FLOAT: irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE)); break; case IREP_TT_STRING: irep->pool[i] = mrb_str_pool(mrb, s); break; default: /* should not happen */ irep->pool[i] = mrb_nil_value(); break; } irep->plen++; mrb_gc_arena_restore(mrb, ai); } } /* SYMS BLOCK */ irep->slen = (size_t)bin_to_uint32(src); /* syms length */ src += sizeof(uint32_t); if (irep->slen > 0) { if (SIZE_ERROR_MUL(sizeof(mrb_sym), irep->slen)) { return NULL; } irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen); for (i = 0; i < irep->slen; i++) { snl = bin_to_uint16(src); /* symbol name length */ src += sizeof(uint16_t); if (snl == MRB_DUMP_NULL_SYM_LEN) { irep->syms[i] = 0; continue; } if (alloc) { irep->syms[i] = mrb_intern(mrb, (char *)src, snl); } else { irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl); } src += snl + 1; mrb_gc_arena_restore(mrb, ai); } } irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen); diff = src - bin; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); *len = (size_t)diff; return irep; }
static int32_t read_rite_section_irep_file(mrb_state *mrb, FILE *fp) { int32_t result; size_t sirep; uint16_t nirep; uint16_t n; uint32_t len, buf_size; uint8_t *buf = NULL; const size_t record_header_size = 1 + 4; struct rite_section_irep_header header; if (fread(&header, sizeof(struct rite_section_irep_header), 1, fp) == 0) { return MRB_DUMP_READ_FAULT; } sirep = mrb->irep_len; nirep = bin_to_uint16(header.nirep); buf_size = record_header_size; /* You don't need use SIZE_ERROR as buf_size is enough small. */ buf = (uint8_t *)mrb_malloc(mrb, buf_size); if (!buf) { result = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } //Read Binary Data Section for (n = 0; n < nirep; n++) { void *ptr; if (fread(buf, record_header_size, 1, fp) == 0) { result = MRB_DUMP_READ_FAULT; goto error_exit; } buf_size = bin_to_uint32(&buf[0]); if (SIZE_ERROR(buf_size)) { result = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } ptr = mrb_realloc(mrb, buf, buf_size); if (!ptr) { result = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } buf = (uint8_t *)ptr; if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) { result = MRB_DUMP_READ_FAULT; goto error_exit; } result = read_rite_irep_record(mrb, buf, &len); if (result != MRB_DUMP_OK) goto error_exit; } result = nirep; error_exit: if (buf) { mrb_free(mrb, buf); } if (result < MRB_DUMP_OK) { irep_free(sirep, mrb); } return result; }
static int read_rite_debug_record(mrb_state *mrb, const uint8_t *start, size_t irepno, uint32_t *len, const mrb_sym *filenames, size_t filenames_len) { const uint8_t *bin = start; mrb_irep *irep = mrb->irep[irepno]; size_t record_size; uint16_t f_idx; if(irep->debug_info) { return MRB_DUMP_INVALID_IREP; } irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info)); irep->debug_info->pc_count = irep->ilen; record_size = bin_to_uint32(bin); bin += sizeof(uint32_t); irep->debug_info->flen = bin_to_uint16(bin); irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_malloc(mrb, sizeof(mrb_irep_debug_info*) * irep->debug_info->flen); bin += sizeof(uint16_t); for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { mrb_irep_debug_info_file *file; uint16_t filename_idx; size_t len; file = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*file)); irep->debug_info->files[f_idx] = file; file->start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); // filename filename_idx = bin_to_uint16(bin); bin += sizeof(uint16_t); mrb_assert(filename_idx < filenames_len); file->filename_sym = filenames[filename_idx]; len = 0; file->filename = mrb_sym2name_len(mrb, file->filename_sym, &len); file->line_entry_count = bin_to_uint32(bin); bin += sizeof(uint32_t); file->line_type = bin_to_uint8(bin); bin += sizeof(uint8_t); switch(file->line_type) { case mrb_debug_line_ary: { size_t l; file->line_ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * file->line_entry_count); for(l = 0; l < file->line_entry_count; ++l) { file->line_ary[l] = bin_to_uint16(bin); bin += sizeof(uint16_t); } } break; case mrb_debug_line_flat_map: { size_t l; file->line_flat_map = mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * file->line_entry_count); for(l = 0; l < file->line_entry_count; ++l) { file->line_flat_map[l].start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); file->line_flat_map[l].line = bin_to_uint16(bin); bin += sizeof(uint16_t); } } break; default: return MRB_DUMP_GENERAL_FAILURE; } } if((long)record_size != (bin - start)) { return MRB_DUMP_GENERAL_FAILURE; } *len = bin - start; return MRB_DUMP_OK; }