mono/mini/mini-native-types.c

   1 /**
   2  * \file
   3  * intrinsics for variable sized int/floats
   4  *
   5  * Author:
   6  *   Rodrigo Kumpera (kumpera@gmail.com)
   7  *
   8  * (C) 2013 Xamarin
   9  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  10  */
  11
  12 #include <config.h>
  13 #include <stdio.h>
  14
  15 #include "mini.h"
  16 #include "ir-emit.h"
  17 #include "glib.h"
  18
  19
  20 typedef struct {
  21         const char *op_name;
  22         short op_table[4];
  23 } IntIntrisic;
  24
  25 typedef struct {
  26         short op_index;
  27 #ifdef __cplusplus
  28         MonoStackType big_stack_type : 16;
  29         MonoStackType small_stack_type : 16;
  30         MonoStackType stack_type : 16;
  31 #else
  32         short big_stack_type;
  33         short small_stack_type;
  34         short stack_type;
  35 #endif
  36         short conv_4_to_8;
  37         short conv_8_to_4;
  38         short move;
  39         short inc_op;
  40         short dec_op;
  41         short store_op;
  42         short compare_op;
  43 } MagicTypeInfo;
  44
  45
  46 #if TARGET_SIZEOF_VOID_P == 8
  47 #define OP_PT_ADD OP_LADD
  48 #define OP_PT_SUB OP_LSUB
  49 #define OP_PT_MUL OP_LMUL
  50 #define OP_PT_DIV OP_LDIV
  51 #define OP_PT_REM OP_LREM
  52 #define OP_PT_NEG OP_LNEG
  53 #define OP_PT_AND OP_LAND
  54 #define OP_PT_OR OP_LOR
  55 #define OP_PT_XOR OP_LXOR
  56 #define OP_PT_NOT OP_LNOT
  57 #define OP_PT_SHL OP_LSHL
  58 #define OP_PT_SHR OP_LSHR
  59
  60 #define OP_PT_DIV_UN OP_LDIV_UN
  61 #define OP_PT_REM_UN OP_LREM_UN
  62 #define OP_PT_SHR_UN OP_LSHR_UN
  63
  64 #define OP_PT_ADD_IMM OP_LADD_IMM
  65 #define OP_PT_SUB_IMM OP_LSUB_IMM
  66
  67 #define OP_PT_STORE_FP_MEMBASE_REG OP_STORER8_MEMBASE_REG
  68
  69 #define OP_PCOMPARE OP_LCOMPARE
  70
  71 #else
  72 #define OP_PT_ADD OP_IADD
  73 #define OP_PT_SUB OP_ISUB
  74 #define OP_PT_MUL OP_IMUL
  75 #define OP_PT_DIV OP_IDIV
  76 #define OP_PT_REM OP_IREM
  77 #define OP_PT_NEG OP_INEG
  78 #define OP_PT_AND OP_IAND
  79 #define OP_PT_OR OP_IOR
  80 #define OP_PT_XOR OP_IXOR
  81 #define OP_PT_NOT OP_INOT
  82 #define OP_PT_SHL OP_ISHL
  83 #define OP_PT_SHR OP_ISHR
  84
  85 #define OP_PT_DIV_UN OP_IDIV_UN
  86 #define OP_PT_REM_UN OP_IREM_UN
  87 #define OP_PT_SHR_UN OP_ISHR_UN
  88
  89 #define OP_PT_ADD_IMM OP_IADD_IMM
  90 #define OP_PT_SUB_IMM OP_ISUB_IMM
  91
  92 #define OP_PT_STORE_FP_MEMBASE_REG OP_STORER4_MEMBASE_REG
  93
  94 #define OP_PCOMPARE OP_ICOMPARE
  95
  96 #endif
  97
  98 static const IntIntrisic int_binop[] = {
  99         { "op_Addition", { OP_PT_ADD, OP_PT_ADD, OP_FADD, OP_RADD } },
 100         { "op_Subtraction", { OP_PT_SUB, OP_PT_SUB, OP_FSUB, OP_RSUB } },
 101         { "op_Multiply", { OP_PT_MUL, OP_PT_MUL, OP_FMUL, OP_RMUL } },
 102         { "op_Division", { OP_PT_DIV, OP_PT_DIV_UN, OP_FDIV, OP_RDIV } },
 103         { "op_Modulus", { OP_PT_REM, OP_PT_REM_UN, OP_FREM, OP_RREM } },
 104         { "op_BitwiseAnd", { OP_PT_AND, OP_PT_AND } },
 105         { "op_BitwiseOr", { OP_PT_OR, OP_PT_OR } },
 106         { "op_ExclusiveOr", { OP_PT_XOR, OP_PT_XOR } },
 107         { "op_LeftShift", { OP_PT_SHL, OP_PT_SHL } },
 108         { "op_RightShift", { OP_PT_SHR, OP_PT_SHR_UN } },
 109 };
 110
 111 static const IntIntrisic int_unnop[] = {
 112         { "op_UnaryPlus", { OP_MOVE, OP_MOVE, OP_FMOVE, OP_RMOVE } },
 113         { "op_UnaryNegation", { OP_PT_NEG, OP_PT_NEG, OP_FNEG, OP_RNEG } },
 114         { "op_OnesComplement", { OP_PT_NOT, OP_PT_NOT, OP_FNOT, OP_RNOT } },
 115 };
 116
 117 static const IntIntrisic int_cmpop[] = {
 118         { "op_Inequality", { OP_ICNEQ, OP_ICNEQ, OP_FCNEQ, OP_RCNEQ } },
 119         { "op_Equality", { OP_ICEQ, OP_ICEQ, OP_FCEQ, OP_RCEQ } },
 120         { "op_GreaterThan", { OP_ICGT, OP_ICGT_UN, OP_FCGT, OP_RCGT } },
 121         { "op_GreaterThanOrEqual", { OP_ICGE, OP_ICGE_UN, OP_FCLT_UN, OP_RCLT_UN } },
 122         { "op_LessThan", { OP_ICLT, OP_ICLT_UN, OP_FCLT, OP_RCLT } },
 123         { "op_LessThanOrEqual", { OP_ICLE, OP_ICLE_UN, OP_FCGT_UN, OP_RCGT_UN } },
 124 };
 125
 126 static const MagicTypeInfo type_info[] = {
 127         //nint
 128         { 0, STACK_I8, STACK_I4, STACK_PTR, OP_ICONV_TO_I8, OP_LCONV_TO_I4, OP_MOVE, OP_PT_ADD_IMM, OP_PT_SUB_IMM, OP_STORE_MEMBASE_REG, OP_PCOMPARE },
 129         //nuint
 130         { 1, STACK_I8, STACK_I4, STACK_PTR, OP_ICONV_TO_U8, OP_LCONV_TO_U4, OP_MOVE, OP_PT_ADD_IMM, OP_PT_SUB_IMM, OP_STORE_MEMBASE_REG, OP_PCOMPARE },
 131         //nfloat
 132         { 2, STACK_R8, STACK_R8, STACK_R8, OP_FCONV_TO_R8, OP_FCONV_TO_R4, OP_FMOVE, 0, 0, OP_PT_STORE_FP_MEMBASE_REG, 0 },
 133 };
 134
 135
 136 gsize
 137 mini_magic_type_size (MonoCompile *cfg, MonoType *type)
 138 {
 139         if (type->type == MONO_TYPE_I4 || type->type == MONO_TYPE_U4)
 140                 return 4;
 141         else if (type->type == MONO_TYPE_I8 || type->type == MONO_TYPE_U8)
 142                 return 8;
 143         else if (type->type == MONO_TYPE_R4 && !type->byref && (!cfg || cfg->r4fp))
 144                 return 4;
 145         else if (type->type == MONO_TYPE_R8 && !type->byref)
 146                 return 8;
 147         return TARGET_SIZEOF_VOID_P;
 148 }
 149
 150 #ifndef DISABLE_JIT
 151
 152 static MonoInst*
 153 emit_narrow (MonoCompile *cfg, const MagicTypeInfo *info, int sreg)
 154 {
 155         MonoInst *ins;
 156
 157         MONO_INST_NEW (cfg, ins, info->conv_8_to_4);
 158         ins->sreg1 = sreg;
 159         if (info->conv_8_to_4 == OP_FCONV_TO_R4)
 160                 ins->type = cfg->r4_stack_type;
 161         else
 162                 ins->type = info->small_stack_type;
 163         ins->dreg = alloc_dreg (cfg, (MonoStackType)ins->type);
 164         MONO_ADD_INS (cfg->cbb, ins);
 165         return mono_decompose_opcode (cfg, ins);
 166 }
 167
 168 static MonoInst*
 169 emit_widen (MonoCompile *cfg, const MagicTypeInfo *info, int sreg)
 170 {
 171         MonoInst *ins;
 172
 173         if (cfg->r4fp && info->conv_4_to_8 == OP_FCONV_TO_R8)
 174                 MONO_INST_NEW (cfg, ins, OP_RCONV_TO_R8);
 175         else
 176                 MONO_INST_NEW (cfg, ins, info->conv_4_to_8);
 177         ins->sreg1 = sreg;
 178         ins->type = info->big_stack_type;
 179         ins->dreg = alloc_dreg (cfg, info->big_stack_type);
 180         MONO_ADD_INS (cfg->cbb, ins);
 181         return mono_decompose_opcode (cfg, ins);
 182 }
 183
 184 static MonoInst*
 185 emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, const MagicTypeInfo *info)
 186 {
 187         int i = 0;
 188         const char *name = cmethod->name;
 189         MonoInst *ins;
 190         int type_index;
 191         MonoStackType stack_type;
 192
 193         if (info->op_index == 2 && cfg->r4fp && TARGET_SIZEOF_VOID_P == 4) {
 194                 type_index = 3;
 195                 stack_type = STACK_R4;
 196         } else {
 197                 type_index = info->op_index;
 198                 stack_type = info->stack_type;
 199         }
 200
 201         if (!strcmp ("op_Implicit", name) || !strcmp ("op_Explicit", name)) {
 202                 int source_size = mini_magic_type_size (cfg, fsig->params [0]);
 203                 int dest_size = mini_magic_type_size (cfg, fsig->ret);
 204
 205                 switch (info->big_stack_type) {
 206                 case STACK_I8:
 207                         if (!mini_magic_is_int_type (fsig->params [0]) || !mini_magic_is_int_type (fsig->ret))
 208                                 return NULL;
 209                         break;
 210                 case STACK_R8:
 211                         if (!mini_magic_is_float_type (fsig->params [0]) || !mini_magic_is_float_type (fsig->ret))
 212                                 return NULL;
 213                         break;
 214                 default:
 215                         g_assert_not_reached ();
 216                 }
 217
 218                 //4 -> 4 or 8 -> 8
 219                 if (source_size == dest_size)
 220                         return args [0];
 221
 222                 //4 -> 8
 223                 if (source_size < dest_size)
 224                         return emit_widen (cfg, info, args [0]->dreg);
 225
 226                 //8 -> 4
 227                 return emit_narrow (cfg, info, args [0]->dreg);
 228         }
 229
 230         if (!strcmp (".ctor", name)) {
 231                 gboolean is_ldaddr = args [0]->opcode == OP_LDADDR;
 232                 int arg0 = args [1]->dreg;
 233                 int arg_size = mini_magic_type_size (cfg, fsig->params [0]);
 234
 235                 if (arg_size > TARGET_SIZEOF_VOID_P) //8 -> 4
 236                         arg0 = emit_narrow (cfg, info, arg0)->dreg;
 237                 else if (arg_size < TARGET_SIZEOF_VOID_P) //4 -> 8
 238                         arg0 = emit_widen (cfg, info, arg0)->dreg;
 239
 240                 if (is_ldaddr) { /*Eliminate LDADDR if it's initing a local var*/
 241                         int dreg = ((MonoInst*)args [0]->inst_p0)->dreg;
 242                         NULLIFY_INS (args [0]);
 243                         EMIT_NEW_UNALU (cfg, ins, info->move, dreg, arg0);
 244                         cfg->has_indirection = TRUE;
 245                 } else {
 246                         EMIT_NEW_STORE_MEMBASE (cfg, ins, info->store_op, args [0]->dreg, 0, arg0);
 247                 }
 248                 return ins;
 249         }
 250
 251         if (!strcmp ("op_Increment", name) || !strcmp ("op_Decrement", name)) {
 252                 gboolean inc = !strcmp ("op_Increment", name);
 253                 /* FIXME float inc is too complex to bother with*/
 254                 //this is broken with ints too
 255                 // if (!info->inc_op)
 256                         return NULL;
 257
 258                 /* We have IR for inc/dec */
 259                 MONO_INST_NEW (cfg, ins, inc ? info->inc_op : info->dec_op);
 260                 ins->dreg = alloc_dreg (cfg, (MonoStackType)info->stack_type);
 261                 ins->sreg1 = args [0]->dreg;
 262                 ins->inst_imm = 1;
 263                 ins->type = info->stack_type;
 264                 MONO_ADD_INS (cfg->cbb, ins);
 265                 return ins;
 266         }
 267
 268         for (i = 0; i < sizeof (int_binop) / sizeof  (IntIntrisic); ++i) {
 269                 if (!strcmp (int_binop [i].op_name, name)) {
 270                         if (!int_binop [i].op_table [info->op_index])
 271                                 return NULL;
 272                         g_assert (int_binop [i].op_table [type_index]);
 273
 274                         MONO_INST_NEW (cfg, ins, int_binop [i].op_table [type_index]);
 275                         ins->dreg = alloc_dreg (cfg, stack_type);
 276                         ins->sreg1 = args [0]->dreg;
 277                 ins->sreg2 = args [1]->dreg;
 278                         ins->type = stack_type;
 279                         MONO_ADD_INS (cfg->cbb, ins);
 280                         return mono_decompose_opcode (cfg, ins);
 281                 }
 282         }
 283
 284         for (i = 0; i < sizeof (int_unnop) / sizeof  (IntIntrisic); ++i) {
 285                 if (!strcmp (int_unnop [i].op_name, name)) {
 286                         g_assert (int_unnop [i].op_table [type_index]);
 287
 288                         MONO_INST_NEW (cfg, ins, int_unnop [i].op_table [type_index]);
 289                         ins->dreg = alloc_dreg (cfg, stack_type);
 290                         ins->sreg1 = args [0]->dreg;
 291                         ins->type = stack_type;
 292                         MONO_ADD_INS (cfg->cbb, ins);
 293                         return ins;
 294                 }
 295         }
 296
 297         for (i = 0; i < sizeof (int_cmpop) / sizeof  (IntIntrisic); ++i) {
 298                 if (!strcmp (int_cmpop [i].op_name, name)) {
 299                         short op_cmp = int_cmpop [i].op_table [type_index];
 300
 301                         g_assert (op_cmp);
 302
 303                         if (info->compare_op) {
 304                                 MONO_INST_NEW (cfg, ins, info->compare_op);
 305                         ins->dreg = -1;
 306                                 ins->sreg1 = args [0]->dreg;
 307                         ins->sreg2 = args [1]->dreg;
 308                                 MONO_ADD_INS (cfg->cbb, ins);
 309
 310                                 MONO_INST_NEW (cfg, ins, op_cmp);
 311                         ins->dreg = alloc_preg (cfg);
 312                                 ins->type = STACK_I4;
 313                                 MONO_ADD_INS (cfg->cbb, ins);
 314                         } else {
 315                                 MONO_INST_NEW (cfg, ins, op_cmp);
 316                                 guint32 fcmp_dreg = ins->dreg = alloc_ireg (cfg);
 317                                 ins->sreg1 = args [0]->dreg;
 318                         ins->sreg2 = args [1]->dreg;
 319                                 MONO_ADD_INS (cfg->cbb, ins);
 320                                 if (op_cmp == OP_FCLT_UN || op_cmp == OP_FCGT_UN || op_cmp == OP_RCLT_UN || op_cmp == OP_RCGT_UN) {
 321                                         /* we have to negate the result of this comparison:
 322                                          *  - op_GreaterThanOrEqual maps to NOT x OP_FCLT_UN / OP_RCLT_UN
 323                                          *  - op_LessThanOrEqual    maps to NOT x OP_FCGT_UN / OP_RCGT_UN
 324                                          *
 325                                          *  this matches generated bytecode by C# when doing the
 326                                          *  same operations on float/double. the `_UN` suffix says
 327                                          *  that if an operand is NaN, the result is true. If
 328                                          *  OP_FCGE/OP_FCLE is used, it is mapped to instructions
 329                                          *  on some architectures that don't detect NaN. For
 330                                          *  example, on arm64 the condition `eq` doesn't respect
 331                                          *  NaN results of a `fcmp` instruction.
 332                                          */
 333                                         MONO_INST_NEW (cfg, ins, OP_ICOMPARE_IMM);
 334                                         ins->dreg = -1;
 335                                         ins->sreg1 = fcmp_dreg;
 336                                         ins->inst_imm = 0;
 337                                         MONO_ADD_INS (cfg->cbb, ins);
 338
 339                                         MONO_INST_NEW (cfg, ins, OP_CEQ);
 340                                         ins->dreg = alloc_preg (cfg);
 341                                         ins->type = STACK_I4;
 342                                         MONO_ADD_INS (cfg->cbb, ins);
 343                                 }
 344                         }
 345
 346                         return ins;
 347                 }
 348         }
 349
 350         return NULL;
 351 }
 352
 353
 354 MonoInst*
 355 mono_emit_native_types_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
 356 {
 357         if (mono_class_is_magic_int (cmethod->klass)) {
 358                 const char *class_name = m_class_get_name (cmethod->klass);
 359                 if (!strcmp ("nint", class_name))
 360                         return emit_intrinsics (cfg, cmethod, fsig, args, &type_info [0]);
 361                 else
 362                         return emit_intrinsics (cfg, cmethod, fsig, args, &type_info [1]);
 363         } else if (mono_class_is_magic_float (cmethod->klass))
 364                 return emit_intrinsics (cfg, cmethod, fsig, args, &type_info [2]);
 365
 366         return NULL;
 367 }
 368
 369 #endif /* !DISABLE_JIT */
 370
 371 static inline gboolean
 372 mono_class_is_magic_assembly (MonoClass *klass)
 373 {
 374         const char *aname = m_class_get_image (klass)->assembly_name;
 375         if (!aname)
 376                 return FALSE;
 377         if (!strcmp ("Xamarin.iOS", aname))
 378                 return TRUE;
 379         if (!strcmp ("Xamarin.Mac", aname))
 380                 return TRUE;
 381         if (!strcmp ("Xamarin.WatchOS", aname))
 382                 return TRUE;
 383         /* regression test suite */
 384         if (!strcmp ("builtin-types", aname))
 385                 return TRUE;
 386         if (!strcmp ("mini_tests", aname))
 387                 return TRUE;
 388         return FALSE;
 389 }
 390
 391 gboolean
 392 mono_class_is_magic_int (MonoClass *klass)
 393 {
 394         static MonoClass *magic_nint_class;
 395         static MonoClass *magic_nuint_class;
 396
 397         if (klass == magic_nint_class)
 398                 return TRUE;
 399
 400         if (klass == magic_nuint_class)
 401                 return TRUE;
 402
 403         if (magic_nint_class && magic_nuint_class)
 404                 return FALSE;
 405
 406         if (!mono_class_is_magic_assembly (klass))
 407                 return FALSE;
 408
 409         if (strcmp ("System", m_class_get_name_space (klass)) != 0)
 410                 return FALSE;
 411
 412         if (strcmp ("nint", m_class_get_name (klass)) == 0) {
 413                 magic_nint_class = klass;
 414                 return TRUE;
 415         }
 416
 417         if (strcmp ("nuint", m_class_get_name (klass)) == 0){
 418                 magic_nuint_class = klass;
 419                 return TRUE;
 420         }
 421         return FALSE;
 422 }
 423
 424 gboolean
 425 mono_class_is_magic_float (MonoClass *klass)
 426 {
 427         static MonoClass *magic_nfloat_class;
 428
 429         if (klass == magic_nfloat_class)
 430                 return TRUE;
 431
 432         if (magic_nfloat_class)
 433                 return FALSE;
 434
 435         if (!mono_class_is_magic_assembly (klass))
 436                 return FALSE;
 437
 438         if (strcmp ("System", m_class_get_name_space (klass)) != 0)
 439                 return FALSE;
 440
 441         if (strcmp ("nfloat", m_class_get_name (klass)) == 0) {
 442                 magic_nfloat_class = klass;
 443
 444                 /* Assert that we are using the matching assembly */
 445                 MonoClassField *value_field = mono_class_get_field_from_name_full (klass, "v", NULL);
 446                 g_assert (value_field);
 447                 MonoType *t = mono_field_get_type_internal (value_field);
 448                 MonoType *native = mini_native_type_replace_type (m_class_get_byval_arg (klass));
 449                 if (t->type != native->type)
 450                         g_error ("Assembly used for native types '%s' doesn't match this runtime, %s is mapped to %s, expecting %s.\n", m_class_get_image (klass)->name, m_class_get_name (klass), mono_type_full_name (t), mono_type_full_name (native));
 451                 return TRUE;
 452         }
 453         return FALSE;
 454 }
 455
 456 gboolean
 457 mini_magic_is_int_type (MonoType *t)
 458 {
 459         if (t->type != MONO_TYPE_I && t->type != MONO_TYPE_I4 && t->type != MONO_TYPE_I8 && t->type != MONO_TYPE_U4 && t->type != MONO_TYPE_U8 && !mono_class_is_magic_int (mono_class_from_mono_type_internal (t)))
 460                 return FALSE;
 461         return TRUE;
 462 }
 463
 464 gboolean
 465 mini_magic_is_float_type (MonoType *t)
 466 {
 467         if (t->type != MONO_TYPE_R4 && t->type != MONO_TYPE_R8 && !mono_class_is_magic_float (mono_class_from_mono_type_internal (t)))
 468                 return FALSE;
 469         return TRUE;
 470 }
 471
 472 MonoType*
 473 mini_native_type_replace_type (MonoType *type)
 474 {
 475         MonoClass *klass;
 476
 477         if (type->type != MONO_TYPE_VALUETYPE)
 478                 return type;
 479         klass = type->data.klass;
 480
 481         if (mono_class_is_magic_int (klass))
 482                 return type->byref ? m_class_get_this_arg (mono_defaults.int_class) : mono_get_int_type ();
 483         if (mono_class_is_magic_float (klass))
 484 #if TARGET_SIZEOF_VOID_P == 8
 485                 return type->byref ? m_class_get_this_arg (mono_defaults.double_class) : m_class_get_byval_arg (mono_defaults.double_class);
 486 #else
 487                 return type->byref ? m_class_get_this_arg (mono_defaults.single_class) : m_class_get_byval_arg (mono_defaults.single_class);
 488 #endif
 489         return type;
 490 }