diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-05 11:19:16 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-05 12:07:37 +0000 |
commit | b485aab7e71c1625cfc27e0f92c9509f42378458 (patch) | |
tree | ae9abe108601079d1679194de237c9a435ae5b55 /web/server/h2o/libh2o/deps/mruby/src/dump.c | |
parent | Adding upstream version 1.44.3. (diff) | |
download | netdata-b485aab7e71c1625cfc27e0f92c9509f42378458.tar.xz netdata-b485aab7e71c1625cfc27e0f92c9509f42378458.zip |
Adding upstream version 1.45.3+dfsg.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'web/server/h2o/libh2o/deps/mruby/src/dump.c')
-rw-r--r-- | web/server/h2o/libh2o/deps/mruby/src/dump.c | 1100 |
1 files changed, 0 insertions, 1100 deletions
diff --git a/web/server/h2o/libh2o/deps/mruby/src/dump.c b/web/server/h2o/libh2o/deps/mruby/src/dump.c deleted file mode 100644 index d479a1a4f..000000000 --- a/web/server/h2o/libh2o/deps/mruby/src/dump.c +++ /dev/null @@ -1,1100 +0,0 @@ -/* -** dump.c - mruby binary dumper (mrbc binary format) -** -** See Copyright Notice in mruby.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 MRB_USE_FLOAT -#define MRB_FLOAT_FMT "%.8e" -#else -#define MRB_FLOAT_FMT "%.16e" -#endif - -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((uint32_t)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; - int iseq_no; - - cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */ - cur += write_padding(cur); - switch (flags & DUMP_ENDIAN_NAT) { - case DUMP_ENDIAN_BIG: - if (bigendian_p()) goto native; - for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { - cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */ - } - break; - case DUMP_ENDIAN_LIL: - if (!bigendian_p()) goto native; - for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { - cur += uint32l_to_bin(irep->iseq[iseq_no], cur); /* opcode */ - } - break; - - native: - case DUMP_ENDIAN_NAT: - memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code)); - cur += irep->ilen * sizeof(mrb_code); - break; - } - - return cur - buf; -} - - -static size_t -get_pool_block_size(mrb_state *mrb, mrb_irep *irep) -{ - int pool_no; - size_t size = 0; - mrb_value str; - - 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: - str = mrb_float_to_str(mrb, irep->pool[pool_no], MRB_FLOAT_FMT); - { - 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_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) -{ - int pool_no; - uint8_t *cur = buf; - uint16_t len; - mrb_value str; - const char *char_ptr; - - 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); - break; - - case MRB_TT_FLOAT: - cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ - str = mrb_float_to_str(mrb, irep->pool[pool_no], MRB_FLOAT_FMT); - break; - - case MRB_TT_STRING: - cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */ - str = irep->pool[pool_no]; - break; - - default: - continue; - } - - char_ptr = RSTRING_PTR(str); - { - mrb_int tlen = RSTRING_LEN(str); - mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX); - len = (uint16_t)tlen; - } - - 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; - int 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) -{ - int 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; - int 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) -{ - int 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_ident, RITE_BINARY_EOF, sizeof(footer.section_ident)); - 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_ident, RITE_SECTION_IREP_IDENT, sizeof(header->section_ident)); - - 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_ident, RITE_SECTION_LINENO_IDENT, sizeof(header->section_ident)); - 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; - int 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 rlen, size = 0; - int i; - - 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; - int 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 size = 0; - mrb_irep_debug_info *di = irep->debug_info; - int i; - - 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((uint32_t)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; - int 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_ident, RITE_SECTION_DEBUG_IDENT, sizeof(header->section_ident)); - mrb_assert(section_size <= INT32_MAX); - uint32_to_bin((uint32_t)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) -{ - int 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; - int 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; - int 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_ident, RITE_SECTION_LV_IDENT, sizeof(header->section_ident)); - - diff = cur - start; - mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); - uint32_to_bin((uint32_t)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; - - switch (flags & DUMP_ENDIAN_NAT) { - endian_big: - case DUMP_ENDIAN_BIG: - memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)); - break; - endian_little: - case DUMP_ENDIAN_LIL: - memcpy(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)); - break; - - case DUMP_ENDIAN_NAT: - if (bigendian_p()) goto endian_big; - goto endian_little; - break; - } - - 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 = (uint32_t)((&(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) -{ - int 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) -{ - int 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 uint8_t -dump_flags(uint8_t flags, uint8_t native) -{ - if (native == FLAG_BYTEORDER_NATIVE) { - if ((flags & DUMP_ENDIAN_NAT) == 0) { - return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_NAT; - } - return flags; - } - if ((flags & DUMP_ENDIAN_NAT) == 0) { - return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_BIG; - } - return flags; -} - -static int -dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) -{ - 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 (flags & DUMP_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 (flags & DUMP_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; - } - mrb_free(mrb, lv_syms); - mrb_free(mrb, filenames); - return result; -} - -int -mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) -{ - return dump_irep(mrb, irep, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), bin, bin_size); -} - -#ifndef MRB_DISABLE_STDIO - -int -mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, 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, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), &bin, &bin_size); - 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 -dump_bigendian_p(uint8_t flags) -{ - switch (flags & DUMP_ENDIAN_NAT) { - case DUMP_ENDIAN_BIG: - return TRUE; - case DUMP_ENDIAN_LIL: - return FALSE; - default: - case DUMP_ENDIAN_NAT: - return bigendian_p(); - } -} - -int -mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname) -{ - uint8_t *bin = NULL; - size_t bin_size = 0, bin_idx = 0; - int result; - - if (fp == NULL || initname == NULL || initname[0] == '\0') { - return MRB_DUMP_INVALID_ARGUMENT; - } - flags = dump_flags(flags, FLAG_BYTEORDER_NATIVE); - result = dump_irep(mrb, irep, flags, &bin, &bin_size); - if (result == MRB_DUMP_OK) { - if (!dump_bigendian_p(flags)) { - if (fprintf(fp, "/* dumped in little endian order.\n" - " use `mrbc -E` option for big endian CPU. */\n") < 0) { - mrb_free(mrb, bin); - return MRB_DUMP_WRITE_FAULT; - } - } - else { - if (fprintf(fp, "/* dumped in big endian order.\n" - " use `mrbc -e` option for better performance on little endian CPU. */\n") < 0) { - mrb_free(mrb, bin); - return MRB_DUMP_WRITE_FAULT; - } - } - 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, - "extern const uint8_t %s[];\n" - "const uint8_t\n" - "#if defined __GNUC__\n" - "__attribute__((aligned(%u)))\n" - "#elif defined _MSC_VER\n" - "__declspec(align(%u))\n" - "#endif\n" - "%s[] = {", - initname, - (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 /* MRB_DISABLE_STDIO */ |