third-party/mruby/src/load.c

   1 /*
   2 ** load.c - mruby binary loader
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <limits.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <math.h>
  11 #include <mruby/dump.h>
  12 #include <mruby/irep.h>
  13 #include <mruby/proc.h>
  14 #include <mruby/string.h>
  15 #include <mruby/debug.h>
  16 #include <mruby/error.h>
  17 #include <mruby/data.h>
  18
  19 #if SIZE_MAX < UINT32_MAX
  20 # error size_t must be at least 32 bits wide
  21 #endif
  22
  23 #define FLAG_SRC_MALLOC 1
  24 #define FLAG_SRC_STATIC 0
  25
  26 #define SIZE_ERROR_MUL(nmemb, size) ((size_t)(nmemb) > SIZE_MAX / (size))
  27
  28 static size_t
  29 skip_padding(const uint8_t *buf)
  30 {
  31   const size_t align = MRB_DUMP_ALIGNMENT;
  32   return -(intptr_t)buf & (align-1);
  33 }
  34
  35 static size_t
  36 offset_crc_body(void)
  37 {
  38   struct rite_binary_header header;
  39   return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc);
  40 }
  41
  42 #ifndef MRB_WITHOUT_FLOAT
  43 double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck);
  44
  45 static double
  46 str_to_double(mrb_state *mrb, const char *p, size_t len)
  47 {
  48   /* `i`, `inf`, `infinity` */
  49   if (len > 0 && p[0] == 'i') return INFINITY;
  50
  51   /* `I`, `-inf`, `-infinity` */
  52   if (p[0] == 'I' || (len > 1 && p[0] == '-' && p[1] == 'i')) return -INFINITY;
  53   return mrb_str_len_to_dbl(mrb, p, len, TRUE);
  54 }
  55 #endif
  56
  57 mrb_value mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base, int badcheck);
  58
  59 static void
  60 tempirep_free(mrb_state *mrb, void *p)
  61 {
  62   if (p) mrb_irep_decref(mrb, (mrb_irep *)p);
  63 }
  64
  65 static const mrb_data_type tempirep_type = { "temporary irep", tempirep_free };
  66
  67 static mrb_irep*
  68 read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
  69 {
  70   int i;
  71   const uint8_t *src = bin;
  72   ptrdiff_t diff;
  73   uint16_t tt, pool_data_len, snl;
  74   int plen;
  75   struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
  76   mrb_irep *irep = mrb_add_irep(mrb);
  77   int ai = mrb_gc_arena_save(mrb);
  78
  79   irep_obj->data = irep;
  80
  81   /* skip record size */
  82   src += sizeof(uint32_t);
  83
  84   /* number of local variable */
  85   irep->nlocals = bin_to_uint16(src);
  86   src += sizeof(uint16_t);
  87
  88   /* number of register variable */
  89   irep->nregs = bin_to_uint16(src);
  90   src += sizeof(uint16_t);
  91
  92   /* number of child irep */
  93   irep->rlen = (size_t)bin_to_uint16(src);
  94   src += sizeof(uint16_t);
  95
  96   /* Binary Data Section */
  97   /* ISEQ BLOCK */
  98   irep->ilen = (uint16_t)bin_to_uint32(src);
  99   src += sizeof(uint32_t);
 100   src += skip_padding(src);
 101
 102   if (irep->ilen > 0) {
 103     if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) {
 104       return NULL;
 105     }
 106     if ((flags & FLAG_SRC_MALLOC) == 0) {
 107       irep->iseq = (mrb_code*)src;
 108       src += sizeof(mrb_code) * irep->ilen;
 109       irep->flags |= MRB_ISEQ_NO_FREE;
 110     }
 111     else {
 112       size_t data_len = sizeof(mrb_code) * irep->ilen;
 113       void *buf = mrb_malloc(mrb, data_len);
 114       irep->iseq = (mrb_code *)buf;
 115       memcpy(buf, src, data_len);
 116       src += data_len;
 117     }
 118   }
 119
 120   /* POOL BLOCK */
 121   plen = bin_to_uint32(src); /* number of pool */
 122   src += sizeof(uint32_t);
 123   if (plen > 0) {
 124     if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) {
 125       return NULL;
 126     }
 127     irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
 128
 129     for (i = 0; i < plen; i++) {
 130       const char *s;
 131       mrb_bool st = (flags & FLAG_SRC_MALLOC)==0;
 132
 133       tt = *src++; /* pool TT */
 134       pool_data_len = bin_to_uint16(src); /* pool data length */
 135       src += sizeof(uint16_t);
 136       s = (const char*)src;
 137       src += pool_data_len;
 138       switch (tt) { /* pool data */
 139       case IREP_TT_FIXNUM: {
 140         mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE);
 141 #ifdef MRB_WITHOUT_FLOAT
 142         irep->pool[i] = num;
 143 #else
 144         irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num;
 145 #endif
 146         }
 147         break;
 148
 149 #ifndef MRB_WITHOUT_FLOAT
 150       case IREP_TT_FLOAT:
 151         irep->pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len));
 152         break;
 153 #endif
 154
 155       case IREP_TT_STRING:
 156         irep->pool[i] = mrb_str_pool(mrb, s, pool_data_len, st);
 157         break;
 158
 159       default:
 160         /* should not happen */
 161         irep->pool[i] = mrb_nil_value();
 162         break;
 163       }
 164       irep->plen++;
 165       mrb_gc_arena_restore(mrb, ai);
 166     }
 167   }
 168
 169   /* SYMS BLOCK */
 170   irep->slen = (uint16_t)bin_to_uint32(src);  /* syms length */
 171   src += sizeof(uint32_t);
 172   if (irep->slen > 0) {
 173     if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
 174       return NULL;
 175     }
 176     irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
 177
 178     for (i = 0; i < irep->slen; i++) {
 179       snl = bin_to_uint16(src);               /* symbol name length */
 180       src += sizeof(uint16_t);
 181
 182       if (snl == MRB_DUMP_NULL_SYM_LEN) {
 183         irep->syms[i] = 0;
 184         continue;
 185       }
 186
 187       if (flags & FLAG_SRC_MALLOC) {
 188         irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
 189       }
 190       else {
 191         irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
 192       }
 193       src += snl + 1;
 194
 195       mrb_gc_arena_restore(mrb, ai);
 196     }
 197   }
 198
 199   irep->reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*));
 200
 201   diff = src - bin;
 202   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 203   *len = (size_t)diff;
 204
 205   irep_obj->data = NULL;
 206
 207   return irep;
 208 }
 209
 210 static mrb_irep*
 211 read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
 212 {
 213   struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
 214   int ai = mrb_gc_arena_save(mrb);
 215   mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags);
 216   int i;
 217
 218   mrb_gc_arena_restore(mrb, ai);
 219   if (irep == NULL) {
 220     return NULL;
 221   }
 222
 223   irep_obj->data = irep;
 224
 225   bin += *len;
 226   for (i=0; i<irep->rlen; i++) {
 227     size_t rlen;
 228
 229     irep->reps[i] = read_irep_record(mrb, bin, &rlen, flags);
 230     mrb_gc_arena_restore(mrb, ai);
 231     if (irep->reps[i] == NULL) {
 232       return NULL;
 233     }
 234     bin += rlen;
 235     *len += rlen;
 236   }
 237
 238   irep_obj->data = NULL;
 239
 240   return irep;
 241 }
 242
 243 static mrb_irep*
 244 read_section_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags)
 245 {
 246   size_t len;
 247
 248   bin += sizeof(struct rite_section_irep_header);
 249   return read_irep_record(mrb, bin, &len, flags);
 250 }
 251
 252 static int
 253 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)
 254 {
 255   const uint8_t *bin = start;
 256   ptrdiff_t diff;
 257   size_t record_size;
 258   uint16_t f_idx;
 259   int i;
 260
 261   if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
 262
 263   irep->debug_info = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info));
 264   irep->debug_info->pc_count = (uint32_t)irep->ilen;
 265
 266   record_size = (size_t)bin_to_uint32(bin);
 267   bin += sizeof(uint32_t);
 268
 269   irep->debug_info->flen = bin_to_uint16(bin);
 270   irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
 271   bin += sizeof(uint16_t);
 272
 273   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
 274     mrb_irep_debug_info_file *file;
 275     uint16_t filename_idx;
 276
 277     file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file));
 278     irep->debug_info->files[f_idx] = file;
 279
 280     file->start_pos = bin_to_uint32(bin);
 281     bin += sizeof(uint32_t);
 282
 283     /* filename */
 284     filename_idx = bin_to_uint16(bin);
 285     bin += sizeof(uint16_t);
 286     mrb_assert(filename_idx < filenames_len);
 287     file->filename_sym = filenames[filename_idx];
 288
 289     file->line_entry_count = bin_to_uint32(bin);
 290     bin += sizeof(uint32_t);
 291     file->line_type = (mrb_debug_line_type)bin_to_uint8(bin);
 292     bin += sizeof(uint8_t);
 293     switch (file->line_type) {
 294       case mrb_debug_line_ary: {
 295         uint32_t l;
 296
 297         file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count));
 298         for (l = 0; l < file->line_entry_count; ++l) {
 299           file->lines.ary[l] = bin_to_uint16(bin);
 300           bin += sizeof(uint16_t);
 301         }
 302       } break;
 303
 304       case mrb_debug_line_flat_map: {
 305         uint32_t l;
 306
 307         file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_calloc(
 308             mrb, (size_t)(file->line_entry_count), sizeof(mrb_irep_debug_info_line));
 309         for (l = 0; l < file->line_entry_count; ++l) {
 310           file->lines.flat_map[l].start_pos = bin_to_uint32(bin);
 311           bin += sizeof(uint32_t);
 312           file->lines.flat_map[l].line = bin_to_uint16(bin);
 313           bin += sizeof(uint16_t);
 314         }
 315       } break;
 316
 317       default: return MRB_DUMP_GENERAL_FAILURE;
 318     }
 319   }
 320
 321   diff = bin - start;
 322   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 323
 324   if (record_size != (size_t)diff) {
 325     return MRB_DUMP_GENERAL_FAILURE;
 326   }
 327
 328   for (i = 0; i < irep->rlen; i++) {
 329     size_t len;
 330     int ret;
 331
 332     ret = read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len);
 333     if (ret != MRB_DUMP_OK) return ret;
 334     bin += len;
 335   }
 336
 337   diff = bin - start;
 338   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 339   *record_len = (size_t)diff;
 340
 341   return MRB_DUMP_OK;
 342 }
 343
 344 static int
 345 read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags)
 346 {
 347   const uint8_t *bin;
 348   ptrdiff_t diff;
 349   struct rite_section_debug_header *header;
 350   uint16_t i;
 351   size_t len = 0;
 352   int result;
 353   uint16_t filenames_len;
 354   mrb_sym *filenames;
 355   mrb_value filenames_obj;
 356
 357   bin = start;
 358   header = (struct rite_section_debug_header *)bin;
 359   bin += sizeof(struct rite_section_debug_header);
 360
 361   filenames_len = bin_to_uint16(bin);
 362   bin += sizeof(uint16_t);
 363   filenames_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)filenames_len);
 364   filenames = (mrb_sym*)RSTRING_PTR(filenames_obj);
 365   for (i = 0; i < filenames_len; ++i) {
 366     uint16_t f_len = bin_to_uint16(bin);
 367     bin += sizeof(uint16_t);
 368     if (flags & FLAG_SRC_MALLOC) {
 369       filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len);
 370     }
 371     else {
 372       filenames[i] = mrb_intern_static(mrb, (const char *)bin, (size_t)f_len);
 373     }
 374     bin += f_len;
 375   }
 376
 377   result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len);
 378   if (result != MRB_DUMP_OK) goto debug_exit;
 379
 380   bin += len;
 381   diff = bin - start;
 382   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 383   if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
 384     result = MRB_DUMP_GENERAL_FAILURE;
 385   }
 386
 387 debug_exit:
 388   mrb_str_resize(mrb, filenames_obj, 0);
 389   return result;
 390 }
 391
 392 static int
 393 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)
 394 {
 395   const uint8_t *bin = start;
 396   ptrdiff_t diff;
 397   int i;
 398
 399   irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
 400
 401   for (i = 0; i + 1< irep->nlocals; ++i) {
 402     uint16_t const sym_idx = bin_to_uint16(bin);
 403     bin += sizeof(uint16_t);
 404     if (sym_idx == RITE_LV_NULL_MARK) {
 405       irep->lv[i].name = 0;
 406       irep->lv[i].r = 0;
 407     }
 408     else {
 409       if (sym_idx >= syms_len) {
 410         return MRB_DUMP_GENERAL_FAILURE;
 411       }
 412       irep->lv[i].name = syms[sym_idx];
 413
 414       irep->lv[i].r = bin_to_uint16(bin);
 415     }
 416     bin += sizeof(uint16_t);
 417   }
 418
 419   for (i = 0; i < irep->rlen; ++i) {
 420     size_t len;
 421     int ret;
 422
 423     ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len);
 424     if (ret != MRB_DUMP_OK) return ret;
 425     bin += len;
 426   }
 427
 428   diff = bin - start;
 429   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 430   *record_len = (size_t)diff;
 431
 432   return MRB_DUMP_OK;
 433 }
 434
 435 static int
 436 read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags)
 437 {
 438   const uint8_t *bin;
 439   ptrdiff_t diff;
 440   struct rite_section_lv_header const *header;
 441   uint32_t i;
 442   size_t len = 0;
 443   int result;
 444   uint32_t syms_len;
 445   mrb_sym *syms;
 446   mrb_value syms_obj;
 447   mrb_sym (*intern_func)(mrb_state*, const char*, size_t) =
 448     (flags & FLAG_SRC_MALLOC)? mrb_intern : mrb_intern_static;
 449
 450   bin = start;
 451   header = (struct rite_section_lv_header const*)bin;
 452   bin += sizeof(struct rite_section_lv_header);
 453
 454   syms_len = bin_to_uint32(bin);
 455   bin += sizeof(uint32_t);
 456   syms_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)syms_len);
 457   syms = (mrb_sym*)RSTRING_PTR(syms_obj);
 458   for (i = 0; i < syms_len; ++i) {
 459     uint16_t const str_len = bin_to_uint16(bin);
 460     bin += sizeof(uint16_t);
 461
 462     syms[i] = intern_func(mrb, (const char*)bin, str_len);
 463     bin += str_len;
 464   }
 465
 466   result = read_lv_record(mrb, bin, irep, &len, syms, syms_len);
 467   if (result != MRB_DUMP_OK) goto lv_exit;
 468
 469   bin += len;
 470   diff = bin - start;
 471   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
 472   if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
 473     result = MRB_DUMP_GENERAL_FAILURE;
 474   }
 475
 476 lv_exit:
 477   mrb_str_resize(mrb, syms_obj, 0);
 478   return result;
 479 }
 480
 481 static int
 482 read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint16_t *crc, uint8_t *flags)
 483 {
 484   const struct rite_binary_header *header = (const struct rite_binary_header *)bin;
 485
 486   if (bufsize < sizeof(struct rite_binary_header)) {
 487     return MRB_DUMP_READ_FAULT;
 488   }
 489
 490   if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) != 0) {
 491     return MRB_DUMP_INVALID_FILE_HEADER;
 492   }
 493
 494   if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) {
 495     return MRB_DUMP_INVALID_FILE_HEADER;
 496   }
 497
 498   if (crc) {
 499     *crc = bin_to_uint16(header->binary_crc);
 500   }
 501   *bin_size = (size_t)bin_to_uint32(header->binary_size);
 502
 503   if (bufsize < *bin_size) {
 504     return MRB_DUMP_READ_FAULT;
 505   }
 506
 507   return MRB_DUMP_OK;
 508 }
 509
 510 static mrb_irep*
 511 read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags)
 512 {
 513   int result;
 514   struct RData *irep_obj = NULL;
 515   mrb_irep *irep = NULL;
 516   const struct rite_section_header *section_header;
 517   uint16_t crc;
 518   size_t bin_size = 0;
 519   size_t n;
 520
 521   if ((mrb == NULL) || (bin == NULL)) {
 522     return NULL;
 523   }
 524
 525   result = read_binary_header(bin, bufsize, &bin_size, &crc, &flags);
 526   if (result != MRB_DUMP_OK) {
 527     return NULL;
 528   }
 529
 530   n = offset_crc_body();
 531   if (crc != calc_crc_16_ccitt(bin + n, bin_size - n, 0)) {
 532     return NULL;
 533   }
 534
 535   irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
 536
 537   bin += sizeof(struct rite_binary_header);
 538   do {
 539     section_header = (const struct rite_section_header *)bin;
 540     if (memcmp(section_header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(section_header->section_ident)) == 0) {
 541       irep = read_section_irep(mrb, bin, flags);
 542       if (!irep) return NULL;
 543       irep_obj->data = irep;
 544     }
 545     else if (memcmp(section_header->section_ident, RITE_SECTION_DEBUG_IDENT, sizeof(section_header->section_ident)) == 0) {
 546       if (!irep) return NULL;   /* corrupted data */
 547       result = read_section_debug(mrb, bin, irep, flags);
 548       if (result < MRB_DUMP_OK) {
 549         return NULL;
 550       }
 551     }
 552     else if (memcmp(section_header->section_ident, RITE_SECTION_LV_IDENT, sizeof(section_header->section_ident)) == 0) {
 553       if (!irep) return NULL;
 554       result = read_section_lv(mrb, bin, irep, flags);
 555       if (result < MRB_DUMP_OK) {
 556         return NULL;
 557       }
 558     }
 559     bin += bin_to_uint32(section_header->section_size);
 560   } while (memcmp(section_header->section_ident, RITE_BINARY_EOF, sizeof(section_header->section_ident)) != 0);
 561
 562   irep_obj->data = NULL;
 563
 564   return irep;
 565 }
 566
 567 mrb_irep*
 568 mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
 569 {
 570 #if defined(MRB_USE_LINK_TIME_RO_DATA_P) || defined(MRB_USE_CUSTOM_RO_DATA_P)
 571   uint8_t flags = mrb_ro_data_p((char*)bin) ? FLAG_SRC_STATIC : FLAG_SRC_MALLOC;
 572 #else
 573   uint8_t flags = FLAG_SRC_STATIC;
 574 #endif
 575
 576   return read_irep(mrb, bin, (size_t)-1, flags);
 577 }
 578
 579 MRB_API mrb_irep*
 580 mrb_read_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
 581 {
 582   return read_irep(mrb, (const uint8_t *)buf, bufsize, FLAG_SRC_MALLOC);
 583 }
 584
 585 void mrb_exc_set(mrb_state *mrb, mrb_value exc);
 586
 587 static void
 588 irep_error(mrb_state *mrb)
 589 {
 590   mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
 591 }
 592
 593 void mrb_codedump_all(mrb_state*, struct RProc*);
 594
 595 static mrb_value
 596 load_irep(mrb_state *mrb, mrb_irep *irep, mrbc_context *c)
 597 {
 598   struct RProc *proc;
 599
 600   if (!irep) {
 601     irep_error(mrb);
 602     return mrb_nil_value();
 603   }
 604   proc = mrb_proc_new(mrb, irep);
 605   proc->c = NULL;
 606   mrb_irep_decref(mrb, irep);
 607   if (c && c->dump_result) mrb_codedump_all(mrb, proc);
 608   if (c && c->no_exec) return mrb_obj_value(proc);
 609   return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
 610 }
 611
 612 MRB_API mrb_value
 613 mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
 614 {
 615   struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
 616   mrb_irep *irep = mrb_read_irep(mrb, bin);
 617   mrb_value ret;
 618
 619   irep_obj->data = irep;
 620   mrb_irep_incref(mrb, irep);
 621   ret = load_irep(mrb, irep, c);
 622   irep_obj->data = NULL;
 623   mrb_irep_decref(mrb, irep);
 624   return ret;
 625 }
 626
 627 MRB_API mrb_value
 628 mrb_load_irep_buf_cxt(mrb_state *mrb, const void *buf, size_t bufsize, mrbc_context *c)
 629 {
 630   return load_irep(mrb, mrb_read_irep_buf(mrb, buf, bufsize), c);
 631 }
 632
 633 MRB_API mrb_value
 634 mrb_load_irep(mrb_state *mrb, const uint8_t *bin)
 635 {
 636   return mrb_load_irep_cxt(mrb, bin, NULL);
 637 }
 638
 639 MRB_API mrb_value
 640 mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
 641 {
 642   return mrb_load_irep_buf_cxt(mrb, buf, bufsize, NULL);
 643 }
 644
 645 #ifndef MRB_DISABLE_STDIO
 646
 647 mrb_irep*
 648 mrb_read_irep_file(mrb_state *mrb, FILE* fp)
 649 {
 650   mrb_irep *irep = NULL;
 651   uint8_t *buf;
 652   const size_t header_size = sizeof(struct rite_binary_header);
 653   size_t buf_size = 0;
 654   uint8_t flags = 0;
 655   int result;
 656
 657   if ((mrb == NULL) || (fp == NULL)) {
 658     return NULL;
 659   }
 660
 661   buf = (uint8_t*)mrb_malloc(mrb, header_size);
 662   if (fread(buf, header_size, 1, fp) == 0) {
 663     goto irep_exit;
 664   }
 665   result = read_binary_header(buf, (size_t)-1, &buf_size, NULL, &flags);
 666   if (result != MRB_DUMP_OK || buf_size <= header_size) {
 667     goto irep_exit;
 668   }
 669
 670   buf = (uint8_t*)mrb_realloc(mrb, buf, buf_size);
 671   if (fread(buf+header_size, buf_size-header_size, 1, fp) == 0) {
 672     goto irep_exit;
 673   }
 674   irep = read_irep(mrb, buf, (size_t)-1, FLAG_SRC_MALLOC);
 675
 676 irep_exit:
 677   mrb_free(mrb, buf);
 678   return irep;
 679 }
 680
 681 MRB_API mrb_value
 682 mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
 683 {
 684   return load_irep(mrb, mrb_read_irep_file(mrb, fp), c);
 685 }
 686
 687 MRB_API mrb_value
 688 mrb_load_irep_file(mrb_state *mrb, FILE* fp)
 689 {
 690   return mrb_load_irep_file_cxt(mrb, fp, NULL);
 691 }
 692 #endif /* MRB_DISABLE_STDIO */