1 /*
2 ** dump.c - mruby binary dumper (mrbc binary format)
3 **
4 ** See Copyright Notice in mruby.h
5 */
6
7 #include <string.h>
8 #include <limits.h>
9 #include <math.h>
10 #include <mruby/dump.h>
11 #include <mruby/string.h>
12 #include <mruby/irep.h>
13 #include <mruby/numeric.h>
14 #include <mruby/debug.h>
15
16 #define FLAG_BYTEORDER_NATIVE 2
17 #define FLAG_BYTEORDER_NONATIVE 0
18
19 #ifndef MRB_WITHOUT_FLOAT
20 #ifdef MRB_USE_FLOAT
21 #define MRB_FLOAT_FMT "%.9g"
22 #else
23 #define MRB_FLOAT_FMT "%.17g"
24 #endif
25 #endif
26
27 static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep);
28
29 #if UINT32_MAX > SIZE_MAX
30 # error This code cannot be built on your environment.
31 #endif
32
33 static size_t
write_padding(uint8_t * buf)34 write_padding(uint8_t *buf)
35 {
36 const size_t align = MRB_DUMP_ALIGNMENT;
37 size_t pad_len = -(intptr_t)buf & (align-1);
38 if (pad_len > 0) {
39 memset(buf, 0, pad_len);
40 }
41 return pad_len;
42 }
43
44 static size_t
get_irep_header_size(mrb_state * mrb)45 get_irep_header_size(mrb_state *mrb)
46 {
47 size_t size = 0;
48
49 size += sizeof(uint32_t) * 1;
50 size += sizeof(uint16_t) * 3;
51
52 return size;
53 }
54
55 static ptrdiff_t
write_irep_header(mrb_state * mrb,mrb_irep * irep,uint8_t * buf)56 write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
57 {
58 uint8_t *cur = buf;
59
60 cur += uint32_to_bin((uint32_t)get_irep_record_size_1(mrb, irep), cur); /* record size */
61 cur += uint16_to_bin((uint16_t)irep->nlocals, cur); /* number of local variable */
62 cur += uint16_to_bin((uint16_t)irep->nregs, cur); /* number of register variable */
63 cur += uint16_to_bin((uint16_t)irep->rlen, cur); /* number of child irep */
64
65 return cur - buf;
66 }
67
68
69 static size_t
get_iseq_block_size(mrb_state * mrb,mrb_irep * irep)70 get_iseq_block_size(mrb_state *mrb, mrb_irep *irep)
71 {
72 size_t size = 0;
73
74 size += sizeof(uint32_t); /* ilen */
75 size += sizeof(uint32_t); /* max padding */
76 size += sizeof(uint32_t) * irep->ilen; /* iseq(n) */
77
78 return size;
79 }
80
81 static ptrdiff_t
write_iseq_block(mrb_state * mrb,mrb_irep * irep,uint8_t * buf,uint8_t flags)82 write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
83 {
84 uint8_t *cur = buf;
85
86 cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
87 cur += write_padding(cur);
88 memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code));
89 cur += irep->ilen * sizeof(mrb_code);
90
91 return cur - buf;
92 }
93
94 #ifndef MRB_WITHOUT_FLOAT
95 static mrb_value
float_to_str(mrb_state * mrb,mrb_value flt)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
106
107 static size_t
get_pool_block_size(mrb_state * mrb,mrb_irep * irep)108 get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
109 {
110 int pool_no;
111 size_t size = 0;
112 mrb_value str;
113
114 size += sizeof(uint32_t); /* plen */
115 size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */
116
117 for (pool_no = 0; pool_no < irep->plen; pool_no++) {
118 int ai = mrb_gc_arena_save(mrb);
119
120 switch (mrb_type(irep->pool[pool_no])) {
121 case MRB_TT_FIXNUM:
122 str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
123 {
124 mrb_int len = RSTRING_LEN(str);
125 mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
126 size += (size_t)len;
127 }
128 break;
129
130 #ifndef MRB_WITHOUT_FLOAT
131 case MRB_TT_FLOAT:
132 str = float_to_str(mrb, irep->pool[pool_no]);
133 {
134 mrb_int len = RSTRING_LEN(str);
135 mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
136 size += (size_t)len;
137 }
138 break;
139 #endif
140
141 case MRB_TT_STRING:
142 {
143 mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
144 mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
145 size += (size_t)len;
146 }
147 break;
148
149 default:
150 break;
151 }
152 mrb_gc_arena_restore(mrb, ai);
153 }
154
155 return size;
156 }
157
158 static ptrdiff_t
write_pool_block(mrb_state * mrb,mrb_irep * irep,uint8_t * buf)159 write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
160 {
161 int pool_no;
162 uint8_t *cur = buf;
163 uint16_t len;
164 mrb_value str;
165 const char *char_ptr;
166
167 cur += uint32_to_bin(irep->plen, cur); /* number of pool */
168
169 for (pool_no = 0; pool_no < irep->plen; pool_no++) {
170 int ai = mrb_gc_arena_save(mrb);
171
172 switch (mrb_type(irep->pool[pool_no])) {
173 case MRB_TT_FIXNUM:
174 cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */
175 str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
176 break;
177
178 #ifndef MRB_WITHOUT_FLOAT
179 case MRB_TT_FLOAT:
180 cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */
181 str = float_to_str(mrb, irep->pool[pool_no]);
182 break;
183 #endif
184
185 case MRB_TT_STRING:
186 cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */
187 str = irep->pool[pool_no];
188 break;
189
190 default:
191 continue;
192 }
193
194 char_ptr = RSTRING_PTR(str);
195 {
196 mrb_int tlen = RSTRING_LEN(str);
197 mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
198 len = (uint16_t)tlen;
199 }
200
201 cur += uint16_to_bin(len, cur); /* data length */
202 memcpy(cur, char_ptr, (size_t)len);
203 cur += len;
204
205 mrb_gc_arena_restore(mrb, ai);
206 }
207
208 return cur - buf;
209 }
210
211
212 static size_t
get_syms_block_size(mrb_state * mrb,mrb_irep * irep)213 get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
214 {
215 size_t size = 0;
216 int sym_no;
217 mrb_int len;
218
219 size += sizeof(uint32_t); /* slen */
220 for (sym_no = 0; sym_no < irep->slen; sym_no++) {
221 size += sizeof(uint16_t); /* snl(n) */
222 if (irep->syms[sym_no] != 0) {
223 mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
224 size += len + 1; /* sn(n) + null char */
225 }
226 }
227
228 return size;
229 }
230
231 static ptrdiff_t
write_syms_block(mrb_state * mrb,mrb_irep * irep,uint8_t * buf)232 write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
233 {
234 int sym_no;
235 uint8_t *cur = buf;
236 const char *name;
237
238 cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
239
240 for (sym_no = 0; sym_no < irep->slen; sym_no++) {
241 if (irep->syms[sym_no] != 0) {
242 mrb_int len;
243
244 name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
245
246 mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
247 cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
248 memcpy(cur, name, len); /* symbol name */
249 cur += (uint16_t)len;
250 *cur++ = '\0';
251 }
252 else {
253 cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
254 }
255 }
256
257 return cur - buf;
258 }
259
260 static size_t
get_irep_record_size_1(mrb_state * mrb,mrb_irep * irep)261 get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep)
262 {
263 size_t size = 0;
264
265 size += get_irep_header_size(mrb);
266 size += get_iseq_block_size(mrb, irep);
267 size += get_pool_block_size(mrb, irep);
268 size += get_syms_block_size(mrb, irep);
269 return size;
270 }
271
272 static size_t
get_irep_record_size(mrb_state * mrb,mrb_irep * irep)273 get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
274 {
275 size_t size = 0;
276 int irep_no;
277
278 size = get_irep_record_size_1(mrb, irep);
279 for (irep_no = 0; irep_no < irep->rlen; irep_no++) {
280 size += get_irep_record_size(mrb, irep->reps[irep_no]);
281 }
282 return size;
283 }
284
285 static int
write_irep_record(mrb_state * mrb,mrb_irep * irep,uint8_t * bin,size_t * irep_record_size,uint8_t flags)286 write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
287 {
288 int i;
289 uint8_t *src = bin;
290
291 if (irep == NULL) {
292 return MRB_DUMP_INVALID_IREP;
293 }
294
295 *irep_record_size = get_irep_record_size_1(mrb, irep);
296 if (*irep_record_size == 0) {
297 return MRB_DUMP_GENERAL_FAILURE;
298 }
299
300 bin += write_irep_header(mrb, irep, bin);
301 bin += write_iseq_block(mrb, irep, bin, flags);
302 bin += write_pool_block(mrb, irep, bin);
303 bin += write_syms_block(mrb, irep, bin);
304
305 for (i = 0; i < irep->rlen; i++) {
306 int result;
307 size_t rsize;
308
309 result = write_irep_record(mrb, irep->reps[i], bin, &rsize, flags);
310 if (result != MRB_DUMP_OK) {
311 return result;
312 }
313 bin += rsize;
314 }
315 *irep_record_size = bin - src;
316 return MRB_DUMP_OK;
317 }
318
319 static uint32_t
write_footer(mrb_state * mrb,uint8_t * bin)320 write_footer(mrb_state *mrb, uint8_t *bin)
321 {
322 struct rite_binary_footer footer;
323
324 memcpy(footer.section_ident, RITE_BINARY_EOF, sizeof(footer.section_ident));
325 uint32_to_bin(sizeof(struct rite_binary_footer), footer.section_size);
326 memcpy(bin, &footer, sizeof(struct rite_binary_footer));
327
328 return sizeof(struct rite_binary_footer);
329 }
330
331
332 static int
write_section_irep_header(mrb_state * mrb,size_t section_size,uint8_t * bin)333 write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
334 {
335 struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin;
336
337 memcpy(header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(header->section_ident));
338
339 mrb_assert_int_fit(size_t, section_size, uint32_t, UINT32_MAX);
340 uint32_to_bin((uint32_t)section_size, header->section_size);
341 memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version));
342
343 return MRB_DUMP_OK;
344 }
345
346 static int
write_section_irep(mrb_state * mrb,mrb_irep * irep,uint8_t * bin,size_t * len_p,uint8_t flags)347 write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
348 {
349 int result;
350 size_t rsize = 0;
351 uint8_t *cur = bin;
352
353 if (mrb == NULL || bin == NULL) {
354 return MRB_DUMP_INVALID_ARGUMENT;
355 }
356
357 cur += sizeof(struct rite_section_irep_header);
358
359 result = write_irep_record(mrb, irep, cur, &rsize, flags);
360 if (result != MRB_DUMP_OK) {
361 return result;
362 }
363 *len_p = cur - bin + rsize;
364 write_section_irep_header(mrb, *len_p, bin);
365
366 return MRB_DUMP_OK;
367 }
368
369 static size_t
get_debug_record_size(mrb_state * mrb,mrb_irep * irep)370 get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
371 {
372 size_t ret = 0;
373 uint16_t f_idx;
374 int i;
375
376 ret += sizeof(uint32_t); /* record size */
377 ret += sizeof(uint16_t); /* file count */
378
379 for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
380 mrb_irep_debug_info_file const* file = irep->debug_info->files[f_idx];
381
382 ret += sizeof(uint32_t); /* position */
383 ret += sizeof(uint16_t); /* filename index */
384
385 /* lines */
386 ret += sizeof(uint32_t); /* entry count */
387 ret += sizeof(uint8_t); /* line type */
388 switch (file->line_type) {
389 case mrb_debug_line_ary:
390 ret += sizeof(uint16_t) * (size_t)(file->line_entry_count);
391 break;
392
393 case mrb_debug_line_flat_map:
394 ret += (sizeof(uint32_t) + sizeof(uint16_t)) * (size_t)(file->line_entry_count);
395 break;
396
397 default: mrb_assert(0); break;
398 }
399 }
400 for (i=0; i<irep->rlen; i++) {
401 ret += get_debug_record_size(mrb, irep->reps[i]);
402 }
403
404 return ret;
405 }
406
407 static int
find_filename_index(const mrb_sym * ary,int ary_len,mrb_sym s)408 find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s)
409 {
410 int i;
411
412 for (i = 0; i < ary_len; ++i) {
413 if (ary[i] == s) { return i; }
414 }
415 return -1;
416 }
417
418 static size_t
get_filename_table_size(mrb_state * mrb,mrb_irep * irep,mrb_sym ** fp,uint16_t * lp)419 get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
420 {
421 mrb_sym *filenames = *fp;
422 size_t size = 0;
423 mrb_irep_debug_info *di = irep->debug_info;
424 int i;
425
426 mrb_assert(lp);
427 for (i = 0; i < di->flen; ++i) {
428 mrb_irep_debug_info_file *file;
429 mrb_int filename_len;
430
431 file = di->files[i];
432 if (find_filename_index(filenames, *lp, file->filename_sym) == -1) {
433 /* register filename */
434 *lp += 1;
435 *fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
436 filenames[*lp - 1] = file->filename_sym;
437
438 /* filename */
439 mrb_sym2name_len(mrb, file->filename_sym, &filename_len);
440 size += sizeof(uint16_t) + (size_t)filename_len;
441 }
442 }
443 for (i=0; i<irep->rlen; i++) {
444 size += get_filename_table_size(mrb, irep->reps[i], fp, lp);
445 }
446 return size;
447 }
448
449 static size_t
write_debug_record_1(mrb_state * mrb,mrb_irep * irep,uint8_t * bin,mrb_sym const * filenames,uint16_t filenames_len)450 write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
451 {
452 uint8_t *cur;
453 uint16_t f_idx;
454 ptrdiff_t ret;
455
456 cur = bin + sizeof(uint32_t); /* skip record size */
457 cur += uint16_to_bin(irep->debug_info->flen, cur); /* file count */
458
459 for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
460 int filename_idx;
461 const mrb_irep_debug_info_file *file = irep->debug_info->files[f_idx];
462
463 /* position */
464 cur += uint32_to_bin(file->start_pos, cur);
465
466 /* filename index */
467 filename_idx = find_filename_index(filenames, filenames_len,
468 file->filename_sym);
469 mrb_assert_int_fit(int, filename_idx, uint16_t, UINT16_MAX);
470 cur += uint16_to_bin((uint16_t)filename_idx, cur);
471
472 /* lines */
473 cur += uint32_to_bin(file->line_entry_count, cur);
474 cur += uint8_to_bin(file->line_type, cur);
475 switch (file->line_type) {
476 case mrb_debug_line_ary: {
477 uint32_t l;
478 for (l = 0; l < file->line_entry_count; ++l) {
479 cur += uint16_to_bin(file->lines.ary[l], cur);
480 }
481 } break;
482
483 case mrb_debug_line_flat_map: {
484 uint32_t line;
485 for (line = 0; line < file->line_entry_count; ++line) {
486 cur += uint32_to_bin(file->lines.flat_map[line].start_pos, cur);
487 cur += uint16_to_bin(file->lines.flat_map[line].line, cur);
488 }
489 } break;
490
491 default: mrb_assert(0); break;
492 }
493 }
494
495 ret = cur - bin;
496 mrb_assert_int_fit(ptrdiff_t, ret, uint32_t, UINT32_MAX);
497 uint32_to_bin((uint32_t)ret, bin);
498
499 mrb_assert_int_fit(ptrdiff_t, ret, size_t, SIZE_MAX);
500 return (size_t)ret;
501 }
502
503 static size_t
write_debug_record(mrb_state * mrb,mrb_irep * irep,uint8_t * bin,mrb_sym const * filenames,uint16_t filenames_len)504 write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
505 {
506 size_t size, len;
507 int irep_no;
508
509 size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len);
510 bin += len;
511 for (irep_no = 0; irep_no < irep->rlen; irep_no++) {
512 len = write_debug_record(mrb, irep->reps[irep_no], bin, filenames, filenames_len);
513 bin += len;
514 size += len;
515 }
516
517 mrb_assert(size == get_debug_record_size(mrb, irep));
518 return size;
519 }
520
521 static int
write_section_debug(mrb_state * mrb,mrb_irep * irep,uint8_t * cur,mrb_sym const * filenames,uint16_t filenames_len)522 write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
523 {
524 size_t section_size = 0;
525 const uint8_t *bin = cur;
526 struct rite_section_debug_header *header;
527 size_t dlen;
528 uint16_t i;
529 char const *sym; mrb_int sym_len;
530
531 if (mrb == NULL || cur == NULL) {
532 return MRB_DUMP_INVALID_ARGUMENT;
533 }
534
535 header = (struct rite_section_debug_header *)bin;
536 cur += sizeof(struct rite_section_debug_header);
537 section_size += sizeof(struct rite_section_debug_header);
538
539 /* filename table */
540 cur += uint16_to_bin(filenames_len, cur);
541 section_size += sizeof(uint16_t);
542 for (i = 0; i < filenames_len; ++i) {
543 sym = mrb_sym2name_len(mrb, filenames[i], &sym_len);
544 mrb_assert(sym);
545 cur += uint16_to_bin((uint16_t)sym_len, cur);
546 memcpy(cur, sym, sym_len);
547 cur += sym_len;
548 section_size += sizeof(uint16_t) + sym_len;
549 }
550
551 /* debug records */
552 dlen = write_debug_record(mrb, irep, cur, filenames, filenames_len);
553 section_size += dlen;
554
555 memcpy(header->section_ident, RITE_SECTION_DEBUG_IDENT, sizeof(header->section_ident));
556 mrb_assert(section_size <= INT32_MAX);
557 uint32_to_bin((uint32_t)section_size, header->section_size);
558
559 return MRB_DUMP_OK;
560 }
561
562 static void
create_lv_sym_table(mrb_state * mrb,const mrb_irep * irep,mrb_sym ** syms,uint32_t * syms_len)563 create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len)
564 {
565 int i;
566
567 if (*syms == NULL) {
568 *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
569 }
570
571 for (i = 0; i + 1 < irep->nlocals; ++i) {
572 mrb_sym const name = irep->lv[i].name;
573 if (name == 0) continue;
574 if (find_filename_index(*syms, *syms_len, name) != -1) continue;
575
576 ++(*syms_len);
577 *syms = (mrb_sym*)mrb_realloc(mrb, *syms, sizeof(mrb_sym) * (*syms_len));
578 (*syms)[*syms_len - 1] = name;
579 }
580
581 for (i = 0; i < irep->rlen; ++i) {
582 create_lv_sym_table(mrb, irep->reps[i], syms, syms_len);
583 }
584 }
585
586 static int
write_lv_sym_table(mrb_state * mrb,uint8_t ** start,mrb_sym const * syms,uint32_t syms_len)587 write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
588 {
589 uint8_t *cur = *start;
590 uint32_t i;
591 const char *str;
592 mrb_int str_len;
593
594 cur += uint32_to_bin(syms_len, cur);
595
596 for (i = 0; i < syms_len; ++i) {
597 str = mrb_sym2name_len(mrb, syms[i], &str_len);
598 cur += uint16_to_bin((uint16_t)str_len, cur);
599 memcpy(cur, str, str_len);
600 cur += str_len;
601 }
602
603 *start = cur;
604
605 return MRB_DUMP_OK;
606 }
607
608 static int
write_lv_record(mrb_state * mrb,const mrb_irep * irep,uint8_t ** start,mrb_sym const * syms,uint32_t syms_len)609 write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
610 {
611 uint8_t *cur = *start;
612 int i;
613
614 for (i = 0; i + 1 < irep->nlocals; ++i) {
615 if (irep->lv[i].name == 0) {
616 cur += uint16_to_bin(RITE_LV_NULL_MARK, cur);
617 cur += uint16_to_bin(0, cur);
618 }
619 else {
620 int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
621 mrb_assert(sym_idx != -1); /* local variable name must be in syms */
622
623 cur += uint16_to_bin(sym_idx, cur);
624 cur += uint16_to_bin(irep->lv[i].r, cur);
625 }
626 }
627
628 for (i = 0; i < irep->rlen; ++i) {
629 write_lv_record(mrb, irep->reps[i], &cur, syms, syms_len);
630 }
631
632 *start = cur;
633
634 return MRB_DUMP_OK;
635 }
636
637 static size_t
get_lv_record_size(mrb_state * mrb,mrb_irep * irep)638 get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
639 {
640 size_t ret = 0;
641 int i;
642
643 ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1);
644
645 for (i = 0; i < irep->rlen; ++i) {
646 ret += get_lv_record_size(mrb, irep->reps[i]);
647 }
648
649 return ret;
650 }
651
652 static size_t
get_lv_section_size(mrb_state * mrb,mrb_irep * irep,mrb_sym const * syms,uint32_t syms_len)653 get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
654 {
655 size_t ret = 0, i;
656
657 ret += sizeof(uint32_t); /* syms_len */
658 ret += sizeof(uint16_t) * syms_len; /* symbol name lengths */
659 for (i = 0; i < syms_len; ++i) {
660 mrb_int str_len;
661 mrb_sym2name_len(mrb, syms[i], &str_len);
662 ret += str_len;
663 }
664
665 ret += get_lv_record_size(mrb, irep);
666
667 return ret;
668 }
669
670 static int
write_section_lv(mrb_state * mrb,mrb_irep * irep,uint8_t * start,mrb_sym const * syms,uint32_t const syms_len)671 write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
672 {
673 uint8_t *cur = start;
674 struct rite_section_lv_header *header;
675 ptrdiff_t diff;
676 int result = MRB_DUMP_OK;
677
678 if (mrb == NULL || cur == NULL) {
679 return MRB_DUMP_INVALID_ARGUMENT;
680 }
681
682 header = (struct rite_section_lv_header*)cur;
683 cur += sizeof(struct rite_section_lv_header);
684
685 result = write_lv_sym_table(mrb, &cur, syms, syms_len);
686 if (result != MRB_DUMP_OK) {
687 goto lv_section_exit;
688 }
689
690 result = write_lv_record(mrb, irep, &cur, syms, syms_len);
691 if (result != MRB_DUMP_OK) {
692 goto lv_section_exit;
693 }
694
695 memcpy(header->section_ident, RITE_SECTION_LV_IDENT, sizeof(header->section_ident));
696
697 diff = cur - start;
698 mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
699 uint32_to_bin((uint32_t)diff, header->section_size);
700
701 lv_section_exit:
702 return result;
703 }
704
705 static int
write_rite_binary_header(mrb_state * mrb,size_t binary_size,uint8_t * bin,uint8_t flags)706 write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8_t flags)
707 {
708 struct rite_binary_header *header = (struct rite_binary_header *)bin;
709 uint16_t crc;
710 uint32_t offset;
711
712 switch (flags & DUMP_ENDIAN_NAT) {
713 endian_big:
714 case DUMP_ENDIAN_BIG:
715 memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident));
716 break;
717 endian_little:
718 case DUMP_ENDIAN_LIL:
719 memcpy(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident));
720 break;
721
722 case DUMP_ENDIAN_NAT:
723 if (bigendian_p()) goto endian_big;
724 goto endian_little;
725 break;
726 }
727
728 memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
729 memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
730 memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
731 mrb_assert(binary_size <= UINT32_MAX);
732 uint32_to_bin((uint32_t)binary_size, header->binary_size);
733
734 offset = (uint32_t)((&(header->binary_crc[0]) - bin) + sizeof(uint16_t));
735 crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0);
736 uint16_to_bin(crc, header->binary_crc);
737
738 return MRB_DUMP_OK;
739 }
740
741 static mrb_bool
debug_info_defined_p(mrb_irep * irep)742 debug_info_defined_p(mrb_irep *irep)
743 {
744 int i;
745
746 if (!irep->debug_info) return FALSE;
747 for (i=0; i<irep->rlen; i++) {
748 if (!debug_info_defined_p(irep->reps[i])) return FALSE;
749 }
750 return TRUE;
751 }
752
753 static mrb_bool
lv_defined_p(mrb_irep * irep)754 lv_defined_p(mrb_irep *irep)
755 {
756 int i;
757
758 if (irep->lv) { return TRUE; }
759
760 for (i = 0; i < irep->rlen; ++i) {
761 if (lv_defined_p(irep->reps[i])) { return TRUE; }
762 }
763
764 return FALSE;
765 }
766
767 static uint8_t
dump_flags(uint8_t flags,uint8_t native)768 dump_flags(uint8_t flags, uint8_t native)
769 {
770 if (native == FLAG_BYTEORDER_NATIVE) {
771 if ((flags & DUMP_ENDIAN_NAT) == 0) {
772 return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_NAT;
773 }
774 return flags;
775 }
776 if ((flags & DUMP_ENDIAN_NAT) == 0) {
777 return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_BIG;
778 }
779 return flags;
780 }
781
782 static int
dump_irep(mrb_state * mrb,mrb_irep * irep,uint8_t flags,uint8_t ** bin,size_t * bin_size)783 dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
784 {
785 int result = MRB_DUMP_GENERAL_FAILURE;
786 size_t malloc_size;
787 size_t section_irep_size;
788 size_t section_lineno_size = 0, section_lv_size = 0;
789 uint8_t *cur = NULL;
790 mrb_bool const debug_info_defined = debug_info_defined_p(irep), lv_defined = lv_defined_p(irep);
791 mrb_sym *lv_syms = NULL; uint32_t lv_syms_len = 0;
792 mrb_sym *filenames = NULL; uint16_t filenames_len = 0;
793
794 if (mrb == NULL) {
795 *bin = NULL;
796 return MRB_DUMP_GENERAL_FAILURE;
797 }
798
799 section_irep_size = sizeof(struct rite_section_irep_header);
800 section_irep_size += get_irep_record_size(mrb, irep);
801
802 /* DEBUG section size */
803 if (flags & DUMP_DEBUG_INFO) {
804 if (debug_info_defined) {
805 section_lineno_size += sizeof(struct rite_section_debug_header);
806 /* filename table */
807 filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) + 1);
808
809 /* filename table size */
810 section_lineno_size += sizeof(uint16_t);
811 section_lineno_size += get_filename_table_size(mrb, irep, &filenames, &filenames_len);
812
813 section_lineno_size += get_debug_record_size(mrb, irep);
814 }
815 }
816
817 if (lv_defined) {
818 section_lv_size += sizeof(struct rite_section_lv_header);
819 create_lv_sym_table(mrb, irep, &lv_syms, &lv_syms_len);
820 section_lv_size += get_lv_section_size(mrb, irep, lv_syms, lv_syms_len);
821 }
822
823 malloc_size = sizeof(struct rite_binary_header) +
824 section_irep_size + section_lineno_size + section_lv_size +
825 sizeof(struct rite_binary_footer);
826 cur = *bin = (uint8_t*)mrb_malloc(mrb, malloc_size);
827 cur += sizeof(struct rite_binary_header);
828
829 result = write_section_irep(mrb, irep, cur, §ion_irep_size, flags);
830 if (result != MRB_DUMP_OK) {
831 goto error_exit;
832 }
833 cur += section_irep_size;
834 *bin_size = sizeof(struct rite_binary_header) +
835 section_irep_size + section_lineno_size + section_lv_size +
836 sizeof(struct rite_binary_footer);
837
838 /* write DEBUG section */
839 if (flags & DUMP_DEBUG_INFO) {
840 if (debug_info_defined) {
841 result = write_section_debug(mrb, irep, cur, filenames, filenames_len);
842 if (result != MRB_DUMP_OK) {
843 goto error_exit;
844 }
845 }
846 cur += section_lineno_size;
847 }
848
849 if (lv_defined) {
850 result = write_section_lv(mrb, irep, cur, lv_syms, lv_syms_len);
851 if (result != MRB_DUMP_OK) {
852 goto error_exit;
853 }
854 cur += section_lv_size;
855 }
856
857 write_footer(mrb, cur);
858 write_rite_binary_header(mrb, *bin_size, *bin, flags);
859
860 error_exit:
861 if (result != MRB_DUMP_OK) {
862 mrb_free(mrb, *bin);
863 *bin = NULL;
864 }
865 mrb_free(mrb, lv_syms);
866 mrb_free(mrb, filenames);
867 return result;
868 }
869
870 int
mrb_dump_irep(mrb_state * mrb,mrb_irep * irep,uint8_t flags,uint8_t ** bin,size_t * bin_size)871 mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
872 {
873 return dump_irep(mrb, irep, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), bin, bin_size);
874 }
875
876 #ifndef MRB_DISABLE_STDIO
877
878 int
mrb_dump_irep_binary(mrb_state * mrb,mrb_irep * irep,uint8_t flags,FILE * fp)879 mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp)
880 {
881 uint8_t *bin = NULL;
882 size_t bin_size = 0;
883 int result;
884
885 if (fp == NULL) {
886 return MRB_DUMP_INVALID_ARGUMENT;
887 }
888
889 result = dump_irep(mrb, irep, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), &bin, &bin_size);
890 if (result == MRB_DUMP_OK) {
891 if (fwrite(bin, sizeof(bin[0]), bin_size, fp) != bin_size) {
892 result = MRB_DUMP_WRITE_FAULT;
893 }
894 }
895
896 mrb_free(mrb, bin);
897 return result;
898 }
899
900 static mrb_bool
dump_bigendian_p(uint8_t flags)901 dump_bigendian_p(uint8_t flags)
902 {
903 switch (flags & DUMP_ENDIAN_NAT) {
904 case DUMP_ENDIAN_BIG:
905 return TRUE;
906 case DUMP_ENDIAN_LIL:
907 return FALSE;
908 default:
909 case DUMP_ENDIAN_NAT:
910 return bigendian_p();
911 }
912 }
913
914 int
mrb_dump_irep_cfunc(mrb_state * mrb,mrb_irep * irep,uint8_t flags,FILE * fp,const char * initname)915 mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
916 {
917 uint8_t *bin = NULL;
918 size_t bin_size = 0, bin_idx = 0;
919 int result;
920
921 if (fp == NULL || initname == NULL || initname[0] == '\0') {
922 return MRB_DUMP_INVALID_ARGUMENT;
923 }
924 flags = dump_flags(flags, FLAG_BYTEORDER_NATIVE);
925 result = dump_irep(mrb, irep, flags, &bin, &bin_size);
926 if (result == MRB_DUMP_OK) {
927 if (!dump_bigendian_p(flags)) {
928 if (fprintf(fp, "/* dumped in little endian order.\n"
929 " use `mrbc -E` option for big endian CPU. */\n") < 0) {
930 mrb_free(mrb, bin);
931 return MRB_DUMP_WRITE_FAULT;
932 }
933 }
934 else {
935 if (fprintf(fp, "/* dumped in big endian order.\n"
936 " use `mrbc -e` option for better performance on little endian CPU. */\n") < 0) {
937 mrb_free(mrb, bin);
938 return MRB_DUMP_WRITE_FAULT;
939 }
940 }
941 if (fprintf(fp, "#include <stdint.h>\n") < 0) { /* for uint8_t under at least Darwin */
942 mrb_free(mrb, bin);
943 return MRB_DUMP_WRITE_FAULT;
944 }
945 if (fprintf(fp,
946 "extern const uint8_t %s[];\n"
947 "const uint8_t\n"
948 "#if defined __GNUC__\n"
949 "__attribute__((aligned(%u)))\n"
950 "#elif defined _MSC_VER\n"
951 "__declspec(align(%u))\n"
952 "#endif\n"
953 "%s[] = {",
954 initname,
955 (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) {
956 mrb_free(mrb, bin);
957 return MRB_DUMP_WRITE_FAULT;
958 }
959 while (bin_idx < bin_size) {
960 if (bin_idx % 16 == 0) {
961 if (fputs("\n", fp) == EOF) {
962 mrb_free(mrb, bin);
963 return MRB_DUMP_WRITE_FAULT;
964 }
965 }
966 if (fprintf(fp, "0x%02x,", bin[bin_idx++]) < 0) {
967 mrb_free(mrb, bin);
968 return MRB_DUMP_WRITE_FAULT;
969 }
970 }
971 if (fputs("\n};\n", fp) == EOF) {
972 mrb_free(mrb, bin);
973 return MRB_DUMP_WRITE_FAULT;
974 }
975 }
976
977 mrb_free(mrb, bin);
978 return result;
979 }
980
981 #endif /* MRB_DISABLE_STDIO */
982