Changeset 439 for EcnlProtoTool/trunk/mruby-2.1.1/src/dump.c
- Timestamp:
- Jul 9, 2020, 8:51:43 AM (4 years ago)
- Location:
- EcnlProtoTool/trunk/mruby-2.1.1
- Files:
-
- 1 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
EcnlProtoTool/trunk/mruby-2.1.1/src/dump.c
r331 r439 7 7 #include <string.h> 8 8 #include <limits.h> 9 #include <math.h> 9 10 #include <mruby/dump.h> 10 11 #include <mruby/string.h> … … 16 17 #define FLAG_BYTEORDER_NONATIVE 0 17 18 19 #ifndef MRB_WITHOUT_FLOAT 18 20 #ifdef MRB_USE_FLOAT 19 #define MRB_FLOAT_FMT "%. 8e"21 #define MRB_FLOAT_FMT "%.9g" 20 22 #else 21 #define MRB_FLOAT_FMT "%.16e" 23 #define MRB_FLOAT_FMT "%.17g" 24 #endif 22 25 #endif 23 26 … … 80 83 { 81 84 uint8_t *cur = buf; 82 uint32_t iseq_no;83 85 84 86 cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */ 85 87 cur += write_padding(cur); 86 switch (flags & DUMP_ENDIAN_NAT) { 87 case DUMP_ENDIAN_BIG: 88 if (bigendian_p()) goto native; 89 for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { 90 cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */ 91 } 92 break; 93 case DUMP_ENDIAN_LIL: 94 if (!bigendian_p()) goto native; 95 for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) { 96 cur += uint32l_to_bin(irep->iseq[iseq_no], cur); /* opcode */ 97 } 98 break; 99 100 native: 101 case DUMP_ENDIAN_NAT: 102 memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code)); 103 cur += irep->ilen * sizeof(mrb_code); 104 break; 105 } 88 memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code)); 89 cur += irep->ilen * sizeof(mrb_code); 106 90 107 91 return cur - buf; 108 92 } 109 93 94 #ifndef MRB_WITHOUT_FLOAT 95 static mrb_value 96 float_to_str(mrb_state *mrb, mrb_value flt) 97 { 98 mrb_float f = mrb_float(flt); 99 100 if (isinf(f)) { 101 return f < 0 ? mrb_str_new_lit(mrb, "I") : mrb_str_new_lit(mrb, "i"); 102 } 103 return mrb_float_to_str(mrb, flt, MRB_FLOAT_FMT); 104 } 105 #endif 110 106 111 107 static size_t 112 108 get_pool_block_size(mrb_state *mrb, mrb_irep *irep) 113 109 { 110 int pool_no; 114 111 size_t size = 0; 115 size_t pool_no;116 112 mrb_value str; 117 113 … … 132 128 break; 133 129 130 #ifndef MRB_WITHOUT_FLOAT 134 131 case MRB_TT_FLOAT: 135 str = mrb_float_to_str(mrb, irep->pool[pool_no], MRB_FLOAT_FMT);132 str = float_to_str(mrb, irep->pool[pool_no]); 136 133 { 137 134 mrb_int len = RSTRING_LEN(str); … … 140 137 } 141 138 break; 139 #endif 142 140 143 141 case MRB_TT_STRING: … … 161 159 write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) 162 160 { 163 size_t pool_no;161 int pool_no; 164 162 uint8_t *cur = buf; 165 163 uint16_t len; … … 178 176 break; 179 177 178 #ifndef MRB_WITHOUT_FLOAT 180 179 case MRB_TT_FLOAT: 181 180 cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ 182 str = mrb_float_to_str(mrb, irep->pool[pool_no], MRB_FLOAT_FMT);181 str = float_to_str(mrb, irep->pool[pool_no]); 183 182 break; 183 #endif 184 184 185 185 case MRB_TT_STRING: … … 214 214 { 215 215 size_t size = 0; 216 uint32_t sym_no;216 int sym_no; 217 217 mrb_int len; 218 218 … … 221 221 size += sizeof(uint16_t); /* snl(n) */ 222 222 if (irep->syms[sym_no] != 0) { 223 mrb_sym 2name_len(mrb, irep->syms[sym_no], &len);223 mrb_sym_name_len(mrb, irep->syms[sym_no], &len); 224 224 size += len + 1; /* sn(n) + null char */ 225 225 } … … 232 232 write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) 233 233 { 234 uint32_t sym_no;234 int sym_no; 235 235 uint8_t *cur = buf; 236 236 const char *name; … … 242 242 mrb_int len; 243 243 244 name = mrb_sym 2name_len(mrb, irep->syms[sym_no], &len);244 name = mrb_sym_name_len(mrb, irep->syms[sym_no], &len); 245 245 246 246 mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX); … … 274 274 { 275 275 size_t size = 0; 276 size_t irep_no;276 int irep_no; 277 277 278 278 size = get_irep_record_size_1(mrb, irep); … … 286 286 write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags) 287 287 { 288 uint32_t i;288 int i; 289 289 uint8_t *src = bin; 290 290 … … 367 367 } 368 368 369 static int370 write_section_lineno_header(mrb_state *mrb, size_t section_size, uint8_t *bin)371 {372 struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin;373 374 memcpy(header->section_ident, RITE_SECTION_LINENO_IDENT, sizeof(header->section_ident));375 uint32_to_bin((uint32_t)section_size, header->section_size);376 377 return MRB_DUMP_OK;378 }379 380 static size_t381 get_lineno_record_size(mrb_state *mrb, mrb_irep *irep)382 {383 size_t size = 0;384 385 size += sizeof(uint32_t); /* record size */386 size += sizeof(uint16_t); /* filename size */387 if (irep->filename) {388 size += strlen(irep->filename); /* filename */389 }390 size += sizeof(uint32_t); /* niseq */391 if (irep->lines) {392 size += sizeof(uint16_t) * irep->ilen; /* lineno */393 }394 395 return size;396 }397 398 static size_t399 write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)400 {401 uint8_t *cur = bin;402 size_t iseq_no;403 size_t filename_len;404 ptrdiff_t diff;405 406 cur += sizeof(uint32_t); /* record size */407 408 if (irep->filename) {409 filename_len = strlen(irep->filename);410 }411 else {412 filename_len = 0;413 }414 mrb_assert_int_fit(size_t, filename_len, uint16_t, UINT16_MAX);415 cur += uint16_to_bin((uint16_t)filename_len, cur); /* filename size */416 417 if (filename_len) {418 memcpy(cur, irep->filename, filename_len);419 cur += filename_len; /* filename */420 }421 422 if (irep->lines) {423 mrb_assert_int_fit(size_t, irep->ilen, uint32_t, UINT32_MAX);424 cur += uint32_to_bin((uint32_t)(irep->ilen), cur); /* niseq */425 for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {426 cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */427 }428 }429 else {430 cur += uint32_to_bin(0, cur); /* niseq */431 }432 433 diff = cur - bin;434 mrb_assert_int_fit(ptrdiff_t, diff, uint32_t, UINT32_MAX);435 436 uint32_to_bin((uint32_t)diff, bin); /* record size */437 438 mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);439 return (size_t)diff;440 }441 442 static size_t443 write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)444 {445 size_t i;446 size_t rlen, size = 0;447 448 rlen = write_lineno_record_1(mrb, irep, bin);449 bin += rlen;450 size += rlen;451 for (i=0; i<irep->rlen; i++) {452 rlen = write_lineno_record(mrb, irep, bin);453 bin += rlen;454 size += rlen;455 }456 return size;457 }458 459 static int460 write_section_lineno(mrb_state *mrb, mrb_irep *irep, uint8_t *bin)461 {462 size_t section_size = 0;463 size_t rlen = 0; /* size of irep record */464 uint8_t *cur = bin;465 466 if (mrb == NULL || bin == NULL) {467 return MRB_DUMP_INVALID_ARGUMENT;468 }469 470 cur += sizeof(struct rite_section_lineno_header);471 section_size += sizeof(struct rite_section_lineno_header);472 473 rlen = write_lineno_record(mrb, irep, cur);474 section_size += rlen;475 476 write_section_lineno_header(mrb, section_size, bin);477 478 return MRB_DUMP_OK;479 }480 481 369 static size_t 482 370 get_debug_record_size(mrb_state *mrb, mrb_irep *irep) … … 484 372 size_t ret = 0; 485 373 uint16_t f_idx; 486 size_t i;374 int i; 487 375 488 376 ret += sizeof(uint32_t); /* record size */ … … 532 420 { 533 421 mrb_sym *filenames = *fp; 534 size_t i,size = 0;422 size_t size = 0; 535 423 mrb_irep_debug_info *di = irep->debug_info; 424 int i; 536 425 537 426 mrb_assert(lp); … … 548 437 549 438 /* filename */ 550 mrb_sym 2name_len(mrb, file->filename_sym, &filename_len);439 mrb_sym_name_len(mrb, file->filename_sym, &filename_len); 551 440 size += sizeof(uint16_t) + (size_t)filename_len; 552 441 } … … 606 495 ret = cur - bin; 607 496 mrb_assert_int_fit(ptrdiff_t, ret, uint32_t, UINT32_MAX); 608 uint32_to_bin( ret, bin);497 uint32_to_bin((uint32_t)ret, bin); 609 498 610 499 mrb_assert_int_fit(ptrdiff_t, ret, size_t, SIZE_MAX); … … 616 505 { 617 506 size_t size, len; 618 size_t irep_no;507 int irep_no; 619 508 620 509 size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len); … … 652 541 section_size += sizeof(uint16_t); 653 542 for (i = 0; i < filenames_len; ++i) { 654 sym = mrb_sym 2name_len(mrb, filenames[i], &sym_len);543 sym = mrb_sym_name_len(mrb, filenames[i], &sym_len); 655 544 mrb_assert(sym); 656 cur += uint16_to_bin( sym_len, cur);545 cur += uint16_to_bin((uint16_t)sym_len, cur); 657 546 memcpy(cur, sym, sym_len); 658 547 cur += sym_len; … … 666 555 memcpy(header->section_ident, RITE_SECTION_DEBUG_IDENT, sizeof(header->section_ident)); 667 556 mrb_assert(section_size <= INT32_MAX); 668 uint32_to_bin( section_size, header->section_size);557 uint32_to_bin((uint32_t)section_size, header->section_size); 669 558 670 559 return MRB_DUMP_OK; … … 674 563 create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len) 675 564 { 676 size_t i;565 int i; 677 566 678 567 if (*syms == NULL) { … … 706 595 707 596 for (i = 0; i < syms_len; ++i) { 708 str = mrb_sym 2name_len(mrb, syms[i], &str_len);709 cur += uint16_to_bin( str_len, cur);597 str = mrb_sym_name_len(mrb, syms[i], &str_len); 598 cur += uint16_to_bin((uint16_t)str_len, cur); 710 599 memcpy(cur, str, str_len); 711 600 cur += str_len; … … 721 610 { 722 611 uint8_t *cur = *start; 723 size_t i;612 int i; 724 613 725 614 for (i = 0; i + 1 < irep->nlocals; ++i) { … … 749 638 get_lv_record_size(mrb_state *mrb, mrb_irep *irep) 750 639 { 751 size_t ret = 0, i; 640 size_t ret = 0; 641 int i; 752 642 753 643 ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1); … … 769 659 for (i = 0; i < syms_len; ++i) { 770 660 mrb_int str_len; 771 mrb_sym 2name_len(mrb, syms[i], &str_len);661 mrb_sym_name_len(mrb, syms[i], &str_len); 772 662 ret += str_len; 773 663 } … … 807 697 diff = cur - start; 808 698 mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); 809 uint32_to_bin( diff, header->section_size);699 uint32_to_bin((uint32_t)diff, header->section_size); 810 700 811 701 lv_section_exit: … … 842 732 uint32_to_bin((uint32_t)binary_size, header->binary_size); 843 733 844 offset = ( &(header->binary_crc[0]) - bin) + sizeof(uint16_t);734 offset = (uint32_t)((&(header->binary_crc[0]) - bin) + sizeof(uint16_t)); 845 735 crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0); 846 736 uint16_to_bin(crc, header->binary_crc); … … 850 740 851 741 static mrb_bool 852 is_debug_info_defined(mrb_irep *irep)853 { 854 size_t i;742 debug_info_defined_p(mrb_irep *irep) 743 { 744 int i; 855 745 856 746 if (!irep->debug_info) return FALSE; 857 747 for (i=0; i<irep->rlen; i++) { 858 if (! is_debug_info_defined(irep->reps[i])) return FALSE;748 if (!debug_info_defined_p(irep->reps[i])) return FALSE; 859 749 } 860 750 return TRUE; … … 862 752 863 753 static mrb_bool 864 is_lv_defined(mrb_irep *irep)865 { 866 size_t i;754 lv_defined_p(mrb_irep *irep) 755 { 756 int i; 867 757 868 758 if (irep->lv) { return TRUE; } 869 759 870 760 for (i = 0; i < irep->rlen; ++i) { 871 if ( is_lv_defined(irep->reps[i])) { return TRUE; }761 if (lv_defined_p(irep->reps[i])) { return TRUE; } 872 762 } 873 763 … … 898 788 size_t section_lineno_size = 0, section_lv_size = 0; 899 789 uint8_t *cur = NULL; 900 mrb_bool const debug_info_defined = is_debug_info_defined(irep), lv_defined = is_lv_defined(irep);790 mrb_bool const debug_info_defined = debug_info_defined_p(irep), lv_defined = lv_defined_p(irep); 901 791 mrb_sym *lv_syms = NULL; uint32_t lv_syms_len = 0; 902 792 mrb_sym *filenames = NULL; uint16_t filenames_len = 0; … … 923 813 section_lineno_size += get_debug_record_size(mrb, irep); 924 814 } 925 else {926 section_lineno_size += sizeof(struct rite_section_lineno_header);927 section_lineno_size += get_lineno_record_size(mrb, irep);928 }929 815 } 930 816 … … 954 840 if (debug_info_defined) { 955 841 result = write_section_debug(mrb, irep, cur, filenames, filenames_len); 956 } 957 else { 958 result = write_section_lineno(mrb, irep, cur); 959 } 960 if (result != MRB_DUMP_OK) { 961 goto error_exit; 842 if (result != MRB_DUMP_OK) { 843 goto error_exit; 844 } 962 845 } 963 846 cur += section_lineno_size; … … 1061 944 } 1062 945 if (fprintf(fp, 946 "#ifdef __cplusplus\n" 1063 947 "extern const uint8_t %s[];\n" 948 "#endif\n" 1064 949 "const uint8_t\n" 1065 950 "#if defined __GNUC__\n"
Note:
See TracChangeset
for help on using the changeset viewer.