mono/mini/mini-riscv.c

   1 /*
   2  * Licensed to the .NET Foundation under one or more agreements.
   3  * The .NET Foundation licenses this file to you under the MIT license.
   4  * See the LICENSE file in the project root for more information.
   5  */
   6
   7 #include <mono/utils/mono-hwcap.h>
   8
   9 #include "mini-runtime.h"
  10
  11 #ifdef TARGET_RISCV64
  12 #include "cpu-riscv64.h"
  13 #else
  14 #include "cpu-riscv32.h"
  15 #endif
  16
  17 static gboolean riscv_stdext_a, riscv_stdext_b, riscv_stdext_c,
  18                 riscv_stdext_d, riscv_stdext_f, riscv_stdext_j,
  19                 riscv_stdext_l, riscv_stdext_m, riscv_stdext_n,
  20                 riscv_stdext_p, riscv_stdext_q, riscv_stdext_t,
  21                 riscv_stdext_v;
  22
  23 void
  24 mono_arch_cpu_init (void)
  25 {
  26 }
  27
  28 void
  29 mono_arch_init (void)
  30 {
  31         riscv_stdext_a = mono_hwcap_riscv_has_stdext_a;
  32         riscv_stdext_c = mono_hwcap_riscv_has_stdext_c;
  33         riscv_stdext_d = mono_hwcap_riscv_has_stdext_d;
  34         riscv_stdext_f = mono_hwcap_riscv_has_stdext_f;
  35         riscv_stdext_m = mono_hwcap_riscv_has_stdext_m;
  36 }
  37
  38 void
  39 mono_arch_finish_init (void)
  40 {
  41 }
  42
  43 void
  44 mono_arch_register_lowlevel_calls (void)
  45 {
  46 }
  47
  48 void
  49 mono_arch_cleanup (void)
  50 {
  51 }
  52
  53 void
  54 mono_arch_set_target (char *mtriple)
  55 {
  56         // riscv{32,64}[extensions]-[<vendor>-]<system>-<abi>
  57
  58         size_t len = strlen (MONO_RISCV_ARCHITECTURE);
  59
  60         if (!strncmp (mtriple, MONO_RISCV_ARCHITECTURE, len)) {
  61                 mtriple += len;
  62
  63                 for (;;) {
  64                         char c = *mtriple;
  65
  66                         if (!c || c == '-')
  67                                 break;
  68
  69                         // ISA manual says upper and lower case are both OK.
  70                         switch (c) {
  71                         case 'A':
  72                         case 'a':
  73                                 riscv_stdext_a = TRUE;
  74                                 break;
  75                         case 'B':
  76                         case 'b':
  77                                 riscv_stdext_b = TRUE;
  78                                 break;
  79                         case 'C':
  80                         case 'c':
  81                                 riscv_stdext_c = TRUE;
  82                                 break;
  83                         case 'D':
  84                         case 'd':
  85                                 riscv_stdext_d = TRUE;
  86                                 break;
  87                         case 'F':
  88                         case 'f':
  89                                 riscv_stdext_f = TRUE;
  90                                 break;
  91                         case 'J':
  92                         case 'j':
  93                                 riscv_stdext_j = TRUE;
  94                                 break;
  95                         case 'L':
  96                         case 'l':
  97                                 riscv_stdext_l = TRUE;
  98                                 break;
  99                         case 'M':
 100                         case 'm':
 101                                 riscv_stdext_m = TRUE;
 102                                 break;
 103                         case 'N':
 104                         case 'n':
 105                                 riscv_stdext_n = TRUE;
 106                                 break;
 107                         case 'P':
 108                         case 'p':
 109                                 riscv_stdext_p = TRUE;
 110                                 break;
 111                         case 'Q':
 112                         case 'q':
 113                                 riscv_stdext_q = TRUE;
 114                                 break;
 115                         case 'T':
 116                         case 't':
 117                                 riscv_stdext_t = TRUE;
 118                                 break;
 119                         case 'V':
 120                         case 'v':
 121                                 riscv_stdext_v = TRUE;
 122                                 break;
 123                         default:
 124                                 break;
 125                         }
 126
 127                         mtriple++;
 128                 }
 129         }
 130 }
 131
 132 guint32
 133 mono_arch_cpu_optimizations (guint32 *exclude_mask)
 134 {
 135         *exclude_mask = 0;
 136         return 0;
 137 }
 138
 139 guint32
 140 mono_arch_cpu_enumerate_simd_versions (void)
 141 {
 142         return 0;
 143 }
 144
 145 gboolean
 146 mono_arch_have_fast_tls (void)
 147 {
 148         return TRUE;
 149 }
 150
 151 gboolean
 152 mono_arch_opcode_supported (int opcode)
 153 {
 154         switch (opcode) {
 155         case OP_ATOMIC_ADD_I4:
 156         case OP_ATOMIC_EXCHANGE_I4:
 157         case OP_ATOMIC_CAS_I4:
 158         case OP_ATOMIC_LOAD_I1:
 159         case OP_ATOMIC_LOAD_I2:
 160         case OP_ATOMIC_LOAD_I4:
 161         case OP_ATOMIC_LOAD_U1:
 162         case OP_ATOMIC_LOAD_U2:
 163         case OP_ATOMIC_LOAD_U4:
 164         case OP_ATOMIC_STORE_I1:
 165         case OP_ATOMIC_STORE_I2:
 166         case OP_ATOMIC_STORE_I4:
 167         case OP_ATOMIC_STORE_U1:
 168         case OP_ATOMIC_STORE_U2:
 169         case OP_ATOMIC_STORE_U4:
 170 #ifdef TARGET_RISCV64
 171         case OP_ATOMIC_ADD_I8:
 172         case OP_ATOMIC_EXCHANGE_I8:
 173         case OP_ATOMIC_CAS_I8:
 174         case OP_ATOMIC_LOAD_I8:
 175         case OP_ATOMIC_LOAD_U8:
 176         case OP_ATOMIC_STORE_I8:
 177         case OP_ATOMIC_STORE_U8:
 178 #endif
 179                 return riscv_stdext_a;
 180         case OP_ATOMIC_LOAD_R4:
 181         case OP_ATOMIC_STORE_R4:
 182 #ifdef TARGET_RISCV64
 183         case OP_ATOMIC_LOAD_R8:
 184         case OP_ATOMIC_STORE_R8:
 185 #endif
 186                 return riscv_stdext_a && riscv_stdext_d;
 187         default:
 188                 return FALSE;
 189         }
 190 }
 191
 192 const char *
 193 mono_arch_regname (int reg)
 194 {
 195     static const char *names [RISCV_N_GREGS] = {
 196                 "zero", "ra", "sp",  "gp",  "tp", "t0", "t1", "t2",
 197                 "s0",   "s1", "a0",  "a1",  "a2", "a3", "a4", "a5",
 198                 "a6",   "a7", "s2",  "s3",  "s4", "s5", "s6", "s7",
 199                 "s8",   "s9", "s10", "s11", "t3", "t4", "t5", "t6",
 200     };
 201
 202     if (reg >= 0 && reg < G_N_ELEMENTS (names))
 203         return names [reg];
 204
 205     return "x?";
 206 }
 207
 208 const char*
 209 mono_arch_fregname (int reg)
 210 {
 211     static const char *names [RISCV_N_FREGS] = {
 212                 "ft0", "ft1", "ft2",  "ft3",  "ft4", "ft5", "ft6",  "ft7",
 213                 "fs0", "fs1", "fa0",  "fa1",  "fa2", "fa3", "fa4",  "fa5",
 214                 "fa6", "fa7", "fs2",  "fs3",  "fs4", "fs5", "fs6",  "fs7",
 215                 "fs8", "fs9", "fs10", "fs11", "ft8", "ft9", "ft10", "ft11",
 216     };
 217
 218     if (reg >= 0 && reg < G_N_ELEMENTS (names))
 219         return names [reg];
 220
 221     return "f?";
 222 }
 223
 224 gpointer
 225 mono_arch_get_this_arg_from_call (host_mgreg_t *regs, guint8 *code)
 226 {
 227         return (gpointer) regs [RISCV_A0];
 228 }
 229
 230 MonoMethod *
 231 mono_arch_find_imt_method (host_mgreg_t *regs, guint8 *code)
 232 {
 233         return (MonoMethod *) regs [MONO_ARCH_IMT_REG];
 234 }
 235
 236 MonoVTable *
 237 mono_arch_find_static_call_vtable (host_mgreg_t *regs, guint8 *code)
 238 {
 239         return (MonoVTable *) regs [MONO_ARCH_VTABLE_REG];
 240 }
 241
 242 host_mgreg_t
 243 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
 244 {
 245         return ctx->gregs [reg];
 246 }
 247
 248 void
 249 mono_arch_context_set_int_reg (MonoContext *ctx, int reg, host_mgreg_t val)
 250 {
 251         ctx->gregs [reg] = val;
 252 }
 253
 254 void
 255 mono_arch_flush_register_windows (void)
 256 {
 257 }
 258
 259 void
 260 mono_arch_flush_icache (guint8 *code, gint size)
 261 {
 262 #ifndef MONO_CROSS_COMPILE
 263         __builtin___clear_cache (code, code + size);
 264 #endif
 265 }
 266
 267 MonoDynCallInfo *
 268 mono_arch_dyn_call_prepare (MonoMethodSignature *sig)
 269 {
 270         NOT_IMPLEMENTED;
 271         return NULL;
 272 }
 273
 274 void
 275 mono_arch_dyn_call_free (MonoDynCallInfo *info)
 276 {
 277         NOT_IMPLEMENTED;
 278 }
 279
 280 int
 281 mono_arch_dyn_call_get_buf_size (MonoDynCallInfo *info)
 282 {
 283         NOT_IMPLEMENTED;
 284         return 0;
 285 }
 286
 287 void
 288 mono_arch_start_dyn_call (MonoDynCallInfo *info, gpointer **args, guint8 *ret,
 289                           guint8 *buf)
 290 {
 291         NOT_IMPLEMENTED;
 292 }
 293
 294 void
 295 mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf)
 296 {
 297         NOT_IMPLEMENTED;
 298 }
 299
 300 int
 301 mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count,
 302                              MonoJitArgumentInfo *arg_info)
 303 {
 304     NOT_IMPLEMENTED;
 305     return 0;
 306 }
 307
 308 void
 309 mono_arch_patch_code_new (MonoCompile *cfg, MonoDomain *domain, guint8 *code,
 310                           MonoJumpInfo *ji, gpointer target)
 311 {
 312         NOT_IMPLEMENTED;
 313 }
 314
 315 /* Set arguments in the ccontext (for i2n entry) */
 316 void
 317 mono_arch_set_native_call_context_args (CallContext *ccontext, gpointer frame, MonoMethodSignature *sig)
 318 {
 319         NOT_IMPLEMENTED;
 320 }
 321
 322 /* Set return value in the ccontext (for n2i return) */
 323 void
 324 mono_arch_set_native_call_context_ret (CallContext *ccontext, gpointer frame, MonoMethodSignature *sig)
 325 {
 326         NOT_IMPLEMENTED;
 327 }
 328
 329 /* Gets the arguments from ccontext (for n2i entry) */
 330 void
 331 mono_arch_get_native_call_context_args (CallContext *ccontext, gpointer frame, MonoMethodSignature *sig)
 332 {
 333         NOT_IMPLEMENTED;
 334 }
 335
 336 /* Gets the return value from ccontext (for i2n exit) */
 337 void
 338 mono_arch_get_native_call_context_ret (CallContext *ccontext, gpointer frame, MonoMethodSignature *sig)
 339 {
 340         NOT_IMPLEMENTED;
 341 }
 342
 343 #ifndef DISABLE_JIT
 344
 345 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
 346
 347 gboolean
 348 mono_arch_is_soft_float (void)
 349 {
 350         return !riscv_stdext_d;
 351 }
 352
 353 #endif
 354
 355 gboolean
 356 mono_arch_opcode_needs_emulation (MonoCompile *cfg, int opcode)
 357 {
 358         switch (opcode) {
 359         case OP_IDIV:
 360         case OP_IDIV_UN:
 361         case OP_IREM:
 362         case OP_IREM_UN:
 363 #ifdef TARGET_RISCV64
 364         case OP_LDIV:
 365         case OP_LDIV_UN:
 366         case OP_LREM:
 367         case OP_LREM_UN:
 368 #endif
 369                 return !riscv_stdext_m;
 370         default:
 371                 return TRUE;
 372         }
 373 }
 374
 375 gboolean
 376 mono_arch_tailcall_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig, gboolean virtual_)
 377 {
 378         NOT_IMPLEMENTED;
 379 }
 380
 381 gboolean
 382 mono_arch_is_inst_imm (int opcode, int imm_opcode, gint64 imm)
 383 {
 384         // TODO: Make a proper decision based on opcode.
 385         return TRUE;
 386 }
 387
 388 GList *
 389 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
 390 {
 391         GList *vars = NULL;
 392
 393         for (guint i = 0; i < cfg->num_varinfo; i++) {
 394                 MonoInst *ins = cfg->varinfo [i];
 395                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
 396
 397                 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
 398                         continue;
 399
 400                 if ((ins->flags & (MONO_INST_IS_DEAD | MONO_INST_VOLATILE | MONO_INST_INDIRECT)) ||
 401                     (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
 402                         continue;
 403
 404                 if (!mono_is_regsize_var (ins->inst_vtype))
 405                         continue;
 406
 407                 vars = g_list_prepend (vars, vmv);
 408         }
 409
 410         vars = mono_varlist_sort (cfg, vars, 0);
 411
 412         return vars;
 413 }
 414
 415 GList *
 416 mono_arch_get_global_int_regs (MonoCompile *cfg)
 417 {
 418         GList *regs = NULL;
 419
 420         for (int i = RISCV_S0; i <= RISCV_S11; i++)
 421                 regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
 422
 423         return regs;
 424 }
 425
 426 guint32
 427 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
 428 {
 429         return cfg->varinfo [vmv->idx]->opcode == OP_ARG ? 1 : 2;
 430 }
 431
 432 #ifdef ENABLE_LLVM
 433
 434 LLVMCallInfo*
 435 mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
 436 {
 437         NOT_IMPLEMENTED;
 438 }
 439
 440 #endif
 441
 442 void
 443 mono_arch_create_vars (MonoCompile *cfg)
 444 {
 445         NOT_IMPLEMENTED;
 446 }
 447
 448 MonoInst *
 449 mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod,
 450                                 MonoMethodSignature *fsig, MonoInst **args)
 451 {
 452         return NULL;
 453 }
 454
 455 void
 456 mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
 457 {
 458         NOT_IMPLEMENTED;
 459 }
 460
 461 void
 462 mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
 463 {
 464         NOT_IMPLEMENTED;
 465 }
 466
 467 void
 468 mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
 469 {
 470         NOT_IMPLEMENTED;
 471 }
 472
 473 void
 474 mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins)
 475 {
 476         NOT_IMPLEMENTED;
 477 }
 478
 479 void
 480 mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *long_ins)
 481 {
 482 #ifdef TARGET_RISCV32
 483         NOT_IMPLEMENTED;
 484 #endif
 485 }
 486
 487 void
 488 mono_arch_allocate_vars (MonoCompile *cfg)
 489 {
 490         NOT_IMPLEMENTED;
 491 }
 492
 493 void
 494 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
 495 {
 496         NOT_IMPLEMENTED;
 497 }
 498
 499 void
 500 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
 501 {
 502 }
 503
 504 void
 505 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
 506 {
 507 }
 508
 509 // Uses at most 8 bytes on RV32I and 16 bytes on RV64I.
 510 guint8 *
 511 mono_riscv_emit_imm (guint8 *code, int rd, gsize imm)
 512 {
 513 #ifdef TARGET_RISCV64
 514         if (RISCV_VALID_I_IMM (imm)) {
 515                 riscv_addi (code, rd, RISCV_ZERO, imm);
 516                 return code;
 517         }
 518
 519         /*
 520          * This is not pretty, but RV64I doesn't make it easy to load constants.
 521          * Need to figure out something better.
 522          */
 523         riscv_jal (code, rd, sizeof (guint64));
 524         *(guint64 *) code = imm;
 525         code += sizeof (guint64);
 526         riscv_ld (code, rd, rd, 0);
 527 #else
 528         if (RISCV_VALID_I_IMM (imm)) {
 529                 riscv_addi (code, rd, RISCV_ZERO, imm);
 530                 return code;
 531         }
 532
 533         riscv_lui (code, rd, RISCV_BITS (imm, 12, 20));
 534
 535         if (!RISCV_VALID_U_IMM (imm))
 536                 riscv_ori (code, rd, rd, RISCV_BITS (imm, 0, 12));
 537 #endif
 538
 539         return code;
 540 }
 541
 542 // Uses at most 16 bytes on RV32I and 24 bytes on RV64I.
 543 guint8 *
 544 mono_riscv_emit_load (guint8 *code, int rd, int rs1, gint32 imm)
 545 {
 546         if (RISCV_VALID_I_IMM (imm)) {
 547 #ifdef TARGET_RISCV64
 548                 riscv_ld (code, rd, rs1, imm);
 549 #else
 550                 riscv_lw (code, rd, rs1, imm);
 551 #endif
 552         } else {
 553                 code = mono_riscv_emit_imm (code, rd, imm);
 554                 riscv_add (code, rd, rs1, rd);
 555 #ifdef TARGET_RISCV64
 556                 riscv_ld (code, rd, rd, 0);
 557 #else
 558                 riscv_lw (code, rd, rd, 0);
 559 #endif
 560         }
 561
 562         return code;
 563 }
 564
 565 // May clobber t1. Uses at most 16 bytes on RV32I and 24 bytes on RV64I.
 566 guint8 *
 567 mono_riscv_emit_store (guint8 *code, int rs1, int rs2, gint32 imm)
 568 {
 569         if (RISCV_VALID_S_IMM (imm)) {
 570 #ifdef TARGET_RISCV64
 571                 riscv_sd (code, rs1, rs2, imm);
 572 #else
 573                 riscv_sw (code, rs1, rs2, imm);
 574 #endif
 575         } else {
 576                 code = mono_riscv_emit_imm (code, RISCV_T1, imm);
 577                 riscv_add (code, RISCV_T1, rs2, RISCV_T1);
 578 #ifdef TARGET_RISCV64
 579                 riscv_sd (code, rs1, RISCV_T1, 0);
 580 #else
 581                 riscv_sw (code, rs1, RISCV_T1, 0);
 582 #endif
 583         }
 584
 585         return code;
 586 }
 587
 588 guint8 *
 589 mono_arch_emit_prolog (MonoCompile *cfg)
 590 {
 591         NOT_IMPLEMENTED;
 592 }
 593
 594 void
 595 mono_arch_emit_epilog (MonoCompile *cfg)
 596 {
 597         NOT_IMPLEMENTED;
 598 }
 599
 600 void
 601 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 602 {
 603         NOT_IMPLEMENTED;
 604 }
 605
 606 void
 607 mono_arch_emit_exceptions (MonoCompile *cfg)
 608 {
 609         NOT_IMPLEMENTED;
 610 }
 611
 612 guint32
 613 mono_arch_get_patch_offset (guint8 *code)
 614 {
 615         NOT_IMPLEMENTED;
 616         return 0;
 617 }
 618
 619 GSList *
 620 mono_arch_get_trampolines (gboolean aot)
 621 {
 622         NOT_IMPLEMENTED;
 623         return NULL;
 624 }
 625
 626 #endif
 627
 628 #if defined(MONO_ARCH_SOFT_DEBUG_SUPPORTED)
 629 void
 630 mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip)
 631 {
 632         NOT_IMPLEMENTED;
 633 }
 634
 635 void
 636 mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip)
 637 {
 638         NOT_IMPLEMENTED;
 639 }
 640
 641 void
 642 mono_arch_start_single_stepping (void)
 643 {
 644         NOT_IMPLEMENTED;
 645 }
 646
 647 void
 648 mono_arch_stop_single_stepping (void)
 649 {
 650         NOT_IMPLEMENTED;
 651 }
 652
 653 gboolean
 654 mono_arch_is_single_step_event (void *info, void *sigctx)
 655 {
 656         NOT_IMPLEMENTED;
 657         return FALSE;
 658 }
 659
 660 gboolean
 661 mono_arch_is_breakpoint_event (void *info, void *sigctx)
 662 {
 663         NOT_IMPLEMENTED;
 664         return FALSE;
 665 }
 666
 667 void
 668 mono_arch_skip_breakpoint (MonoContext *ctx, MonoJitInfo *ji)
 669 {
 670         NOT_IMPLEMENTED;
 671 }
 672
 673 void
 674 mono_arch_skip_single_step (MonoContext *ctx)
 675 {
 676         NOT_IMPLEMENTED;
 677 }
 678
 679 gpointer
 680 mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code)
 681 {
 682         NOT_IMPLEMENTED;
 683         return NULL;
 684 }
 685 #endif /* MONO_ARCH_SOFT_DEBUG_SUPPORTED */
 686
 687 gpointer
 688 mono_arch_load_function (MonoJitICallId jit_icall_id)
 689 {
 690         return NULL;
 691 }