src/cdump.c

   1 /*
   2 ** cdump.c - mruby binary dumper (in C)
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/string.h>
   9 #include <mruby/dump.h>
  10 #include <mruby/irep.h>
  11 #include <mruby/debug.h>
  12 #include <mruby/internal.h>
  13
  14 #include <string.h>
  15
  16 #ifndef MRB_NO_STDIO
  17
  18 #ifndef MRB_NO_FLOAT
  19 #include <mruby/endian.h>
  20 #define MRB_FLOAT_FMT "%.17g"
  21 #endif
  22
  23 static int
  24 cdump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp)
  25 {
  26   if (p->tt & IREP_TT_NFLAG) {  /* number */
  27     switch (p->tt) {
  28 #ifdef MRB_64BIT
  29     case IREP_TT_INT64:
  30       if (p->u.i64 < INT32_MIN || INT32_MAX < p->u.i64) {
  31         fprintf(fp, "{IREP_TT_INT64, {.i64=%" PRId64 "}},\n", p->u.i64);
  32       }
  33       else {
  34         fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", (int32_t)p->u.i64);
  35       }
  36       break;
  37 #endif
  38     case IREP_TT_INT32:
  39       fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", p->u.i32);
  40       break;
  41     case IREP_TT_FLOAT:
  42 #ifndef MRB_NO_FLOAT
  43       fprintf(fp, "{IREP_TT_FLOAT, {.f=" MRB_FLOAT_FMT "}},\n", p->u.f);
  44 #endif
  45       break;
  46     case IREP_TT_BIGINT:
  47       {
  48         const char *s = p->u.str;
  49         int len = s[0]+2;
  50         fputs("{IREP_TT_BIGINT, {\"", fp);
  51         for (int i=0; i<len; i++) {
  52           fprintf(fp, "\\x%02x", (int)s[i]&0xff);
  53         }
  54         fputs("\"}},\n", fp);
  55       }
  56       break;
  57     }
  58   }
  59   else {                        /* string */
  60     int i, len = p->tt>>2;
  61     const char *s = p->u.str;
  62     fprintf(fp, "{IREP_TT_STR|(%d<<2), {\"", len);
  63     for (i=0; i<len; i++) {
  64       fprintf(fp, "\\x%02x", (int)s[i]&0xff);
  65     }
  66     fputs("\"}},\n", fp);
  67   }
  68   return MRB_DUMP_OK;
  69 }
  70
  71 static mrb_bool
  72 sym_name_word_p(const char *name, mrb_int len)
  73 {
  74   if (len == 0) return FALSE;
  75   if (name[0] != '_' && !ISALPHA(name[0])) return FALSE;
  76   for (int i = 1; i < len; i++) {
  77     if (name[i] != '_' && !ISALNUM(name[i])) return FALSE;
  78   }
  79   return TRUE;
  80 }
  81
  82 static mrb_bool
  83 sym_name_with_equal_p(const char *name, mrb_int len)
  84 {
  85   return len >= 2 && name[len-1] == '=' && sym_name_word_p(name, len-1);
  86 }
  87
  88 static mrb_bool
  89 sym_name_with_question_mark_p(const char *name, mrb_int len)
  90 {
  91   return len >= 2 && name[len-1] == '?' && sym_name_word_p(name, len-1);
  92 }
  93
  94 static mrb_bool
  95 sym_name_with_bang_p(const char *name, mrb_int len)
  96 {
  97   return len >= 2 && name[len-1] == '!' && sym_name_word_p(name, len-1);
  98 }
  99
 100 static mrb_bool
 101 sym_name_ivar_p(const char *name, mrb_int len)
 102 {
 103   return len >= 2 && name[0] == '@' && sym_name_word_p(name+1, len-1);
 104 }
 105
 106 static mrb_bool
 107 sym_name_cvar_p(const char *name, mrb_int len)
 108 {
 109   return len >= 3 && name[0] == '@' && sym_name_ivar_p(name+1, len-1);
 110 }
 111
 112 #define OPERATOR_SYMBOL(sym_name, name) {name, sym_name, sizeof(sym_name)-1}
 113 struct operator_symbol {
 114   const char *name;
 115   const char *sym_name;
 116   uint16_t sym_name_len;
 117 };
 118 static const struct operator_symbol operator_table[] = {
 119   OPERATOR_SYMBOL("!", "not"),
 120   OPERATOR_SYMBOL("%", "mod"),
 121   OPERATOR_SYMBOL("&", "and"),
 122   OPERATOR_SYMBOL("*", "mul"),
 123   OPERATOR_SYMBOL("+", "add"),
 124   OPERATOR_SYMBOL("-", "sub"),
 125   OPERATOR_SYMBOL("/", "div"),
 126   OPERATOR_SYMBOL("<", "lt"),
 127   OPERATOR_SYMBOL(">", "gt"),
 128   OPERATOR_SYMBOL("^", "xor"),
 129   OPERATOR_SYMBOL("`", "tick"),
 130   OPERATOR_SYMBOL("|", "or"),
 131   OPERATOR_SYMBOL("~", "neg"),
 132   OPERATOR_SYMBOL("!=", "neq"),
 133   OPERATOR_SYMBOL("!~", "nmatch"),
 134   OPERATOR_SYMBOL("&&", "andand"),
 135   OPERATOR_SYMBOL("**", "pow"),
 136   OPERATOR_SYMBOL("+@", "plus"),
 137   OPERATOR_SYMBOL("-@", "minus"),
 138   OPERATOR_SYMBOL("<<", "lshift"),
 139   OPERATOR_SYMBOL("<=", "le"),
 140   OPERATOR_SYMBOL("==", "eq"),
 141   OPERATOR_SYMBOL("=~", "match"),
 142   OPERATOR_SYMBOL(">=", "ge"),
 143   OPERATOR_SYMBOL(">>", "rshift"),
 144   OPERATOR_SYMBOL("[]", "aref"),
 145   OPERATOR_SYMBOL("||", "oror"),
 146   OPERATOR_SYMBOL("<=>", "cmp"),
 147   OPERATOR_SYMBOL("===", "eqq"),
 148   OPERATOR_SYMBOL("[]=", "aset"),
 149 };
 150
 151 static const char*
 152 sym_operator_name(const char *sym_name, mrb_int len)
 153 {
 154   mrb_sym table_size = sizeof(operator_table)/sizeof(struct operator_symbol);
 155   if (operator_table[table_size-1].sym_name_len < len) return NULL;
 156
 157   for (mrb_sym start = 0; table_size != 0; table_size/=2) {
 158     mrb_sym idx = start+table_size/2;
 159     const struct operator_symbol *op_sym = &operator_table[idx];
 160     int cmp = (int)len-(int)op_sym->sym_name_len;
 161     if (cmp == 0) {
 162       cmp = memcmp(sym_name, op_sym->sym_name, len);
 163       if (cmp == 0) return op_sym->name;
 164     }
 165     if (0 < cmp) {
 166       start = ++idx;
 167       table_size--;
 168     }
 169   }
 170   return NULL;
 171 }
 172
 173 static const char*
 174 sym_var_name(mrb_state *mrb, const char *initname, const char *key, int n)
 175 {
 176   char buf[32];
 177   mrb_value s = mrb_str_new_cstr(mrb, initname);
 178   mrb_str_cat_lit(mrb, s, "_");
 179   mrb_str_cat_cstr(mrb, s, key);
 180   mrb_str_cat_lit(mrb, s, "_");
 181   snprintf(buf, sizeof(buf), "%d", n);
 182   mrb_str_cat_cstr(mrb, s, buf);
 183   return RSTRING_PTR(s);
 184 }
 185
 186 static int
 187 cdump_sym(mrb_state *mrb, mrb_sym sym, const char *var_name, int idx, mrb_value init_syms_code, FILE *fp)
 188 {
 189   if (sym == 0) {
 190     fputs("0,", fp);
 191     return MRB_DUMP_OK;
 192   }
 193
 194   mrb_int len;
 195
 196   const char *name = mrb_sym_name_len(mrb, sym, &len), *op_name;
 197   if (!name) return MRB_DUMP_INVALID_ARGUMENT;
 198   if (sym_name_word_p(name, len)) {
 199     fprintf(fp, "MRB_SYM(%s)", name);
 200   }
 201   else if (sym_name_with_equal_p(name, len)) {
 202     fprintf(fp, "MRB_SYM_E(%.*s)", (int)(len-1), name);
 203   }
 204   else if (sym_name_with_question_mark_p(name, len)) {
 205     fprintf(fp, "MRB_SYM_Q(%.*s)", (int)(len-1), name);
 206   }
 207   else if (sym_name_with_bang_p(name, len)) {
 208     fprintf(fp, "MRB_SYM_B(%.*s)", (int)(len-1), name);
 209   }
 210   else if (sym_name_ivar_p(name, len)) {
 211     fprintf(fp, "MRB_IVSYM(%s)", name+1);
 212   }
 213   else if (sym_name_cvar_p(name, len)) {
 214     fprintf(fp, "MRB_CVSYM(%s)", name+2);
 215   }
 216   else if ((op_name = sym_operator_name(name, len))) {
 217     fprintf(fp, "MRB_OPSYM(%s)", op_name);
 218   }
 219   else {
 220     char buf[32];
 221     mrb_value name_obj = mrb_str_new(mrb, name, len);
 222     mrb_str_cat_lit(mrb, init_syms_code, "  ");
 223     mrb_str_cat_cstr(mrb, init_syms_code, var_name);
 224     snprintf(buf, sizeof(buf), "[%d] = ", idx);
 225     mrb_str_cat_cstr(mrb, init_syms_code, buf);
 226     mrb_str_cat_lit(mrb, init_syms_code, "mrb_intern_lit(mrb, ");
 227     mrb_str_cat_str(mrb, init_syms_code, mrb_str_dump(mrb, name_obj));
 228     mrb_str_cat_lit(mrb, init_syms_code, ");\n");
 229     fputs("0", fp);
 230   }
 231   fputs(", ", fp);
 232   return MRB_DUMP_OK;
 233 }
 234
 235 static int
 236 cdump_syms(mrb_state *mrb, const char *name, const char *key, int n, int syms_len, const mrb_sym *syms, mrb_value init_syms_code, FILE *fp)
 237 {
 238   int ai = mrb_gc_arena_save(mrb);
 239   mrb_int code_len = RSTRING_LEN(init_syms_code);
 240   const char *var_name = sym_var_name(mrb, name, key, n);
 241
 242   fprintf(fp, "mrb_DEFINE_SYMS_VAR(%s, %d, (", var_name, syms_len);
 243   for (int i=0; i<syms_len; i++) {
 244     cdump_sym(mrb, syms[i], var_name, i, init_syms_code, fp);
 245   }
 246   fputs("), ", fp);
 247   if (code_len == RSTRING_LEN(init_syms_code)) fputs("const", fp);
 248   fputs(");\n", fp);
 249   mrb_gc_arena_restore(mrb, ai);
 250   return MRB_DUMP_OK;
 251 }
 252
 253 //Handle the simple/common case of debug_info:
 254 // - 1 file associated with a single irep
 255 // - mrb_debug_line_ary format only
 256 static int
 257 simple_debug_info(mrb_irep_debug_info *info)
 258 {
 259   if (!info || info->flen != 1) {
 260     return 0;
 261   }
 262   return 1;
 263 }
 264
 265 //Adds debug information to c-structs and
 266 //adds filenames in init_syms_code block
 267 static int
 268 cdump_debug(mrb_state *mrb, const char *name, int n, mrb_irep_debug_info *info,
 269             mrb_value init_syms_code, FILE *fp)
 270 {
 271   int ai = mrb_gc_arena_save(mrb);
 272   char buffer[256];
 273   const char *line_type = "mrb_debug_line_ary";
 274
 275   if (!simple_debug_info(info))
 276     return MRB_DUMP_INVALID_IREP;
 277
 278   int len = info->files[0]->line_entry_count;
 279
 280   const char *filename = mrb_sym_name_len(mrb, info->files[0]->filename_sym, NULL);
 281   snprintf(buffer, sizeof(buffer), "  %s_debug_file_%d.filename_sym = mrb_intern_lit(mrb,", name, n);
 282   mrb_str_cat_cstr(mrb, init_syms_code, buffer);
 283   mrb_str_cat_str(mrb, init_syms_code, mrb_str_dump(mrb, mrb_str_new_cstr(mrb, filename)));
 284   mrb_str_cat_cstr(mrb, init_syms_code, ");\n");
 285
 286   switch (info->files[0]->line_type) {
 287   case mrb_debug_line_ary:
 288     fprintf(fp, "static uint16_t %s_debug_lines_%d[%d] = {", name, n, len);
 289     for (int i=0; i<len; i++) {
 290       if (i%10 == 0) fputs("\n", fp);
 291       fprintf(fp, "0x%04x,", info->files[0]->lines.ary[i]);
 292     }
 293     fputs("};\n", fp);
 294     break;
 295
 296   case mrb_debug_line_flat_map:
 297     line_type = "mrb_debug_line_flat_map";
 298     fprintf(fp, "static struct mrb_irep_debug_info_line %s_debug_lines_%d[%d] = {", name, n, len);
 299     for (int i=0; i<len; i++) {
 300       const mrb_irep_debug_info_line *fmap = &info->files[0]->lines.flat_map[i];
 301       fprintf(fp, "\t{.start_pos=0x%04x,.line=%d},\n", fmap->start_pos, fmap->line);
 302     }
 303     fputs("};\n", fp);
 304     break;
 305
 306   case mrb_debug_line_packed_map:
 307     line_type = "mrb_debug_line_packed_map";
 308     fprintf(fp, "static const char %s_debug_lines_%d[] = \"", name, n);
 309     const uint8_t *pmap = info->files[0]->lines.packed_map;
 310     for (int i=0; i<len; i++) {
 311       fprintf(fp, "\\x%02x", pmap[i]&0xff);
 312     }
 313     fputs("\";\n", fp);
 314     break;
 315   }
 316   fprintf(fp, "static mrb_irep_debug_info_file %s_debug_file_%d = {\n", name, n);
 317   fprintf(fp, "%d, %d, %d, %s, {%s_debug_lines_%d}};\n",
 318           info->files[0]->start_pos,
 319           info->files[0]->filename_sym,
 320           info->files[0]->line_entry_count,
 321           line_type,
 322           name, n);
 323   fprintf(fp, "static mrb_irep_debug_info_file *%s_debug_file_%d_ = &%s_debug_file_%d;\n", name, n, name, n);
 324
 325   fprintf(fp, "static mrb_irep_debug_info %s_debug_%d = {\n", name, n);
 326   fprintf(fp, "%d, %d, &%s_debug_file_%d_};\n", info->pc_count, info->flen, name, n);
 327
 328   mrb_gc_arena_restore(mrb, ai);
 329   return MRB_DUMP_OK;
 330 }
 331
 332 static int
 333 cdump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *name, int n, mrb_value init_syms_code, int *mp)
 334 {
 335   int i, len;
 336   int max = *mp;
 337   int debug_available = 0;
 338
 339   /* dump reps */
 340   if (irep->reps) {
 341     for (i=0,len=irep->rlen; i<len; i++) {
 342       *mp += len;
 343       if (cdump_irep_struct(mrb, irep->reps[i], flags, fp, name, max+i, init_syms_code, mp) != MRB_DUMP_OK)
 344         return MRB_DUMP_INVALID_ARGUMENT;
 345     }
 346     fprintf(fp,   "static const mrb_irep *%s_reps_%d[%d] = {\n", name, n, len);
 347     for (i=0,len=irep->rlen; i<len; i++) {
 348       fprintf(fp,   "  &%s_irep_%d,\n", name, max+i);
 349     }
 350     fputs("};\n", fp);
 351   }
 352   /* dump pool */
 353   if (irep->pool) {
 354     len=irep->plen;
 355     fprintf(fp,   "static const mrb_pool_value %s_pool_%d[%d] = {\n", name, n, len);
 356     for (i=0; i<len; i++) {
 357       if (cdump_pool(mrb, &irep->pool[i], fp) != MRB_DUMP_OK)
 358         return MRB_DUMP_INVALID_ARGUMENT;
 359     }
 360     fputs("};\n", fp);
 361   }
 362   /* dump syms */
 363   if (irep->syms) {
 364     cdump_syms(mrb, name, "syms", n, irep->slen, irep->syms, init_syms_code, fp);
 365   }
 366   /* dump iseq */
 367   len=irep->ilen+sizeof(struct mrb_irep_catch_handler)*irep->clen;
 368   fprintf(fp,   "static const mrb_code %s_iseq_%d[%d] = {", name, n, len);
 369   for (i=0; i<len; i++) {
 370     if (i%20 == 0) fputs("\n", fp);
 371     fprintf(fp, "0x%02x,", irep->iseq[i]);
 372   }
 373   fputs("};\n", fp);
 374   /* dump lv */
 375   if (irep->lv) {
 376     cdump_syms(mrb, name, "lv", n, irep->nlocals-1, irep->lv, init_syms_code, fp);
 377   }
 378   /* dump debug */
 379   if (flags & MRB_DUMP_DEBUG_INFO) {
 380     if (cdump_debug(mrb, name, n, irep->debug_info, init_syms_code, fp) == MRB_DUMP_OK) {
 381       debug_available = 1;
 382     }
 383   }
 384
 385
 386   /* dump irep */
 387   fprintf(fp, "static const mrb_irep %s_irep_%d = {\n", name, n);
 388   fprintf(fp,   "  %d,%d,%d,\n", irep->nlocals, irep->nregs, irep->clen);
 389   fprintf(fp,   "  MRB_IREP_STATIC,%s_iseq_%d,\n", name, n);
 390   if (irep->pool) {
 391     fprintf(fp, "  %s_pool_%d,", name, n);
 392   }
 393   else {
 394     fputs(      "  NULL,", fp);
 395   }
 396   if (irep->syms) {
 397     fprintf(fp, "%s_syms_%d,", name, n);
 398   }
 399   else {
 400     fputs(      "NULL,", fp);
 401   }
 402   if (irep->reps) {
 403     fprintf(fp, "%s_reps_%d,\n", name, n);
 404   }
 405   else {
 406     fputs(      "NULL,\n", fp);
 407   }
 408   if (irep->lv) {
 409     fprintf(fp, "  %s_lv_%d,\n", name, n);
 410   }
 411   else {
 412     fputs(      "  NULL,\t\t\t\t\t/* lv */\n", fp);
 413   }
 414   if (debug_available) {
 415     fprintf(fp, "  &%s_debug_%d,\n", name, n);
 416   }
 417   else {
 418     fputs("  NULL,\t\t\t\t\t/* debug_info */\n", fp);
 419   }
 420   fprintf(fp,   "  %d,%d,%d,%d,0\n};\n", irep->ilen, irep->plen, irep->slen, irep->rlen);
 421
 422   return MRB_DUMP_OK;
 423 }
 424
 425 int
 426 mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
 427 {
 428   if (fp == NULL || initname == NULL || initname[0] == '\0') {
 429     return MRB_DUMP_INVALID_ARGUMENT;
 430   }
 431   if (fprintf(fp, "#include <mruby.h>\n"
 432                   "#include <mruby/irep.h>\n"
 433                   "#include <mruby/debug.h>\n"
 434                   "#include <mruby/proc.h>\n"
 435                   "#include <mruby/presym.h>\n"
 436                   "\n") < 0) {
 437     return MRB_DUMP_WRITE_FAULT;
 438   }
 439   fputs("#define mrb_BRACED(...) {__VA_ARGS__}\n", fp);
 440   fputs("#define mrb_DEFINE_SYMS_VAR(name, len, syms, qualifier) \\\n", fp);
 441   fputs("  static qualifier mrb_sym name[len] = mrb_BRACED syms\n", fp);
 442   fputs("\n", fp);
 443   mrb_value init_syms_code = mrb_str_new_capa(mrb, 0);
 444   int max = 1;
 445   int n = cdump_irep_struct(mrb, irep, flags, fp, initname, 0, init_syms_code, &max);
 446   if (n != MRB_DUMP_OK) return n;
 447   fprintf(fp,
 448           "%s\n"
 449           "const struct RProc %s[] = {{\n",
 450           (flags & MRB_DUMP_STATIC) ? "static"
 451                                     : "#ifdef __cplusplus\n"
 452                                       "extern\n"
 453                                       "#endif",
 454           initname);
 455   fprintf(fp, "NULL,NULL,MRB_TT_PROC,MRB_GC_RED,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname);
 456   fputs("static void\n", fp);
 457   fprintf(fp, "%s_init_syms(mrb_state *mrb)\n", initname);
 458   fputs("{\n", fp);
 459   fputs(RSTRING_PTR(init_syms_code), fp);
 460   fputs("}\n", fp);
 461   return MRB_DUMP_OK;
 462 }
 463 #endif