load.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constat values *******************************************************/
// for mrb file structure.
static const char RITE[4] = "RITE";
static const char RITE_VERSION[4] = "0400";
static const int SIZE_RITE_BINARY_HEADER = 20;
static const int SIZE_RITE_SECTION_HEADER = 12;
static const int SIZE_RITE_CATCH_HANDLER = 13;
static const char IREP[4] = "IREP";
static const char END[4] = "END\0";
 

enum irep_pool_type {
  IREP_TT_STR    = 0,   // string (need free)
  IREP_TT_SSTR   = 2,   // string (static)
  IREP_TT_INT32  = 1,   // 32bit integer
  IREP_TT_INT64  = 3,   // 64bit integer
  IREP_TT_BIGINT = 7,   // big integer
  IREP_TT_FLOAT  = 5,   // float (double/float)
};
 
 
/***** Macros ***************************************************************/
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
 
//================================================================
static int load_header(mrbc_vm *vm, const uint8_t *bin)
{
  if( memcmp(bin, RITE, sizeof(RITE)) != 0 ) {
    mrbc_raise( vm, MRBC_CLASS(Exception), "Illegal bytecode");
    return -1;
  }
  bin += sizeof(RITE);
 
  if( memcmp(bin, RITE_VERSION, sizeof(RITE_VERSION)) != 0 ) {
    mrbc_raise( vm, MRBC_CLASS(Exception), "Bytecode version mismatch");
    return -1;
  }
 
  /* Ignore others. */
 
  return 0;
}
 
 
//================================================================
static mrbc_irep * load_irep_1(mrbc_vm *vm, const uint8_t *bin, int *len)
{
  mrbc_irep irep;
  const uint8_t *p = bin + 4;   // 4 = skip record size.
 
#if defined(MRBC_DEBUG)
  irep.obj_mark_[0] = 'I';      // set "IR"
  irep.obj_mark_[1] = 'R';
#endif
 
  irep.ref_count = 0;
#if defined(MRBC_DEBUG)
  irep.nlocals = bin_to_uint16(p);      p += 2;
#else
  p += 2;       // skip nlocals
#endif
  irep.nregs = bin_to_uint16(p);        p += 2;
  irep.rlen = bin_to_uint16(p);         p += 2;
  irep.clen = bin_to_uint16(p);         p += 2;
  uint32_t ilen = bin_to_uint32(p);     p += 4;
  if( ilen > 0xffff ) goto ERROR_TOO_LARGE;
  irep.ilen = ilen;
  irep.inst = p;
 
  // POOL block
  p += irep.ilen + SIZE_RITE_CATCH_HANDLER * irep.clen;
  irep.pool = p;
  uint16_t plen = bin_to_uint16(p);     p += 2;
 
  // skip pool
  for( int i = 0; i < plen; i++ ) {
    int siz = 0;
    int tt = *p++;
 
    switch( tt ) {
    case IREP_TT_STR:
    case IREP_TT_SSTR:   siz = bin_to_uint16(p) + 3; break;
    case IREP_TT_INT32:  siz = 4; break;
 
#if defined(MRBC_INT64)
    case IREP_TT_INT64:  siz = 8; break;
    case IREP_TT_BIGINT: siz = *p + 2; break;
#else
    case IREP_TT_INT64:
    case IREP_TT_BIGINT:
       mrbc_raise(vm, MRBC_CLASS(NotImplementedError), "Unsupported int64 (set MRBC_INT64 in vm_config)");
       return NULL;
#endif
 
    case IREP_TT_FLOAT: siz = 8; break;
    default:
      mrbc_raisef(vm, MRBC_CLASS(Exception), "Not support such type (IREP_TT=%d)", tt);
      return NULL;
    }
    p += siz;
  }
 
  // num of symbols, offset of tbl_ireps.
  uint16_t slen = bin_to_uint16(p);     p += 2;
  uint32_t siz = sizeof(mrbc_sym) * slen;
  if( siz > 0xffff ) goto ERROR_TOO_LARGE;
  irep.ofs_pools = siz;
 
  siz += sizeof(uint16_t) * plen;
  // tbl_ireps holds pointers, so align to the pointer size.
  //  in 32bit: sizeof(mrbc_irep *) - 1 = 0x03
  //  in 64bit: sizeof(mrbc_irep *) - 1 = 0x07
  siz += (-siz & (uint32_t)(sizeof(mrbc_irep *) - 1));
  if( siz > 0xffff ) goto ERROR_TOO_LARGE;
  irep.ofs_ireps = siz;
 
#if defined(MRBC_DEBUG)
  irep.plen = plen;
  irep.slen = slen;
#endif
 
  // allocate new irep
  siz = sizeof(mrbc_irep) + siz + sizeof(mrbc_irep*) * irep.rlen;
  mrbc_irep *p_irep = mrbc_raw_alloc( siz );
  *p_irep = irep;
 
  // make a symbol ID table. (tbl_syms[slen])
  mrbc_sym *tbl_syms = mrbc_irep_tbl_syms(p_irep);
  for( int i = 0; i < slen; i++ ) {
    int siz = bin_to_uint16(p) + 1;     p += 2;
    char *sym_str;
 
    if (vm->flag_permanence == 1) {
      sym_str = mrbc_raw_alloc_no_free(siz);
      memcpy(sym_str, p, siz);
    } else {
      sym_str = (char *)p;
    }
 
    mrbc_sym sym = mrbc_str_to_symid( sym_str );
    if( sym < 0 ) {
      mrbc_raise(vm, MRBC_CLASS(Exception), "Overflow MAX_SYMBOLS_COUNT");
      return NULL;
    }
 
    *tbl_syms++ = sym;
    p += siz;
  }
 
  // make a pool data's offset table. (tbl_pools[plen])
  uint16_t *ofs_pools = mrbc_irep_tbl_pools(p_irep);
  p = p_irep->pool + 2;
  for( int i = 0; i < plen; i++ ) {
    int siz = 0;
    if( (p - irep.pool) > UINT16_MAX ) {
      mrbc_raise(vm, MRBC_CLASS(Exception), "Overflow IREP data offset table");
      return NULL;
    }
    *ofs_pools++ = (uint16_t)(p - irep.pool);
    switch( *p++ ) {
    case IREP_TT_STR:
    case IREP_TT_SSTR:   siz = bin_to_uint16(p) + 3; break;
    case IREP_TT_INT32:  siz = 4; break;
#if defined(MRBC_INT64)
    case IREP_TT_INT64:  siz = 8; break;
    case IREP_TT_BIGINT: siz = *p + 2; break;
#endif
    case IREP_TT_FLOAT: siz = 8;  break;
    }
    p += siz;
  }
 
  // return length
  *len = bin_to_uint32(bin);
  return p_irep;
 
 
 ERROR_TOO_LARGE:
  mrbc_raise(vm, MRBC_CLASS(Exception), "Too large IREP size");
  return NULL;
}
 
 
//================================================================
static mrbc_irep *load_irep(mrbc_vm *vm, const uint8_t *bin, int *len)
{
  int len1;
  mrbc_irep *irep = load_irep_1(vm, bin, &len1);
  if( !irep ) return NULL;
  int total_len = len1;
 
  mrbc_irep **tbl_ireps = mrbc_irep_tbl_ireps(irep);
 
  for( int i = 0; i < irep->rlen; i++ ) {
    tbl_ireps[i] = load_irep(vm, bin + total_len, &len1);
    if( ! tbl_ireps[i] ) return NULL;
    total_len += len1;
  }
 
  if( len ) *len = total_len;
  return irep;
}
 
 
/***** Global functions *****************************************************/
 
