mono/mini/mini-wasm.c

   1 #include "mini.h"
   2 #include "mini-runtime.h"
   3 #include <mono/metadata/mono-debug.h>
   4 #include <mono/metadata/assembly.h>
   5 #include <mono/metadata/metadata.h>
   6 #include <mono/metadata/loader-internals.h>
   7 #include <mono/metadata/icall-internals.h>
   8 #include <mono/metadata/seq-points-data.h>
   9 #include <mono/mini/aot-runtime.h>
  10 #include <mono/mini/seq-points.h>
  11
  12 //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle
  13 #include <mono/mini/interp/interp-internals.h>
  14
  15 #ifndef DISABLE_JIT
  16
  17 #include "ir-emit.h"
  18 #include "cpu-wasm.h"
  19
  20  //FIXME figure out if we need to distingush between i,l,f,d types
  21 typedef enum {
  22         ArgOnStack,
  23         ArgValuetypeAddrOnStack,
  24         ArgGsharedVTOnStack,
  25         ArgValuetypeAddrInIReg,
  26         ArgInvalid,
  27 } ArgStorage;
  28
  29 typedef struct {
  30         ArgStorage storage : 8;
  31 } ArgInfo;
  32
  33 struct CallInfo {
  34         int nargs;
  35         gboolean gsharedvt;
  36
  37         ArgInfo ret;
  38         ArgInfo args [1];
  39 };
  40
  41 static ArgStorage
  42 get_storage (MonoType *type, gboolean is_return)
  43 {
  44         switch (type->type) {
  45         case MONO_TYPE_I1:
  46         case MONO_TYPE_U1:
  47         case MONO_TYPE_I2:
  48         case MONO_TYPE_U2:
  49         case MONO_TYPE_I4:
  50         case MONO_TYPE_U4:
  51         case MONO_TYPE_I:
  52         case MONO_TYPE_U:
  53         case MONO_TYPE_PTR:
  54         case MONO_TYPE_FNPTR:
  55         case MONO_TYPE_OBJECT:
  56                 return ArgOnStack;
  57
  58         case MONO_TYPE_U8:
  59         case MONO_TYPE_I8:
  60                 return ArgOnStack;
  61
  62         case MONO_TYPE_R4:
  63                 return ArgOnStack;
  64
  65         case MONO_TYPE_R8:
  66                 return ArgOnStack;
  67
  68         case MONO_TYPE_GENERICINST:
  69                 if (!mono_type_generic_inst_is_valuetype (type))
  70                         return ArgOnStack;
  71
  72                 if (mini_is_gsharedvt_type (type)) {
  73                         return ArgGsharedVTOnStack;
  74                 }
  75                 /* fall through */
  76         case MONO_TYPE_VALUETYPE:
  77         case MONO_TYPE_TYPEDBYREF: {
  78                 return is_return ? ArgValuetypeAddrInIReg : ArgValuetypeAddrOnStack;
  79                 break;
  80         }
  81         case MONO_TYPE_VAR:
  82         case MONO_TYPE_MVAR:
  83                 g_assert (mini_is_gsharedvt_type (type));
  84                 return ArgGsharedVTOnStack;
  85                 break;
  86         case MONO_TYPE_VOID:
  87                 g_assert (is_return);
  88                 break;
  89         default:
  90                 g_error ("Can't handle as return value 0x%x", type->type);
  91         }
  92         return ArgInvalid;
  93 }
  94
  95 static CallInfo*
  96 get_call_info (MonoMemPool *mp, MonoMethodSignature *sig)
  97 {
  98         int n = sig->hasthis + sig->param_count;
  99         CallInfo *cinfo;
 100
 101         if (mp)
 102                 cinfo = (CallInfo *)mono_mempool_alloc0 (mp, sizeof (CallInfo) + (sizeof (ArgInfo) * n));
 103         else
 104                 cinfo = (CallInfo *)g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
 105
 106         cinfo->nargs = n;
 107         cinfo->gsharedvt = mini_is_gsharedvt_variable_signature (sig);
 108
 109         /* return value */
 110         cinfo->ret.storage = get_storage (mini_get_underlying_type (sig->ret), TRUE);
 111
 112         if (sig->hasthis)
 113                 cinfo->args [0].storage = ArgOnStack;
 114
 115         // not supported
 116         g_assert (sig->call_convention != MONO_CALL_VARARG);
 117
 118         int i;
 119         for (i = 0; i < sig->param_count; ++i)
 120                 cinfo->args [i + sig->hasthis].storage = get_storage (mini_get_underlying_type (sig->params [i]), FALSE);
 121
 122         return cinfo;
 123 }
 124
 125 gboolean
 126 mono_arch_have_fast_tls (void)
 127 {
 128         return FALSE;
 129 }
 130
 131 guint32
 132 mono_arch_get_patch_offset (guint8 *code)
 133 {
 134         g_error ("mono_arch_get_patch_offset");
 135         return 0;
 136 }
 137 gpointer
 138 mono_arch_ip_from_context (void *sigctx)
 139 {
 140         g_error ("mono_arch_ip_from_context");
 141 }
 142
 143 gboolean
 144 mono_arch_is_inst_imm (int opcode, int imm_opcode, gint64 imm)
 145 {
 146         return TRUE;
 147 }
 148
 149 void
 150 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
 151 {
 152 }
 153
 154 gboolean
 155 mono_arch_opcode_supported (int opcode)
 156 {
 157         return FALSE;
 158 }
 159
 160 void
 161 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 162 {
 163         g_error ("mono_arch_output_basic_block");
 164 }
 165
 166 void
 167 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
 168 {
 169 }
 170
 171 void
 172 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
 173 {
 174 }
 175
 176 guint32
 177 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
 178 {
 179         return 0;
 180 }
 181
 182 GList *
 183 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
 184 {
 185         g_error ("mono_arch_get_allocatable_int_vars");
 186 }
 187
 188 GList *
 189 mono_arch_get_global_int_regs (MonoCompile *cfg)
 190 {
 191         g_error ("mono_arch_get_global_int_regs");
 192 }
 193
 194 void
 195 mono_arch_allocate_vars (MonoCompile *cfg)
 196 {
 197         g_error ("mono_arch_allocate_vars");
 198 }
 199
 200 void
 201 mono_arch_create_vars (MonoCompile *cfg)
 202 {
 203         MonoMethodSignature *sig;
 204         CallInfo *cinfo;
 205         MonoType *sig_ret;
 206
 207         sig = mono_method_signature_internal (cfg->method);
 208
 209         if (!cfg->arch.cinfo)
 210                 cfg->arch.cinfo = get_call_info (cfg->mempool, sig);
 211         cinfo = (CallInfo *)cfg->arch.cinfo;
 212
 213         // if (cinfo->ret.storage == ArgValuetypeInReg)
 214         //      cfg->ret_var_is_local = TRUE;
 215
 216         sig_ret = mini_get_underlying_type (sig->ret);
 217         if (cinfo->ret.storage == ArgValuetypeAddrInIReg || cinfo->ret.storage == ArgGsharedVTOnStack) {
 218                 cfg->vret_addr = mono_compile_create_var (cfg, mono_get_int_type (), OP_ARG);
 219                 if (G_UNLIKELY (cfg->verbose_level > 1)) {
 220                         printf ("vret_addr = ");
 221                         mono_print_ins (cfg->vret_addr);
 222                 }
 223         }
 224
 225         if (cfg->gen_sdb_seq_points)
 226                 g_error ("gen_sdb_seq_points not supported");
 227
 228         if (cfg->method->save_lmf)
 229                 cfg->create_lmf_var = TRUE;
 230
 231         if (cfg->method->save_lmf)
 232                 cfg->lmf_ir = TRUE;
 233 }
 234
 235 void
 236 mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
 237 {
 238         g_error ("mono_arch_emit_call");
 239 }
 240
 241 void
 242 mono_arch_emit_epilog (MonoCompile *cfg)
 243 {
 244         g_error ("mono_arch_emit_epilog");
 245 }
 246
 247 void
 248 mono_arch_emit_exceptions (MonoCompile *cfg)
 249 {
 250         g_error ("mono_arch_emit_exceptions");
 251 }
 252
 253 MonoInst*
 254 mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
 255 {
 256         return NULL;
 257 }
 258
 259 void
 260 mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
 261 {
 262         g_error ("mono_arch_emit_outarg_vt");
 263 }
 264
 265 guint8 *
 266 mono_arch_emit_prolog (MonoCompile *cfg)
 267 {
 268         g_error ("mono_arch_emit_prolog");
 269 }
 270
 271 void
 272 mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
 273 {
 274         MonoType *ret = mini_get_underlying_type (mono_method_signature_internal (method)->ret);
 275
 276         if (!ret->byref) {
 277                 if (ret->type == MONO_TYPE_R4) {
 278                         MONO_EMIT_NEW_UNALU (cfg, cfg->r4fp ? OP_RMOVE : OP_FMOVE, cfg->ret->dreg, val->dreg);
 279                         return;
 280                 } else if (ret->type == MONO_TYPE_R8) {
 281                         MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, cfg->ret->dreg, val->dreg);
 282                         return;
 283                 } else if (ret->type == MONO_TYPE_I8 || ret->type == MONO_TYPE_U8) {
 284                         MONO_EMIT_NEW_UNALU (cfg, OP_LMOVE, cfg->ret->dreg, val->dreg);
 285                         return;
 286                 }
 287         }
 288         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg, val->dreg);
 289 }
 290
 291 void
 292 mono_arch_flush_icache (guint8 *code, gint size)
 293 {
 294 }
 295
 296 LLVMCallInfo*
 297 mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
 298 {
 299         int i, n;
 300         CallInfo *cinfo;
 301         LLVMCallInfo *linfo;
 302
 303         cinfo = get_call_info (cfg->mempool, sig);
 304         n = cinfo->nargs;
 305
 306         linfo = mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMCallInfo) + (sizeof (LLVMArgInfo) * n));
 307
 308         if (mini_type_is_vtype (sig->ret)) {
 309                 /* Vtype returned using a hidden argument */
 310                 linfo->ret.storage = LLVMArgVtypeRetAddr;
 311                 // linfo->vret_arg_index = cinfo->vret_arg_index;
 312         } else {
 313                 if (sig->ret->type != MONO_TYPE_VOID)
 314                         linfo->ret.storage = LLVMArgNormal;
 315         }
 316
 317         for (i = 0; i < n; ++i) {
 318                 ArgInfo *ainfo = &cinfo->args[i];
 319
 320                 switch (ainfo->storage) {
 321                 case ArgOnStack:
 322                         linfo->args [i].storage = LLVMArgNormal;
 323                         break;
 324                 case ArgValuetypeAddrOnStack:
 325                         linfo->args [i].storage = LLVMArgVtypeByRef;
 326                         break;
 327                 case ArgGsharedVTOnStack:
 328                         linfo->args [i].storage = LLVMArgGsharedvtVariable;
 329                         break;
 330                 case ArgValuetypeAddrInIReg:
 331                         g_error ("this is only valid for sig->ret");
 332                         break;
 333                 }
 334         }
 335
 336         return linfo;
 337 }
 338
 339 gboolean
 340 mono_arch_tailcall_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig, gboolean virtual_)
 341 {
 342         return FALSE;
 343 }
 344
 345 #endif // DISABLE_JIT
 346
 347 const char*
 348 mono_arch_fregname (int reg)
 349 {
 350         return "freg0";
 351 }
 352
 353 const char*
 354 mono_arch_regname (int reg)
 355 {
 356         return "r0";
 357 }
 358
 359 int
 360 mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
 361 {
 362         g_error ("mono_arch_get_argument_info");
 363 }
 364
 365 GSList*
 366 mono_arch_get_delegate_invoke_impls (void)
 367 {
 368         g_error ("mono_arch_get_delegate_invoke_impls");
 369 }
 370
 371 gpointer
 372 mono_arch_get_gsharedvt_call_info (gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig, gboolean gsharedvt_in, gint32 vcall_offset, gboolean calli)
 373 {
 374         g_error ("mono_arch_get_gsharedvt_call_info");
 375         return NULL;
 376 }
 377
 378 gpointer
 379 mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target)
 380 {
 381         g_error ("mono_arch_get_delegate_invoke_impl");
 382 }
 383
 384 #ifdef HOST_WASM
 385
 386 #include <emscripten.h>
 387
 388 //functions exported to be used by JS
 389 G_BEGIN_DECLS
 390 EMSCRIPTEN_KEEPALIVE void mono_set_timeout_exec (int id);
 391
 392 //JS functions imported that we use
 393 extern void mono_set_timeout (int t, int d);
 394 G_END_DECLS
 395
 396 #endif // HOST_WASM
 397
 398 gpointer
 399 mono_arch_get_this_arg_from_call (host_mgreg_t *regs, guint8 *code)
 400 {
 401         g_error ("mono_arch_get_this_arg_from_call");
 402 }
 403
 404 gpointer
 405 mono_arch_get_delegate_virtual_invoke_impl (MonoMethodSignature *sig, MonoMethod *method, int offset, gboolean load_imt_reg)
 406 {
 407         g_error ("mono_arch_get_delegate_virtual_invoke_impl");
 408 }
 409
 410
 411 void
 412 mono_arch_cpu_init (void)
 413 {
 414         // printf ("mono_arch_cpu_init\n");
 415 }
 416
 417 void
 418 mono_arch_finish_init (void)
 419 {
 420         // printf ("mono_arch_finish_init\n");
 421 }
 422
 423 void
 424 mono_arch_init (void)
 425 {
 426         // printf ("mono_arch_init\n");
 427 }
 428
 429 void
 430 mono_arch_cleanup (void)
 431 {
 432 }
 433
 434 void
 435 mono_arch_register_lowlevel_calls (void)
 436 {
 437 }
 438
 439 void
 440 mono_arch_flush_register_windows (void)
 441 {
 442 }
 443
 444 MonoMethod*
 445 mono_arch_find_imt_method (host_mgreg_t *regs, guint8 *code)
 446 {
 447         g_error ("mono_arch_find_static_call_vtable");
 448         return (MonoMethod*) regs [MONO_ARCH_IMT_REG];
 449 }
 450
 451 MonoVTable*
 452 mono_arch_find_static_call_vtable (host_mgreg_t *regs, guint8 *code)
 453 {
 454         g_error ("mono_arch_find_static_call_vtable");
 455         return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
 456 }
 457
 458 gpointer
 459 mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp)
 460 {
 461         g_error ("mono_arch_build_imt_trampoline");
 462 }
 463
 464 guint32
 465 mono_arch_cpu_enumerate_simd_versions (void)
 466 {
 467         return 0;
 468 }
 469
 470 guint32
 471 mono_arch_cpu_optimizations (guint32 *exclude_mask)
 472 {
 473         /* No arch specific passes yet */
 474         *exclude_mask = 0;
 475         return 0;
 476 }
 477
 478 host_mgreg_t
 479 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
 480 {
 481         g_error ("mono_arch_context_get_int_reg");
 482         return 0;
 483 }
 484
 485 #ifdef HOST_WASM
 486
 487 void
 488 mono_runtime_setup_stat_profiler (void)
 489 {
 490         g_error ("mono_runtime_setup_stat_profiler");
 491 }
 492
 493
 494 void
 495 mono_runtime_shutdown_stat_profiler (void)
 496 {
 497         g_error ("mono_runtime_shutdown_stat_profiler");
 498 }
 499
 500
 501 gboolean
 502 MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal)
 503 {
 504         g_error ("mono_chain_signal");
 505
 506         return FALSE;
 507 }
 508
 509 void
 510 mono_runtime_install_handlers (void)
 511 {
 512 }
 513
 514 void
 515 mono_runtime_cleanup_handlers (void)
 516 {
 517 }
 518
 519 void
 520 mono_init_native_crash_info (void)
 521 {
 522         return;
 523 }
 524
 525 void
 526 mono_cleanup_native_crash_info (void)
 527 {
 528         return;
 529 }
 530
 531 gboolean
 532 mono_thread_state_init_from_handle (MonoThreadUnwindState *tctx, MonoThreadInfo *info, void *sigctx)
 533 {
 534         g_error ("WASM systems don't support mono_thread_state_init_from_handle");
 535         return FALSE;
 536 }
 537
 538 EMSCRIPTEN_KEEPALIVE void
 539 mono_set_timeout_exec (int id)
 540 {
 541         ERROR_DECL (error);
 542         MonoClass *klass = mono_class_load_from_name (mono_defaults.corlib, "System.Threading", "WasmRuntime");
 543         g_assert (klass);
 544
 545         MonoMethod *method = mono_class_get_method_from_name_checked (klass, "TimeoutCallback", -1, 0, error);
 546         mono_error_assert_ok (error);
 547         g_assert (method);
 548
 549         gpointer params[1] = { &id };
 550         MonoObject *exc = NULL;
 551
 552         mono_runtime_try_invoke (method, NULL, params, &exc, error);
 553
 554         //YES we swallow exceptions cuz there's nothing much we can do from here.
 555         //FIXME Maybe call the unhandled exception function?
 556         if (!is_ok (error)) {
 557                 printf ("timeout callback failed due to %s\n", mono_error_get_message (error));
 558                 mono_error_cleanup (error);
 559         }
 560
 561         if (exc) {
 562                 char *type_name = mono_type_get_full_name (mono_object_class (exc));
 563                 printf ("timeout callback threw a %s\n", type_name);
 564                 g_free (type_name);
 565         }
 566 }
 567
 568 #endif
 569
 570 void
 571 mono_wasm_set_timeout (int timeout, int id)
 572 {
 573 #ifdef HOST_WASM
 574         mono_set_timeout (timeout, id);
 575 #endif
 576 }
 577
 578 void
 579 mono_arch_register_icall (void)
 580 {
 581         mono_add_internal_call_internal ("System.Threading.WasmRuntime::SetTimeout", mono_wasm_set_timeout);
 582 }
 583
 584 void
 585 mono_arch_patch_code_new (MonoCompile *cfg, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gpointer target)
 586 {
 587         g_error ("mono_arch_patch_code_new");
 588 }
 589
 590 #ifdef HOST_WASM
 591
 592 /*
 593 The following functions don't belong here, but are due to laziness.
 594 */
 595 gboolean mono_w32file_get_file_system_type (const gunichar2 *path, gunichar2 *fsbuffer, gint fsbuffersize);
 596
 597 G_BEGIN_DECLS
 598
 599 void * getgrnam (const char *name);
 600 void * getgrgid (gid_t gid);
 601 int inotify_init (void);
 602 int inotify_rm_watch (int fd, int wd);
 603 int inotify_add_watch (int fd, const char *pathname, uint32_t mask);
 604 int sem_timedwait (sem_t *sem, const struct timespec *abs_timeout);
 605
 606 G_END_DECLS
 607
 608 //w32file-wasm.c
 609 gboolean
 610 mono_w32file_get_file_system_type (const gunichar2 *path, gunichar2 *fsbuffer, gint fsbuffersize)
 611 {
 612         glong len;
 613         gboolean status = FALSE;
 614
 615         gunichar2 *ret = g_utf8_to_utf16 ("memfs", -1, NULL, &len, NULL);
 616         if (ret != NULL && len < fsbuffersize) {
 617                 memcpy (fsbuffer, ret, len * sizeof (gunichar2));
 618                 fsbuffer [len] = 0;
 619                 status = TRUE;
 620         }
 621         if (ret != NULL)
 622                 g_free (ret);
 623
 624         return status;
 625 }
 626
 627 G_BEGIN_DECLS
 628
 629 //llvm builtin's that we should not have used in the first place
 630
 631 #include <sys/types.h>
 632 #include <pwd.h>
 633 #include <uuid/uuid.h>
 634
 635 #ifndef __EMSCRIPTEN_PTHREADS__
 636 int pthread_getschedparam (pthread_t thread, int *policy, struct sched_param *param)
 637 {
 638         g_error ("pthread_getschedparam");
 639         return 0;
 640 }
 641 #endif
 642
 643 int
 644 pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
 645 {
 646         return 0;
 647 }
 648
 649 int
 650 pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
 651 {
 652         return 0;
 653 }
 654
 655
 656 int
 657 sigsuspend(const sigset_t *sigmask)
 658 {
 659         g_error ("sigsuspend");
 660         return 0;
 661 }
 662
 663 int
 664 getdtablesize (void)
 665 {
 666         return 256; //random constant that is the fd limit
 667 }
 668
 669 void *
 670 getgrnam (const char *name)
 671 {
 672         return NULL;
 673 }
 674
 675 void *
 676 getgrgid (gid_t gid)
 677 {
 678         return NULL;
 679 }
 680
 681 int
 682 inotify_init (void)
 683 {
 684         g_error ("inotify_init");
 685 }
 686
 687 int
 688 inotify_rm_watch (int fd, int wd)
 689 {
 690         g_error ("inotify_rm_watch");
 691         return 0;
 692 }
 693
 694 int
 695 inotify_add_watch (int fd, const char *pathname, uint32_t mask)
 696 {
 697         g_error ("inotify_add_watch");
 698         return 0;
 699 }
 700
 701 #ifndef __EMSCRIPTEN_PTHREADS__
 702 int
 703 sem_timedwait (sem_t *sem, const struct timespec *abs_timeout)
 704 {
 705         g_error ("sem_timedwait");
 706         return 0;
 707 }
 708 #endif
 709
 710 ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
 711
 712 ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
 713 {
 714         g_error ("sendfile");
 715         return 0;
 716 }
 717
 718 int
 719 getpwnam_r (const char *name, struct passwd *pwd, char *buffer, size_t bufsize,
 720                         struct passwd **result)
 721 {
 722         g_error ("getpwnam_r");
 723         return 0;
 724 }
 725
 726 int
 727 getpwuid_r (uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize,
 728                         struct passwd **result)
 729 {
 730         g_error ("getpwuid_r");
 731         return 0;
 732 }
 733
 734 G_END_DECLS
 735
 736 #endif // HOST_WASM
 737
 738 gpointer
 739 mono_arch_load_function (MonoJitICallId jit_icall_id)
 740 {
 741         return NULL;
 742 }