//================================================================
int mrbc_load_mrb(mrbc_vm *vm, const void *bytecode)
{
  const uint8_t *bin = bytecode;
 
  mrbc_set_nil( &vm->exception );
  if( load_header(vm, bin) != 0 ) return -1;
 
  bin += SIZE_RITE_BINARY_HEADER;
 
  while( 1 ) {
    if( memcmp(bin, IREP, sizeof(IREP)) == 0 ) {
      if( mrbc_load_irep( vm, bin ) != 0 ) break;
 
    } else if( memcmp(bin, END, sizeof(END)) == 0 ) {
      break;
    }
    // ignore other section.
 
    bin += bin_to_uint32(bin+4);        // add section size, to next section.
  }
 
  return mrbc_israised(vm);
}
 
 
//================================================================
int mrbc_load_irep(mrbc_vm *vm, const void *bytecode)
{
  const uint8_t *bin = bytecode;
 
  vm->top_irep = load_irep( vm, bin + SIZE_RITE_SECTION_HEADER, 0 );
  if( vm->top_irep == NULL ) return -1;
 
  return mrbc_israised(vm);
}
 
 
//================================================================
//void mrbc_irep_free(struct IREP *irep)
void mrbc_irep_free(mrbc_irep *irep)
{
  // release child ireps.
  for( int i = 0; i < irep->rlen; i++ ) {
    mrbc_irep_free( mrbc_irep_child_irep(irep, i) );
  }
 
  if( irep->ref_count == 0 ) {
    mrbc_raw_free( irep );
  }
}
 
#if defined(MRBC_INT64)
//----------------------------------------------------------------
static mrbc_int_t conv_bigint( const uint8_t *p )
{
  int len = *p++;
  int base = *(const int8_t *)p++;
  int sign = base;
  if( base < 0 ) base = -base;
  mrbc_int_t ret = 0;
 
  if( base <= 10 ) {
    for( int i = 0; i < len; i++ ) {
      ret = (ret * base) + (*p++ - '0');
    }
  } else {
    for( int i = 0; i < len; i++ ) {
      int n = *p++ - '0';
      if( n > 9 ) n += ('9' - 'a' + 1);
      ret = (ret * base) + n;
    }
  }
 
  return (sign < 0) ? -ret : ret;
}
#endif
 
 
//================================================================
mrbc_value mrbc_irep_pool_value(mrbc_vm *vm, int n)
{
  const uint8_t *p = mrbc_irep_pool_ptr(vm->cur_irep, n);
  mrbc_value obj;
 
  int tt = *p++;
  switch( tt ) {
#if MRBC_USE_STRING
  case IREP_TT_STR:
  case IREP_TT_SSTR: {
    int len = bin_to_uint16(p);
    obj = mrbc_string_new( vm, p+2, len );
    break;
  }
#endif
 
  case IREP_TT_INT32:
    mrbc_set_integer(&obj, bin_to_uint32(p));
    break;
 
#if MRBC_USE_FLOAT
  case IREP_TT_FLOAT:
    mrbc_set_float(&obj, bin_to_double64(p));
    break;
#endif
 
#if defined(MRBC_INT64)
  case IREP_TT_INT64:
    mrbc_set_integer(&obj, bin_to_int64(p));
    break;
 
  case IREP_TT_BIGINT:
    mrbc_set_integer(&obj, conv_bigint(p));
    break;
#endif
 
  default:
    mrbc_raisef(vm, MRBC_CLASS(Exception), "Not support such type (IREP_TT=%d)", tt);
    mrbc_set_nil(&obj);
  }
 
  return obj;
}