mono/mini/mini-s390x.c

   1 /*------------------------------------------------------------------*/
   2 /*                                                                  */
   3 /* Name        - mini-s390.c                                        */
   4 /*                                                                  */
   5 /* Function    - S/390 backend for the Mono code generator.         */
   6 /*                                                                  */
   7 /* Name        - Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com) */
   8 /*                                                                  */
   9 /* Date        - January, 2004                                      */
  10 /*                                                                  */
  11 /* Derivation  - From mini-x86 & mini-ppc by -                      */
  12 /*               Paolo Molaro (lupus@ximian.com)                    */
  13 /*               Dietmar Maurer (dietmar@ximian.com)                */
  14 /*                                                                  */
  15 /*------------------------------------------------------------------*/
  16
  17 /*------------------------------------------------------------------*/
  18 /*                 D e f i n e s                                    */
  19 /*------------------------------------------------------------------*/
  20
  21 #define MAX_ARCH_DELEGATE_PARAMS 7
  22
  23 #define EMIT_COND_BRANCH(ins,cond)                                              \
  24 {                                                                               \
  25 if (ins->inst_true_bb->native_offset) {                                         \
  26         int displace;                                                           \
  27         displace = ((cfg->native_code +                                         \
  28                     ins->inst_true_bb->native_offset) - code) / 2;              \
  29         if (s390_is_imm16(displace)) {                                          \
  30                 s390_brc (code, cond, displace);                                \
  31         } else {                                                                \
  32                 s390_jcl (code, cond, displace);                                \
  33         }                                                                       \
  34 } else {                                                                        \
  35         mono_add_patch_info (cfg, code - cfg->native_code,                      \
  36                              MONO_PATCH_INFO_BB, ins->inst_true_bb);            \
  37         s390_jcl (code, cond, 0);                                               \
  38 }                                                                               \
  39 }
  40
  41 #define EMIT_UNCOND_BRANCH(ins)                                                 \
  42 {                                                                               \
  43 if (ins->inst_target_bb->native_offset) {                                       \
  44         int displace;                                                           \
  45         displace = ((cfg->native_code +                                         \
  46                     ins->inst_target_bb->native_offset) - code) / 2;            \
  47         if (s390_is_imm16(displace)) {                                          \
  48                 s390_brc (code, S390_CC_UN, displace);                          \
  49         } else {                                                                \
  50                 s390_jcl (code, S390_CC_UN, displace);                          \
  51         }                                                                       \
  52 } else {                                                                        \
  53         mono_add_patch_info (cfg, code - cfg->native_code,                      \
  54                              MONO_PATCH_INFO_BB, ins->inst_target_bb);          \
  55         s390_jcl (code, S390_CC_UN, 0);                                         \
  56 }                                                                               \
  57 }
  58
  59 #define EMIT_COND_SYSTEM_EXCEPTION(cond,exc_name)                       \
  60         do {                                                            \
  61                 mono_add_patch_info (cfg, code - cfg->native_code,      \
  62                                      MONO_PATCH_INFO_EXC, exc_name);    \
  63                 s390_jcl (code, cond, 0);                               \
  64         } while (0);
  65
  66 #define CHECK_SRCDST_COM                                                \
  67         if (ins->dreg == ins->sreg2) {                                  \
  68                 src2 = ins->sreg1;                                      \
  69         } else {                                                        \
  70                 src2 = ins->sreg2;                                      \
  71                 if (ins->dreg != ins->sreg1) {                          \
  72                         s390_lgr (code, ins->dreg, ins->sreg1);         \
  73                 }                                                       \
  74         }
  75
  76 #define CHECK_SRCDST_NCOM                                               \
  77         if (ins->dreg == ins->sreg2) {                                  \
  78                 src2 = s390_r13;                                        \
  79                 s390_lgr (code, s390_r13, ins->sreg2);                  \
  80         } else {                                                        \
  81                 src2 = ins->sreg2;                                      \
  82         }                                                               \
  83         if (ins->dreg != ins->sreg1) {                                  \
  84                 s390_lgr (code, ins->dreg, ins->sreg1);                 \
  85         }
  86
  87 #define CHECK_SRCDST_COM_I                                              \
  88         if (ins->dreg == ins->sreg2) {                                  \
  89                 src2 = ins->sreg1;                                      \
  90         } else {                                                        \
  91                 src2 = ins->sreg2;                                      \
  92                 if (ins->dreg != ins->sreg1) {                          \
  93                         s390_lgfr (code, ins->dreg, ins->sreg1);        \
  94                 }                                                       \
  95         }
  96
  97 #define CHECK_SRCDST_NCOM_I                                             \
  98         if (ins->dreg == ins->sreg2) {                                  \
  99                 src2 = s390_r13;                                        \
 100                 s390_lgfr (code, s390_r13, ins->sreg2);                 \
 101         } else {                                                        \
 102                 src2 = ins->sreg2;                                      \
 103         }                                                               \
 104         if (ins->dreg != ins->sreg1) {                                  \
 105                 s390_lgfr (code, ins->dreg, ins->sreg1);                \
 106         }
 107
 108 #define CHECK_SRCDST_COM_F                                              \
 109         if (ins->dreg == ins->sreg2) {                                  \
 110                 src2 = ins->sreg1;                                      \
 111         } else {                                                        \
 112                 src2 = ins->sreg2;                                      \
 113                 if (ins->dreg != ins->sreg1) {                          \
 114                         s390_ldr (code, ins->dreg, ins->sreg1);         \
 115                 }                                                       \
 116         }
 117
 118 #define CHECK_SRCDST_NCOM_F                                             \
 119         if (ins->dreg == ins->sreg2) {                                  \
 120                 src2 = s390_f15;                                        \
 121                 s390_ldr (code, s390_r13, ins->sreg2);                  \
 122         } else {                                                        \
 123                 src2 = ins->sreg2;                                      \
 124         }                                                               \
 125         if (ins->dreg != ins->sreg1) {                                  \
 126                 s390_ldr (code, ins->dreg, ins->sreg1);                 \
 127         }
 128
 129 #define MONO_EMIT_NEW_MOVE(cfg,dest,offset,src,imm,size) do {                   \
 130                 MonoInst *inst;                                                 \
 131                 int sReg, dReg;                                                 \
 132                 MONO_INST_NEW (cfg, inst, OP_NOP);                              \
 133                 if (size > 256) {                                               \
 134                         inst->dreg        = dest;                               \
 135                         inst->inst_offset = offset;                             \
 136                         inst->sreg1       = src;                                \
 137                         inst->inst_imm    = imm;                                \
 138                 } else {                                                        \
 139                         if (s390_is_uimm12(offset)) {                           \
 140                                 inst->dreg        = dest;                       \
 141                                 inst->inst_offset = offset;                     \
 142                         } else {                                                \
 143                                 dReg = mono_alloc_preg (cfg);                   \
 144                                 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM,        \
 145                                         dReg, dest, offset);                    \
 146                                 inst->dreg        = dReg;                       \
 147                                 inst->inst_offset = 0;                          \
 148                         }                                                       \
 149                         if (s390_is_uimm12(imm)) {                              \
 150                                 inst->sreg1       = src;                        \
 151                                 inst->inst_imm    = imm;                        \
 152                         } else {                                                \
 153                                 sReg = mono_alloc_preg (cfg);                   \
 154                                 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM,        \
 155                                         sReg, src, imm);                        \
 156                                 inst->sreg1       = sReg;                       \
 157                                 inst->inst_imm    = 0;                          \
 158                         }                                                       \
 159                 }                                                               \
 160                 inst->opcode            = OP_S390_MOVE;                         \
 161                 inst->backend.size      = size;                                 \
 162         MONO_ADD_INS (cfg->cbb, inst);                                          \
 163         } while (0)
 164
 165 #define MONO_OUTPUT_VTR(cfg, size, dr, sr, so) do {                             \
 166         int reg = mono_alloc_preg (cfg); \
 167         switch (size) {                                                         \
 168                 case 0:                                                         \
 169                         MONO_EMIT_NEW_ICONST(cfg, reg, 0);                      \
 170                 break;                                                          \
 171                 case 1:                                                         \
 172                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE,   \
 173                                 reg, sr, so);                                   \
 174                 break;                                                          \
 175                 case 2:                                                         \
 176                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE,   \
 177                                 reg, sr, so);                                   \
 178                 break;                                                          \
 179                 case 4:                                                         \
 180                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI4_MEMBASE,   \
 181                                 reg, sr, so);                                   \
 182                 break;                                                          \
 183                 case 8:                                                         \
 184                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI8_MEMBASE,   \
 185                                 reg, sr, so);                                   \
 186                 break;                                                          \
 187         }                                                                       \
 188         mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE);               \
 189 } while (0)
 190
 191 #define MONO_OUTPUT_VTS(cfg, size, dr, dx, sr, so) do {                         \
 192         int tmpr;                                                               \
 193         switch (size) {                                                         \
 194                 case 0:                                                         \
 195                         tmpr = mono_alloc_preg (cfg); \
 196                         MONO_EMIT_NEW_ICONST(cfg, tmpr, 0);                     \
 197                         MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG,  \
 198                                 dr, dx, tmpr);                                  \
 199                 break;                                                          \
 200                 case 1:                                                         \
 201                         tmpr = mono_alloc_preg (cfg); \
 202                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE,   \
 203                                 tmpr, sr, so);                                  \
 204                         MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG,  \
 205                                 dr, dx, tmpr);                                  \
 206                 break;                                                          \
 207                 case 2:                                                         \
 208                         tmpr = mono_alloc_preg (cfg);                           \
 209                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE,   \
 210                                 tmpr, sr, so);                                  \
 211                         MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG,  \
 212                                 dr, dx, tmpr);                                  \
 213                 break;                                                          \
 214                 case 4:                                                         \
 215                         tmpr = mono_alloc_preg (cfg);                           \
 216                         MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI4_MEMBASE,   \
 217                                 tmpr, sr, so);                                  \
 218                         MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG,  \
 219                                 dr, dx, tmpr);                                  \
 220                 break;                                                          \
 221                 case 8:                                                         \
 222                         MONO_EMIT_NEW_MOVE (cfg, dr, dx, sr, so, size);         \
 223                 break;                                                          \
 224         }                                                                       \
 225 } while (0)
 226
 227 #undef DEBUG
 228 #define DEBUG(a) if (cfg->verbose_level > 1) a
 229
 230 #define MAX_EXC 16
 231
 232 #define S390_TRACE_STACK_SIZE (5*sizeof(gpointer)+4*sizeof(gdouble))
 233
 234 #define BREAKPOINT_SIZE         sizeof(breakpoint_t)
 235 #define S390X_NOP_SIZE          sizeof(RR_Format)
 236
 237 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 238
 239 /*
 240  * imt trampoline size values
 241  */
 242 #define CMP_SIZE        24
 243 #define LOADCON_SIZE    20
 244 #define LOAD_SIZE       6
 245 #define BR_SIZE         2
 246 #define JUMP_SIZE       6
 247 #define ENABLE_WRONG_METHOD_CHECK 0
 248
 249 #define mono_mini_arch_lock() mono_os_mutex_lock (&mini_arch_mutex)
 250 #define mono_mini_arch_unlock() mono_os_mutex_unlock (&mini_arch_mutex)
 251
 252 /*========================= End of Defines =========================*/
 253
 254 /*------------------------------------------------------------------*/
 255 /*                 I n c l u d e s                                  */
 256 /*------------------------------------------------------------------*/
 257
 258 #include "mini.h"
 259 #include <string.h>
 260 #include <sys/types.h>
 261 #include <unistd.h>
 262
 263 #include <mono/metadata/abi-details.h>
 264 #include <mono/metadata/appdomain.h>
 265 #include <mono/metadata/debug-helpers.h>
 266 #include <mono/metadata/profiler-private.h>
 267 #include <mono/utils/mono-error.h>
 268 #include <mono/utils/mono-error-internals.h>
 269 #include <mono/utils/mono-math.h>
 270 #include <mono/utils/mono-mmap.h>
 271 #include <mono/utils/mono-hwcap.h>
 272 #include <mono/utils/mono-threads.h>
 273
 274 #include "mini-s390x.h"
 275 #include "cpu-s390x.h"
 276 #include "support-s390x.h"
 277 #include "jit-icalls.h"
 278 #include "ir-emit.h"
 279 #include "trace.h"
 280 #include "mini-gc.h"
 281
 282 /*========================= End of Includes ========================*/
 283
 284 /*------------------------------------------------------------------*/
 285 /*                 T y p e d e f s                                  */
 286 /*------------------------------------------------------------------*/
 287
 288 typedef struct {
 289         guint stack_size,
 290               local_size,
 291               code_size,
 292               parm_size,
 293               offset,
 294               offStruct,
 295               retStruct;
 296 } size_data;
 297
 298 /*------------------------------------------------------------------*/
 299 /* Used by the instrument_emit_epilog                               */
 300 /*------------------------------------------------------------------*/
 301
 302 enum {
 303         SAVE_NONE,
 304         SAVE_STRUCT,
 305         SAVE_ONE,
 306         SAVE_TWO,
 307         SAVE_R4,
 308         SAVE_R8
 309 };
 310
 311 typedef struct InstList InstList;
 312
 313 struct InstList {
 314         InstList *prev;
 315         InstList *next;
 316         MonoInst *data;
 317 };
 318
 319 typedef enum {
 320         RegTypeGeneral,
 321         RegTypeBase,
 322         RegTypeFP,
 323         RegTypeFPR4,
 324         RegTypeStructByVal,
 325         RegTypeStructByValInFP,
 326         RegTypeStructByAddr,
 327         RegTypeStructByAddrOnStack
 328 } ArgStorage;
 329
 330 typedef struct {
 331         gint32  offset;         /* offset from caller's stack */
 332         gint32  offparm;        /* offset from callee's stack */
 333         guint16 vtsize;         /* in param area */
 334         guint8  reg;
 335         ArgStorage regtype;
 336         guint32 size;           /* Size of structure used by RegTypeStructByVal */
 337         gint32  type;           /* Data type of argument */
 338 } ArgInfo;
 339
 340 typedef struct {
 341         int nargs;
 342         int lastgr;
 343         guint32 stack_usage;
 344         guint32 struct_ret;
 345         ArgInfo ret;
 346         ArgInfo sigCookie;
 347         size_data sz;
 348         int vret_arg_index;
 349         ArgInfo args [1];
 350 } CallInfo;
 351
 352 typedef struct {
 353         gint64  gr[5];          /* R2-R6                            */
 354         gdouble fp[3];          /* F0-F2                            */
 355 } __attribute__ ((packed)) RegParm;
 356
 357 typedef struct {
 358         RR_Format  basr;
 359         RI_Format  j;
 360         void       *pTrigger;
 361         RXY_Format lg;
 362         RXY_Format trigger;
 363 } __attribute__ ((packed)) breakpoint_t;
 364
 365 /*========================= End of Typedefs ========================*/
 366
 367 /*------------------------------------------------------------------*/
 368 /*                   P r o t o t y p e s                            */
 369 /*------------------------------------------------------------------*/
 370
 371 static void indent (int);
 372 static guint8 * backUpStackPtr(MonoCompile *, guint8 *);
 373 static void decodeParm (MonoType *, void *, int);
 374 static void enter_method (MonoMethod *, RegParm *, char *);
 375 static void leave_method (MonoMethod *, ...);
 376 static inline void add_general (guint *, size_data *, ArgInfo *);
 377 static inline void add_stackParm (guint *, size_data *, ArgInfo *, gint);
 378 static inline void add_float (guint *, size_data *, ArgInfo *);
 379 static CallInfo * get_call_info (MonoCompile *, MonoMemPool *, MonoMethodSignature *);
 380 static guchar * emit_float_to_int (MonoCompile *, guchar *, int, int, int, gboolean);
 381 static guint8 * emit_load_volatile_arguments (guint8 *, MonoCompile *);
 382 static __inline__ void emit_unwind_regs(MonoCompile *, guint8 *, int, int, long);
 383
 384 /*========================= End of Prototypes ======================*/
 385
 386 /*------------------------------------------------------------------*/
 387 /*                 G l o b a l   V a r i a b l e s                  */
 388 /*------------------------------------------------------------------*/
 389
 390 int mono_exc_esp_offset = 0;
 391
 392 __thread int indent_level = 0;
 393
 394 static gint appdomain_tls_offset = -1,
 395             lmf_tls_offset = -1,
 396             lmf_addr_tls_offset = -1;
 397
 398 pthread_key_t lmf_addr_key;
 399
 400 gboolean lmf_addr_key_inited = FALSE;
 401
 402 /*
 403  * The code generated for sequence points reads from this location,
 404  * which is made read-only when single stepping is enabled.
 405  */
 406 static gpointer ss_trigger_page;
 407
 408 /*
 409  * Enabled breakpoints read from this trigger page
 410  */
 411 static gpointer bp_trigger_page;
 412
 413 breakpoint_t breakpointCode;
 414
 415 static mono_mutex_t mini_arch_mutex;
 416
 417 static const char * grNames[] = {
 418         "s390_r0", "s390_sp", "s390_r2", "s390_r3", "s390_r4",
 419         "s390_r5", "s390_r6", "s390_r7", "s390_r8", "s390_r9",
 420         "s390_r10", "s390_r11", "s390_r12", "s390_r13", "s390_r14",
 421         "s390_r15"
 422 };
 423
 424 static const char * fpNames[] = {
 425         "s390_f0", "s390_f1", "s390_f2", "s390_f3", "s390_f4",
 426         "s390_f5", "s390_f6", "s390_f7", "s390_f8", "s390_f9",
 427         "s390_f10", "s390_f11", "s390_f12", "s390_f13", "s390_f14",
 428         "s390_f15"
 429 };
 430
 431 static const char * vrNames[] = {
 432         "vr0",  "vr1",  "vr2",  "vr3",  "vr4",  "vr5",  "vr6",  "vr7",
 433         "vr8",  "vr9",  "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
 434         "vr16", "vr17", "vr18", "vr19", "vr20", "vr21", "vr22", "vr23",
 435         "vr24", "vr25", "vr26", "vr27", "vr28", "vr29", "vr30", "vr31"
 436 };
 437
 438 /*====================== End of Global Variables ===================*/
 439
 440 /*------------------------------------------------------------------*/
 441 /*                                                                  */
 442 /* Name         - mono_arch_regname                                 */
 443 /*                                                                  */
 444 /* Function     - Returns the name of the register specified by     */
 445 /*                the input parameter.                              */
 446 /*                                                                  */
 447 /*------------------------------------------------------------------*/
 448
 449 const char*
 450 mono_arch_regname (int reg)
 451 {
 452         if (reg >= 0 && reg < 16)
 453                 return grNames [reg];
 454         else
 455                 return "unknown";
 456 }
 457
 458 /*========================= End of Function ========================*/
 459
 460 /*------------------------------------------------------------------*/
 461 /*                                                                  */
 462 /* Name         - mono_arch_fregname                                */
 463 /*                                                                  */
 464 /* Function     - Returns the name of the register specified by     */
 465 /*                the input parameter.                              */
 466 /*                                                                  */
 467 /*------------------------------------------------------------------*/
 468
 469 const char*
 470 mono_arch_fregname (int reg)
 471 {
 472         if (reg >= 0 && reg < 16)
 473                 return fpNames [reg];
 474         else
 475                 return "unknown";
 476 }
 477
 478 /*========================= End of Function ========================*/
 479
 480 /*------------------------------------------------------------------*/
 481 /*                                                                  */
 482 /* Name         - mono_arch_xregname                                */
 483 /*                                                                  */
 484 /* Function     - Returns the name of the register specified by     */
 485 /*                the input parameter.                              */
 486 /*                                                                  */
 487 /*------------------------------------------------------------------*/
 488
 489 const char *
 490 mono_arch_xregname (int reg)
 491 {
 492         if (reg < s390_VR_NREG)
 493                 return vrNames [reg];
 494         else
 495                 return "unknown";
 496 }
 497
 498 /*========================= End of Function ========================*/
 499
 500 /*------------------------------------------------------------------*/
 501 /*                                                                  */
 502 /* Name         - arch_get_argument_info                            */
 503 /*                                                                  */
 504 /* Function     - Gathers information on parameters such as size,   */
 505 /*                alignment, and padding. arg_info should be large  */
 506 /*                enough to hold param_count + 1 entries.           */
 507 /*                                                                  */
 508 /* Parameters   - @csig - Method signature                          */
 509 /*                @param_count - No. of parameters to consider      */
 510 /*                @arg_info - An array to store the result info     */
 511 /*                                                                  */
 512 /* Returns      - Size of the activation frame                      */
 513 /*                                                                  */
 514 /*------------------------------------------------------------------*/
 515
 516 int
 517 mono_arch_get_argument_info (MonoMethodSignature *csig,
 518                              int param_count,
 519                              MonoJitArgumentInfo *arg_info)
 520 {
 521         int k, frame_size = 0;
 522         int size, align, pad;
 523         int offset = 8;
 524
 525         if (MONO_TYPE_ISSTRUCT (csig->ret)) {
 526                 frame_size += sizeof (gpointer);
 527                 offset += 8;
 528         }
 529
 530         arg_info [0].offset = offset;
 531
 532         if (csig->hasthis) {
 533                 frame_size += sizeof (gpointer);
 534                 offset += 8;
 535         }
 536
 537         arg_info [0].size = frame_size;
 538
 539         for (k = 0; k < param_count; k++) {
 540
 541                 if (csig->pinvoke)
 542                         size = mono_type_native_stack_size (csig->params [k], (guint32 *) &align);
 543                 else
 544                         size = mini_type_stack_size (csig->params [k], &align);
 545
 546                 frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 547                 arg_info [k].pad = pad;
 548                 frame_size += size;
 549                 arg_info [k + 1].pad = 0;
 550                 arg_info [k + 1].size = size;
 551                 offset += pad;
 552                 arg_info [k + 1].offset = offset;
 553                 offset += size;
 554         }
 555
 556         align = MONO_ARCH_FRAME_ALIGNMENT;
 557         frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 558         arg_info [k].pad = pad;
 559
 560         return frame_size;
 561 }
 562
 563 /*========================= End of Function ========================*/
 564
 565 /*------------------------------------------------------------------*/
 566 /*                                                                  */
 567 /* Name         - emit_unwind_regs.                                 */
 568 /*                                                                  */
 569 /* Function     - Determines if a value can be returned in one or   */
 570 /*                two registers.                                    */
 571 /*                                                                  */
 572 /*------------------------------------------------------------------*/
 573
 574 static void __inline__
 575 emit_unwind_regs(MonoCompile *cfg, guint8 *code, int start, int end, long offset)
 576 {
 577         int i;
 578
 579         for (i = start; i < end; i++) {
 580                 mono_emit_unwind_op_offset (cfg, code, i, offset);
 581                 mini_gc_set_slot_type_from_cfa (cfg, offset, SLOT_NOREF);
 582                 offset += sizeof(gulong);
 583         }
 584 }
 585
 586 /*========================= End of Function ========================*/
 587
 588 /*------------------------------------------------------------------*/
 589 /*                                                                  */
 590 /* Name         - retFitsInReg.                                     */
 591 /*                                                                  */
 592 /* Function     - Determines if a value can be returned in one or   */
 593 /*                two registers.                                    */
 594 /*                                                                  */
 595 /*------------------------------------------------------------------*/
 596
 597 static inline gboolean
 598 retFitsInReg(guint32 size)
 599 {
 600         switch (size) {
 601                 case 0:
 602                 case 1:
 603                 case 2:
 604                 case 4:
 605                 case 8:
 606                         return (TRUE);
 607                 break;
 608                 default:
 609                         return (FALSE);
 610         }
 611 }
 612
 613 /*========================= End of Function ========================*/
 614
 615 /*------------------------------------------------------------------*/
 616 /*                                                                  */
 617 /* Name         - backStackPtr.                                     */
 618 /*                                                                  */
 619 /* Function     - Restore Stack Pointer to previous frame.          */
 620 /*                                                                  */
 621 /*------------------------------------------------------------------*/
 622
 623 static inline guint8 *
 624 backUpStackPtr(MonoCompile *cfg, guint8 *code)
 625 {
 626         int stackSize = cfg->stack_usage;
 627
 628         if (cfg->frame_reg != STK_BASE)
 629                 s390_lgr (code, STK_BASE, cfg->frame_reg);
 630
 631         if (s390_is_imm16 (stackSize)) {
 632                 s390_aghi  (code, STK_BASE, stackSize);
 633         } else {
 634                 while (stackSize > 32767) {
 635                         s390_aghi  (code, STK_BASE, 32767);
 636                         stackSize -= 32767;
 637                 }
 638                 s390_aghi  (code, STK_BASE, stackSize);
 639         }
 640         return (code);
 641 }
 642
 643 /*========================= End of Function ========================*/
 644
 645 /*------------------------------------------------------------------*/
 646 /*                                                                  */
 647 /* Name         - indent                                            */
 648 /*                                                                  */
 649 /* Function     - Perform nice indenting to current level           */
 650 /*                                                                  */
 651 /*------------------------------------------------------------------*/
 652
 653 static void
 654 indent (int diff) {
 655         int v;
 656         if (diff < 0)
 657                 indent_level += diff;
 658         v = indent_level;
 659         printf("%p [%3d] ",(void *)pthread_self(),v);
 660         while (v-- > 0) {
 661                 printf (". ");
 662         }
 663         if (diff > 0)
 664                 indent_level += diff;
 665 }
 666
 667 /*========================= End of Function ========================*/
 668
 669 /*------------------------------------------------------------------*/
 670 /*                                                                  */
 671 /* Name         - cvtMonoType                                       */
 672 /*                                                                  */
 673 /* Function     - Convert a mono-type to a string.                  */
 674 /*                                                                  */
 675 /*------------------------------------------------------------------*/
 676
 677 static const char *
 678 cvtMonoType(MonoTypeEnum t)
 679 {
 680   switch(t)
 681     {
 682     case MONO_TYPE_END:
 683       return "MONO_TYPE_END";
 684     case MONO_TYPE_VOID:
 685       return "MONO_TYPE_VOID";
 686     case MONO_TYPE_BOOLEAN:
 687       return "MONO_TYPE_BOOLEAN";
 688     case MONO_TYPE_CHAR:
 689       return "MONO_TYPE_CHAR";
 690     case MONO_TYPE_I1:
 691       return "MONO_TYPE_I1";
 692     case MONO_TYPE_U1:
 693       return "MONO_TYPE_U1";
 694     case MONO_TYPE_I2:
 695       return "MONO_TYPE_I2";
 696     case MONO_TYPE_U2:
 697       return "MONO_TYPE_U2";
 698     case MONO_TYPE_I4:
 699       return "MONO_TYPE_I4";
 700     case MONO_TYPE_U4:
 701       return "MONO_TYPE_U4";
 702     case MONO_TYPE_I8:
 703       return "MONO_TYPE_I8";
 704     case MONO_TYPE_U8:
 705       return "MONO_TYPE_U8";
 706     case MONO_TYPE_R4:
 707       return "MONO_TYPE_R4";
 708     case MONO_TYPE_R8:
 709       return "MONO_TYPE_R8";
 710     case MONO_TYPE_STRING:
 711       return "MONO_TYPE_STRING";
 712     case MONO_TYPE_PTR:
 713       return "MONO_TYPE_PTR";
 714     case MONO_TYPE_BYREF:
 715       return "MONO_TYPE_BYREF";
 716     case MONO_TYPE_VALUETYPE:
 717       return "MONO_TYPE_VALUETYPE";
 718     case MONO_TYPE_CLASS:
 719       return "MONO_TYPE_CLASS";
 720     case MONO_TYPE_VAR:
 721       return "MONO_TYPE_VAR";
 722     case MONO_TYPE_ARRAY:
 723       return "MONO_TYPE_ARRAY";
 724     case MONO_TYPE_GENERICINST:
 725       return "MONO_TYPE_GENERICINST";
 726     case MONO_TYPE_TYPEDBYREF:
 727       return "MONO_TYPE_TYPEDBYREF";
 728     case MONO_TYPE_I:
 729       return "MONO_TYPE_I";
 730     case MONO_TYPE_U:
 731       return "MONO_TYPE_U";
 732     case MONO_TYPE_FNPTR:
 733       return "MONO_TYPE_FNPTR";
 734     case MONO_TYPE_OBJECT:
 735       return "MONO_TYPE_OBJECT";
 736     case MONO_TYPE_SZARRAY:
 737       return "MONO_TYPE_SZARRAY";
 738     case MONO_TYPE_MVAR:
 739       return "MONO_TYPE_MVAR";
 740     case MONO_TYPE_CMOD_REQD:
 741       return "MONO_TYPE_CMOD_REQD";
 742     case MONO_TYPE_CMOD_OPT:
 743       return "MONO_TYPE_CMOD_OPT";
 744     case MONO_TYPE_INTERNAL:
 745       return "MONO_TYPE_INTERNAL";
 746     case MONO_TYPE_MODIFIER:
 747       return "MONO_TYPE_MODIFIER";
 748     case MONO_TYPE_SENTINEL:
 749       return "MONO_TYPE_SENTINEL";
 750     case MONO_TYPE_PINNED:
 751       return "MONO_TYPE_PINNED";
 752     default:
 753       ;
 754     }
 755   return "unknown";
 756 }
 757
 758 /*========================= End of Function ========================*/
 759
 760 /*------------------------------------------------------------------*/
 761 /*                                                                  */
 762 /* Name         - decodeParm                                        */
 763 /*                                                                  */
 764 /* Function     - Decode a parameter for the trace.                 */
 765 /*                                                                  */
 766 /*------------------------------------------------------------------*/
 767
 768 static void
 769 decodeParmString (MonoString *s)
 770 {
 771         MonoError error;
 772         char *str = mono_string_to_utf8_checked(s, &error);
 773         if (is_ok (&error))  {
 774                 printf("[STRING:%p:%s], ", s, str);
 775                 g_free (str);
 776         } else {
 777                 mono_error_cleanup (&error);
 778                 printf("[STRING:%p:], ", s);
 779         }
 780 }
 781
 782 static void
 783 decodeParm(MonoType *type, void *curParm, int size)
 784 {
 785         guint32 simpleType;
 786
 787         if (type->byref) {
 788                 printf("[BYREF:%p], ", *((char **) curParm));
 789         } else {
 790                 simpleType = mini_get_underlying_type(type)->type;
 791 enum_parmtype:
 792                 switch (simpleType) {
 793                         case MONO_TYPE_I :
 794                                 printf ("[INTPTR:%p], ", *((int **) curParm));
 795                                 break;
 796                         case MONO_TYPE_U :
 797                                 printf ("[UINTPTR:%p], ", *((int **) curParm));
 798                                 break;
 799                         case MONO_TYPE_BOOLEAN :
 800                                 printf ("[BOOL:%ld], ", *((gint64 *) curParm));
 801                                 break;
 802                         case MONO_TYPE_CHAR :
 803                                 printf ("[CHAR:%c], ", *((int  *) curParm));
 804                                 break;
 805                         case MONO_TYPE_I1 :
 806                                 printf ("[INT1:%ld], ", *((gint64 *) curParm));
 807                                 break;
 808                         case MONO_TYPE_I2 :
 809                                 printf ("[INT2:%ld], ", *((gint64 *) curParm));
 810                                 break;
 811                         case MONO_TYPE_I4 :
 812                                 printf ("[INT4:%ld], ", *((gint64 *) curParm));
 813                                 break;
 814                         case MONO_TYPE_U1 :
 815                                 printf ("[UINT1:%lu], ", *((guint64 *) curParm));
 816                                 break;
 817                         case MONO_TYPE_U2 :
 818                                 printf ("[UINT2:%lu], ", *((guint64 *) curParm));
 819                                 break;
 820                         case MONO_TYPE_U4 :
 821                                 printf ("[UINT4:%lu], ", *((guint64 *) curParm));
 822                                 break;
 823                         case MONO_TYPE_U8 :
 824                                 printf ("[UINT8:%lu], ", *((guint64 *) curParm));
 825                                 break;
 826                         case MONO_TYPE_STRING : {
 827                                 MonoString *s = *((MonoString **) curParm);
 828                                 if (s) {
 829                                         g_assert (((MonoObject *) s)->vtable->klass == mono_defaults.string_class);
 830                                         decodeParmString (s);
 831                                 } else {
 832                                         printf("[STRING:null], ");
 833                                 }
 834                                 break;
 835                         }
 836                         case MONO_TYPE_CLASS :
 837                         case MONO_TYPE_OBJECT : {
 838                                 MonoObject *obj = *((MonoObject **) curParm);
 839                                 MonoClass *klass;
 840                                 if ((obj) && (obj->vtable)) {
 841                                         printf("[CLASS/OBJ:");
 842                                         klass = obj->vtable->klass;
 843                                         printf("%p [%p] ",obj,curParm);
 844                                         if (klass == mono_defaults.string_class) {
 845                                                 decodeParmString ((MonoString *)obj);
 846                                         } else if (klass == mono_defaults.int32_class) {
 847                                                 printf("[INT32:%p:%d]",
 848                                                         obj, *(gint32 *)((char *)obj + sizeof (MonoObject)));
 849                                         } else
 850                                                 printf("[%s.%s:%p]",
 851                                                        klass->name_space, klass->name, obj);
 852                                         printf("], ");
 853                                 } else {
 854                                         printf("[OBJECT:null], ");
 855                                 }
 856                                 break;
 857                         }
 858                         case MONO_TYPE_PTR :
 859                                 printf("[PTR:%p], ", *((gpointer **) (curParm)));
 860                                 break;
 861                         case MONO_TYPE_FNPTR :
 862                                 printf("[FNPTR:%p], ", *((gpointer **) (curParm)));
 863                                 break;
 864                         case MONO_TYPE_ARRAY :
 865                                 printf("[ARRAY:%p], ", *((gpointer **) (curParm)));
 866                                 break;
 867                         case MONO_TYPE_SZARRAY :
 868                                 printf("[SZARRAY:%p], ", *((gpointer **) (curParm)));
 869                                 break;
 870                         case MONO_TYPE_I8 :
 871                                 printf("[INT8:%ld], ", *((gint64 *) (curParm)));
 872                                 break;
 873                         case MONO_TYPE_R4 :
 874                                 printf("[FLOAT4:%g], ", *((float *) (curParm)));
 875                                 break;
 876                         case MONO_TYPE_R8 :
 877                                 printf("[FLOAT8:%g], ", *((double *) (curParm)));
 878                                 break;
 879                         case MONO_TYPE_VALUETYPE : {
 880                                 int i;
 881                                 MonoMarshalType *info;
 882
 883                                 if (type->data.klass->enumtype) {
 884                                         simpleType = mono_class_enum_basetype (type->data.klass)->type;
 885                                         printf("{VALUETYPE} - ");
 886                                         goto enum_parmtype;
 887                                 }
 888
 889                                 info = mono_marshal_load_type_info (type->data.klass);
 890
 891                                 if ((info->native_size == sizeof(float)) &&
 892                                     (info->num_fields  == 1) &&
 893                                     (info->fields[0].field->type->type == MONO_TYPE_R4)) {
 894                                                 printf("[FLOAT4:%f], ", *((float *) (curParm)));
 895                                         break;
 896                                 }
 897
 898                                 if ((info->native_size == sizeof(double)) &&
 899                                     (info->num_fields  == 1) &&
 900                                     (info->fields[0].field->type->type == MONO_TYPE_R8)) {
 901                                         printf("[FLOAT8:%g], ", *((double *) (curParm)));
 902                                         break;
 903                                 }
 904
 905                                 printf("[VALUETYPE:");
 906                                 for (i = 0; i < size; i++)
 907                                         printf("%02x,", *((guint8 *)curParm+i));
 908                                 printf("], ");
 909                                 break;
 910                         }
 911                         case MONO_TYPE_TYPEDBYREF: {
 912                                 int i;
 913                                 printf("[TYPEDBYREF:");
 914                                 for (i = 0; i < size; i++)
 915                                         printf("%02x,", *((guint8 *)curParm+i));
 916                                 printf("]");
 917                                 break;
 918                         }
 919                         default :
 920                                 printf("[%s], ",cvtMonoType(simpleType));
 921                 }
 922         }
 923 }
 924
 925 /*========================= End of Function ========================*/
 926
 927 /*------------------------------------------------------------------*/
 928 /*                                                                  */
 929 /* Name         - enter_method                                      */
 930 /*                                                                  */
 931 /* Function     - Perform tracing of the entry to the current       */
 932 /*                method.                                           */
 933 /*                                                                  */
 934 /*------------------------------------------------------------------*/
 935
 936 static void
 937 enter_method (MonoMethod *method, RegParm *rParm, char *sp)
 938 {
 939         int i, oParm = 0, iParm = 0;
 940         MonoClass *klass;
 941         MonoObject *obj;
 942         MonoMethodSignature *sig;
 943         char *fname;
 944         guint64 ip;
 945         CallInfo *cinfo;
 946         ArgInfo *ainfo;
 947         void *curParm;
 948
 949         fname = mono_method_full_name (method, TRUE);
 950         indent (1);
 951         printf ("ENTER: %s ", fname);
 952         g_free (fname);
 953
 954         ip  = (*(guint64 *) (sp+S390_RET_ADDR_OFFSET));
 955         printf ("ip: %p sp: %p - ", (gpointer) ip, sp);
 956
 957         if (rParm == NULL)
 958                 return;
 959
 960         sig = mono_method_signature (method);
 961
 962         cinfo = get_call_info (NULL, NULL, sig);
 963
 964         if (cinfo->struct_ret) {
 965                 printf ("[STRUCTRET:%p], ", (gpointer) rParm->gr[0]);
 966                 iParm = 1;
 967         }
 968
 969         if (sig->hasthis) {
 970                 gpointer *this_arg = (gpointer *) rParm->gr[iParm];
 971                 obj = (MonoObject *) this_arg;
 972                 switch(method->klass->this_arg.type) {
 973                 case MONO_TYPE_VALUETYPE:
 974                         if (obj) {
 975                                 guint64 *value = (guint64 *) ((uintptr_t)this_arg + sizeof(MonoObject));
 976                                 printf("this:[value:%p:%016lx], ", this_arg, *value);
 977                         } else
 978                                 printf ("this:[NULL], ");
 979                         break;
 980                 case MONO_TYPE_STRING:
 981                         if (obj) {
 982                                 if (obj->vtable) {
 983                                         klass = obj->vtable->klass;
 984                                         if (klass == mono_defaults.string_class) {
 985                                                 printf ("this:");
 986                                                 decodeParmString((MonoString *)obj);
 987                                         } else {
 988                                                 printf ("this:%p[%s.%s], ",
 989                                                         obj, klass->name_space, klass->name);
 990                                         }
 991                                 } else
 992                                         printf("vtable:[NULL], ");
 993                         } else
 994                                 printf ("this:[NULL], ");
 995                         break;
 996                 default :
 997                         printf("this[%s]: %p, ",cvtMonoType(method->klass->this_arg.type),this_arg);
 998                 }
 999                 oParm++;
1000         }
1001
1002         for (i = 0; i < sig->param_count; ++i) {
1003                 ainfo = &cinfo->args[i + oParm];
1004                 switch (ainfo->regtype) {
1005                         case RegTypeGeneral :
1006                                 decodeParm(sig->params[i], &(rParm->gr[ainfo->reg-2]), ainfo->size);
1007                                 break;
1008                         case RegTypeFP :
1009                                 decodeParm(sig->params[i], &(rParm->fp[ainfo->reg]), ainfo->size);
1010                                 break;
1011                         case RegTypeBase :
1012                                 decodeParm(sig->params[i], sp+ainfo->offset, ainfo->size);
1013                                 break;
1014                         case RegTypeStructByVal :
1015                                 if (ainfo->reg != STK_BASE) {
1016                                         int offset = sizeof(glong) - ainfo->size;
1017                                         curParm = &(rParm->gr[ainfo->reg-2])+offset;
1018                                 }
1019                                 else
1020                                         curParm = sp+ainfo->offset;
1021
1022                                 if (retFitsInReg (ainfo->vtsize))
1023                                         decodeParm(sig->params[i],
1024                                                    curParm,
1025                                                    ainfo->size);
1026                                 else
1027                                         decodeParm(sig->params[i],
1028                                                    *((char **) curParm),
1029                                                    ainfo->vtsize);
1030                                 break;
1031                         case RegTypeStructByAddr :
1032                                 if (ainfo->reg != STK_BASE)
1033                                         curParm = &(rParm->gr[ainfo->reg-2]);
1034                                 else
1035                                         curParm = sp+ainfo->offset;
1036
1037                                 decodeParm(sig->params[i],
1038                                            *((char **) curParm),
1039                                            ainfo->vtsize);
1040                                 break;
1041
1042                         default :
1043                                 printf("???, ");
1044                 }
1045         }
1046         printf("\n");
1047         g_free(cinfo);
1048 }
1049
1050 /*========================= End of Function ========================*/
1051
1052 /*------------------------------------------------------------------*/
1053 /*                                                                  */
1054 /* Name         - leave_method                                      */
1055 /*                                                                  */
1056 /* Function     -                                                   */
1057 /*                                                                  */
1058 /*------------------------------------------------------------------*/
1059
1060 static void
1061 leave_method (MonoMethod *method, ...)
1062 {
1063         MonoType *type;
1064         char *fname;
1065         guint64 ip;
1066         va_list ap;
1067
1068         va_start(ap, method);
1069
1070         fname = mono_method_full_name (method, TRUE);
1071         indent (-1);
1072         printf ("LEAVE: %s", fname);
1073         g_free (fname);
1074
1075         type = mono_method_signature (method)->ret;
1076
1077 handle_enum:
1078         switch (type->type) {
1079         case MONO_TYPE_VOID:
1080                 break;
1081         case MONO_TYPE_BOOLEAN: {
1082                 int val = va_arg (ap, int);
1083                 if (val)
1084                         printf ("[TRUE:%d]", val);
1085                 else
1086                         printf ("[FALSE]");
1087
1088                 break;
1089         }
1090         case MONO_TYPE_CHAR: {
1091                 int val = va_arg (ap, int);
1092                 printf ("[CHAR:%d]", val);
1093                 break;
1094         }
1095         case MONO_TYPE_I1: {
1096                 int val = va_arg (ap, int);
1097                 printf ("[INT1:%d]", val);
1098                 break;
1099         }
1100         case MONO_TYPE_U1: {
1101                 int val = va_arg (ap, int);
1102                 printf ("[UINT1:%d]", val);
1103                 break;
1104         }
1105         case MONO_TYPE_I2: {
1106                 int val = va_arg (ap, int);
1107                 printf ("[INT2:%d]", val);
1108                 break;
1109         }
1110         case MONO_TYPE_U2: {
1111                 int val = va_arg (ap, int);
1112                 printf ("[UINT2:%d]", val);
1113                 break;
1114         }
1115         case MONO_TYPE_I4: {
1116                 int val = va_arg (ap, int);
1117                 printf ("[INT4:%d]", val);
1118                 break;
1119         }
1120         case MONO_TYPE_U4: {
1121                 int val = va_arg (ap, int);
1122                 printf ("[UINT4:%d]", val);
1123                 break;
1124         }
1125         case MONO_TYPE_I: {
1126                 gint64 val = va_arg (ap, gint64);
1127                 printf ("[INT:%ld]", val);
1128                 printf("]");
1129                 break;
1130         }
1131         case MONO_TYPE_U: {
1132                 gint64 val = va_arg (ap, gint64);
1133                 printf ("[UINT:%lu]", val);
1134                 printf("]");
1135                 break;
1136         }
1137         case MONO_TYPE_STRING: {
1138                 MonoString *s = va_arg (ap, MonoString *);
1139 ;
1140                 if (s) {
1141                         g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class);
1142                         decodeParmString (s);
1143                 } else
1144                         printf ("[STRING:null], ");
1145                 break;
1146         }
1147         case MONO_TYPE_CLASS:
1148         case MONO_TYPE_OBJECT: {
1149                 MonoObject *o = va_arg (ap, MonoObject *);
1150
1151                 if ((o) && (o->vtable)) {
1152                         if (o->vtable->klass == mono_defaults.boolean_class) {
1153                                 printf ("[BOOLEAN:%p:%d]", o, *((guint8 *)o + sizeof (MonoObject)));
1154                         } else if  (o->vtable->klass == mono_defaults.int32_class) {
1155                                 printf ("[INT32:%p:%d]", o, *((gint32 *)((char *)o + sizeof (MonoObject))));
1156                         } else if  (o->vtable->klass == mono_defaults.int64_class) {
1157                                 printf ("[INT64:%p:%ld]", o, *((gint64 *)((char *)o + sizeof (MonoObject))));
1158                         } else
1159                                 printf ("[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o);
1160                 } else
1161                         printf ("[OBJECT:%p]", o);
1162
1163                 break;
1164         }
1165         case MONO_TYPE_PTR:
1166         case MONO_TYPE_FNPTR:
1167         case MONO_TYPE_ARRAY:
1168         case MONO_TYPE_SZARRAY: {
1169                 gpointer p = va_arg (ap, gpointer);
1170                 printf ("[result=%p]", p);
1171                 break;
1172         }
1173         case MONO_TYPE_I8: {
1174                 gint64 l =  va_arg (ap, gint64);
1175                 printf ("[LONG:%ld]", l);
1176                 break;
1177         }
1178         case MONO_TYPE_U8: {
1179                 guint64 l =  va_arg (ap, guint64);
1180                 printf ("[ULONG:%lu]", l);
1181                 break;
1182         }
1183         case MONO_TYPE_R4: {
1184                 double f = va_arg (ap, double);
1185                 printf ("[FLOAT4:%g]\n", f);
1186                 break;
1187         }
1188         case MONO_TYPE_R8: {
1189                 double f = va_arg (ap, double);
1190                 printf ("[FLOAT8:%g]\n", f);
1191                 break;
1192         }
1193         case MONO_TYPE_VALUETYPE: {
1194                 MonoMarshalType *info;
1195                 if (type->data.klass->enumtype) {
1196                         type = mono_class_enum_basetype (type->data.klass);
1197                         goto handle_enum;
1198                 } else {
1199                         int size, align;
1200
1201                         info = mono_marshal_load_type_info (type->data.klass);
1202
1203                         if ((info->native_size == sizeof(float)) &&
1204                             (info->num_fields  == 1) &&
1205                             (info->fields[0].field->type->type == MONO_TYPE_R4)) {
1206                                 double f = va_arg (ap, double);
1207                                 printf("[FLOAT4:%g]\n", (double) f);
1208                                 break;
1209                         }
1210
1211                         if ((info->native_size == sizeof(double)) &&
1212                             (info->num_fields  == 1) &&
1213                             (info->fields[0].field->type->type == MONO_TYPE_R8)) {
1214                                 double f = va_arg (ap, double);
1215                                 printf("[FLOAT8:%g]\n", f);
1216                                 break;
1217                         }
1218
1219                         size = mono_type_size (type, &align);
1220                         switch (size) {
1221                                 case 1: {
1222                                         guint32 p = va_arg (ap, guint32);
1223                                         printf ("[%02x]\n",p);
1224                                         break;
1225                                 }
1226                                 case 2: {
1227                                         guint32 p = va_arg (ap, guint32);
1228                                         printf ("[%04x]\n",p);
1229                                         break;
1230                                 }
1231                                 case 4: {
1232                                         guint32 p = va_arg (ap, guint32);
1233                                         printf ("[%08x]\n",p);
1234                                         break;
1235                                 }
1236                                 case 8: {
1237                                         guint64 p = va_arg (ap, guint64);
1238                                         printf ("[%016lx]\n",p);
1239                                         break;
1240                                 }
1241                                 default: {
1242                                         gpointer p = va_arg (ap, gpointer);
1243                                         printf ("[VALUETYPE] %p\n",p);
1244                                 }
1245                         }
1246                 }
1247                 break;
1248         }
1249         case MONO_TYPE_TYPEDBYREF: {
1250                 guint8 *p = va_arg (ap, gpointer);
1251                 int j, size, align;
1252                 size = mono_type_size (type, &align);
1253                 switch (size) {
1254                 case 1:
1255                 case 2:
1256                 case 4:
1257                 case 8:
1258                         printf ("[");
1259                         for (j = 0; p && j < size; j++)
1260                                 printf ("%02x,", p [j]);
1261                         printf ("]\n");
1262                         break;
1263                 default:
1264                         printf ("[TYPEDBYREF]\n");
1265                 }
1266         }
1267                 break;
1268         case MONO_TYPE_GENERICINST: {
1269                 printf("[GENERICINST]\n");
1270         }
1271                 break;
1272         case MONO_TYPE_MVAR: {
1273                 printf("[MVAR]\n");
1274         }
1275                 break;
1276         case MONO_TYPE_CMOD_REQD: {
1277                 printf("[CMOD_REQD]\n");
1278         }
1279                 break;
1280         case MONO_TYPE_CMOD_OPT: {
1281                 printf("[CMOD_OPT]\n");
1282         }
1283                 break;
1284         case MONO_TYPE_INTERNAL: {
1285                 printf("[INTERNAL]\n");
1286         }
1287                 break;
1288         default:
1289                 printf ("(unknown return type %x)",
1290                         mono_method_signature (method)->ret->type);
1291         }
1292
1293         ip = ((gint64) __builtin_extract_return_addr (__builtin_return_address (0)));
1294         printf (" ip: %p\n", (gpointer) ip);
1295         va_end (ap);
1296 }
1297
1298 /*========================= End of Function ========================*/
1299
1300 /*------------------------------------------------------------------*/
1301 /*                                                                  */
1302 /* Name         - mono_arch_cpu_init                                */
1303 /*                                                                  */
1304 /* Function     - Perform CPU specific initialization to execute    */
1305 /*                managed code.                                     */
1306 /*                                                                  */
1307 /*------------------------------------------------------------------*/
1308
1309 void
1310 mono_arch_cpu_init (void)
1311 {
1312 }
1313
1314 /*========================= End of Function ========================*/
1315
1316 /*------------------------------------------------------------------*/
1317 /*                                                                  */
1318 /* Name         - mono_arch_init.                                   */
1319 /*                                                                  */
1320 /* Function     - Initialize architecture specific code.            */
1321 /*                                                                  */
1322 /*------------------------------------------------------------------*/
1323
1324 void
1325 mono_arch_init (void)
1326 {
1327         guint8 *code;
1328
1329         mono_set_partial_sharing_supported (FALSE);
1330         mono_os_mutex_init_recursive (&mini_arch_mutex);
1331
1332         ss_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ, MONO_MEM_ACCOUNT_OTHER);
1333         bp_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ, MONO_MEM_ACCOUNT_OTHER);
1334         mono_mprotect (bp_trigger_page, mono_pagesize (), 0);
1335
1336         code = (guint8 *) &breakpointCode;
1337         s390_basr(code, s390_r13, 0);
1338         s390_j(code, 6);
1339         s390_llong(code, 0);
1340         s390_lg(code, s390_r13, 0, s390_r13, 4);
1341         s390_lg(code, s390_r0, 0, s390_r13, 0);
1342 }
1343
1344 /*========================= End of Function ========================*/
1345
1346 /*------------------------------------------------------------------*/
1347 /*                                                                  */
1348 /* Name         - mono_arch_cleanup.                                */
1349 /*                                                                  */
1350 /* Function     - Cleanup architecture specific code    .           */
1351 /*                                                                  */
1352 /*------------------------------------------------------------------*/
1353
1354 void
1355 mono_arch_cleanup (void)
1356 {
1357         if (ss_trigger_page)
1358                 mono_vfree (ss_trigger_page, mono_pagesize (), MONO_MEM_ACCOUNT_OTHER);
1359         if (bp_trigger_page)
1360                 mono_vfree (bp_trigger_page, mono_pagesize (), MONO_MEM_ACCOUNT_OTHER);
1361         mono_os_mutex_destroy (&mini_arch_mutex);
1362 }
1363
1364 /*========================= End of Function ========================*/
1365
1366 /*------------------------------------------------------------------*/
1367 /*                                                                  */
1368 /* Name         - mono_arch_cpu_optimizations                       */
1369 /*                                                                  */
1370 /* Function     - Returns the optimizations supported on this CPU   */
1371 /*                                                                  */
1372 /*------------------------------------------------------------------*/
1373
1374 guint32
1375 mono_arch_cpu_optimizations (guint32 *exclude_mask)
1376 {
1377         guint32 opts = 0;
1378
1379         /*----------------------------------------------------------*/
1380         /* No s390-specific optimizations yet                       */
1381         /*----------------------------------------------------------*/
1382         *exclude_mask = MONO_OPT_LINEARS;
1383         return opts;
1384 }
1385
1386 /*========================= End of Function ========================*/
1387
1388 /*------------------------------------------------------------------*/
1389 /*                                                                  */
1390 /* Name         - mono_arch_get_allocatable_int_vars                */
1391 /*                                                                  */
1392 /* Function     -                                                   */
1393 /*                                                                  */
1394 /*------------------------------------------------------------------*/
1395
1396 GList *
1397 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
1398 {
1399         GList *vars = NULL;
1400         int i;
1401
1402         for (i = 0; i < cfg->num_varinfo; i++) {
1403                 MonoInst *ins = cfg->varinfo [i];
1404                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
1405
1406                 /* unused vars */
1407                 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
1408                         continue;
1409
1410                 if (ins->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) ||
1411                     (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
1412                         continue;
1413
1414                 /* we can only allocate 32 bit values */
1415                 if (mono_is_regsize_var(ins->inst_vtype)) {
1416                         g_assert (MONO_VARINFO (cfg, i)->reg == -1);
1417                         g_assert (i == vmv->idx);
1418                         vars = mono_varlist_insert_sorted (cfg, vars, vmv, FALSE);
1419                 }
1420         }
1421
1422         return vars;
1423 }
1424
1425 /*========================= End of Function ========================*/
1426
1427 /*------------------------------------------------------------------*/
1428 /*                                                                  */
1429 /* Name         - mono_arch_global_int_regs                         */
1430 /*                                                                  */
1431 /* Function     - Return a list of usable integer registers.        */
1432 /*                                                                  */
1433 /*------------------------------------------------------------------*/
1434
1435 GList *
1436 mono_arch_get_global_int_regs (MonoCompile *cfg)
1437 {
1438         GList *regs = NULL;
1439         MonoMethodHeader *header;
1440         int i, top = 13;
1441
1442         header = cfg->header;
1443         if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
1444                 cfg->frame_reg = s390_r11;
1445
1446
1447         /* FIXME: s390_r12 is reserved for bkchain_reg. Only reserve it if needed */
1448         top = 12;
1449         for (i = 8; i < top; ++i) {
1450                 if (cfg->frame_reg != i)
1451                         regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
1452         }
1453
1454         return regs;
1455 }
1456
1457 /*========================= End of Function ========================*/
1458
1459 /*------------------------------------------------------------------*/
1460 /*                                                                  */
1461 /* Name         -  mono_arch_flush_icache                           */
1462 /*                                                                  */
1463 /* Function     -  Flush the CPU icache.                            */
1464 /*                                                                  */
1465 /*------------------------------------------------------------------*/
1466
1467 void
1468 mono_arch_flush_icache (guint8 *code, gint size)
1469 {
1470 }
1471
1472 /*========================= End of Function ========================*/
1473
1474 /*------------------------------------------------------------------*/
1475 /*                                                                  */
1476 /* Name         - add_general                                       */
1477 /*                                                                  */
1478 /* Function     - Determine code and stack size incremements for a  */
1479 /*                parameter.                                        */
1480 /*                                                                  */
1481 /*------------------------------------------------------------------*/
1482
1483 static void inline
1484 add_general (guint *gr, size_data *sz, ArgInfo *ainfo)
1485 {
1486         if (*gr > S390_LAST_ARG_REG) {
1487                 sz->stack_size  = S390_ALIGN(sz->stack_size, sizeof(long));
1488                 ainfo->offset   = sz->stack_size;
1489                 ainfo->reg      = STK_BASE;
1490                 ainfo->regtype  = RegTypeBase;
1491                 sz->stack_size += sizeof(long);
1492                 sz->local_size += sizeof(long);
1493                 sz->offStruct  += sizeof(long);
1494                 sz->code_size  += 12;
1495         } else {
1496                 ainfo->reg      = *gr;
1497                 sz->code_size  += 8;
1498         }
1499         (*gr) ++;
1500 }
1501
1502 /*========================= End of Function ========================*/
1503
1504 /*------------------------------------------------------------------*/
1505 /*                                                                  */
1506 /* Name         - add_stackParm                                     */
1507 /*                                                                  */
1508 /* Function     - Determine code and stack size incremements for a  */
1509 /*                parameter.                                        */
1510 /*                                                                  */
1511 /*------------------------------------------------------------------*/
1512
1513 static void inline
1514 add_stackParm (guint *gr, size_data *sz, ArgInfo *ainfo, gint size)
1515 {
1516         if (*gr > S390_LAST_ARG_REG) {
1517                 sz->stack_size  = S390_ALIGN(sz->stack_size, sizeof(long));
1518                 ainfo->reg          = STK_BASE;
1519                 ainfo->offset   = sz->stack_size;
1520                 ainfo->regtype  = RegTypeStructByAddrOnStack;
1521                 sz->stack_size += sizeof (gpointer);
1522                 sz->parm_size  += sizeof(gpointer);
1523                 sz->offStruct  += sizeof(gpointer);
1524         } else {
1525                 ainfo->reg      = *gr;
1526                 ainfo->offset   = sz->stack_size;
1527                 ainfo->regtype  = RegTypeStructByAddr;
1528         }
1529         (*gr) ++;
1530         ainfo->offparm  = sz->offset;
1531         sz->offset      = S390_ALIGN(sz->offset+size, sizeof(long));
1532         ainfo->size     = size;
1533         ainfo->vtsize   = size;
1534         sz->parm_size  += size;
1535 }
1536
1537 /*========================= End of Function ========================*/
1538
1539 /*------------------------------------------------------------------*/
1540 /*                                                                  */
1541 /* Name         - add_float                                         */
1542 /*                                                                  */
1543 /* Function     - Determine code and stack size incremements for a  */
1544 /*                float parameter.                                  */
1545 /*                                                                  */
1546 /*------------------------------------------------------------------*/
1547
1548 static void inline
1549 add_float (guint *fr,  size_data *sz, ArgInfo *ainfo)
1550 {
1551         if ((*fr) <= S390_LAST_FPARG_REG) {
1552                 ainfo->regtype = RegTypeFP;
1553                 ainfo->reg     = *fr;
1554                 sz->code_size += 4;
1555                 (*fr) += 2;
1556         }
1557         else {
1558                 ainfo->offset   = sz->stack_size;
1559                 ainfo->reg      = STK_BASE;
1560                 ainfo->regtype  = RegTypeBase;
1561                 sz->code_size  += 4;
1562                 sz->stack_size += sizeof(double);
1563                 sz->local_size += sizeof(double);
1564                 sz->offStruct  += sizeof(double);
1565         }
1566 }
1567
1568 /*========================= End of Function ========================*/
1569
1570 /*------------------------------------------------------------------*/
1571 /*                                                                  */
1572 /* Name         - get_call_info                                     */
1573 /*                                                                  */
1574 /* Function     - Determine the amount of space required for code   */
1575 /*                and stack. In addition determine starting points  */
1576 /*                for stack-based parameters, and area for struct-  */
1577 /*                ures being returned on the stack.                 */
1578 /*                                                                  */
1579 /*------------------------------------------------------------------*/
1580
1581 static CallInfo *
1582 get_call_info (MonoCompile *cfg, MonoMemPool *mp, MonoMethodSignature *sig)
1583 {
1584         guint i, fr, gr, size, pstart;
1585         int nParm = sig->hasthis + sig->param_count;
1586         MonoType *ret_type;
1587         guint32 simpleType, align;
1588         gboolean is_pinvoke = sig->pinvoke;
1589         CallInfo *cinfo;
1590         size_data *sz;
1591
1592         if (mp)
1593                 cinfo = mono_mempool_alloc0 (mp, sizeof (CallInfo) + sizeof (ArgInfo) * nParm);
1594         else
1595                 cinfo = g_malloc0 (sizeof (CallInfo) + sizeof (ArgInfo) * nParm);
1596
1597         fr                = 0;
1598         gr                = s390_r2;
1599         nParm             = 0;
1600         cinfo->struct_ret = 0;
1601         sz                = &cinfo->sz;
1602         sz->retStruct     = 0;
1603         sz->offset        = 0;
1604         sz->offStruct     = S390_MINIMAL_STACK_SIZE;
1605         sz->stack_size    = S390_MINIMAL_STACK_SIZE;
1606         sz->code_size     = 0;
1607         sz->parm_size     = 0;
1608         sz->local_size    = 0;
1609         align             = 0;
1610         size              = 0;
1611
1612         /*----------------------------------------------------------*/
1613         /* We determine the size of the return code/stack in case we*/
1614         /* need to reserve a register to be used to address a stack */
1615         /* area that the callee will use.                           */
1616         /*----------------------------------------------------------*/
1617
1618         ret_type = mini_get_underlying_type (sig->ret);
1619         simpleType = ret_type->type;
1620 enum_retvalue:
1621         switch (simpleType) {
1622                 case MONO_TYPE_BOOLEAN:
1623                 case MONO_TYPE_I1:
1624                 case MONO_TYPE_U1:
1625                 case MONO_TYPE_I2:
1626                 case MONO_TYPE_U2:
1627                 case MONO_TYPE_CHAR:
1628                 case MONO_TYPE_I4:
1629                 case MONO_TYPE_U4:
1630                 case MONO_TYPE_I:
1631                 case MONO_TYPE_U:
1632                 case MONO_TYPE_CLASS:
1633                 case MONO_TYPE_OBJECT:
1634                 case MONO_TYPE_SZARRAY:
1635                 case MONO_TYPE_ARRAY:
1636                 case MONO_TYPE_PTR:
1637                 case MONO_TYPE_FNPTR:
1638                 case MONO_TYPE_STRING:
1639                         cinfo->ret.reg = s390_r2;
1640                         sz->code_size += 4;
1641                         break;
1642                 case MONO_TYPE_R4:
1643                 case MONO_TYPE_R8:
1644                         cinfo->ret.reg = s390_f0;
1645                         sz->code_size += 4;
1646                         break;
1647                 case MONO_TYPE_I8:
1648                 case MONO_TYPE_U8:
1649                         cinfo->ret.reg = s390_r2;
1650                         sz->code_size += 4;
1651                         break;
1652                 case MONO_TYPE_GENERICINST:
1653                         if (!mono_type_generic_inst_is_valuetype (sig->ret)) {
1654                                 cinfo->ret.reg = s390_r2;
1655                                 sz->code_size += 4;
1656                                 break;
1657                         }
1658                         /* Fall through */
1659                 case MONO_TYPE_VALUETYPE: {
1660                         MonoClass *klass = mono_class_from_mono_type (sig->ret);
1661                         if (klass->enumtype) {
1662                                 simpleType = mono_class_enum_basetype (klass)->type;
1663                                 goto enum_retvalue;
1664                         }
1665                         size = mini_type_stack_size_full (&klass->byval_arg, NULL, sig->pinvoke);
1666
1667                         cinfo->struct_ret = 1;
1668                         cinfo->ret.size   = size;
1669                         cinfo->ret.vtsize = size;
1670                         break;
1671                 }
1672                 case MONO_TYPE_TYPEDBYREF:
1673                         size = sizeof (MonoTypedRef);
1674                         cinfo->struct_ret = 1;
1675                         cinfo->ret.size   = size;
1676                         cinfo->ret.vtsize = size;
1677                         break;
1678                 case MONO_TYPE_VOID:
1679                         break;
1680                 default:
1681                         g_error ("Can't handle as return value 0x%x", sig->ret->type);
1682         }
1683
1684
1685         pstart = 0;
1686         /*
1687          * To simplify get_this_arg_reg () and LLVM integration, emit the vret arg after
1688          * the first argument, allowing 'this' to be always passed in the first arg reg.
1689          * Also do this if the first argument is a reference type, since virtual calls
1690          * are sometimes made using calli without sig->hasthis set, like in the delegate
1691          * invoke wrappers.
1692          */
1693         if (cinfo->struct_ret && !is_pinvoke &&
1694             (sig->hasthis ||
1695              (sig->param_count > 0 &&
1696               MONO_TYPE_IS_REFERENCE (mini_get_underlying_type (sig->params [0]))))) {
1697                 if (sig->hasthis) {
1698                         cinfo->args[nParm].size = sizeof (gpointer);
1699                         add_general (&gr, sz, cinfo->args + nParm);
1700                 } else {
1701                         cinfo->args[nParm].size = sizeof (gpointer);
1702                         add_general (&gr, sz, &cinfo->args [sig->hasthis + nParm]);
1703                         pstart = 1;
1704                 }
1705                 nParm ++;
1706                 cinfo->vret_arg_index = 1;
1707                 cinfo->ret.reg = gr;
1708                 gr ++;
1709         } else {
1710                 /* this */
1711                 if (sig->hasthis) {
1712                         cinfo->args[nParm].size = sizeof (gpointer);
1713                         add_general (&gr, sz, cinfo->args + nParm);
1714                         nParm ++;
1715                 }
1716
1717                 if (cinfo->struct_ret) {
1718                         cinfo->ret.reg = gr;
1719                         gr ++;
1720                 }
1721         }
1722
1723         if ((sig->call_convention == MONO_CALL_VARARG) && (sig->param_count == 0)) {
1724                 gr = S390_LAST_ARG_REG + 1;
1725                 fr = S390_LAST_FPARG_REG + 1;
1726
1727                 /* Emit the signature cookie just before the implicit arguments */
1728                 add_general (&gr, sz, &cinfo->sigCookie);
1729         }
1730
1731         /*----------------------------------------------------------*/
1732         /* We determine the size of the parameter code and stack    */
1733         /* requirements by checking the types and sizes of the      */
1734         /* parameters.                                              */
1735         /*----------------------------------------------------------*/
1736
1737         for (i = pstart; i < sig->param_count; ++i) {
1738                 MonoType *ptype;
1739
1740                 /*--------------------------------------------------*/
1741                 /* Handle vararg type calls. All args are put on    */
1742                 /* the stack.                                       */
1743                 /*--------------------------------------------------*/
1744                 if ((sig->call_convention == MONO_CALL_VARARG) &&
1745                     (i == sig->sentinelpos)) {
1746                         gr = S390_LAST_ARG_REG + 1;
1747                         fr = S390_LAST_FPARG_REG + 1;
1748                         add_general (&gr, sz, &cinfo->sigCookie);
1749                 }
1750
1751                 if (sig->params [i]->byref) {
1752                         add_general (&gr, sz, cinfo->args+nParm);
1753                         cinfo->args[nParm].size = sizeof(gpointer);
1754                         nParm++;
1755                         continue;
1756                 }
1757
1758                 ptype = mini_get_underlying_type (sig->params [i]);
1759                 simpleType = ptype->type;
1760                 cinfo->args[nParm].type = simpleType;
1761                 switch (simpleType) {
1762                 case MONO_TYPE_BOOLEAN:
1763                 case MONO_TYPE_I1:
1764                 case MONO_TYPE_U1:
1765                         cinfo->args[nParm].size = sizeof(char);
1766                         add_general (&gr, sz, cinfo->args+nParm);
1767                         nParm++;
1768                         break;
1769                 case MONO_TYPE_I2:
1770                 case MONO_TYPE_U2:
1771                 case MONO_TYPE_CHAR:
1772                         cinfo->args[nParm].size = sizeof(short);
1773                         add_general (&gr, sz, cinfo->args+nParm);
1774                         nParm++;
1775                         break;
1776                 case MONO_TYPE_I4:
1777                 case MONO_TYPE_U4:
1778                         cinfo->args[nParm].size = sizeof(int);
1779                         add_general (&gr, sz, cinfo->args+nParm);
1780                         nParm++;
1781                         break;
1782                 case MONO_TYPE_I:
1783                 case MONO_TYPE_U:
1784                 case MONO_TYPE_PTR:
1785                 case MONO_TYPE_FNPTR:
1786                 case MONO_TYPE_CLASS:
1787                 case MONO_TYPE_OBJECT:
1788                 case MONO_TYPE_STRING:
1789                 case MONO_TYPE_SZARRAY:
1790                 case MONO_TYPE_ARRAY:
1791                         cinfo->args[nParm].size = sizeof(gpointer);
1792                         add_general (&gr, sz, cinfo->args+nParm);
1793                         nParm++;
1794                         break;
1795                 case MONO_TYPE_I8:
1796                 case MONO_TYPE_U8:
1797                         cinfo->args[nParm].size = sizeof(long long);
1798                         add_general (&gr, sz, cinfo->args+nParm);
1799                         nParm++;
1800                         break;
1801                 case MONO_TYPE_R4:
1802                         cinfo->args[nParm].size = sizeof(float);
1803                         add_float (&fr, sz, cinfo->args+nParm);
1804                         nParm++;
1805                         break;
1806                 case MONO_TYPE_R8:
1807                         cinfo->args[nParm].size = sizeof(double);
1808                         add_float (&fr, sz, cinfo->args+nParm);
1809                         nParm++;
1810                         break;
1811                 case MONO_TYPE_GENERICINST:
1812                         if (!mono_type_generic_inst_is_valuetype (ptype)) {
1813                                 cinfo->args[nParm].size = sizeof(gpointer);
1814                                 add_general (&gr, sz, cinfo->args+nParm);
1815                                 nParm++;
1816                                 break;
1817                         }
1818                         /* Fall through */
1819                 case MONO_TYPE_VALUETYPE: {
1820                         MonoMarshalType *info;
1821                         MonoClass *klass = mono_class_from_mono_type (ptype);
1822
1823                         if (sig->pinvoke)
1824                                 size = mono_class_native_size(klass, NULL);
1825                         else
1826                                 size = mono_class_value_size(klass, NULL);
1827
1828                         if (simpleType != MONO_TYPE_GENERICINST) {
1829                                 info = mono_marshal_load_type_info(klass);
1830
1831                                 if ((info->native_size == sizeof(float)) &&
1832                                     (info->num_fields  == 1) &&
1833                                     (info->fields[0].field->type->type == MONO_TYPE_R4)) {
1834                                         cinfo->args[nParm].size = sizeof(float);
1835                                         add_float(&fr, sz, cinfo->args+nParm);
1836                                         nParm ++;
1837                                         break;
1838                                 }
1839
1840                                 if ((info->native_size == sizeof(double)) &&
1841                                     (info->num_fields  == 1) &&
1842                                     (info->fields[0].field->type->type == MONO_TYPE_R8)) {
1843                                         cinfo->args[nParm].size = sizeof(double);
1844                                         add_float(&fr, sz, cinfo->args+nParm);
1845                                         nParm ++;
1846                                         break;
1847                                 }
1848                         }
1849
1850                         cinfo->args[nParm].vtsize  = 0;
1851                         cinfo->args[nParm].size    = 0;
1852
1853                         switch (size) {
1854                                 /*----------------------------------*/
1855                                 /* On S/390, structures of size 1,  */
1856                                 /* 2, 4, and 8 bytes are passed in  */
1857                                 /* (a) register(s).                 */
1858                                 /*----------------------------------*/
1859                                 case 0:
1860                                 case 1:
1861                                 case 2:
1862                                 case 4:
1863                                 case 8:
1864                                         add_general(&gr, sz, cinfo->args+nParm);
1865                                         cinfo->args[nParm].size    = size;
1866                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1867                                         nParm++;
1868                                         sz->local_size            += sizeof(long);
1869                                         break;
1870                                 default:
1871                                         add_stackParm(&gr, sz, cinfo->args+nParm, size);
1872                                         nParm++;
1873                         }
1874                 }
1875                         break;
1876                 case MONO_TYPE_TYPEDBYREF: {
1877                         int size = sizeof (MonoTypedRef);
1878
1879                         cinfo->args[nParm].vtsize  = 0;
1880                         cinfo->args[nParm].size    = 0;
1881
1882                         switch (size) {
1883                                 /*----------------------------------*/
1884                                 /* On S/390, structures of size 1,  */
1885                                 /* 2, 4, and 8 bytes are passed in  */
1886                                 /* (a) register(s).                 */
1887                                 /*----------------------------------*/
1888                                 case 0:
1889                                 case 1:
1890                                 case 2:
1891                                 case 4:
1892                                 case 8:
1893                                         add_general(&gr, sz, cinfo->args+nParm);
1894                                         cinfo->args[nParm].size    = size;
1895                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1896                                         nParm++;
1897                                         sz->local_size            += sizeof(long);
1898                                         break;
1899                                 default:
1900                                         add_stackParm(&gr, sz, cinfo->args+nParm, size);
1901                                         nParm++;
1902                         }
1903                 }
1904                         break;
1905                 default:
1906                         g_error ("Can't trampoline 0x%x", ptype);
1907                 }
1908         }
1909
1910         /*----------------------------------------------------------*/
1911         /* Handle the case where there are no implicit arguments    */
1912         /*----------------------------------------------------------*/
1913         if ((sig->call_convention == MONO_CALL_VARARG) &&
1914             (nParm > 0) &&
1915             (!sig->pinvoke) &&
1916             (sig->param_count == sig->sentinelpos)) {
1917                 gr = S390_LAST_ARG_REG + 1;
1918                 fr = S390_LAST_FPARG_REG + 1;
1919                 add_general (&gr, sz, &cinfo->sigCookie);
1920         }
1921
1922         /*----------------------------------------------------------*/
1923         /* If we are passing a structure back then if it won't be   */
1924         /* in a register(s) then we make room at the end of the     */
1925         /* parameters that may have been placed on the stack        */
1926         /*----------------------------------------------------------*/
1927         if (cinfo->struct_ret) {
1928                 cinfo->ret.offset = sz->stack_size;
1929                 switch (cinfo->ret.size) {
1930                 case 0:
1931                 case 1:
1932                 case 2:
1933                 case 4:
1934                 case 8:
1935                         break;
1936                 default:
1937                         sz->stack_size   += S390_ALIGN(cinfo->ret.size, align);
1938                 }
1939         }
1940
1941         cinfo->lastgr   = gr;
1942         sz->stack_size  = sz->stack_size + sz->local_size + sz->parm_size +
1943                           sz->offset;
1944         sz->stack_size  = S390_ALIGN(sz->stack_size, sizeof(long));
1945
1946         return (cinfo);
1947 }
1948
1949 /*========================= End of Function ========================*/
1950
1951 /*------------------------------------------------------------------*/
1952 /*                                                                  */
1953 /* Name         - mono_arch_allocate_vars                           */
1954 /*                                                                  */
1955 /* Function     - Set var information according to the calling      */
1956 /*                convention for S/390. The local var stuff should  */
1957 /*                most likely be split in another method.           */
1958 /*                                                                  */
1959 /* Parameter    - @m - Compile unit.                                */
1960 /*                                                                  */
1961 /*------------------------------------------------------------------*/
1962
1963 void
1964 mono_arch_allocate_vars (MonoCompile *cfg)
1965 {
1966         MonoMethodSignature *sig;
1967         MonoMethodHeader *header;
1968         MonoInst *inst;
1969         CallInfo *cinfo;
1970         int iParm, iVar, offset, align, size, curinst;
1971         int frame_reg = STK_BASE;
1972         int sArg, eArg;
1973
1974         header  = cfg->header;
1975
1976         cfg->flags |= MONO_CFG_HAS_SPILLUP;
1977
1978         /*---------------------------------------------------------*/
1979         /* We use the frame register also for any method that has  */
1980         /* filter clauses. This way, when the handlers are called, */
1981         /* the code will reference local variables using the frame */
1982         /* reg instead of the stack pointer: if we had to restore  */
1983         /* the stack pointer, we'd corrupt the method frames that  */
1984         /* are already on the stack (since filters get called      */
1985         /* before stack unwinding happens) when the filter code    */
1986         /* would call any method.                                  */
1987         /*---------------------------------------------------------*/
1988         if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
1989                 frame_reg = s390_r11;
1990
1991         cfg->frame_reg = frame_reg;
1992
1993         cfg->arch.bkchain_reg = -1;
1994
1995         if (frame_reg != STK_BASE)
1996                 cfg->used_int_regs |= (1 << frame_reg);
1997
1998         if (cfg->uses_rgctx_reg)
1999                 cfg->used_int_regs |= (1 << MONO_ARCH_IMT_REG);
2000
2001         sig     = mono_method_signature (cfg->method);
2002
2003         cinfo   = get_call_info (cfg, cfg->mempool, sig);
2004
2005         if (!cinfo->struct_ret) {
2006                 switch (mini_get_underlying_type (sig->ret)->type) {
2007                 case MONO_TYPE_VOID:
2008                         break;
2009                 default:
2010                         cfg->ret->opcode = OP_REGVAR;
2011                         cfg->ret->dreg   = s390_r2;
2012                         break;
2013                 }
2014         }
2015
2016         /*--------------------------------------------------------------*/
2017         /* local vars are at a positive offset from the stack pointer   */
2018         /* also note that if the function uses alloca, we use s390_r11  */
2019         /* to point at the local variables.                             */
2020         /* add parameter area size for called functions                 */
2021         /*--------------------------------------------------------------*/
2022         if (cfg->param_area == 0)
2023                 offset = S390_MINIMAL_STACK_SIZE;
2024         else
2025                 offset = cfg->param_area;
2026
2027         cfg->sig_cookie = 0;
2028
2029         if (cinfo->struct_ret) {
2030                 inst               = cfg->vret_addr;
2031                 offset             = S390_ALIGN(offset, sizeof(gpointer));
2032                 inst->inst_offset  = offset;
2033                 inst->opcode       = OP_REGOFFSET;
2034                 inst->inst_basereg = frame_reg;
2035                 offset            += sizeof(gpointer);
2036                 if (G_UNLIKELY (cfg->verbose_level > 1)) {
2037                         printf ("vret_addr =");
2038                         mono_print_ins (cfg->vret_addr);
2039                 }
2040         }
2041
2042         if (sig->hasthis) {
2043                 inst = cfg->args [0];
2044                 if (inst->opcode != OP_REGVAR) {
2045                         inst->opcode       = OP_REGOFFSET;
2046                         inst->inst_basereg = frame_reg;
2047                         offset             = S390_ALIGN(offset, sizeof(gpointer));
2048                         inst->inst_offset  = offset;
2049                         offset            += sizeof (gpointer);
2050                 }
2051                 curinst = sArg = 1;
2052         } else {
2053                 curinst = sArg = 0;
2054         }
2055
2056         eArg = sig->param_count + sArg;
2057
2058         if (sig->call_convention == MONO_CALL_VARARG)
2059                 cfg->sig_cookie += S390_MINIMAL_STACK_SIZE;
2060
2061         for (iParm = sArg; iParm < eArg; ++iParm) {
2062                 inst = cfg->args [curinst];
2063                 if (inst->opcode != OP_REGVAR) {
2064                         switch (cinfo->args[iParm].regtype) {
2065                         case RegTypeStructByAddr : {
2066                                 MonoInst *indir;
2067
2068                                 size = sizeof (gpointer);
2069
2070                                 inst->opcode       = OP_REGOFFSET;
2071                                 inst->inst_basereg = frame_reg;
2072                                 offset             = S390_ALIGN (offset, sizeof (gpointer));
2073                                 inst->inst_offset  = offset;
2074
2075                                 /* Add a level of indirection */
2076                                 MONO_INST_NEW (cfg, indir, 0);
2077                                 *indir          = *inst;
2078                                 inst->opcode    = OP_VTARG_ADDR;
2079                                 inst->inst_left = indir;
2080                         }
2081                                 break;
2082                         case RegTypeStructByAddrOnStack : {
2083                                 MonoInst *indir;
2084
2085                                 size = sizeof (gpointer);
2086
2087                                 /* Similar to the == STK_BASE case below */
2088                                 cfg->arch.bkchain_reg = s390_r12;
2089                                 cfg->used_int_regs |= 1 << cfg->arch.bkchain_reg;
2090
2091                                 inst->opcode = OP_REGOFFSET;
2092                                 inst->dreg = mono_alloc_preg (cfg);
2093                                 inst->inst_basereg = cfg->arch.bkchain_reg;
2094                                 inst->inst_offset = cinfo->args [iParm].offset;
2095
2096                                 /* Add a level of indirection */
2097                                 MONO_INST_NEW (cfg, indir, 0);
2098                                 *indir = *inst;
2099                                 inst->opcode = OP_VTARG_ADDR;
2100                                 inst->inst_left = indir;
2101                                 break;
2102                         }
2103                         case RegTypeStructByVal :
2104                                 size               = cinfo->args[iParm].size;
2105                                 offset             = S390_ALIGN(offset, size);
2106                                 inst->opcode       = OP_REGOFFSET;
2107                                 inst->inst_basereg = frame_reg;
2108                                 inst->inst_offset  = offset;
2109                                 break;
2110                         default :
2111                                 if (cinfo->args [iParm].reg == STK_BASE) {
2112                                         /*
2113                                          * These arguments are in the previous frame, so we can't
2114                                          * compute their offset from the current frame pointer right
2115                                          * now, since cfg->stack_offset is not yet known, so dedicate a
2116                                          * register holding the previous frame pointer.
2117                                          */
2118                                         cfg->arch.bkchain_reg = s390_r12;
2119                                         cfg->used_int_regs |= 1 << cfg->arch.bkchain_reg;
2120
2121                                         inst->opcode       = OP_REGOFFSET;
2122                                         inst->inst_basereg = cfg->arch.bkchain_reg;
2123                                         size               = (cinfo->args[iParm].size < 8
2124                                                                           ? 8 - cinfo->args[iParm].size
2125                                                                           : 0);
2126                                         inst->inst_offset  = cinfo->args [iParm].offset + size;
2127                                         size = sizeof (long);
2128                                 } else {
2129                                         inst->opcode       = OP_REGOFFSET;
2130                                         inst->inst_basereg = frame_reg;
2131                                         size               = (cinfo->args[iParm].size < 8
2132                                                                           ? sizeof(int)
2133                                                                           : sizeof(long));
2134                                         offset             = S390_ALIGN(offset, size);
2135                                         if (cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
2136                                                 inst->inst_offset  = offset;
2137                                         else
2138                                                 inst->inst_offset  = offset + (8 - size);
2139                                 }
2140                                 break;
2141                         }
2142 #if 0
2143                         if ((sig->call_convention == MONO_CALL_VARARG) &&
2144                             (cinfo->args[iParm].regtype != RegTypeGeneral) &&
2145                             (iParm < sig->sentinelpos))
2146                                 cfg->sig_cookie += size;
2147 printf("%s %4d cookine %x\n",__FUNCTION__,__LINE__,cfg->sig_cookie);
2148 #endif
2149
2150                         offset += MAX(size, 8);
2151                 }
2152                 curinst++;
2153         }
2154
2155         cfg->locals_min_stack_offset = offset;
2156
2157         curinst = cfg->locals_start;
2158         for (iVar = curinst; iVar < cfg->num_varinfo; ++iVar) {
2159                 inst = cfg->varinfo [iVar];
2160                 if ((inst->flags & MONO_INST_IS_DEAD) ||
2161                     (inst->opcode == OP_REGVAR))
2162                         continue;
2163
2164                 /*--------------------------------------------------*/
2165                 /* inst->backend.is_pinvoke indicates native sized  */
2166                 /* value typs this is used by the pinvoke wrappers  */
2167                 /* when they call functions returning structure     */
2168                 /*--------------------------------------------------*/
2169                 if (inst->backend.is_pinvoke && MONO_TYPE_ISSTRUCT (inst->inst_vtype))
2170                         size = mono_class_native_size (mono_class_from_mono_type(inst->inst_vtype),
2171                                                        (guint32 *) &align);
2172                 else
2173                         size = mono_type_size (inst->inst_vtype, &align);
2174
2175                 offset             = S390_ALIGN(offset, align);
2176                 inst->inst_offset  = offset;
2177                 inst->opcode       = OP_REGOFFSET;
2178                 inst->inst_basereg = frame_reg;
2179                 offset            += size;
2180                 DEBUG (g_print("allocating local %d to %ld, size: %d\n",
2181                                 iVar, inst->inst_offset, size));
2182         }
2183
2184         cfg->locals_max_stack_offset = offset;
2185
2186         /*------------------------------------------------------*/
2187         /* Allow space for the trace method stack area if needed*/
2188         /*------------------------------------------------------*/
2189         if ((mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method))
2190             || (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE))
2191                 offset += S390_TRACE_STACK_SIZE;
2192
2193         /*------------------------------------------------------*/
2194         /* Reserve space to save LMF and caller saved registers */
2195         /*------------------------------------------------------*/
2196         if (cfg->method->save_lmf)
2197                 offset += sizeof (MonoLMF);
2198
2199         /*------------------------------------------------------*/
2200         /* align the offset                                     */
2201         /*------------------------------------------------------*/
2202         cfg->stack_offset = S390_ALIGN(offset, S390_STACK_ALIGNMENT);
2203
2204         /*------------------------------------------------------*/
2205         /* Fix offsets for args whose value is in parent frame  */
2206         /*------------------------------------------------------*/
2207         for (iParm = sArg; iParm < eArg; ++iParm) {
2208                 inst = cfg->args [iParm];
2209
2210                 if (inst->opcode == OP_S390_STKARG) {
2211                         inst->opcode = OP_REGOFFSET;
2212                         inst->inst_offset += cfg->stack_offset;
2213                 }
2214         }
2215 }
2216
2217 /*========================= End of Function ========================*/
2218
2219 /*------------------------------------------------------------------*/
2220 /*                                                                  */
2221 /* Name         - mono_arch_create_vars                             */
2222 /*                                                                  */
2223 /*------------------------------------------------------------------*/
2224
2225 void
2226 mono_arch_create_vars (MonoCompile *cfg)
2227 {
2228         MonoMethodSignature *sig;
2229         CallInfo *cinfo;
2230
2231         sig = mono_method_signature (cfg->method);
2232
2233         cinfo = get_call_info (cfg, cfg->mempool, sig);
2234
2235         if (cinfo->struct_ret) {
2236                 cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
2237                 if (G_UNLIKELY (cfg->verbose_level > 1)) {
2238                         printf ("vret_addr = ");
2239                         mono_print_ins (cfg->vret_addr);
2240                 }
2241         }
2242 }
2243
2244 /*========================= End of Function ========================*/
2245
2246 /*------------------------------------------------------------------*/
2247 /*                                                                  */
2248 /* Name         - add_outarg_reg2.                                  */
2249 /*                                                                  */
2250 /*------------------------------------------------------------------*/
2251
2252 static void
2253 add_outarg_reg2 (MonoCompile *cfg, MonoCallInst *call, ArgStorage storage, int reg, MonoInst *tree)
2254 {
2255         MonoInst *ins;
2256
2257         switch (storage) {
2258         case RegTypeGeneral:
2259                 MONO_INST_NEW (cfg, ins, OP_MOVE);
2260                 ins->dreg = mono_alloc_ireg (cfg);
2261                 ins->sreg1 = tree->dreg;
2262                 MONO_ADD_INS (cfg->cbb, ins);
2263                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, reg, FALSE);
2264                 break;
2265         case RegTypeFP:
2266                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
2267                 ins->dreg = mono_alloc_freg (cfg);
2268                 ins->sreg1 = tree->dreg;
2269                 MONO_ADD_INS (cfg->cbb, ins);
2270                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, reg, TRUE);
2271                 break;
2272         case RegTypeFPR4:
2273                 MONO_INST_NEW (cfg, ins, OP_S390_SETF4RET);
2274                 ins->dreg = mono_alloc_freg (cfg);
2275                 ins->sreg1 = tree->dreg;
2276                 MONO_ADD_INS (cfg->cbb, ins);
2277                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, reg, TRUE);
2278                 break;
2279         default:
2280                 g_assert_not_reached ();
2281         }
2282 }
2283
2284 /*========================= End of Function ========================*/
2285
2286 /*------------------------------------------------------------------*/
2287 /*                                                                  */
2288 /* Name         - emit_sig_cookie.                                  */
2289 /*                                                                  */
2290 /*------------------------------------------------------------------*/
2291
2292 static void
2293 emit_sig_cookie (MonoCompile *cfg, MonoCallInst *call, CallInfo *cinfo)
2294 {
2295         MonoMethodSignature *tmpSig;
2296         MonoInst *sig_arg;
2297
2298         cfg->disable_aot = TRUE;
2299
2300         /*----------------------------------------------------------*/
2301         /* mono_ArgIterator_Setup assumes the signature cookie is   */
2302         /* passed first and all the arguments which were before it  */
2303         /* passed on the stack after the signature. So compensate   */
2304         /* by passing a different signature.                        */
2305         /*----------------------------------------------------------*/
2306         tmpSig = mono_metadata_signature_dup (call->signature);
2307         tmpSig->param_count -= call->signature->sentinelpos;
2308         tmpSig->sentinelpos  = 0;
2309         if (tmpSig->param_count > 0)
2310                 memcpy (tmpSig->params,
2311                         call->signature->params + call->signature->sentinelpos,
2312                         tmpSig->param_count * sizeof(MonoType *));
2313
2314         MONO_INST_NEW (cfg, sig_arg, OP_ICONST);
2315         sig_arg->dreg = mono_alloc_ireg (cfg);
2316         sig_arg->inst_p0 = tmpSig;
2317         MONO_ADD_INS (cfg->cbb, sig_arg);
2318
2319         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, STK_BASE,
2320                                      cinfo->sigCookie.offset, sig_arg->dreg);
2321 }
2322
2323 /*========================= End of Function ========================*/
2324
2325 /*------------------------------------------------------------------*/
2326 /*                                                                  */
2327 /* Name         - mono_arch_emit_call                               */
2328 /*                                                                  */
2329 /*------------------------------------------------------------------*/
2330
2331 void
2332 mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
2333 {
2334         MonoInst *in;
2335         MonoMethodSignature *sig;
2336         MonoInst *ins;
2337         int i, n, lParamArea;
2338         CallInfo *cinfo;
2339         ArgInfo *ainfo = NULL;
2340         int stackSize;
2341         MonoMethodHeader *header;
2342         int frmReg;
2343
2344         sig = call->signature;
2345         n = sig->param_count + sig->hasthis;
2346         DEBUG (g_print ("Call requires: %d parameters\n",n));
2347
2348         cinfo = get_call_info (cfg, cfg->mempool, sig);
2349
2350         stackSize         = cinfo->sz.stack_size + cinfo->sz.local_size +
2351                             cinfo->sz.parm_size + cinfo->sz.offset;
2352         call->stack_usage = MAX(stackSize, call->stack_usage);
2353         lParamArea        = MAX((call->stack_usage-S390_MINIMAL_STACK_SIZE-cinfo->sz.parm_size), 0);
2354         cfg->param_area   = MAX(((signed) cfg->param_area), lParamArea);
2355         cfg->flags       |= MONO_CFG_HAS_CALLS;
2356
2357         if (cinfo->struct_ret) {
2358                 MONO_INST_NEW (cfg, ins, OP_MOVE);
2359                 ins->sreg1 = call->vret_var->dreg;
2360                 ins->dreg = mono_alloc_preg (cfg);
2361                 MONO_ADD_INS (cfg->cbb, ins);
2362                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, cinfo->ret.reg, FALSE);
2363         }
2364
2365         header = cfg->header;
2366         if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
2367                 frmReg = s390_r11;
2368         else
2369                 frmReg = STK_BASE;
2370
2371         for (i = 0; i < n; ++i) {
2372                 MonoType *t;
2373
2374                 ainfo = cinfo->args + i;
2375                 if (i >= sig->hasthis)
2376                         t = sig->params [i - sig->hasthis];
2377                 else
2378                         t = &mono_defaults.int_class->byval_arg;
2379                 t = mini_get_underlying_type (t);
2380
2381                 in = call->args [i];
2382
2383                 if ((sig->call_convention == MONO_CALL_VARARG) &&
2384                     (!sig->pinvoke) &&
2385                     (i == sig->sentinelpos)) {
2386                         emit_sig_cookie (cfg, call, cinfo);
2387                 }
2388
2389                 switch (ainfo->regtype) {
2390                 case RegTypeGeneral:
2391                         add_outarg_reg2 (cfg, call, ainfo->regtype, ainfo->reg, in);
2392                         break;
2393                 case RegTypeFP:
2394                         if (MONO_TYPE_ISSTRUCT (t)) {
2395                                 /* Valuetype passed in one fp register */
2396                                 ainfo->regtype = RegTypeStructByValInFP;
2397                                 /* Fall through */
2398                         } else {
2399                                 if (ainfo->size == 4)
2400                                         ainfo->regtype = RegTypeFPR4;
2401                                 add_outarg_reg2 (cfg, call, ainfo->regtype, ainfo->reg, in);
2402                                 break;
2403                         }
2404                 case RegTypeStructByVal:
2405                 case RegTypeStructByAddr:
2406                 case RegTypeStructByAddrOnStack: {
2407                         guint32 align;
2408                         guint32 size;
2409
2410                         if (sig->params [i - sig->hasthis]->type == MONO_TYPE_TYPEDBYREF) {
2411                                 size = sizeof (MonoTypedRef);
2412                                 align = sizeof (gpointer);
2413                         }
2414                         else
2415                                 if (sig->pinvoke)
2416                                         size = mono_type_native_stack_size (&in->klass->byval_arg, &align);
2417                                 else {
2418                                         /*
2419                                          * Other backends use mono_type_stack_size (), but that
2420                                          * aligns the size to 8, which is larger than the size of
2421                                          * the source, leading to reads of invalid memory if the
2422                                          * source is at the end of address space.
2423                                          */
2424                                         size = mono_class_value_size (in->klass, &align);
2425                                 }
2426
2427                         g_assert (in->klass);
2428
2429                         ainfo->offparm += cinfo->sz.offStruct;
2430
2431                         MONO_INST_NEW (cfg, ins, OP_OUTARG_VT);
2432                         ins->sreg1 = in->dreg;
2433                         ins->klass = in->klass;
2434                         ins->backend.size = ainfo->size;
2435                         ins->inst_p0 = call;
2436                         ins->inst_p1 = mono_mempool_alloc (cfg->mempool, sizeof (ArgInfo));
2437                         memcpy (ins->inst_p1, ainfo, sizeof (ArgInfo));
2438
2439                         MONO_ADD_INS (cfg->cbb, ins);
2440
2441                         if (ainfo->regtype == RegTypeStructByAddr) {
2442                                 /*
2443                                  * We use OP_OUTARG_VT to copy the valuetype to a stack location, then
2444                                  * use the normal OUTARG opcodes to pass the address of the location to
2445                                  * the callee.
2446                                  */
2447                                 int treg = mono_alloc_preg (cfg);
2448                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, treg,
2449                                                          frmReg, ainfo->offparm);
2450                                 mono_call_inst_add_outarg_reg (cfg, call, treg, ainfo->reg, FALSE);
2451                         } else if (ainfo->regtype == RegTypeStructByAddrOnStack) {
2452                                 /* The address of the valuetype is passed on the stack */
2453                                 int treg = mono_alloc_preg (cfg);
2454                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, treg,
2455                                                          frmReg, ainfo->offparm);
2456                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG,
2457                                                              ainfo->reg, ainfo->offset, treg);
2458
2459                                 if (cfg->compute_gc_maps) {
2460                                         MonoInst *def;
2461
2462                                         EMIT_NEW_GC_PARAM_SLOT_LIVENESS_DEF (cfg, def, ainfo->offset, t);
2463                                 }
2464                         }
2465                         break;
2466                 }
2467                 case RegTypeBase:
2468                         if (!t->byref && t->type == MONO_TYPE_R4) {
2469                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORER4_MEMBASE_REG,
2470                                                              STK_BASE, ainfo->offset + 4,
2471                                                              in->dreg);
2472                         } else if (!t->byref && (t->type == MONO_TYPE_R8)) {
2473                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORER8_MEMBASE_REG,
2474                                                              STK_BASE, ainfo->offset,
2475                                                              in->dreg);
2476                         } else {
2477                                 MONO_INST_NEW (cfg, ins, OP_STORE_MEMBASE_REG);
2478                                 ins->inst_destbasereg = STK_BASE;
2479                                 ins->inst_offset = ainfo->offset;
2480                                 ins->sreg1 = in->dreg;
2481
2482 #if 0
2483                                 /* This is needed by MonoTypedRef->value to point to the correct data */
2484                                 if ((sig->call_convention == MONO_CALL_VARARG) &&
2485                                         (i >= sig->sentinelpos)) {
2486                                         switch (ainfo->size) {
2487                                         case 1:
2488                                                 ins->opcode = OP_STOREI1_MEMBASE_REG;
2489                                                 break;
2490                                         case 2:
2491                                                 ins->opcode = OP_STOREI2_MEMBASE_REG;
2492                                                 break;
2493                                         case 4:
2494                                                 ins->opcode = OP_STOREI4_MEMBASE_REG;
2495                                                 break;
2496                                         default:
2497                                                 break;
2498                                         }
2499                                 }
2500 #endif
2501
2502                                 MONO_ADD_INS (cfg->cbb, ins);
2503                         }
2504                         break;
2505                 default:
2506                         g_assert_not_reached ();
2507                         break;
2508                 }
2509         }
2510
2511         /*
2512          * Handle the case where there are no implicit arguments
2513          */
2514         if ((sig->call_convention == MONO_CALL_VARARG) &&
2515             (!sig->pinvoke) &&
2516             (i == sig->sentinelpos)) {
2517                 emit_sig_cookie (cfg, call, cinfo);
2518         }
2519 }
2520
2521 /*========================= End of Function ========================*/
2522
2523 /*------------------------------------------------------------------*/
2524 /*                                                                  */
2525 /* Name         - mono_arch_emit_outarg_vt                          */
2526 /*                                                                  */
2527 /*------------------------------------------------------------------*/
2528
2529 void
2530 mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
2531 {
2532         MonoCallInst *call = (MonoCallInst*)ins->inst_p0;
2533         ArgInfo *ainfo = (ArgInfo*)ins->inst_p1;
2534         int size = ins->backend.size;
2535
2536         if (ainfo->regtype == RegTypeStructByVal) {
2537                 /*
2538                                 arg->ins.sreg1  = ainfo->reg;
2539                                 arg->ins.opcode = OP_OUTARG_VT;
2540                                 arg->size       = ainfo->size;
2541                                 arg->offset     = ainfo->offset;
2542                                 arg->offPrm     = ainfo->offparm + cinfo->sz.offStruct;
2543                 */
2544                 if (ainfo->reg != STK_BASE) {
2545                         MONO_OUTPUT_VTR (cfg, size, ainfo->reg, src->dreg, 0);
2546                 } else {
2547                         MONO_OUTPUT_VTS (cfg, size, ainfo->reg, ainfo->offset,
2548                                                           src->dreg, 0);
2549                 }
2550         } else if (ainfo->regtype == RegTypeStructByValInFP) {
2551                 int dreg = mono_alloc_freg (cfg);
2552
2553                 if (ainfo->size == 4) {
2554                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR4_MEMBASE, dreg, src->dreg, 0);
2555                         MONO_EMIT_NEW_UNALU (cfg, OP_S390_SETF4RET, dreg, dreg);
2556                 } else {
2557                         g_assert (ainfo->size == 8);
2558
2559                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR8_MEMBASE, dreg, src->dreg, 0);
2560                 }
2561
2562                 mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, TRUE);
2563         } else {
2564                 MonoError error;
2565                 MonoMethodHeader *header;
2566                 int srcReg;
2567
2568                 header = mono_method_get_header_checked (cfg->method, &error);
2569                 mono_error_assert_ok (&error); /* FIXME don't swallow the error */
2570                 if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
2571                         srcReg = s390_r11;
2572                 else
2573                         srcReg = STK_BASE;
2574
2575                 MONO_EMIT_NEW_MOVE (cfg, srcReg, ainfo->offparm,
2576                                                          src->dreg, 0, size);
2577
2578                 if (cfg->compute_gc_maps) {
2579                         MonoInst *def;
2580
2581                         EMIT_NEW_GC_PARAM_SLOT_LIVENESS_DEF (cfg, def, ainfo->offset, &ins->klass->byval_arg);
2582                 }
2583         }
2584 }
2585
2586 /*========================= End of Function ========================*/
2587
2588 /*------------------------------------------------------------------*/
2589 /*                                                                  */
2590 /* Name         - mono_arch_emit_setret                             */
2591 /*                                                                  */
2592 /*------------------------------------------------------------------*/
2593
2594 void
2595 mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
2596 {
2597         MonoType *ret = mini_get_underlying_type (mono_method_signature (method)->ret);
2598
2599         if (!ret->byref) {
2600                 if (ret->type == MONO_TYPE_R4) {
2601                         MONO_EMIT_NEW_UNALU (cfg, OP_S390_SETF4RET, s390_f0, val->dreg);
2602                         return;
2603                 } else if (ret->type == MONO_TYPE_R8) {
2604                         MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, s390_f0, val->dreg);
2605                         return;
2606                 }
2607         }
2608
2609         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg, val->dreg);
2610 }
2611
2612 /*========================= End of Function ========================*/
2613
2614 /*------------------------------------------------------------------*/
2615 /*                                                                  */
2616 /* Name         - mono_arch_instrument_mem_needs                    */
2617 /*                                                                  */
2618 /* Function     - Allow tracing to work with this interface (with   */
2619 /*                an optional argument).                            */
2620 /*                                                                  */
2621 /*------------------------------------------------------------------*/
2622
2623 void
2624 mono_arch_instrument_mem_needs (MonoMethod *method, int *stack, int *code)
2625 {
2626         /* no stack room needed now (may be needed for FASTCALL-trace support) */
2627         *stack = 0;
2628         /* split prolog-epilog requirements? */
2629         *code = 50; /* max bytes needed: check this number */
2630 }
2631
2632 /*========================= End of Function ========================*/
2633
2634 /*------------------------------------------------------------------*/
2635 /*                                                                  */
2636 /* Name         - mono_arch_instrument_prolog                       */
2637 /*                                                                  */
2638 /* Function     - Create an "instrumented" prolog.                  */
2639 /*                                                                  */
2640 /*------------------------------------------------------------------*/
2641
2642 void*
2643 mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p,
2644                              gboolean enable_arguments)
2645 {
2646         guchar  *code = p;
2647         int     parmOffset,
2648                 fpOffset,
2649                 baseReg;
2650
2651         parmOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE;
2652         if (cfg->method->save_lmf)
2653                 parmOffset -= sizeof(MonoLMF);
2654         fpOffset   = parmOffset + (5*sizeof(gpointer));
2655         baseReg = STK_BASE;
2656
2657         s390_stmg (code, s390_r2, s390_r6, STK_BASE, parmOffset);
2658         s390_stdy (code, s390_f0, 0, STK_BASE, fpOffset);
2659         s390_stdy (code, s390_f2, 0, STK_BASE, fpOffset+sizeof(gdouble));
2660         s390_stdy (code, s390_f4, 0, STK_BASE, fpOffset+2*sizeof(gdouble));
2661         s390_stdy (code, s390_f6, 0, STK_BASE, fpOffset+3*sizeof(gdouble));
2662         S390_SET  (code, s390_r1, func);
2663         S390_SET  (code, s390_r2, cfg->method);
2664         s390_lay  (code, s390_r3, 0, STK_BASE, parmOffset);
2665         s390_lgr  (code, s390_r4, STK_BASE);
2666         s390_aghi (code, s390_r4, cfg->stack_usage);
2667         s390_basr (code, s390_r14, s390_r1);
2668         s390_ldy  (code, s390_f6, 0, STK_BASE, fpOffset+3*sizeof(gdouble));
2669         s390_ldy  (code, s390_f4, 0, STK_BASE, fpOffset+2*sizeof(gdouble));
2670         s390_ldy  (code, s390_f2, 0, STK_BASE, fpOffset+sizeof(gdouble));
2671         s390_ldy  (code, s390_f0, 0, STK_BASE, fpOffset);
2672         s390_lmg  (code, s390_r2, s390_r6, STK_BASE, parmOffset);
2673
2674         return code;
2675 }
2676
2677 /*========================= End of Function ========================*/
2678
2679 /*------------------------------------------------------------------*/
2680 /*                                                                  */
2681 /* Name         - mono_arch_instrument_epilog                       */
2682 /*                                                                  */
2683 /* Function     - Create an epilog that will handle the returned    */
2684 /*                values used in instrumentation.                   */
2685 /*                                                                  */
2686 /*------------------------------------------------------------------*/
2687
2688 void*
2689 mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers)
2690 {
2691         guchar     *code = p;
2692         int        save_mode = SAVE_NONE,
2693                    saveOffset,
2694                    offset;
2695         MonoMethod *method = cfg->method;
2696         int rtype = mini_get_underlying_type (mono_method_signature (method)->ret)->type;
2697
2698         offset = code - cfg->native_code;
2699         /*-----------------------------------------*/
2700         /* We need about 128 bytes of instructions */
2701         /*-----------------------------------------*/
2702         if (offset > (cfg->code_size - 128)) {
2703                 cfg->code_size *= 2;
2704                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2705                 code = cfg->native_code + offset;
2706         }
2707
2708         saveOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE;
2709         if (method->save_lmf)
2710                 saveOffset -= sizeof(MonoLMF);
2711
2712 handle_enum:
2713         switch (rtype) {
2714         case MONO_TYPE_VOID:
2715                 /* special case string .ctor icall */
2716                 if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
2717                         save_mode = SAVE_ONE;
2718                 else
2719                         save_mode = SAVE_NONE;
2720                 break;
2721         case MONO_TYPE_I8:
2722         case MONO_TYPE_U8:
2723                 save_mode = SAVE_ONE;
2724                 break;
2725         case MONO_TYPE_R4:
2726                 save_mode = SAVE_R4;
2727                 break;
2728         case MONO_TYPE_R8:
2729                 save_mode = SAVE_R8;
2730                 break;
2731         case MONO_TYPE_VALUETYPE:
2732                 if (mono_method_signature (method)->ret->data.klass->enumtype) {
2733                         rtype = mono_class_enum_basetype (mono_method_signature (method)->ret->data.klass)->type;
2734                         goto handle_enum;
2735                 }
2736                 save_mode = SAVE_STRUCT;
2737                 break;
2738         default:
2739                 save_mode = SAVE_ONE;
2740                 break;
2741         }
2742
2743         switch (save_mode) {
2744         case SAVE_ONE:
2745                 s390_stg (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2746                 if (enable_arguments) {
2747                         s390_lgr (code, s390_r3, s390_r2);
2748                 }
2749                 break;
2750         case SAVE_R4:
2751                 s390_std (code, s390_f0, 0, cfg->frame_reg, saveOffset);
2752                 if (enable_arguments) {
2753                         s390_ldebr (code, s390_f0, s390_f0);
2754                 }
2755                 break;
2756         case SAVE_R8:
2757                 s390_std (code, s390_f0, 0, cfg->frame_reg, saveOffset);
2758                 break;
2759         case SAVE_STRUCT:
2760                 s390_stg (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2761                 if (enable_arguments) {
2762                         s390_lg (code, s390_r3, 0, cfg->frame_reg,
2763                                  S390_MINIMAL_STACK_SIZE+cfg->param_area);
2764                 }
2765                 break;
2766         case SAVE_NONE:
2767         default:
2768                 break;
2769         }
2770
2771         S390_SET  (code, s390_r1, func);
2772         S390_SET  (code, s390_r2, cfg->method);
2773         s390_basr (code, s390_r14, s390_r1);
2774
2775         switch (save_mode) {
2776         case SAVE_ONE:
2777                 s390_lg  (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2778                 break;
2779         case SAVE_R4:
2780         case SAVE_R8:
2781                 s390_ld  (code, s390_f0, 0, cfg->frame_reg, saveOffset);
2782                 break;
2783         case SAVE_STRUCT:
2784                 s390_lg  (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2785                 break;
2786         case SAVE_NONE:
2787         default:
2788                 break;
2789         }
2790
2791         return code;
2792 }
2793
2794 /*========================= End of Function ========================*/
2795
2796 /*------------------------------------------------------------------*/
2797 /*                                                                  */
2798 /* Name         - mono_arch_peephole_pass_1                         */
2799 /*                                                                  */
2800 /* Function     - Form a peephole pass at the code looking for      */
2801 /*                simple optimizations.                             */
2802 /*                                                                  */
2803 /*------------------------------------------------------------------*/
2804
2805 void
2806 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
2807 {
2808 }
2809
2810 /*========================= End of Function ========================*/
2811
2812 /*------------------------------------------------------------------*/
2813 /*                                                                  */
2814 /* Name         - mono_arch_peephole_pass_2                         */
2815 /*                                                                  */
2816 /* Function     - Form a peephole pass at the code looking for      */
2817 /*                simple optimizations.                             */
2818 /*                                                                  */
2819 /*------------------------------------------------------------------*/
2820
2821 void
2822 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
2823 {
2824         MonoInst *ins, *n;
2825
2826         MONO_BB_FOR_EACH_INS_SAFE (bb, n, ins) {
2827                 mono_peephole_ins (bb, ins);
2828         }
2829 }
2830
2831 /*========================= End of Function ========================*/
2832
2833 /*------------------------------------------------------------------*/
2834 /*                                                                  */
2835 /* Name         - mono_arch_lowering_pass.                          */
2836 /*                                                                  */
2837 /*------------------------------------------------------------------*/
2838
2839 void
2840 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
2841 {
2842         MonoInst *ins, *next;
2843
2844         MONO_BB_FOR_EACH_INS_SAFE (bb, next, ins) {
2845                 switch (ins->opcode) {
2846                 case OP_DIV_IMM:
2847                 case OP_REM_IMM:
2848                 case OP_IDIV_IMM:
2849                 case OP_IREM_IMM:
2850                 case OP_IDIV_UN_IMM:
2851                 case OP_IREM_UN_IMM:
2852                 case OP_LAND_IMM:
2853                 case OP_LOR_IMM:
2854                 case OP_LREM_IMM:
2855                 case OP_LXOR_IMM:
2856                 case OP_LOCALLOC_IMM:
2857                         mono_decompose_op_imm (cfg, bb, ins);
2858                         break;
2859                 case OP_LADD_IMM:
2860                         if (!s390_is_imm16 (ins->inst_imm))
2861                                 /* This is created by the memcpy code which ignores is_inst_imm */
2862                                 mono_decompose_op_imm (cfg, bb, ins);
2863                         break;
2864                 default:
2865                         break;
2866                 }
2867         }
2868
2869         bb->max_vreg = cfg->next_vreg;
2870 }
2871
2872 /*========================= End of Function ========================*/
2873
2874 /*------------------------------------------------------------------*/
2875 /*                                                                  */
2876 /* Name         - emit_float_to_int                                 */
2877 /*                                                                  */
2878 /* Function     - Create instructions which will convert a floating */
2879 /*                point value to integer.                           */
2880 /*                                                                  */
2881 /*------------------------------------------------------------------*/
2882
2883 static guchar*
2884 emit_float_to_int (MonoCompile *cfg, guchar *code, int dreg, int sreg, int size, gboolean is_signed)
2885 {
2886         /* sreg is a float, dreg is an integer reg. */
2887         if (is_signed) {
2888                 s390_cgdbr (code, dreg, 5, sreg);
2889                 switch (size) {
2890                 case 1:
2891                         s390_ltgr (code, dreg, dreg);
2892                         s390_jnl  (code, 4);
2893                         s390_oill (code, dreg, 0x80);
2894                         s390_lghi (code, s390_r0, 0xff);
2895                         s390_ngr  (code, dreg, s390_r0);
2896                         break;
2897                 case 2:
2898                         s390_ltgr (code, dreg, dreg);
2899                         s390_jnl  (code, 4);
2900                         s390_oill (code, dreg, 0x8000);
2901                         s390_llill(code, s390_r0, 0xffff);
2902                         s390_ngr  (code, dreg, s390_r0);
2903                         break;
2904                 }
2905         } else {
2906                 short *o[1];
2907                 S390_SET    (code, s390_r13, 0x41e0000000000000llu);
2908                 s390_ldgr   (code, s390_f14, s390_r13);
2909                 s390_ldr    (code, s390_f15, sreg);
2910                 s390_cdbr   (code, s390_f15, s390_f14);
2911                 s390_jl     (code, 0); CODEPTR (code, o[0]);
2912                 S390_SET    (code, s390_r13, 0x41f0000000000000llu);
2913                 s390_ldgr   (code, s390_f14, s390_r13);
2914                 s390_sdbr   (code, s390_f15, s390_f14);
2915                 s390_cfdbr  (code, dreg, 7, s390_f15);
2916                 s390_j      (code, 4);
2917                 PTRSLOT (code, o[0]);
2918                 s390_cfdbr  (code, dreg, 5, sreg);
2919                 switch (size) {
2920                 case 1:
2921                         s390_lghi (code, s390_r0, 0xff);
2922                         s390_ngr  (code, dreg, s390_r0);
2923                         break;
2924                 case 2:
2925                         s390_llill(code, s390_r0, 0xffff);
2926                         s390_ngr  (code, dreg, s390_r0);
2927                         break;
2928                 }
2929         }
2930         return code;
2931 }
2932
2933 /*========================= End of Function ========================*/
2934
2935 /*------------------------------------------------------------------*/
2936 /*                                                                  */
2937 /* Name         - gboolean_is_unsigned.                             */
2938 /*                                                                  */
2939 /* Function     - Return TRUE if next opcode is checking for un-    */
2940 /*                signed value.                                     */
2941 /*                                                                  */
2942 /*------------------------------------------------------------------*/
2943
2944 static
2945 gboolean is_unsigned (MonoInst *next)
2946 {
2947         if ((next) &&
2948                 (((next->opcode >= OP_IBNE_UN) &&
2949                   (next->opcode <= OP_IBLT_UN)) ||
2950                  ((next->opcode >= OP_LBNE_UN) &&
2951                   (next->opcode <= OP_LBLT_UN)) ||
2952                  ((next->opcode >= OP_COND_EXC_NE_UN) &&
2953                   (next->opcode <= OP_COND_EXC_LT_UN)) ||
2954                  ((next->opcode >= OP_COND_EXC_INE_UN) &&
2955                   (next->opcode <= OP_COND_EXC_ILT_UN)) ||
2956                  ((next->opcode == OP_CLT_UN) ||
2957                   (next->opcode == OP_CGT_UN)) ||
2958                  ((next->opcode == OP_ICLT_UN) ||
2959                   (next->opcode == OP_ICGT_UN) ||
2960                   (next->opcode == OP_LCLT_UN) ||
2961                   (next->opcode == OP_LCGT_UN))))
2962                 return TRUE;
2963         else
2964                 return FALSE;
2965 }
2966
2967 /*========================= End of Function ========================*/
2968
2969 /*------------------------------------------------------------------*/
2970 /*                                                                  */
2971 /* Name         - mono_arch_output_basic_block                      */
2972 /*                                                                  */
2973 /* Function     - Perform the "real" work of emitting instructions  */
2974 /*                that will do the work of in the basic block.      */
2975 /*                                                                  */
2976 /*------------------------------------------------------------------*/
2977
2978 void
2979 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
2980 {
2981         MonoInst *ins;
2982         MonoCallInst *call;
2983         guint offset;
2984         guint8 *code = cfg->native_code + cfg->code_len;
2985         guint last_offset = 0;
2986         int max_len, src2;
2987
2988         /* we don't align basic blocks of loops on s390 */
2989
2990         if (cfg->verbose_level > 2)
2991                 g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset);
2992
2993         if ((cfg->prof_options & MONO_PROFILE_COVERAGE) && cfg->coverage_info) {
2994                 MonoProfileCoverageInfo *cov = cfg->coverage_info;
2995                 g_assert (!mono_compile_aot);
2996                 cov->data [bb->dfn].cil_code = bb->cil_code;
2997                 /* This is not thread save, but good enough */
2998                 S390_SET (code, s390_r1, &cov->data [bb->dfn].count);
2999                 s390_alsi (code, 0, s390_r1, 1);
3000         }
3001
3002         MONO_BB_FOR_EACH_INS (bb, ins) {
3003                 offset = code - cfg->native_code;
3004
3005                 max_len = ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
3006
3007                 if (offset > (cfg->code_size - max_len - 16)) {
3008                         cfg->code_size *= 2;
3009                         cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
3010                         code = cfg->native_code + offset;
3011                 }
3012
3013                 mono_debug_record_line_number (cfg, ins, offset);
3014
3015                 switch (ins->opcode) {
3016                 case OP_STOREI1_MEMBASE_IMM: {
3017                         s390_lghi (code, s390_r0, ins->inst_imm);
3018                         S390_LONG (code, stcy, stc, s390_r0, 0,
3019                                    ins->inst_destbasereg, ins->inst_offset);
3020                 }
3021                         break;
3022                 case OP_STOREI2_MEMBASE_IMM: {
3023                         s390_lghi (code, s390_r0, ins->inst_imm);
3024                         S390_LONG (code, sthy, sth, s390_r0, 0,
3025                                    ins->inst_destbasereg, ins->inst_offset);
3026                 }
3027                         break;
3028                 case OP_STOREI4_MEMBASE_IMM: {
3029                         s390_lgfi (code, s390_r0, ins->inst_imm);
3030                         S390_LONG (code, sty, st, s390_r0, 0,
3031                                    ins->inst_destbasereg, ins->inst_offset);
3032                 }
3033                         break;
3034                 case OP_STORE_MEMBASE_IMM:
3035                 case OP_STOREI8_MEMBASE_IMM: {
3036                         S390_SET (code, s390_r0, ins->inst_imm);
3037                         S390_LONG (code, stg, stg, s390_r0, 0,
3038                                    ins->inst_destbasereg, ins->inst_offset);
3039                 }
3040                         break;
3041                 case OP_STOREI1_MEMBASE_REG: {
3042                         S390_LONG (code, stcy, stc, ins->sreg1, 0,
3043                                    ins->inst_destbasereg, ins->inst_offset);
3044                 }
3045                         break;
3046                 case OP_STOREI2_MEMBASE_REG: {
3047                         S390_LONG (code, sthy, sth, ins->sreg1, 0,
3048                                    ins->inst_destbasereg, ins->inst_offset);
3049                 }
3050                         break;
3051                 case OP_STOREI4_MEMBASE_REG: {
3052                         S390_LONG (code, sty, st, ins->sreg1, 0,
3053                                    ins->inst_destbasereg, ins->inst_offset);
3054                 }
3055                         break;
3056                 case OP_STORE_MEMBASE_REG:
3057                 case OP_STOREI8_MEMBASE_REG: {
3058                         S390_LONG (code, stg, stg, ins->sreg1, 0,
3059                                    ins->inst_destbasereg, ins->inst_offset);
3060                 }
3061                         break;
3062                 case OP_LOADU4_MEM:
3063                         g_assert_not_reached ();
3064                         break;
3065                 case OP_LOAD_MEMBASE:
3066                 case OP_LOADI8_MEMBASE: {
3067                         S390_LONG (code, lg, lg, ins->dreg, 0,
3068                                    ins->inst_basereg, ins->inst_offset);
3069                 }
3070                         break;
3071                 case OP_LOADI4_MEMBASE: {
3072                         S390_LONG (code, lgf, lgf, ins->dreg, 0,
3073                                    ins->inst_basereg, ins->inst_offset);
3074                 }
3075                         break;
3076                 case OP_LOADU4_MEMBASE: {
3077                         S390_LONG (code, llgf, llgf, ins->dreg, 0,
3078                                    ins->inst_basereg, ins->inst_offset);
3079                 }
3080                         break;
3081                 case OP_LOADU1_MEMBASE: {
3082                         S390_LONG (code, llgc, llgc, ins->dreg, 0,
3083                                    ins->inst_basereg, ins->inst_offset);
3084                 }
3085                         break;
3086                 case OP_LOADI1_MEMBASE: {
3087                         S390_LONG (code, lgb, lgb, ins->dreg, 0,
3088                                    ins->inst_basereg, ins->inst_offset);
3089                 }
3090                         break;
3091                 case OP_LOADU2_MEMBASE: {
3092                         S390_LONG (code, llgh, llgh, ins->dreg, 0,
3093                                    ins->inst_basereg, ins->inst_offset);
3094                 }
3095                         break;
3096                 case OP_LOADI2_MEMBASE: {
3097                         S390_LONG (code, lgh, lgh, ins->dreg, 0,
3098                                    ins->inst_basereg, ins->inst_offset);
3099                 }
3100                         break;
3101                 case OP_LCONV_TO_I1: {
3102                         s390_lgbr (code, ins->dreg, ins->sreg1);
3103                 }
3104                         break;
3105                 case OP_LCONV_TO_I2: {
3106                         s390_lghr (code, ins->dreg, ins->sreg1);
3107                 }
3108                         break;
3109                 case OP_LCONV_TO_U1: {
3110                         s390_llgcr (code, ins->dreg, ins->sreg1);
3111                 }
3112                         break;
3113                 case OP_LCONV_TO_U2: {
3114                         s390_llghr (code, ins->dreg, ins->sreg1);
3115                 }
3116                         break;
3117                 case OP_ICONV_TO_I1: {
3118                         s390_lgbr  (code, ins->dreg, ins->sreg1);
3119                 }
3120                         break;
3121                 case OP_ICONV_TO_I2: {
3122                         s390_lghr  (code, ins->dreg, ins->sreg1);
3123                 }
3124                         break;
3125                 case OP_ICONV_TO_U1: {
3126                         s390_llgcr (code, ins->dreg, ins->sreg1);
3127                 }
3128                         break;
3129                 case OP_ICONV_TO_U2: {
3130                         s390_llghr (code, ins->dreg, ins->sreg1);
3131                 }
3132                         break;
3133                 case OP_COMPARE:
3134                 case OP_LCOMPARE: {
3135                         if (is_unsigned (ins->next))
3136                                 s390_clgr (code, ins->sreg1, ins->sreg2);
3137                         else
3138                                 s390_cgr  (code, ins->sreg1, ins->sreg2);
3139                 }
3140                         break;
3141                 case OP_ICOMPARE: {
3142                         if (is_unsigned (ins->next))
3143                                 s390_clr  (code, ins->sreg1, ins->sreg2);
3144                         else
3145                                 s390_cr   (code, ins->sreg1, ins->sreg2);
3146                 }
3147                         break;
3148                 case OP_COMPARE_IMM:
3149                 case OP_LCOMPARE_IMM: {
3150                         S390_SET (code, s390_r0, ins->inst_imm);
3151                         if (is_unsigned (ins->next))
3152                                 s390_clgr (code, ins->sreg1, s390_r0);
3153                         else
3154                                 s390_cgr  (code, ins->sreg1, s390_r0);
3155                 }
3156                         break;
3157                 case OP_ICOMPARE_IMM: {
3158                         S390_SET (code, s390_r0, ins->inst_imm);
3159                         if (is_unsigned (ins->next))
3160                                 s390_clr  (code, ins->sreg1, s390_r0);
3161                         else
3162                                 s390_cr   (code, ins->sreg1, s390_r0);
3163                 }
3164                         break;
3165                 case OP_BREAK: {
3166                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_ABS,
3167                                              mono_break);
3168                         S390_CALL_TEMPLATE (code, s390_r14);
3169                 }
3170                         break;
3171                 case OP_ADDCC: {
3172                         CHECK_SRCDST_COM;
3173                         s390_agr  (code, ins->dreg, src2);
3174                 }
3175                         break;
3176                 case OP_LADD: {
3177                         CHECK_SRCDST_COM;
3178                         s390_agr   (code, ins->dreg, src2);
3179                 }
3180                         break;
3181                 case OP_ADC: {
3182                         CHECK_SRCDST_COM;
3183                         s390_alcgr (code, ins->dreg, src2);
3184                 }
3185                         break;
3186                 case OP_ADD_IMM: {
3187                         if (ins->dreg != ins->sreg1) {
3188                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3189                         }
3190                         if (s390_is_imm16 (ins->inst_imm)) {
3191                                 s390_aghi (code, ins->dreg, ins->inst_imm);
3192                         } else if (s390_is_imm32 (ins->inst_imm)) {
3193                                 s390_agfi (code, ins->dreg, ins->inst_imm);
3194                         } else {
3195                                 S390_SET  (code, s390_r0, ins->inst_imm);
3196                                 s390_agr  (code, ins->dreg, s390_r0);
3197                         }
3198                 }
3199                         break;
3200                 case OP_LADD_IMM: {
3201                         if (ins->dreg != ins->sreg1) {
3202                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3203                         }
3204                         g_assert (s390_is_imm16 (ins->inst_imm));
3205                         s390_aghi (code, ins->dreg, ins->inst_imm);
3206                 }
3207                         break;
3208                 case OP_ADC_IMM: {
3209                         if (ins->dreg != ins->sreg1) {
3210                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3211                         }
3212                         if (s390_is_imm16 (ins->inst_imm)) {
3213                                 s390_lghi  (code, s390_r0, ins->inst_imm);
3214                                 s390_alcgr (code, ins->dreg, s390_r0);
3215                         } else {
3216                                 S390_SET   (code, s390_r0, ins->inst_imm);
3217                                 s390_alcgr (code, ins->dreg, s390_r0);
3218                         }
3219                 }
3220                         break;
3221                 case OP_IADD_OVF:
3222                 case OP_S390_IADD_OVF: {
3223                         CHECK_SRCDST_COM;
3224                         s390_ar    (code, ins->dreg, src2);
3225                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3226                         s390_lgfr  (code, ins->dreg, ins->dreg);
3227                 }
3228                         break;
3229                 case OP_IADD_OVF_UN:
3230                 case OP_S390_IADD_OVF_UN: {
3231                         CHECK_SRCDST_COM;
3232                         s390_algr  (code, ins->dreg, src2);
3233                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
3234                         s390_llgfr (code, ins->dreg, ins->dreg);
3235                 }
3236                         break;
3237                 case OP_ADD_OVF_CARRY: {
3238                         CHECK_SRCDST_COM;
3239                         s390_lghi  (code, s390_r0, 0);
3240                         s390_lgr   (code, s390_r1, s390_r0);
3241                         s390_alcgr (code, s390_r0, s390_r1);
3242                         s390_agr   (code, ins->dreg, src2);
3243                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3244                         s390_agr   (code, ins->dreg, s390_r0);
3245                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3246                 }
3247                         break;
3248                 case OP_ADD_OVF_UN_CARRY: {
3249                         CHECK_SRCDST_COM;
3250                         s390_alcgr (code, ins->dreg, src2);
3251                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
3252                 }
3253                         break;
3254                 case OP_SUBCC: {
3255                         CHECK_SRCDST_NCOM;
3256                         s390_sgr (code, ins->dreg, src2);
3257                 }
3258                         break;
3259                 case OP_LSUB: {
3260                         CHECK_SRCDST_NCOM;
3261                         s390_sgr  (code, ins->dreg, src2);
3262                 }
3263                         break;
3264                 case OP_SBB: {
3265                         CHECK_SRCDST_NCOM;
3266                         s390_slbgr(code, ins->dreg, src2);
3267                 }
3268                         break;
3269                 case OP_SUB_IMM: {
3270                         if (ins->dreg != ins->sreg1) {
3271                                 s390_lgr   (code, ins->dreg, ins->sreg1);
3272                         }
3273                         if (s390_is_imm16 (-ins->inst_imm)) {
3274                                 s390_aghi  (code, ins->dreg, -ins->inst_imm);
3275                         } else if (s390_is_imm32 (-ins->inst_imm)) {
3276                                 s390_slgfi  (code, ins->dreg, ins->inst_imm);
3277                         } else {
3278                                 S390_SET  (code, s390_r0, ins->inst_imm);
3279                                 s390_slgr (code, ins->dreg, s390_r0);
3280                         }
3281                 }
3282                         break;
3283                 case OP_LSUB_IMM: {
3284                         if (ins->dreg != ins->sreg1) {
3285                                 s390_lgr   (code, ins->dreg, ins->sreg1);
3286                         }
3287                         if (s390_is_imm16 (-ins->inst_imm)) {
3288                                 s390_aghi  (code, ins->dreg, -ins->inst_imm);
3289                         } else if (s390_is_imm32 (-ins->inst_imm)) {
3290                                 s390_slgfi (code, ins->dreg, ins->inst_imm);
3291                         } else {
3292                                 S390_SET  (code, s390_r0, ins->inst_imm);
3293                                 s390_slgr (code, ins->dreg, s390_r0);
3294                         }
3295                 }
3296                         break;
3297                 case OP_SBB_IMM: {
3298                         if (ins->dreg != ins->sreg1) {
3299                                 s390_lgr   (code, ins->dreg, ins->sreg1);
3300                         }
3301                         if (s390_is_imm16 (-ins->inst_imm)) {
3302                                 s390_lghi  (code, s390_r0, ins->inst_imm);
3303                                 s390_slbgr (code, ins->dreg, s390_r0);
3304                         } else {
3305                                 S390_SET  (code, s390_r0, ins->inst_imm);
3306                                 s390_slbgr(code, ins->dreg, s390_r0);
3307                         }
3308                 }
3309                         break;
3310                 case OP_SUB_OVF_CARRY: {
3311                         CHECK_SRCDST_NCOM;
3312                         s390_lghi  (code, s390_r0, 0);
3313                         s390_lgr   (code, s390_r1, s390_r0);
3314                         s390_slbgr (code, s390_r0, s390_r1);
3315                         s390_sgr   (code, ins->dreg, src2);
3316                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3317                         s390_agr   (code, ins->dreg, s390_r0);
3318                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3319                 }
3320                         break;
3321                 case OP_SUB_OVF_UN_CARRY: {
3322                         CHECK_SRCDST_NCOM;
3323                         s390_slbgr (code, ins->dreg, src2);
3324                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, "OverflowException");
3325                 }
3326                         break;
3327                 case OP_LAND: {
3328                         if (ins->sreg1 == ins->dreg) {
3329                                 s390_ngr  (code, ins->dreg, ins->sreg2);
3330                         }
3331                         else {
3332                                 if (ins->sreg2 == ins->dreg) {
3333                                         s390_ngr (code, ins->dreg, ins->sreg1);
3334                                 }
3335                                 else {
3336                                         s390_lgr (code, ins->dreg, ins->sreg1);
3337                                         s390_ngr (code, ins->dreg, ins->sreg2);
3338                                 }
3339                         }
3340                 }
3341                         break;
3342                 case OP_AND_IMM: {
3343                         if (ins->dreg != ins->sreg1) {
3344                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3345                         }
3346                         S390_SET_MASK (code, s390_r0, ins->inst_imm);
3347                         s390_ngr (code, ins->dreg, s390_r0);
3348                 }
3349                         break;
3350                 case OP_LDIV: {
3351                         s390_lgr  (code, s390_r1, ins->sreg1);
3352                         s390_dsgr (code, s390_r0, ins->sreg2);
3353                         s390_lgr  (code, ins->dreg, s390_r1);
3354                 }
3355                         break;
3356                 case OP_LDIV_UN: {
3357                         s390_lgr   (code, s390_r1, ins->sreg1);
3358                         s390_lghi  (code, s390_r0, 0);
3359                         s390_dlgr  (code, s390_r0, ins->sreg2);
3360                         s390_lgr   (code, ins->dreg, s390_r1);
3361                 }
3362                         break;
3363                 case OP_LREM: {
3364                         s390_lgr  (code, s390_r1, ins->sreg1);
3365                         s390_dsgr (code, s390_r0, ins->sreg2);
3366                         s390_lgr  (code, ins->dreg, s390_r0);
3367                         break;
3368                 }
3369                 case OP_LREM_IMM: {
3370                         if (s390_is_imm16 (ins->inst_imm)) {
3371                                 s390_lghi (code, s390_r13, ins->inst_imm);
3372                         } else {
3373                                 s390_lgfi (code, s390_r13, ins->inst_imm);
3374                         }
3375                         s390_lgr  (code, s390_r0, ins->sreg1);
3376                         s390_dsgr (code, s390_r0, s390_r13);
3377                         s390_lgfr (code, ins->dreg, s390_r0);
3378                 }
3379                         break;
3380                 case OP_LREM_UN: {
3381                         s390_lgr   (code, s390_r1, ins->sreg1);
3382                         s390_lghi  (code, s390_r0, 0);
3383                         s390_dlgr  (code, s390_r0, ins->sreg2);
3384                         s390_lgr   (code, ins->dreg, s390_r0);
3385                 }
3386                         break;
3387                 case OP_LOR: {
3388                         if (ins->sreg1 == ins->dreg) {
3389                                 s390_ogr  (code, ins->dreg, ins->sreg2);
3390                         }
3391                         else {
3392                                 if (ins->sreg2 == ins->dreg) {
3393                                         s390_ogr (code, ins->dreg, ins->sreg1);
3394                                 }
3395                                 else {
3396                                         s390_lgr (code, ins->dreg, ins->sreg1);
3397                                         s390_ogr (code, ins->dreg, ins->sreg2);
3398                                 }
3399                         }
3400                 }
3401                         break;
3402                 case OP_OR_IMM: {
3403                         if (ins->dreg != ins->sreg1) {
3404                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3405                         }
3406                         S390_SET_MASK(code, s390_r0, ins->inst_imm);
3407                         s390_ogr (code, ins->dreg, s390_r0);
3408                 }
3409                         break;
3410                 case OP_LXOR: {
3411                         if (ins->sreg1 == ins->dreg) {
3412                                 s390_xgr  (code, ins->dreg, ins->sreg2);
3413                         }
3414                         else {
3415                                 if (ins->sreg2 == ins->dreg) {
3416                                         s390_xgr (code, ins->dreg, ins->sreg1);
3417                                 }
3418                                 else {
3419                                         s390_lgr (code, ins->dreg, ins->sreg1);
3420                                         s390_xgr (code, ins->dreg, ins->sreg2);
3421                                 }
3422                         }
3423                 }
3424                         break;
3425                 case OP_XOR_IMM: {
3426                         if (ins->dreg != ins->sreg1) {
3427                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3428                         }
3429                         S390_SET_MASK (code, s390_r0, ins->inst_imm);
3430                         s390_xgr (code, ins->dreg, s390_r0);
3431                 }
3432                         break;
3433                 case OP_LSHL: {
3434                         CHECK_SRCDST_NCOM;
3435                         s390_sllg (code, ins->dreg, ins->dreg, src2, 0);
3436                 }
3437                         break;
3438                 case OP_SHL_IMM:
3439                 case OP_LSHL_IMM: {
3440                         if (ins->sreg1 != ins->dreg) {
3441                                 s390_lgr   (code, ins->dreg, ins->sreg1);
3442                         }
3443                         s390_sllg (code, ins->dreg, ins->dreg, 0, (ins->inst_imm & 0x3f));
3444                 }
3445                         break;
3446                 case OP_LSHR: {
3447                         CHECK_SRCDST_NCOM;
3448                         s390_srag  (code, ins->dreg, ins->dreg, src2, 0);
3449                 }
3450                         break;
3451                 case OP_SHR_IMM:
3452                 case OP_LSHR_IMM: {
3453                         if (ins->sreg1 != ins->dreg) {
3454                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3455                         }
3456                         s390_srag  (code, ins->dreg, ins->dreg, 0, (ins->inst_imm & 0x3f));
3457                 }
3458                         break;
3459                 case OP_SHR_UN_IMM:
3460                 case OP_LSHR_UN_IMM: {
3461                         if (ins->sreg1 != ins->dreg) {
3462                                 s390_lgr   (code, ins->dreg, ins->sreg1);
3463                         }
3464                         s390_srlg (code, ins->dreg, ins->dreg, 0, (ins->inst_imm & 0x3f));
3465                 }
3466                         break;
3467                 case OP_LSHR_UN: {
3468                         CHECK_SRCDST_NCOM;
3469                         s390_srlg (code, ins->dreg, ins->dreg, src2, 0);
3470                 }
3471                         break;
3472                 case OP_LNOT: {
3473                         if (ins->sreg1 != ins->dreg) {
3474                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3475                         }
3476                         s390_lghi (code, s390_r0, -1);
3477                         s390_xgr  (code, ins->dreg, s390_r0);
3478                 }
3479                         break;
3480                 case OP_LNEG: {
3481                         s390_lcgr (code, ins->dreg, ins->sreg1);
3482                 }
3483                         break;
3484                 case OP_LMUL: {
3485                         CHECK_SRCDST_COM;
3486                         s390_msgr (code, ins->dreg, src2);
3487                 }
3488                         break;
3489                 case OP_MUL_IMM:
3490                 case OP_LMUL_IMM: {
3491                         if (ins->dreg != ins->sreg1) {
3492                                 s390_lgr  (code, ins->dreg, ins->sreg1);
3493                         }
3494                         if (s390_is_imm16 (ins->inst_imm)) {
3495                                 s390_lghi (code, s390_r13, ins->inst_imm);
3496                         } else if (s390_is_imm32 (ins->inst_imm)) {
3497                                 s390_lgfi (code, s390_r13, ins->inst_imm);
3498                         } else {
3499                                 S390_SET (code, s390_r13, ins->inst_imm);
3500                         }
3501                         s390_msgr (code, ins->dreg, s390_r13);
3502                 }
3503                         break;
3504                 case OP_LMUL_OVF: {
3505                         short int *o[2];
3506                         s390_ltgr (code, s390_r1, ins->sreg1);
3507                         s390_jz   (code, 0); CODEPTR(code, o[0]);
3508                         s390_ltgr (code, s390_r0, ins->sreg2);
3509                         s390_jnz  (code, 6);
3510                         s390_lghi (code, s390_r1, 0);
3511                         s390_j    (code, 0); CODEPTR(code, o[1]);
3512                         s390_xgr  (code, s390_r0, s390_r1);
3513                         s390_msgr (code, s390_r1, ins->sreg2);
3514                         s390_xgr  (code, s390_r0, s390_r1);
3515                         s390_srlg (code, s390_r0, s390_r0, 0, 63);
3516                         s390_ltgr (code, s390_r0, s390_r0);
3517                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3518                         PTRSLOT   (code, o[0]);
3519                         PTRSLOT   (code, o[1]);
3520                         s390_lgr  (code, ins->dreg, s390_r1);
3521                 }
3522                         break;
3523                 case OP_LMUL_OVF_UN: {
3524                         s390_lghi  (code, s390_r0, 0);
3525                         s390_lgr   (code, s390_r1, ins->sreg1);
3526                         s390_mlgr  (code, s390_r0, ins->sreg2);
3527                         s390_ltgr  (code, s390_r0, s390_r0);
3528                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3529                         s390_lgr   (code, ins->dreg, s390_r1);
3530                 }
3531                         break;
3532                 case OP_IADDCC: {
3533                         g_assert_not_reached ();
3534                         CHECK_SRCDST_COM_I;
3535                         s390_algr (code, ins->dreg, src2);
3536                 }
3537                         break;
3538                 case OP_IADD: {
3539                         CHECK_SRCDST_COM_I;
3540                         s390_agr  (code, ins->dreg, src2);
3541                 }
3542                         break;
3543                 case OP_IADC: {
3544                         g_assert_not_reached ();
3545                         CHECK_SRCDST_COM_I;
3546                         s390_alcgr (code, ins->dreg, src2);
3547                 }
3548                         break;
3549                 case OP_IADD_IMM: {
3550                         if (ins->dreg != ins->sreg1) {
3551                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3552                         }
3553                         if (s390_is_imm16 (ins->inst_imm)) {
3554                                 s390_aghi (code, ins->dreg, ins->inst_imm);
3555                         } else {
3556                                 s390_afi  (code, ins->dreg, ins->inst_imm);
3557                         }
3558                 }
3559                         break;
3560                 case OP_IADC_IMM: {
3561                         if (ins->dreg != ins->sreg1) {
3562                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3563                         }
3564                         if (s390_is_imm16 (ins->inst_imm)) {
3565                                 s390_lghi  (code, s390_r0, ins->inst_imm);
3566                                 s390_alcgr (code, ins->dreg, s390_r0);
3567                         } else {
3568                                 S390_SET   (code, s390_r0, ins->inst_imm);
3569                                 s390_alcgr (code, ins->dreg, s390_r0);
3570                         }
3571                 }
3572                         break;
3573                 case OP_LADD_OVF:
3574                 case OP_S390_LADD_OVF: {
3575                         CHECK_SRCDST_COM;
3576                         s390_agr    (code, ins->dreg, src2);
3577                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3578                 }
3579                         break;
3580                 case OP_LADD_OVF_UN:
3581                 case OP_S390_LADD_OVF_UN: {
3582                         CHECK_SRCDST_COM;
3583                         s390_algr  (code, ins->dreg, src2);
3584                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
3585                 }
3586                         break;
3587                 case OP_ISUBCC: {
3588                         CHECK_SRCDST_NCOM_I;
3589                         s390_slgr (code, ins->dreg, src2);
3590                 }
3591                         break;
3592                 case OP_ISUB: {
3593                         CHECK_SRCDST_NCOM_I;
3594                         s390_sgr  (code, ins->dreg, src2);
3595                 }
3596                         break;
3597                 case OP_ISBB: {
3598                         CHECK_SRCDST_NCOM_I;
3599                         s390_slbgr (code, ins->dreg, src2);
3600                 }
3601                         break;
3602                 case OP_ISUB_IMM: {
3603                         if (ins->dreg != ins->sreg1) {
3604                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3605                         }
3606                         if (s390_is_imm16 (-ins->inst_imm)) {
3607                                 s390_aghi (code, ins->dreg, -ins->inst_imm);
3608                         } else {
3609                                 s390_agfi (code, ins->dreg, -ins->inst_imm);
3610                         }
3611                 }
3612                         break;
3613                 case OP_ISBB_IMM: {
3614                         S390_SET (code, s390_r0, ins->inst_imm);
3615                         s390_slgfr (code, ins->dreg, s390_r0);
3616                 }
3617                         break;
3618                 case OP_ISUB_OVF:
3619                 case OP_S390_ISUB_OVF: {
3620                         CHECK_SRCDST_NCOM;
3621                         s390_sr   (code, ins->dreg, src2);
3622                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3623                         s390_lgfr (code, ins->dreg, ins->dreg);
3624                 }
3625                         break;
3626                 case OP_ISUB_OVF_UN:
3627                 case OP_S390_ISUB_OVF_UN: {
3628                         CHECK_SRCDST_NCOM;
3629                         s390_slr  (code, ins->dreg, src2);
3630                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, "OverflowException");
3631                         s390_llgfr(code, ins->dreg, ins->dreg);
3632                 }
3633                         break;
3634                 case OP_LSUB_OVF:
3635                 case OP_S390_LSUB_OVF: {
3636                         CHECK_SRCDST_NCOM;
3637                         s390_sgr   (code, ins->dreg, src2);
3638                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
3639                 }
3640                         break;
3641                 case OP_LSUB_OVF_UN:
3642                 case OP_S390_LSUB_OVF_UN: {
3643                         CHECK_SRCDST_NCOM;
3644                         s390_slgr  (code, ins->dreg, src2);
3645                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, "OverflowException");
3646                 }
3647                         break;
3648                 case OP_IAND: {
3649                         CHECK_SRCDST_NCOM_I;
3650                         s390_ngr (code, ins->dreg, src2);
3651                 }
3652                         break;
3653                 case OP_IAND_IMM: {
3654                         if (ins->dreg != ins->sreg1) {
3655                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3656                         }
3657                         S390_SET_MASK (code, s390_r0, ins->inst_imm);
3658                         s390_ngr  (code, ins->dreg, s390_r0);
3659                 }
3660                         break;
3661                 case OP_IDIV: {
3662                         s390_lgfr (code, s390_r0, ins->sreg1);
3663                         s390_srda (code, s390_r0, 0, 32);
3664                         s390_dr   (code, s390_r0, ins->sreg2);
3665                         s390_lgfr (code, ins->dreg, s390_r1);
3666                 }
3667                         break;
3668                 case OP_IDIV_UN: {
3669                         s390_lgfr (code, s390_r0, ins->sreg1);
3670                         s390_srdl (code, s390_r0, 0, 32);
3671                         s390_dlr  (code, s390_r0, ins->sreg2);
3672                         s390_lgfr (code, ins->dreg, s390_r1);
3673                 }
3674                         break;
3675                 case OP_IDIV_IMM: {
3676                         if (s390_is_imm16 (ins->inst_imm)) {
3677                                 s390_lghi (code, s390_r13, ins->inst_imm);
3678                         } else {
3679                                 s390_lgfi (code, s390_r13, ins->inst_imm);
3680                         }
3681                         s390_lgfr (code, s390_r0, ins->sreg1);
3682                         s390_srda (code, s390_r0, 0, 32);
3683                         s390_dr   (code, s390_r0, ins->sreg2);
3684                         s390_lgfr (code, ins->dreg, s390_r1);
3685                 }
3686                         break;
3687                 case OP_IREM: {
3688                         s390_lgfr (code, s390_r0, ins->sreg1);
3689                         s390_srda (code, s390_r0, 0, 32);
3690                         s390_dr   (code, s390_r0, ins->sreg2);
3691                         s390_lgfr (code, ins->dreg, s390_r0);
3692                         break;
3693                 case OP_IREM_UN:
3694                         s390_lgfr (code, s390_r0, ins->sreg1);
3695                         s390_srdl (code, s390_r0, 0, 32);
3696                         s390_dlr  (code, s390_r0, ins->sreg2);
3697                         s390_lgfr (code, ins->dreg, s390_r0);
3698                 }
3699                         break;
3700                 case OP_IREM_IMM: {
3701                         if (s390_is_imm16 (ins->inst_imm)) {
3702                                 s390_lghi (code, s390_r13, ins->inst_imm);
3703                         } else {
3704                                 s390_lgfi (code, s390_r13, ins->inst_imm);
3705                         }
3706                         s390_lgfr (code, s390_r0, ins->sreg1);
3707                         s390_srda (code, s390_r0, 0, 32);
3708                         s390_dr   (code, s390_r0, ins->sreg2);
3709                         s390_lgfr (code, ins->dreg, s390_r0);
3710                 }
3711                         break;
3712                 case OP_IOR: {
3713                         CHECK_SRCDST_COM_I;
3714                         s390_ogr (code, ins->dreg, src2);
3715                 }
3716                         break;
3717                 case OP_IOR_IMM: {
3718                         if (ins->dreg != ins->sreg1) {
3719                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3720                         }
3721                         S390_SET_MASK (code, s390_r0, ins->inst_imm);
3722                         s390_ogr  (code, ins->dreg, s390_r0);
3723                 }
3724                         break;
3725                 case OP_IXOR: {
3726                         CHECK_SRCDST_COM_I;
3727                         s390_xgr (code, ins->dreg, src2);
3728                 }
3729                         break;
3730                 case OP_IXOR_IMM: {
3731                         if (ins->dreg != ins->sreg1) {
3732                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3733                         }
3734                         S390_SET_MASK (code, s390_r0, ins->inst_imm);
3735                         s390_xgr  (code, ins->dreg, s390_r0);
3736                 }
3737                         break;
3738                 case OP_ISHL: {
3739                         CHECK_SRCDST_NCOM;
3740                         s390_sll  (code, ins->dreg, src2, 0);
3741                 }
3742                         break;
3743                 case OP_ISHL_IMM: {
3744                         if (ins->sreg1 != ins->dreg) {
3745                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3746                         }
3747                         s390_sll (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3748                 }
3749                         break;
3750                 case OP_ISHR: {
3751                         CHECK_SRCDST_NCOM;
3752                         s390_sra (code, ins->dreg, src2, 0);
3753                 }
3754                         break;
3755                 case OP_ISHR_IMM: {
3756                         if (ins->sreg1 != ins->dreg) {
3757                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3758                         }
3759                         s390_sra (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3760                 }
3761                         break;
3762                 case OP_ISHR_UN_IMM: {
3763                         if (ins->sreg1 != ins->dreg) {
3764                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3765                         }
3766                         s390_srl (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3767                 }
3768                         break;
3769                 case OP_ISHR_UN: {
3770                         CHECK_SRCDST_NCOM;
3771                         s390_srl  (code, ins->dreg, src2, 0);
3772                 }
3773                         break;
3774                 case OP_INOT: {
3775                         if (ins->sreg1 != ins->dreg) {
3776                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3777                         }
3778                         s390_lghi (code, s390_r0, -1);
3779                         s390_xgr  (code, ins->dreg, s390_r0);
3780                 }
3781                         break;
3782                 case OP_INEG: {
3783                         s390_lcgr (code, ins->dreg, ins->sreg1);
3784                 }
3785                         break;
3786                 case OP_IMUL: {
3787                         CHECK_SRCDST_COM_I;
3788                         s390_msr (code, ins->dreg, src2);
3789                 }
3790                         break;
3791                 case OP_IMUL_IMM: {
3792                         if (ins->dreg != ins->sreg1) {
3793                                 s390_lgfr (code, ins->dreg, ins->sreg1);
3794                         }
3795                         if (s390_is_imm16 (ins->inst_imm)) {
3796                                 s390_lghi (code, s390_r0, ins->inst_imm);
3797                         } else {
3798                                 s390_lgfi (code, s390_r0, ins->inst_imm);
3799                         }
3800                         s390_msr  (code, ins->dreg, s390_r0);
3801                 }
3802                         break;
3803                 case OP_IMUL_OVF: {
3804                         short int *o[2];
3805                         s390_ltr  (code, s390_r1, ins->sreg1);
3806                         s390_jz   (code, 0); CODEPTR(code, o[0]);
3807                         s390_ltr  (code, s390_r0, ins->sreg2);
3808                         s390_jnz  (code, 6);
3809                         s390_lhi  (code, s390_r1, 0);
3810                         s390_j    (code, 0); CODEPTR(code, o[1]);
3811                         s390_xr   (code, s390_r0, s390_r1);
3812                         s390_msr  (code, s390_r1, ins->sreg2);
3813                         s390_xr   (code, s390_r0, s390_r1);
3814                         s390_srl  (code, s390_r0, 0, 31);
3815                         s390_ltr  (code, s390_r0, s390_r0);
3816                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3817                         PTRSLOT   (code, o[0]);
3818                         PTRSLOT   (code, o[1]);
3819                         s390_lgfr (code, ins->dreg, s390_r1);
3820                 }
3821                         break;
3822                 case OP_IMUL_OVF_UN: {
3823                         s390_lhi  (code, s390_r0, 0);
3824                         s390_lr   (code, s390_r1, ins->sreg1);
3825                         s390_mlr  (code, s390_r0, ins->sreg2);
3826                         s390_ltr  (code, s390_r0, s390_r0);
3827                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3828                         s390_lgfr (code, ins->dreg, s390_r1);
3829                 }
3830                         break;
3831                 case OP_ICONST:
3832                 case OP_I8CONST: {
3833                         S390_SET (code, ins->dreg, ins->inst_c0);
3834                 }
3835                         break;
3836                 case OP_AOTCONST: {
3837                         mono_add_patch_info (cfg, code - cfg->native_code,
3838                                 (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3839                         S390_LOAD_TEMPLATE (code, ins->dreg);
3840                 }
3841                         break;
3842                 case OP_JUMP_TABLE: {
3843                         mono_add_patch_info (cfg, code - cfg->native_code,
3844                                 (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3845                         S390_LOAD_TEMPLATE (code, ins->dreg);
3846                 }
3847                         break;
3848                 case OP_MOVE:
3849                         if (ins->dreg != ins->sreg1) {
3850                                 s390_lgr (code, ins->dreg, ins->sreg1);
3851                         }
3852                         break;
3853                 case OP_LCONV_TO_I:
3854                 case OP_LCONV_TO_I8:
3855                 case OP_SEXT_I4:
3856                         s390_lgfr (code, ins->dreg, ins->sreg1);
3857                         break;
3858                 case OP_LCONV_TO_I4:
3859                         s390_lgfr (code, ins->dreg, ins->sreg1);
3860                         break;
3861                 case OP_LCONV_TO_U:
3862                 case OP_LCONV_TO_U8:
3863                 case OP_LCONV_TO_U4:
3864                 case OP_ZEXT_I4:
3865                         s390_llgfr (code, ins->dreg, ins->sreg1);
3866                         break;
3867                 case OP_LCONV_TO_OVF_U4:
3868                         S390_SET  (code, s390_r0, 4294967295);
3869                         s390_clgr (code, ins->sreg1, s390_r0);
3870                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT, "OverflowException");
3871                         s390_ltgr (code, ins->sreg1, ins->sreg1);
3872                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT, "OverflowException");
3873                         s390_llgfr(code, ins->dreg, ins->sreg1);
3874                         break;
3875                 case OP_LCONV_TO_OVF_I4_UN:
3876                         S390_SET  (code, s390_r0, 2147483647);
3877                         s390_cgr  (code, ins->sreg1, s390_r0);
3878                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT, "OverflowException");
3879                         s390_ltgr (code, ins->sreg1, ins->sreg1);
3880                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT, "OverflowException");
3881                         s390_lgfr (code, ins->dreg, ins->sreg1);
3882                         break;
3883                 case OP_FMOVE:
3884                         if (ins->dreg != ins->sreg1) {
3885                                 s390_ldr   (code, ins->dreg, ins->sreg1);
3886                         }
3887                         break;
3888                 case OP_MOVE_F_TO_I8:
3889                         s390_lgdr (code, ins->dreg, ins->sreg1);
3890                         break;
3891                 case OP_MOVE_I8_TO_F:
3892                         s390_ldgr (code, ins->dreg, ins->sreg1);
3893                         break;
3894                 case OP_MOVE_F_TO_I4:
3895                         s390_ledbr (code, s390_f0, ins->sreg1);
3896                         s390_lgdr (code, ins->dreg, s390_f0);
3897                         s390_srag (code, ins->dreg, ins->dreg, 0, 32);
3898                         break;
3899                 case OP_MOVE_I4_TO_F:
3900                         s390_slag (code, s390_r0, ins->sreg1, 0, 32);
3901                         s390_ldgr (code, ins->dreg, s390_r0);
3902                         s390_ldebr (code, ins->dreg, ins->dreg);
3903                         break;
3904                 case OP_FCONV_TO_R4:
3905                         s390_ledbr (code, ins->dreg, ins->sreg1);
3906                         s390_ldebr (code, ins->dreg, ins->dreg);
3907                         break;
3908                 case OP_S390_SETF4RET:
3909                         s390_ledbr (code, ins->dreg, ins->sreg1);
3910                         break;
3911                 case OP_TLS_GET: {
3912                         if (s390_is_imm16 (ins->inst_offset)) {
3913                                 s390_lghi (code, s390_r13, ins->inst_offset);
3914                         } else if (s390_is_imm32 (ins->inst_offset)) {
3915                                 s390_lgfi (code, s390_r13, ins->inst_offset);
3916                         } else {
3917                                 S390_SET  (code, s390_r13, ins->inst_offset);
3918                         }
3919                         s390_ear (code, s390_r1, 0);
3920                         s390_sllg(code, s390_r1, s390_r1, 0, 32);
3921                         s390_ear (code, s390_r1, 1);
3922                         s390_lg  (code, ins->dreg, s390_r13, s390_r1, 0);
3923                 }
3924                         break;
3925                 case OP_JMP: {
3926                         if (cfg->method->save_lmf)
3927                                 restoreLMF(code, cfg->frame_reg, cfg->stack_usage);
3928
3929                         if (cfg->flags & MONO_CFG_HAS_TAIL) {
3930                                 code =  emit_load_volatile_arguments (code, cfg);
3931                         }
3932
3933                         code = backUpStackPtr(cfg, code);
3934                         s390_lg  (code, s390_r14, 0, cfg->frame_reg, S390_RET_ADDR_OFFSET);
3935                         mono_add_patch_info (cfg, code - cfg->native_code,
3936                                              MONO_PATCH_INFO_METHOD_JUMP,
3937                                              ins->inst_p0);
3938                         s390_jcl (code, S390_CC_UN, 0);
3939                 }
3940                         break;
3941                 case OP_CHECK_THIS: {
3942                         /* ensure ins->sreg1 is not NULL */
3943                         s390_lg   (code, s390_r0, 0, ins->sreg1, 0);
3944                         s390_ltgr (code, s390_r0, s390_r0);
3945 //                      EMIT_COND_SYSTEM_EXCEPTION (S390_CC_ZR, "NullReferenceException");
3946                 }
3947                         break;
3948                 case OP_ARGLIST: {
3949                         int offset = cfg->sig_cookie + cfg->stack_usage;
3950
3951                         if (s390_is_imm16 (offset)) {
3952                                 s390_lghi (code, s390_r0, offset);
3953                         } else if (s390_is_imm32 (offset)) {
3954                                 s390_lgfi (code, s390_r0, offset);
3955                         } else {
3956                                 S390_SET  (code, s390_r0, offset);
3957                         }
3958                         s390_agr  (code, s390_r0, cfg->frame_reg);
3959                         s390_stg  (code, s390_r0, 0, ins->sreg1, 0);
3960                 }
3961                         break;
3962                 case OP_FCALL: {
3963                         call = (MonoCallInst*)ins;
3964                         if (ins->flags & MONO_INST_HAS_METHOD)
3965                                 mono_add_patch_info (cfg, code-cfg->native_code,
3966                                                      MONO_PATCH_INFO_METHOD,
3967                                                      call->method);
3968                         else
3969                                 mono_add_patch_info (cfg, code-cfg->native_code,
3970                                                      MONO_PATCH_INFO_ABS,
3971                                                      call->fptr);
3972                         S390_CALL_TEMPLATE (code, s390_r14);
3973                         if (call->signature->ret->type == MONO_TYPE_R4)
3974                                 s390_ldebr (code, s390_f0, s390_f0);
3975                 }
3976                         break;
3977                 case OP_LCALL:
3978                 case OP_VCALL:
3979                 case OP_VCALL2:
3980                 case OP_VOIDCALL:
3981                 case OP_CALL: {
3982                         call = (MonoCallInst*)ins;
3983                         if (ins->flags & MONO_INST_HAS_METHOD)
3984                                 mono_add_patch_info (cfg, code-cfg->native_code,
3985                                                      MONO_PATCH_INFO_METHOD,
3986                                                      call->method);
3987                         else
3988                                 mono_add_patch_info (cfg, code-cfg->native_code,
3989                                                      MONO_PATCH_INFO_ABS,
3990                                                      call->fptr);
3991                         S390_CALL_TEMPLATE (code, s390_r14);
3992                 }
3993                         break;
3994                 case OP_FCALL_REG: {
3995                         call = (MonoCallInst*)ins;
3996                         s390_lgr  (code, s390_r1, ins->sreg1);
3997                         s390_basr (code, s390_r14, s390_r1);
3998                         if (call->signature->ret->type == MONO_TYPE_R4)
3999                                 s390_ldebr (code, s390_f0, s390_f0);
4000                 }
4001                         break;
4002                 case OP_LCALL_REG:
4003                 case OP_VCALL_REG:
4004                 case OP_VCALL2_REG:
4005                 case OP_VOIDCALL_REG:
4006                 case OP_CALL_REG: {
4007                         s390_lgr  (code, s390_r1, ins->sreg1);
4008                         s390_basr (code, s390_r14, s390_r1);
4009                 }
4010                         break;
4011                 case OP_FCALL_MEMBASE: {
4012                         call = (MonoCallInst*)ins;
4013                         s390_lg   (code, s390_r1, 0, ins->sreg1, ins->inst_offset);
4014                         s390_basr (code, s390_r14, s390_r1);
4015                         if (call->signature->ret->type == MONO_TYPE_R4)
4016                                 s390_ldebr (code, s390_f0, s390_f0);
4017                 }
4018                         break;
4019                 case OP_LCALL_MEMBASE:
4020                 case OP_VCALL_MEMBASE:
4021                 case OP_VCALL2_MEMBASE:
4022                 case OP_VOIDCALL_MEMBASE:
4023                 case OP_CALL_MEMBASE: {
4024                         s390_lg   (code, s390_r1, 0, ins->sreg1, ins->inst_offset);
4025                         s390_basr (code, s390_r14, s390_r1);
4026                 }
4027                         break;
4028                 case OP_LOCALLOC: {
4029                         int alloca_skip;
4030                         int area_offset;
4031
4032                         if (cfg->param_area == 0)
4033                                 alloca_skip = S390_MINIMAL_STACK_SIZE;
4034                         else
4035                                 alloca_skip = cfg->param_area;
4036
4037                         area_offset = S390_ALIGN(alloca_skip, S390_STACK_ALIGNMENT);
4038                         s390_lgr  (code, s390_r1, ins->sreg1);
4039                         if (ins->flags & MONO_INST_INIT)
4040                                 s390_lgr  (code, s390_r0, ins->sreg1);
4041                         s390_aghi (code, s390_r1, 14);
4042                         s390_srlg (code, s390_r1, s390_r1, 0, 3);
4043                         s390_sllg (code, s390_r1, s390_r1, 0, 3);
4044                         if (cfg->method->save_lmf) {
4045                                 /*----------------------------------*/
4046                                 /* we have to adjust lmf ebp value  */
4047                                 /*----------------------------------*/
4048                                 int lmfOffset = cfg->stack_usage - sizeof(MonoLMF);
4049
4050                                 s390_lgr (code, s390_r13, cfg->frame_reg);
4051                                 if (s390_is_imm16(lmfOffset)) {
4052                                         s390_aghi (code, s390_r13, lmfOffset);
4053                                 } else if (s390_is_imm32(lmfOffset)) {
4054                                         s390_agfi (code, s390_r13, lmfOffset);
4055                                 } else {
4056                                         S390_SET  (code, s390_r13, lmfOffset);
4057                                 }
4058                                 s390_lgr (code, s390_r14, STK_BASE);
4059                                 s390_sgr (code, s390_r14, s390_r1);
4060                                 s390_stg (code, s390_r14, 0, s390_r13,
4061                                           G_STRUCT_OFFSET(MonoLMF, ebp));
4062                         }
4063                         s390_lg   (code, s390_r13, 0, STK_BASE, 0);
4064                         s390_sgr  (code, STK_BASE, s390_r1);
4065                         s390_stg  (code, s390_r13, 0, STK_BASE, 0);
4066                         s390_la   (code, ins->dreg, 0, STK_BASE, area_offset);
4067                         s390_srlg (code, ins->dreg, ins->dreg, 0, 3);
4068                         s390_sllg (code, ins->dreg, ins->dreg, 0, 3);
4069                         if (ins->flags & MONO_INST_INIT) {
4070                                 s390_lgr  (code, s390_r1, s390_r0);
4071                                 s390_lgr  (code, s390_r0, ins->dreg);
4072                                 s390_lgr  (code, s390_r14, s390_r12);
4073                                 s390_lghi (code, s390_r13, 0);
4074                                 s390_mvcle(code, s390_r0, s390_r12, 0, 0);
4075                                 s390_jo   (code, -2);
4076                                 s390_lgr  (code, s390_r12, s390_r14);
4077                         }
4078                 }
4079                         break;
4080                 case OP_THROW: {
4081                         s390_lgr  (code, s390_r2, ins->sreg1);
4082                         mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
4083                                              (gpointer) "mono_arch_throw_exception");
4084                         S390_CALL_TEMPLATE(code, s390_r14);
4085                 }
4086                         break;
4087                 case OP_RETHROW: {
4088                         s390_lgr  (code, s390_r2, ins->sreg1);
4089                         mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
4090                                              (gpointer) "mono_arch_rethrow_exception");
4091                         S390_CALL_TEMPLATE(code, s390_r14);
4092                 }
4093                         break;
4094                 case OP_START_HANDLER: {
4095                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4096
4097                         S390_LONG (code, stg, stg, s390_r14, 0,
4098                                    spvar->inst_basereg,
4099                                    spvar->inst_offset);
4100                 }
4101                         break;
4102                 case OP_ENDFILTER: {
4103                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4104
4105                         if (ins->sreg1 != s390_r2)
4106                                 s390_lgr(code, s390_r2, ins->sreg1);
4107                         S390_LONG (code, lg, lg, s390_r14, 0,
4108                                    spvar->inst_basereg,
4109                                    spvar->inst_offset);
4110                         s390_br  (code, s390_r14);
4111                 }
4112                         break;
4113                 case OP_ENDFINALLY: {
4114                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4115
4116                         S390_LONG (code, lg, lg, s390_r14, 0,
4117                                    spvar->inst_basereg,
4118                                    spvar->inst_offset);
4119                         s390_br  (code, s390_r14);
4120                 }
4121                         break;
4122                 case OP_CALL_HANDLER: {
4123                         mono_add_patch_info (cfg, code-cfg->native_code,
4124                                              MONO_PATCH_INFO_BB, ins->inst_target_bb);
4125                         s390_brasl (code, s390_r14, 0);
4126                         mono_cfg_add_try_hole (cfg, ins->inst_eh_block, code, bb);
4127                 }
4128                         break;
4129                 case OP_LABEL: {
4130                         ins->inst_c0 = code - cfg->native_code;
4131                 }
4132                         break;
4133                 case OP_RELAXED_NOP:
4134                 case OP_NOP:
4135                 case OP_DUMMY_USE:
4136                 case OP_DUMMY_STORE:
4137                 case OP_NOT_REACHED:
4138                 case OP_NOT_NULL: {
4139                 }
4140                         break;
4141                 case OP_IL_SEQ_POINT:
4142                         mono_add_seq_point (cfg, bb, ins, code - cfg->native_code);
4143                         break;
4144                 case OP_SEQ_POINT: {
4145                         int i;
4146
4147                         if (cfg->compile_aot)
4148                                 NOT_IMPLEMENTED;
4149
4150                         /*
4151                          * Read from the single stepping trigger page. This will cause a
4152                          * SIGSEGV when single stepping is enabled.
4153                          * We do this _before_ the breakpoint, so single stepping after
4154                          * a breakpoint is hit will step to the next IL offset.
4155                          */
4156                         if (ins->flags & MONO_INST_SINGLE_STEP_LOC) {
4157                                 breakpointCode.pTrigger = ss_trigger_page;
4158                                 memcpy(code, (void *) &breakpointCode, BREAKPOINT_SIZE);
4159                                 code += BREAKPOINT_SIZE;
4160                         }
4161
4162                         mono_add_seq_point (cfg, bb, ins, code - cfg->native_code);
4163
4164                         /*
4165                          * A placeholder for a possible breakpoint inserted by
4166                          * mono_arch_set_breakpoint ().
4167                          */
4168                         for (i = 0; i < (BREAKPOINT_SIZE / S390X_NOP_SIZE); ++i)
4169                                 s390_nop (code);
4170
4171                         /*
4172                          * Add an additional nop so skipping the bp doesn't cause the ip to point
4173                          * to another IL offset.
4174                          */
4175                         s390_nop (code);
4176
4177                         break;
4178                 }
4179                 case OP_GENERIC_CLASS_INIT: {
4180                         static int byte_offset = -1;
4181                         static guint8 bitmask;
4182                         short int *jump;
4183
4184                         g_assert (ins->sreg1 == S390_FIRST_ARG_REG);
4185
4186                         if (byte_offset < 0)
4187                                 mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask);
4188
4189                         s390_tm (code, ins->sreg1, byte_offset, bitmask);
4190                         s390_jo (code, 0); CODEPTR(code, jump);
4191
4192                         mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
4193                                                 "mono_generic_class_init");
4194                         S390_CALL_TEMPLATE(code, s390_r14);
4195
4196                         PTRSLOT (code, jump);
4197
4198                         ins->flags |= MONO_INST_GC_CALLSITE;
4199                         ins->backend.pc_offset = code - cfg->native_code;
4200                         break;
4201                 }
4202                 case OP_BR:
4203                         EMIT_UNCOND_BRANCH(ins);
4204                         break;
4205                 case OP_BR_REG: {
4206                         s390_br  (code, ins->sreg1);
4207                 }
4208                         break;
4209                 case OP_CEQ:
4210                 case OP_ICEQ:
4211                 case OP_LCEQ: {
4212                         s390_lghi(code, ins->dreg, 1);
4213                         s390_jz  (code, 4);
4214                         s390_lghi(code, ins->dreg, 0);
4215                 }
4216                         break;
4217                 case OP_CLT:
4218                 case OP_ICLT:
4219                 case OP_LCLT: {
4220                         s390_lghi(code, ins->dreg, 1);
4221                         s390_jl  (code, 4);
4222                         s390_lghi(code, ins->dreg, 0);
4223                 }
4224                         break;
4225                 case OP_CLT_UN:
4226                 case OP_ICLT_UN:
4227                 case OP_LCLT_UN: {
4228                         s390_lghi(code, ins->dreg, 1);
4229                         s390_jlo (code, 4);
4230                         s390_lghi(code, ins->dreg, 0);
4231                 }
4232                         break;
4233                 case OP_CGT:
4234                 case OP_ICGT:
4235                 case OP_LCGT: {
4236                         s390_lghi(code, ins->dreg, 1);
4237                         s390_jh  (code, 4);
4238                         s390_lghi(code, ins->dreg, 0);
4239                 }
4240                         break;
4241                 case OP_CGT_UN:
4242                 case OP_ICGT_UN:
4243                 case OP_LCGT_UN: {
4244                         s390_lghi(code, ins->dreg, 1);
4245                         s390_jho (code, 4);
4246                         s390_lghi(code, ins->dreg, 0);
4247                 }
4248                         break;
4249                 case OP_COND_EXC_EQ:
4250                 case OP_COND_EXC_IEQ:
4251                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_EQ, ins->inst_p1);
4252                         break;
4253                 case OP_COND_EXC_NE_UN:
4254                 case OP_COND_EXC_INE_UN:
4255                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NE, ins->inst_p1);
4256                         break;
4257                 case OP_COND_EXC_LT:
4258                 case OP_COND_EXC_ILT:
4259                 case OP_COND_EXC_LT_UN:
4260                 case OP_COND_EXC_ILT_UN:
4261                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT, ins->inst_p1);
4262                         break;
4263                 case OP_COND_EXC_GT:
4264                 case OP_COND_EXC_IGT:
4265                 case OP_COND_EXC_GT_UN:
4266                 case OP_COND_EXC_IGT_UN:
4267                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT, ins->inst_p1);
4268                         break;
4269                 case OP_COND_EXC_GE:
4270                 case OP_COND_EXC_IGE:
4271                 case OP_COND_EXC_GE_UN:
4272                 case OP_COND_EXC_IGE_UN:
4273                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GE, ins->inst_p1);
4274                         break;
4275                 case OP_COND_EXC_LE:
4276                 case OP_COND_EXC_ILE:
4277                 case OP_COND_EXC_LE_UN:
4278                 case OP_COND_EXC_ILE_UN:
4279                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LE, ins->inst_p1);
4280                         break;
4281                 case OP_COND_EXC_OV:
4282                 case OP_COND_EXC_IOV:
4283                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, ins->inst_p1);
4284                         break;
4285                 case OP_COND_EXC_NO:
4286                 case OP_COND_EXC_INO:
4287                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NO, ins->inst_p1);
4288                         break;
4289                 case OP_COND_EXC_C:
4290                 case OP_COND_EXC_IC:
4291                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, ins->inst_p1);
4292                         break;
4293                 case OP_COND_EXC_NC:
4294                 case OP_COND_EXC_INC:
4295                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, ins->inst_p1);
4296                         break;
4297                 case OP_LBEQ:
4298                 case OP_IBEQ:
4299                         EMIT_COND_BRANCH (ins, S390_CC_EQ);
4300                         break;
4301                 case OP_LBNE_UN:
4302                 case OP_IBNE_UN:
4303                         EMIT_COND_BRANCH (ins, S390_CC_NE);
4304                         break;
4305                 case OP_LBLT:
4306                 case OP_LBLT_UN:
4307                 case OP_IBLT:
4308                 case OP_IBLT_UN:
4309                         EMIT_COND_BRANCH (ins, S390_CC_LT);
4310                         break;
4311                 case OP_LBGT:
4312                 case OP_LBGT_UN:
4313                 case OP_IBGT:
4314                 case OP_IBGT_UN:
4315                         EMIT_COND_BRANCH (ins, S390_CC_GT);
4316                         break;
4317                 case OP_LBGE:
4318                 case OP_LBGE_UN:
4319                 case OP_IBGE:
4320                 case OP_IBGE_UN:
4321                         EMIT_COND_BRANCH (ins, S390_CC_GE);
4322                         break;
4323                 case OP_LBLE:
4324                 case OP_LBLE_UN:
4325                 case OP_IBLE:
4326                 case OP_IBLE_UN:
4327                         EMIT_COND_BRANCH (ins, S390_CC_LE);
4328                         break;
4329
4330                 /* floating point opcodes */
4331                 case OP_R8CONST: {
4332                         if (*((double *) ins->inst_p0) == 0) {
4333                                 s390_lzdr (code, ins->dreg);
4334                         } else {
4335                                 S390_SET  (code, s390_r13, ins->inst_p0);
4336                                 s390_ld   (code, ins->dreg, 0, s390_r13, 0);
4337                         }
4338                 }
4339                         break;
4340                 case OP_R4CONST: {
4341                         if (*((float *) ins->inst_p0) == 0) {
4342                                 s390_lzdr (code, ins->dreg);
4343                         } else {
4344                                 S390_SET  (code, s390_r13, ins->inst_p0);
4345                                 s390_ldeb (code, ins->dreg, 0, s390_r13, 0);
4346                         }
4347                 }
4348                         break;
4349                 case OP_STORER8_MEMBASE_REG: {
4350                         S390_LONG (code, stdy, std, ins->sreg1, 0,
4351                                    ins->inst_destbasereg, ins->inst_offset);
4352                 }
4353                         break;
4354                 case OP_LOADR8_MEMBASE: {
4355                         S390_LONG (code, ldy, ld, ins->dreg, 0,
4356                                    ins->inst_basereg, ins->inst_offset);
4357                 }
4358                         break;
4359                 case OP_STORER4_MEMBASE_REG: {
4360                         s390_ledbr (code, s390_f15, ins->sreg1);
4361                         S390_LONG (code, stey, ste, s390_f15, 0,
4362                                    ins->inst_destbasereg, ins->inst_offset);
4363                 }
4364                         break;
4365                 case OP_LOADR4_MEMBASE: {
4366                         S390_LONG (code, ley, le, s390_f15, 0,
4367                                    ins->inst_basereg, ins->inst_offset);
4368                         s390_ldebr (code, ins->dreg, s390_f15);
4369                 }
4370                         break;
4371                 case OP_ICONV_TO_R_UN: {
4372                         if (mono_hwcap_s390x_has_fpe) {
4373                                 s390_cdlfbr (code, ins->dreg, 5, ins->sreg1, 0);
4374                         } else {
4375                                 s390_llgfr (code, s390_r0, ins->sreg1);
4376                                 s390_cdgbr (code, ins->dreg, s390_r0);
4377                         }
4378                 }
4379                         break;
4380                 case OP_LCONV_TO_R_UN: {
4381                         if (mono_hwcap_s390x_has_fpe) {
4382                                 s390_cdlgbr (code, ins->dreg, 5, ins->sreg1, 0);
4383                         } else {
4384                                 short int *jump;
4385                                 s390_cxgbr (code, s390_f12, ins->sreg1);
4386                                 s390_ltgr  (code, ins->sreg1, ins->sreg1);
4387                                 s390_jnl   (code, 0); CODEPTR(code, jump);
4388                                 S390_SET   (code, s390_r13, 0x403f000000000000llu);
4389                                 s390_lgdr  (code, s390_f13, s390_r13);
4390                                 s390_lzdr  (code, s390_f15);
4391                                 s390_axbr  (code, s390_f12, s390_f13);
4392                                 PTRSLOT(code, jump);
4393                                 s390_ldxbr (code, s390_f13, s390_f12);
4394                                 s390_ldr   (code, ins->dreg, s390_f13);
4395                         }
4396                 }
4397                         break;
4398                 case OP_LCONV_TO_R4:
4399                 case OP_ICONV_TO_R4: {
4400                         s390_cegbr (code, ins->dreg, ins->sreg1);
4401                         s390_ldebr (code, ins->dreg, ins->dreg);
4402                 }
4403                         break;
4404                 case OP_LCONV_TO_R8:
4405                 case OP_ICONV_TO_R8: {
4406                         s390_cdgbr (code, ins->dreg, ins->sreg1);
4407                 }
4408                         break;
4409                 case OP_FCONV_TO_I1:
4410                         s390_cgdbr (code, ins->dreg, 5, ins->sreg1);
4411                         s390_ltgr  (code, ins->dreg, ins->dreg);
4412                         s390_jnl   (code, 4);
4413                         s390_oill  (code, ins->dreg, 0x80);
4414                         s390_lghi  (code, s390_r0, 0xff);
4415                         s390_ngr   (code, ins->dreg, s390_r0);
4416                         break;
4417                 case OP_FCONV_TO_U1:
4418                         if (mono_hwcap_s390x_has_fpe) {
4419                                 s390_clgdbr (code, ins->dreg, 5, ins->sreg1, 0);
4420                                 s390_lghi  (code, s390_r0, 0xff);
4421                                 s390_ngr   (code, ins->dreg, s390_r0);
4422                         } else {
4423                                 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, FALSE);
4424                         }
4425                         break;
4426                 case OP_FCONV_TO_I2:
4427                         s390_cgdbr (code, ins->dreg, 5, ins->sreg1);
4428                         s390_ltgr  (code, ins->dreg, ins->dreg);
4429                         s390_jnl   (code, 4);
4430                         s390_oill  (code, ins->dreg, 0x8000);
4431                         s390_llill (code, s390_r0, 0xffff);
4432                         s390_ngr   (code, ins->dreg, s390_r0);
4433                         break;
4434                 case OP_FCONV_TO_U2:
4435                         if (mono_hwcap_s390x_has_fpe) {
4436                                 s390_clgdbr (code, ins->dreg, 5, ins->sreg1, 0);
4437                                 s390_llill  (code, s390_r0, 0xffff);
4438                                 s390_ngr    (code, ins->dreg, s390_r0);
4439                         } else {
4440                                 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, FALSE);
4441                         }
4442                         break;
4443                 case OP_FCONV_TO_I4:
4444                 case OP_FCONV_TO_I:
4445                         s390_cfdbr (code, ins->dreg, 5, ins->sreg1);
4446                         break;
4447                 case OP_FCONV_TO_U4:
4448                 case OP_FCONV_TO_U:
4449                         if (mono_hwcap_s390x_has_fpe) {
4450                                 s390_clfdbr (code, ins->dreg, 5, ins->sreg1, 0);
4451                         } else {
4452                                 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
4453                         }
4454                         break;
4455                 case OP_FCONV_TO_I8:
4456                         s390_cgdbr (code, ins->dreg, 5, ins->sreg1);
4457                         break;
4458                 case OP_FCONV_TO_U8:
4459                         if (mono_hwcap_s390x_has_fpe) {
4460                                 s390_clgdbr (code, ins->dreg, 5, ins->sreg1, 0);
4461                         } else {
4462                                 code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 8, FALSE);
4463                         }
4464                         break;
4465                 case OP_LCONV_TO_OVF_I: {
4466                         /* Valid ints: 0xffffffff:8000000 to 00000000:0x7f000000 */
4467                         short int *o[5];
4468                         s390_ltgr (code, ins->sreg2, ins->sreg2);
4469                         s390_jnl  (code, 0); CODEPTR(code, o[0]);
4470                         s390_ltgr (code, ins->sreg1, ins->sreg1);
4471                         s390_jnl  (code, 0); CODEPTR(code, o[1]);
4472                         s390_lhi  (code, s390_r13, -1);
4473                         s390_cgr  (code, ins->sreg1, s390_r13);
4474                         s390_jnz  (code, 0); CODEPTR(code, o[2]);
4475                         if (ins->dreg != ins->sreg2)
4476                                 s390_lgr  (code, ins->dreg, ins->sreg2);
4477                         s390_j    (code, 0); CODEPTR(code, o[3]);
4478                         PTRSLOT(code, o[0]);
4479                         s390_jz   (code, 0); CODEPTR(code, o[4]);
4480                         PTRSLOT(code, o[1]);
4481                         PTRSLOT(code, o[2]);
4482                         mono_add_patch_info (cfg, code - cfg->native_code,
4483                                              MONO_PATCH_INFO_EXC, "OverflowException");
4484                         s390_brasl (code, s390_r14, 0);
4485                         PTRSLOT(code, o[3]);
4486                         PTRSLOT(code, o[4]);
4487                 }
4488                         break;
4489                 case OP_ABS: {
4490                         s390_lpdbr (code, ins->dreg, ins->sreg1);
4491                 }
4492                         break;
4493                 case OP_SQRT: {
4494                         s390_sqdbr (code, ins->dreg, ins->sreg1);
4495                 }
4496                         break;
4497                 case OP_FADD: {
4498                         CHECK_SRCDST_COM_F;
4499                         s390_adbr (code, ins->dreg, src2);
4500                 }
4501                         break;
4502                 case OP_FSUB: {
4503                         CHECK_SRCDST_NCOM_F;
4504                         s390_sdbr (code, ins->dreg, src2);
4505                 }
4506                         break;
4507                 case OP_FMUL: {
4508                         CHECK_SRCDST_COM_F;
4509                         s390_mdbr (code, ins->dreg, src2);
4510                 }
4511                         break;
4512                 case OP_FDIV: {
4513                         CHECK_SRCDST_NCOM_F;
4514                         s390_ddbr (code, ins->dreg, src2);
4515                 }
4516                         break;
4517                 case OP_FNEG: {
4518                         s390_lcdbr (code, ins->dreg, ins->sreg1);
4519                 }
4520                         break;
4521                 case OP_FREM: {
4522                         CHECK_SRCDST_NCOM_F;
4523                         s390_didbr (code, ins->dreg, src2, 5, s390_f15);
4524                 }
4525                         break;
4526                 case OP_FCOMPARE: {
4527                         s390_cdbr (code, ins->sreg1, ins->sreg2);
4528                 }
4529                         break;
4530                 case OP_FCEQ: {
4531                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
4532                         s390_lghi  (code, ins->dreg, 1);
4533                         s390_je    (code, 4);
4534                         s390_lghi  (code, ins->dreg, 0);
4535                 }
4536                         break;
4537                 case OP_FCLT: {
4538                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
4539                         s390_lghi  (code, ins->dreg, 1);
4540                         s390_jl    (code, 4);
4541                         s390_lghi  (code, ins->dreg, 0);
4542                 }
4543                         break;
4544                 case OP_FCLT_UN: {
4545                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
4546                         s390_lghi  (code, ins->dreg, 1);
4547                         s390_jlo   (code, 4);
4548                         s390_lghi  (code, ins->dreg, 0);
4549                 }
4550                         break;
4551                 case OP_FCGT: {
4552                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
4553                         s390_lghi  (code, ins->dreg, 1);
4554                         s390_jh    (code, 4);
4555                         s390_lghi  (code, ins->dreg, 0);
4556                 }
4557                         break;
4558                 case OP_FCGT_UN: {
4559                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
4560                         s390_lghi  (code, ins->dreg, 1);
4561                         s390_jho   (code, 4);
4562                         s390_lghi  (code, ins->dreg, 0);
4563                 }
4564                         break;
4565                 case OP_FBEQ: {
4566                         short *o;
4567                         s390_jo (code, 0); CODEPTR(code, o);
4568                         EMIT_COND_BRANCH (ins, S390_CC_EQ);
4569                         PTRSLOT (code, o);
4570                 }
4571                         break;
4572                 case OP_FBNE_UN:
4573                         EMIT_COND_BRANCH (ins, S390_CC_NE|S390_CC_OV);
4574                         break;
4575                 case OP_FBLT: {
4576                         short *o;
4577                         s390_jo (code, 0); CODEPTR(code, o);
4578                         EMIT_COND_BRANCH (ins, S390_CC_LT);
4579                         PTRSLOT (code, o);
4580                 }
4581                         break;
4582                 case OP_FBLT_UN:
4583                         EMIT_COND_BRANCH (ins, S390_CC_LT|S390_CC_OV);
4584                         break;
4585                 case OP_FBGT: {
4586                         short *o;
4587                         s390_jo (code, 0); CODEPTR(code, o);
4588                         EMIT_COND_BRANCH (ins, S390_CC_GT);
4589                         PTRSLOT (code, o);
4590                 }
4591                         break;
4592                 case OP_FBGT_UN:
4593                         EMIT_COND_BRANCH (ins, S390_CC_GT|S390_CC_OV);
4594                         break;
4595                 case OP_FBGE: {
4596                         short *o;
4597                         s390_jo (code, 0); CODEPTR(code, o);
4598                         EMIT_COND_BRANCH (ins, S390_CC_GE);
4599                         PTRSLOT (code, o);
4600                 }
4601                         break;
4602                 case OP_FBGE_UN:
4603                         EMIT_COND_BRANCH (ins, S390_CC_GE|S390_CC_OV);
4604                         break;
4605                 case OP_FBLE: {
4606                         short *o;
4607                         s390_jo (code, 0); CODEPTR(code, o);
4608                         EMIT_COND_BRANCH (ins, S390_CC_LE);
4609                         PTRSLOT (code, o);
4610                 }
4611                         break;
4612                 case OP_FBLE_UN:
4613                         EMIT_COND_BRANCH (ins, S390_CC_LE|S390_CC_OV);
4614                         break;
4615                 case OP_CKFINITE: {
4616                         short *o;
4617                         s390_lhi  (code, s390_r13, 0x7f);
4618                         s390_tcdb (code, ins->sreg1, 0, s390_r13, 0);
4619                         s390_jz   (code, 0); CODEPTR(code, o);
4620                         mono_add_patch_info (cfg, code - cfg->native_code,
4621                                              MONO_PATCH_INFO_EXC, "OverflowException");
4622                         s390_brasl (code, s390_r14,0);
4623                         PTRSLOT(code, o);
4624                 }
4625                         break;
4626                 case OP_S390_MOVE: {
4627                         if (ins->backend.size > 0) {
4628                                 if (ins->backend.size <= 256) {
4629                                         s390_mvc  (code, ins->backend.size, ins->dreg,
4630                                                    ins->inst_offset, ins->sreg1, ins->inst_imm);
4631                                 } else {
4632                                         s390_lgr  (code, s390_r0, ins->dreg);
4633                                         if (ins->inst_offset > 0) {
4634                                                 if (s390_is_imm16 (ins->inst_offset)) {
4635                                                         s390_aghi (code, s390_r0, ins->inst_offset);
4636                                                 } else if (s390_is_imm32 (ins->inst_offset)) {
4637                                                         s390_agfi (code, s390_r0, ins->inst_offset);
4638                                                 } else {
4639                                                         S390_SET  (code, s390_r13, ins->inst_offset);
4640                                                         s390_agr  (code, s390_r0, s390_r13);
4641                                                 }
4642                                         }
4643                                         s390_lgr  (code, s390_r12, ins->sreg1);
4644                                         if (ins->inst_imm > 0) {
4645                                                 if (s390_is_imm16 (ins->inst_imm)) {
4646                                                         s390_aghi (code, s390_r12, ins->inst_imm);
4647                                                 } else if (s390_is_imm32 (ins->inst_imm)) {
4648                                                         s390_agfi (code, s390_r12, ins->inst_imm);
4649                                                 } else {
4650                                                         S390_SET  (code, s390_r13, ins->inst_imm);
4651                                                         s390_agr  (code, s390_r12, s390_r13);
4652                                                 }
4653                                         }
4654                                         if (s390_is_imm16 (ins->backend.size)) {
4655                                                 s390_lghi (code, s390_r1, ins->backend.size);
4656                                         } else if (s390_is_imm32 (ins->inst_offset)) {
4657                                                 s390_agfi (code, s390_r1, ins->backend.size);
4658                                         } else {
4659                                                 S390_SET  (code, s390_r13, ins->backend.size);
4660                                                 s390_agr  (code, s390_r1, s390_r13);
4661                                         }
4662                                         s390_lgr  (code, s390_r13, s390_r1);
4663                                         s390_mvcle(code, s390_r0, s390_r12, 0, 0);
4664                                         s390_jo   (code, -2);
4665                                 }
4666                         }
4667                 }
4668                         break;
4669                 case OP_ATOMIC_ADD_I8: {
4670                         s390_lgr (code, s390_r1, ins->sreg2);
4671                         s390_lg  (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
4672                         s390_agr (code, s390_r1, s390_r0);
4673                         s390_csg (code, s390_r0, s390_r1, ins->inst_basereg, ins->inst_offset);
4674                         s390_jnz (code, -10);
4675                         s390_lgr (code, ins->dreg, s390_r1);
4676                 }
4677                         break;
4678                 case OP_ATOMIC_EXCHANGE_I8: {
4679                         s390_lg  (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
4680                         s390_csg (code, s390_r0, ins->sreg2, ins->inst_basereg, ins->inst_offset);
4681                         s390_jnz (code, -6);
4682                         s390_lgr (code, ins->dreg, s390_r0);
4683                 }
4684                         break;
4685                 case OP_ATOMIC_ADD_I4: {
4686                         s390_lgfr(code, s390_r1, ins->sreg2);
4687                         s390_lgf (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
4688                         s390_agr (code, s390_r1, s390_r0);
4689                         s390_cs  (code, s390_r0, s390_r1, ins->inst_basereg, ins->inst_offset);
4690                         s390_jnz (code, -9);
4691                         s390_lgfr(code, ins->dreg, s390_r1);
4692                 }
4693                         break;
4694                 case OP_ATOMIC_EXCHANGE_I4: {
4695                         s390_l   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
4696                         s390_cs  (code, s390_r0, ins->sreg2, ins->inst_basereg, ins->inst_offset);
4697                         s390_jnz (code, -4);
4698                         s390_lgfr(code, ins->dreg, s390_r0);
4699                 }
4700                         break;
4701                 case OP_S390_BKCHAIN: {
4702                         s390_lgr  (code, ins->dreg, ins->sreg1);
4703                         if (s390_is_imm16 (cfg->stack_offset)) {
4704                                 s390_aghi (code, ins->dreg, cfg->stack_offset);
4705                         } else if (s390_is_imm32 (cfg->stack_offset)) {
4706                                 s390_agfi (code, ins->dreg, cfg->stack_offset);
4707                         } else {
4708                                 S390_SET  (code, s390_r13, cfg->stack_offset);
4709                                 s390_agr  (code, ins->dreg, s390_r13);
4710                         }
4711                 }
4712                         break;
4713                 case OP_MEMORY_BARRIER:
4714                         s390_mem (code);
4715                         break;
4716                 case OP_GC_SAFE_POINT: {
4717                         guint8 *br;
4718
4719                         g_assert (mono_threads_is_coop_enabled ());
4720
4721                         s390_chi (code, ins->sreg1, 1);
4722                         s390_je  (code, 0); CODEPTR(code, br);
4723                         mono_add_patch_info (cfg, code- cfg->native_code, MONO_PATCH_INFO_ABS,
4724                                              mono_threads_state_poll);
4725                         S390_CALL_TEMPLATE (code, s390_r14);
4726                         PTRSLOT (code, br);
4727                         break;
4728                 }
4729                 case OP_GC_LIVENESS_DEF:
4730                 case OP_GC_LIVENESS_USE:
4731                 case OP_GC_PARAM_SLOT_LIVENESS_DEF:
4732                         ins->backend.pc_offset = code - cfg->native_code;
4733                         break;
4734                 case OP_GC_SPILL_SLOT_LIVENESS_DEF:
4735                         ins->backend.pc_offset = code - cfg->native_code;
4736                         bb->spill_slot_defs = g_slist_prepend_mempool (cfg->mempool, bb->spill_slot_defs, ins);
4737                         break;
4738 #ifdef MONO_ARCH_SIMD_INTRINSICS
4739                 case OP_ADDPS:
4740                         s390x_addps (code, ins->sreg1, ins->sreg2);
4741                         break;
4742                 case OP_DIVPS:
4743                         s390x_divps (code, ins->sreg1, ins->sreg2);
4744                         break;
4745                 case OP_MULPS:
4746                         s390x_mulps (code, ins->sreg1, ins->sreg2);
4747                         break;
4748                 case OP_SUBPS:
4749                         s390x_subps (code, ins->sreg1, ins->sreg2);
4750                         break;
4751                 case OP_MAXPS:
4752                         s390x_maxps (code, ins->sreg1, ins->sreg2);
4753                         break;
4754                 case OP_MINPS:
4755                         s390x_minps (code, ins->sreg1, ins->sreg2);
4756                         break;
4757                 case OP_COMPPS:
4758                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 7);
4759                         s390x_cmpps_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
4760                         break;
4761                 case OP_ANDPS:
4762                         s390x_andps (code, ins->sreg1, ins->sreg2);
4763                         break;
4764                 case OP_ANDNPS:
4765                         s390x_andnps (code, ins->sreg1, ins->sreg2);
4766                         break;
4767                 case OP_ORPS:
4768                         s390x_orps (code, ins->sreg1, ins->sreg2);
4769                         break;
4770                 case OP_XORPS:
4771                         s390x_xorps (code, ins->sreg1, ins->sreg2);
4772                         break;
4773                 case OP_SQRTPS:
4774                         s390x_sqrtps (code, ins->dreg, ins->sreg1);
4775                         break;
4776                 case OP_RSQRTPS:
4777                         s390x_rsqrtps (code, ins->dreg, ins->sreg1);
4778                         break;
4779                 case OP_RCPPS:
4780                         s390x_rcpps (code, ins->dreg, ins->sreg1);
4781                         break;
4782                 case OP_ADDSUBPS:
4783                         s390x_addsubps (code, ins->sreg1, ins->sreg2);
4784                         break;
4785                 case OP_HADDPS:
4786                         s390x_haddps (code, ins->sreg1, ins->sreg2);
4787                         break;
4788                 case OP_HSUBPS:
4789                         s390x_hsubps (code, ins->sreg1, ins->sreg2);
4790                         break;
4791                 case OP_DUPPS_HIGH:
4792                         s390x_movshdup (code, ins->dreg, ins->sreg1);
4793                         break;
4794                 case OP_DUPPS_LOW:
4795                         s390x_movsldup (code, ins->dreg, ins->sreg1);
4796                         break;
4797
4798                 case OP_PSHUFLEW_HIGH:
4799                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
4800                         s390x_pshufhw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
4801                         break;
4802                 case OP_PSHUFLEW_LOW:
4803                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
4804                         s390x_pshuflw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
4805                         break;
4806                 case OP_PSHUFLED:
4807                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
4808                         s390x_pshufd_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
4809                         break;
4810                 case OP_SHUFPS:
4811                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
4812                         s390x_shufps_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
4813                         break;
4814                 case OP_SHUFPD:
4815                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0x3);
4816                         s390x_shufpd_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
4817                         break;
4818
4819                 case OP_ADDPD:
4820                         s390x_addpd (code, ins->sreg1, ins->sreg2);
4821                         break;
4822                 case OP_DIVPD:
4823                         s390x_divpd (code, ins->sreg1, ins->sreg2);
4824                         break;
4825                 case OP_MULPD:
4826                         s390x_mulpd (code, ins->sreg1, ins->sreg2);
4827                         break;
4828                 case OP_SUBPD:
4829                         s390x_subpd (code, ins->sreg1, ins->sreg2);
4830                         break;
4831                 case OP_MAXPD:
4832                         s390x_maxpd (code, ins->sreg1, ins->sreg2);
4833                         break;
4834                 case OP_MINPD:
4835                         s390x_minpd (code, ins->sreg1, ins->sreg2);
4836                         break;
4837                 case OP_COMPPD:
4838                         g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 7);
4839                         s390x_cmppd_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
4840                         break;
4841                 case OP_ANDPD:
4842                         s390x_andpd (code, ins->sreg1, ins->sreg2);
4843                         break;
4844                 case OP_ANDNPD:
4845                         s390x_andnpd (code, ins->sreg1, ins->sreg2);
4846                         break;
4847                 case OP_ORPD:
4848                         s390x_orpd (code, ins->sreg1, ins->sreg2);
4849                         break;
4850                 case OP_XORPD:
4851                         s390x_xorpd (code, ins->sreg1, ins->sreg2);
4852                         break;
4853                 case OP_SQRTPD:
4854                         s390x_sqrtpd (code, ins->dreg, ins->sreg1);
4855                         break;
4856                 case OP_ADDSUBPD:
4857                         s390x_addsubpd (code, ins->sreg1, ins->sreg2);
4858                         break;
4859                 case OP_HADDPD:
4860                         s390x_haddpd (code, ins->sreg1, ins->sreg2);
4861                         break;
4862                 case OP_HSUBPD:
4863                         s390x_hsubpd (code, ins->sreg1, ins->sreg2);
4864                         break;
4865                 case OP_DUPPD:
4866                         s390x_movddup (code, ins->dreg, ins->sreg1);
4867                         break;
4868
4869                 case OP_EXTRACT_MASK:
4870                         s390x_pmovmskb (code, ins->dreg, ins->sreg1);
4871                         break;
4872
4873                 case OP_PAND:
4874                         s390x_pand (code, ins->sreg1, ins->sreg2);
4875                         break;
4876                 case OP_POR:
4877                         s390x_por (code, ins->sreg1, ins->sreg2);
4878                         break;
4879                 case OP_PXOR:
4880                         s390x_pxor (code, ins->sreg1, ins->sreg2);
4881                         break;
4882
4883                 case OP_PADDB:
4884                         s390x_paddb (code, ins->sreg1, ins->sreg2);
4885                         break;
4886                 case OP_PADDW:
4887                         s390x_paddw (code, ins->sreg1, ins->sreg2);
4888                         break;
4889                 case OP_PADDD:
4890                         s390x_paddd (code, ins->sreg1, ins->sreg2);
4891                         break;
4892                 case OP_PADDQ:
4893                         s390x_paddq (code, ins->sreg1, ins->sreg2);
4894                         break;
4895
4896                 case OP_PSUBB:
4897                         s390x_psubb (code, ins->sreg1, ins->sreg2);
4898                         break;
4899                 case OP_PSUBW:
4900                         s390x_psubw (code, ins->sreg1, ins->sreg2);
4901                         break;
4902                 case OP_PSUBD:
4903                         s390x_psubd (code, ins->sreg1, ins->sreg2);
4904                         break;
4905                 case OP_PSUBQ:
4906                         s390x_psubq (code, ins->sreg1, ins->sreg2);
4907                         break;
4908
4909                 case OP_PMAXB_UN:
4910                         s390x_pmaxub (code, ins->sreg1, ins->sreg2);
4911                         break;
4912                 case OP_PMAXW_UN:
4913                         s390x_pmaxuw (code, ins->sreg1, ins->sreg2);
4914                         break;
4915                 case OP_PMAXD_UN:
4916                         s390x_pmaxud (code, ins->sreg1, ins->sreg2);
4917                         break;
4918
4919                 case OP_PMAXB:
4920                         s390x_pmaxsb (code, ins->sreg1, ins->sreg2);
4921                         break;
4922                 case OP_PMAXW:
4923                         s390x_pmaxsw (code, ins->sreg1, ins->sreg2);
4924                         break;
4925                 case OP_PMAXD:
4926                         s390x_pmaxsd (code, ins->sreg1, ins->sreg2);
4927                         break;
4928
4929                 case OP_PAVGB_UN:
4930                         s390x_pavgb (code, ins->sreg1, ins->sreg2);
4931                         break;
4932                 case OP_PAVGW_UN:
4933                         s390x_pavgw (code, ins->sreg1, ins->sreg2);
4934                         break;
4935
4936                 case OP_PMINB_UN:
4937                         s390x_pminub (code, ins->sreg1, ins->sreg2);
4938                         break;
4939                 case OP_PMINW_UN:
4940                         s390x_pminuw (code, ins->sreg1, ins->sreg2);
4941                         break;
4942                 case OP_PMIND_UN:
4943                         s390x_pminud (code, ins->sreg1, ins->sreg2);
4944                         break;
4945
4946                 case OP_PMINB:
4947                         s390x_pminsb (code, ins->sreg1, ins->sreg2);
4948                         break;
4949                 case OP_PMINW:
4950                         s390x_pminsw (code, ins->sreg1, ins->sreg2);
4951                         break;
4952                 case OP_PMIND:
4953                         s390x_pminsd (code, ins->sreg1, ins->sreg2);
4954                         break;
4955
4956                 case OP_PCMPEQB:
4957                         s390x_pcmpeqb (code, ins->sreg1, ins->sreg2);
4958                         break;
4959                 case OP_PCMPEQW:
4960                         s390x_pcmpeqw (code, ins->sreg1, ins->sreg2);
4961                         break;
4962                 case OP_PCMPEQD:
4963                         s390x_pcmpeqd (code, ins->sreg1, ins->sreg2);
4964                         break;
4965                 case OP_PCMPEQQ:
4966                         s390x_pcmpeqq (code, ins->sreg1, ins->sreg2);
4967                         break;
4968
4969                 case OP_PCMPGTB:
4970                         s390x_pcmpgtb (code, ins->sreg1, ins->sreg2);
4971                         break;
4972                 case OP_PCMPGTW:
4973                         s390x_pcmpgtw (code, ins->sreg1, ins->sreg2);
4974                         break;
4975                 case OP_PCMPGTD:
4976                         s390x_pcmpgtd (code, ins->sreg1, ins->sreg2);
4977                         break;
4978                 case OP_PCMPGTQ:
4979                         s390x_pcmpgtq (code, ins->sreg1, ins->sreg2);
4980                         break;
4981
4982                 case OP_PSUM_ABS_DIFF:
4983                         s390x_psadbw (code, ins->sreg1, ins->sreg2);
4984                         break;
4985
4986                 case OP_UNPACK_LOWB:
4987                         s390x_punpcklbw (code, ins->sreg1, ins->sreg2);
4988                         break;
4989                 case OP_UNPACK_LOWW:
4990                         s390x_punpcklwd (code, ins->sreg1, ins->sreg2);
4991                         break;
4992                 case OP_UNPACK_LOWD:
4993                         s390x_punpckldq (code, ins->sreg1, ins->sreg2);
4994                         break;
4995                 case OP_UNPACK_LOWQ:
4996                         s390x_punpcklqdq (code, ins->sreg1, ins->sreg2);
4997                         break;
4998                 case OP_UNPACK_LOWPS:
4999                         s390x_unpcklps (code, ins->sreg1, ins->sreg2);
5000                         break;
5001                 case OP_UNPACK_LOWPD:
5002                         s390x_unpcklpd (code, ins->sreg1, ins->sreg2);
5003                         break;
5004
5005                 case OP_UNPACK_HIGHB:
5006                         s390x_punpckhbw (code, ins->sreg1, ins->sreg2);
5007                         break;
5008                 case OP_UNPACK_HIGHW:
5009                         s390x_punpckhwd (code, ins->sreg1, ins->sreg2);
5010                         break;
5011                 case OP_UNPACK_HIGHD:
5012                         s390x_punpckhdq (code, ins->sreg1, ins->sreg2);
5013                         break;
5014                 case OP_UNPACK_HIGHQ:
5015                         s390x_punpckhqdq (code, ins->sreg1, ins->sreg2);
5016                         break;
5017                 case OP_UNPACK_HIGHPS:
5018                         s390x_unpckhps (code, ins->sreg1, ins->sreg2);
5019                         break;
5020                 case OP_UNPACK_HIGHPD:
5021                         s390x_unpckhpd (code, ins->sreg1, ins->sreg2);
5022                         break;
5023
5024                 case OP_PACKW:
5025                         s390x_packsswb (code, ins->sreg1, ins->sreg2);
5026                         break;
5027                 case OP_PACKD:
5028                         s390x_packssdw (code, ins->sreg1, ins->sreg2);
5029                         break;
5030                 case OP_PACKW_UN:
5031                         s390x_packuswb (code, ins->sreg1, ins->sreg2);
5032                         break;
5033                 case OP_PACKD_UN:
5034                         s390x_packusdw (code, ins->sreg1, ins->sreg2);
5035                         break;
5036
5037                 case OP_PADDB_SAT_UN:
5038                         s390x_paddusb (code, ins->sreg1, ins->sreg2);
5039                         break;
5040                 case OP_PSUBB_SAT_UN:
5041                         s390x_psubusb (code, ins->sreg1, ins->sreg2);
5042                         break;
5043                 case OP_PADDW_SAT_UN:
5044                         s390x_paddusw (code, ins->sreg1, ins->sreg2);
5045                         break;
5046                 case OP_PSUBW_SAT_UN:
5047                         s390x_psubusw (code, ins->sreg1, ins->sreg2);
5048                         break;
5049
5050                 case OP_PADDB_SAT:
5051                         s390x_paddsb (code, ins->sreg1, ins->sreg2);
5052                         break;
5053                 case OP_PSUBB_SAT:
5054                         s390x_psubsb (code, ins->sreg1, ins->sreg2);
5055                         break;
5056                 case OP_PADDW_SAT:
5057                         s390x_paddsw (code, ins->sreg1, ins->sreg2);
5058                         break;
5059                 case OP_PSUBW_SAT:
5060                         s390x_psubsw (code, ins->sreg1, ins->sreg2);
5061                         break;
5062
5063                 case OP_PMULW:
5064                         s390x_pmullw (code, ins->sreg1, ins->sreg2);
5065                         break;
5066                 case OP_PMULD:
5067                         s390x_pmulld (code, ins->sreg1, ins->sreg2);
5068                         break;
5069                 case OP_PMULQ:
5070                         s390x_pmuludq (code, ins->sreg1, ins->sreg2);
5071                         break;
5072                 case OP_PMULW_HIGH_UN:
5073                         s390x_pmulhuw (code, ins->sreg1, ins->sreg2);
5074                         break;
5075                 case OP_PMULW_HIGH:
5076                         s390x_pmulhw (code, ins->sreg1, ins->sreg2);
5077                         break;
5078
5079                 case OP_PSHRW:
5080                         s390x_psrlw_reg_imm (code, ins->dreg, ins->inst_imm);
5081                         break;
5082                 case OP_PSHRW_REG:
5083                         s390x_psrlw (code, ins->dreg, ins->sreg2);
5084                         break;
5085
5086                 case OP_PSARW:
5087                         s390x_psraw_reg_imm (code, ins->dreg, ins->inst_imm);
5088                         break;
5089                 case OP_PSARW_REG:
5090                         s390x_psraw (code, ins->dreg, ins->sreg2);
5091                         break;
5092
5093                 case OP_PSHLW:
5094                         s390x_psllw_reg_imm (code, ins->dreg, ins->inst_imm);
5095                         break;
5096                 case OP_PSHLW_REG:
5097                         s390x_psllw (code, ins->dreg, ins->sreg2);
5098                         break;
5099
5100                 case OP_PSHRD:
5101                         s390x_psrld_reg_imm (code, ins->dreg, ins->inst_imm);
5102                         break;
5103                 case OP_PSHRD_REG:
5104                         s390x_psrld (code, ins->dreg, ins->sreg2);
5105                         break;
5106
5107                 case OP_PSARD:
5108                         s390x_psrad_reg_imm (code, ins->dreg, ins->inst_imm);
5109                         break;
5110                 case OP_PSARD_REG:
5111                         s390x_psrad (code, ins->dreg, ins->sreg2);
5112                         break;
5113
5114                 case OP_PSHLD:
5115                         s390x_pslld_reg_imm (code, ins->dreg, ins->inst_imm);
5116                         break;
5117                 case OP_PSHLD_REG:
5118                         s390x_pslld (code, ins->dreg, ins->sreg2);
5119                         break;
5120
5121                 case OP_PSHRQ:
5122                         s390x_psrlq_reg_imm (code, ins->dreg, ins->inst_imm);
5123                         break;
5124                 case OP_PSHRQ_REG:
5125                         s390x_psrlq (code, ins->dreg, ins->sreg2);
5126                         break;
5127
5128                 /*TODO: This is appart of the sse spec but not added
5129                 case OP_PSARQ:
5130                         s390x_psraq_reg_imm (code, ins->dreg, ins->inst_imm);
5131                         break;
5132                 case OP_PSARQ_REG:
5133                         s390x_psraq (code, ins->dreg, ins->sreg2);
5134                         break;
5135                 */
5136
5137                 case OP_PSHLQ:
5138                         s390x_psllq_reg_imm (code, ins->dreg, ins->inst_imm);
5139                         break;
5140                 case OP_PSHLQ_REG:
5141                         s390x_psllq (code, ins->dreg, ins->sreg2);
5142                         break;
5143                 case OP_CVTDQ2PD:
5144                         s390x_cvtdq2pd (code, ins->dreg, ins->sreg1);
5145                         break;
5146                 case OP_CVTDQ2PS:
5147                         s390x_cvtdq2ps (code, ins->dreg, ins->sreg1);
5148                         break;
5149                 case OP_CVTPD2DQ:
5150                         s390x_cvtpd2dq (code, ins->dreg, ins->sreg1);
5151                         break;
5152                 case OP_CVTPD2PS:
5153                         s390x_cvtpd2ps (code, ins->dreg, ins->sreg1);
5154                         break;
5155                 case OP_CVTPS2DQ:
5156                         s390x_cvtps2dq (code, ins->dreg, ins->sreg1);
5157                         break;
5158                 case OP_CVTPS2PD:
5159                         s390x_cvtps2pd (code, ins->dreg, ins->sreg1);
5160                         break;
5161                 case OP_CVTTPD2DQ:
5162                         s390x_cvttpd2dq (code, ins->dreg, ins->sreg1);
5163                         break;
5164                 case OP_CVTTPS2DQ:
5165                         s390x_cvttps2dq (code, ins->dreg, ins->sreg1);
5166                         break;
5167
5168                 case OP_ICONV_TO_X:
5169                         amd64_movd_xreg_reg_size (code, ins->dreg, ins->sreg1, 4);
5170                         break;
5171                 case OP_EXTRACT_I4:
5172                         amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
5173                         break;
5174                 case OP_EXTRACT_I8:
5175                         if (ins->inst_c0) {
5176                                 amd64_movhlps (code, MONO_ARCH_FP_SCRATCH_REG, ins->sreg1);
5177                                 amd64_movd_reg_xreg_size (code, ins->dreg, MONO_ARCH_FP_SCRATCH_REG, 8);
5178                         } else {
5179                                 amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 8);
5180                         }
5181                         break;
5182                 case OP_EXTRACT_I1:
5183                 case OP_EXTRACT_U1:
5184                         amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
5185                         if (ins->inst_c0)
5186                                 amd64_shift_reg_imm (code, X86_SHR, ins->dreg, ins->inst_c0 * 8);
5187                         amd64_widen_reg (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I1, FALSE);
5188                         break;
5189                 case OP_EXTRACT_I2:
5190                 case OP_EXTRACT_U2:
5191                         /*amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
5192                         if (ins->inst_c0)
5193                                 amd64_shift_reg_imm_size (code, X86_SHR, ins->dreg, 16, 4);*/
5194                         s390x_pextrw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
5195                         amd64_widen_reg_size (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I2, TRUE, 4);
5196                         break;
5197                 case OP_EXTRACT_R8:
5198                         if (ins->inst_c0)
5199                                 amd64_movhlps (code, ins->dreg, ins->sreg1);
5200                         else
5201                                 s390x_movsd (code, ins->dreg, ins->sreg1);
5202                         break;
5203                 case OP_INSERT_I2:
5204                         s390x_pinsrw_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
5205                         break;
5206                 case OP_EXTRACTX_U2:
5207                         s390x_pextrw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
5208                         break;
5209                 case OP_INSERTX_U1_SLOW:
5210                         /*sreg1 is the extracted ireg (scratch)
5211                         /sreg2 is the to be inserted ireg (scratch)
5212                         /dreg is the xreg to receive the value*/
5213
5214                         /*clear the bits from the extracted word*/
5215                         amd64_alu_reg_imm (code, X86_AND, ins->sreg1, ins->inst_c0 & 1 ? 0x00FF : 0xFF00);
5216                         /*shift the value to insert if needed*/
5217                         if (ins->inst_c0 & 1)
5218                                 amd64_shift_reg_imm_size (code, X86_SHL, ins->sreg2, 8, 4);
5219                         /*join them together*/
5220                         amd64_alu (code, X86_OR, ins->sreg1, ins->sreg2);
5221                         s390x_pinsrw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0 / 2);
5222                         break;
5223                 case OP_INSERTX_I4_SLOW:
5224                         s390x_pinsrw_imm (code, ins->dreg, ins->sreg2, ins->inst_c0 * 2);
5225                         amd64_shift_reg_imm (code, X86_SHR, ins->sreg2, 16);
5226                         s390x_pinsrw_imm (code, ins->dreg, ins->sreg2, ins->inst_c0 * 2 + 1);
5227                         break;
5228                 case OP_INSERTX_I8_SLOW:
5229                         amd64_movd_xreg_reg_size(code, MONO_ARCH_FP_SCRATCH_REG, ins->sreg2, 8);
5230                         if (ins->inst_c0)
5231                                 amd64_movlhps (code, ins->dreg, MONO_ARCH_FP_SCRATCH_REG);
5232                         else
5233                                 s390x_movsd (code, ins->dreg, MONO_ARCH_FP_SCRATCH_REG);
5234                         break;
5235
5236                 case OP_INSERTX_R4_SLOW:
5237                         switch (ins->inst_c0) {
5238                         case 0:
5239                                 if (cfg->r4fp)
5240                                         s390x_movss (code, ins->dreg, ins->sreg2);
5241                                 else
5242                                         s390x_cvtsd2ss (code, ins->dreg, ins->sreg2);
5243                                 break;
5244                         case 1:
5245                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(1, 0, 2, 3));
5246                                 if (cfg->r4fp)
5247                                         s390x_movss (code, ins->dreg, ins->sreg2);
5248                                 else
5249                                         s390x_cvtsd2ss (code, ins->dreg, ins->sreg2);
5250                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(1, 0, 2, 3));
5251                                 break;
5252                         case 2:
5253                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(2, 1, 0, 3));
5254                                 if (cfg->r4fp)
5255                                         s390x_movss (code, ins->dreg, ins->sreg2);
5256                                 else
5257                                         s390x_cvtsd2ss (code, ins->dreg, ins->sreg2);
5258                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(2, 1, 0, 3));
5259                                 break;
5260                         case 3:
5261                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(3, 1, 2, 0));
5262                                 if (cfg->r4fp)
5263                                         s390x_movss (code, ins->dreg, ins->sreg2);
5264                                 else
5265                                         s390x_cvtsd2ss (code, ins->dreg, ins->sreg2);
5266                                 s390x_pshufd_imm (code, ins->dreg, ins->dreg, mono_simd_shuffle_mask(3, 1, 2, 0));
5267                                 break;
5268                         }
5269                         break;
5270                 case OP_INSERTX_R8_SLOW:
5271                         if (ins->inst_c0)
5272                                 amd64_movlhps (code, ins->dreg, ins->sreg2);
5273                         else
5274                                 s390x_movsd (code, ins->dreg, ins->sreg2);
5275                         break;
5276                 case OP_STOREX_MEMBASE_REG:
5277                 case OP_STOREX_MEMBASE:
5278                         s390x_movups_membase_reg (code, ins->dreg, ins->inst_offset, ins->sreg1);
5279                         break;
5280                 case OP_LOADX_MEMBASE:
5281                         s390x_movups_reg_membase (code, ins->dreg, ins->sreg1, ins->inst_offset);
5282                         break;
5283                 case OP_LOADX_ALIGNED_MEMBASE:
5284                         s390x_movaps_reg_membase (code, ins->dreg, ins->sreg1, ins->inst_offset);
5285                         break;
5286                 case OP_STOREX_ALIGNED_MEMBASE_REG:
5287                         s390x_movaps_membase_reg (code, ins->dreg, ins->inst_offset, ins->sreg1);
5288                         break;
5289                 case OP_STOREX_NTA_MEMBASE_REG:
5290                         s390x_movntps_reg_membase (code, ins->dreg, ins->sreg1, ins->inst_offset);
5291                         break;
5292                 case OP_PREFETCH_MEMBASE:
5293                         s390x_prefetch_reg_membase (code, ins->backend.arg_info, ins->sreg1, ins->inst_offset);
5294                         break;
5295
5296                 case OP_XMOVE:
5297                         /*FIXME the peephole pass should have killed this*/
5298                         if (ins->dreg != ins->sreg1)
5299                                 s390x_movaps (code, ins->dreg, ins->sreg1);
5300                         break;
5301                 case OP_XZERO:
5302                         s390x_pxor (code, ins->dreg, ins->dreg);
5303                         break;
5304                 case OP_ICONV_TO_R4_RAW:
5305                         amd64_movd_xreg_reg_size (code, ins->dreg, ins->sreg1, 4);
5306                         break;
5307
5308                 case OP_FCONV_TO_R8_X:
5309                         s390x_movsd (code, ins->dreg, ins->sreg1);
5310                         break;
5311
5312                 case OP_XCONV_R8_TO_I4:
5313                         s390x_cvttsd2si_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
5314                         switch (ins->backend.source_opcode) {
5315                         case OP_FCONV_TO_I1:
5316                                 amd64_widen_reg (code, ins->dreg, ins->dreg, TRUE, FALSE);
5317                                 break;
5318                         case OP_FCONV_TO_U1:
5319                                 amd64_widen_reg (code, ins->dreg, ins->dreg, FALSE, FALSE);
5320                                 break;
5321                         case OP_FCONV_TO_I2:
5322                                 amd64_widen_reg (code, ins->dreg, ins->dreg, TRUE, TRUE);
5323                                 break;
5324                         case OP_FCONV_TO_U2:
5325                                 amd64_widen_reg (code, ins->dreg, ins->dreg, FALSE, TRUE);
5326                                 break;
5327                         }
5328                         break;
5329
5330                 case OP_EXPAND_I2:
5331                         s390x_pinsrw_imm (code, ins->dreg, ins->sreg1, 0);
5332                         s390x_pinsrw_imm (code, ins->dreg, ins->sreg1, 1);
5333                         s390x_pshufd_imm (code, ins->dreg, ins->dreg, 0);
5334                         break;
5335                 case OP_EXPAND_I4:
5336                         amd64_movd_xreg_reg_size (code, ins->dreg, ins->sreg1, 4);
5337                         s390x_pshufd_imm (code, ins->dreg, ins->dreg, 0);
5338                         break;
5339                 case OP_EXPAND_I8:
5340                         amd64_movd_xreg_reg_size (code, ins->dreg, ins->sreg1, 8);
5341                         s390x_pshufd_imm (code, ins->dreg, ins->dreg, 0x44);
5342                         break;
5343                 case OP_EXPAND_R4:
5344                         if (cfg->r4fp) {
5345                                 s390x_movsd (code, ins->dreg, ins->sreg1);
5346                         } else {
5347                                 s390x_movsd (code, ins->dreg, ins->sreg1);
5348                                 s390x_cvtsd2ss (code, ins->dreg, ins->dreg);
5349                         }
5350                         s390x_pshufd_imm (code, ins->dreg, ins->dreg, 0);
5351                         break;
5352                 case OP_EXPAND_R8:
5353                         s390x_movsd (code, ins->dreg, ins->sreg1);
5354                         s390x_pshufd_imm (code, ins->dreg, ins->dreg, 0x44);
5355                         break;
5356 #endif
5357                 default:
5358                         g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
5359                         g_assert_not_reached ();
5360                 }
5361
5362                 if ((cfg->opt & MONO_OPT_BRANCH) && ((code - cfg->native_code - offset) > max_len)) {
5363                         g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %ld)",
5364                                    mono_inst_name (ins->opcode), max_len, code - cfg->native_code - offset);
5365                         g_assert_not_reached ();
5366                 }
5367
5368                 last_offset = offset;
5369         }
5370
5371         cfg->code_len = code - cfg->native_code;
5372 }
5373
5374 /*========================= End of Function ========================*/
5375
5376 /*------------------------------------------------------------------*/
5377 /*                                                                  */
5378 /* Name         - mono_arch_register_lowlevel_calls                 */
5379 /*                                                                  */
5380 /* Function     - Register routines to help with --trace operation. */
5381 /*                                                                  */
5382 /*------------------------------------------------------------------*/
5383
5384 void
5385 mono_arch_register_lowlevel_calls (void)
5386 {
5387 }
5388
5389 /*========================= End of Function ========================*/
5390
5391 /*------------------------------------------------------------------*/
5392 /*                                                                  */
5393 /* Name         - mono_arch_patch_code                              */
5394 /*                                                                  */
5395 /* Function     - Process the patch data created during the         */
5396 /*                instruction build process. This resolves jumps,   */
5397 /*                calls, variables etc.                             */
5398 /*                                                                  */
5399 /*------------------------------------------------------------------*/
5400
5401 void
5402 mono_arch_patch_code (MonoCompile *cfg, MonoMethod *method, MonoDomain *domain,
5403                       guint8 *code, MonoJumpInfo *ji, gboolean run_cctors,
5404                       MonoError *error)
5405 {
5406         MonoJumpInfo *patch_info;
5407
5408         mono_error_init (error);
5409
5410         for (patch_info = ji; patch_info; patch_info = patch_info->next) {
5411                 unsigned char *ip = patch_info->ip.i + code;
5412                 gconstpointer target = NULL;
5413
5414                 target = mono_resolve_patch_target (method, domain, code,
5415                                                                                         patch_info, run_cctors, error);
5416                 return_if_nok (error);
5417
5418                 switch (patch_info->type) {
5419                         case MONO_PATCH_INFO_IP:
5420                         case MONO_PATCH_INFO_LDSTR:
5421                         case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
5422                         case MONO_PATCH_INFO_LDTOKEN:
5423                         case MONO_PATCH_INFO_EXC:
5424                                 s390_patch_addr (ip, (guint64) target);
5425                                 continue;
5426                         case MONO_PATCH_INFO_METHOD:
5427                         case MONO_PATCH_INFO_INTERNAL_METHOD:
5428                         case MONO_PATCH_INFO_JIT_ICALL_ADDR:
5429                         case MONO_PATCH_INFO_RGCTX_FETCH:
5430                         case MONO_PATCH_INFO_ABS: {
5431                                 S390_EMIT_CALL (ip, target);
5432                                 continue;
5433                         }
5434                         case MONO_PATCH_INFO_SWITCH:
5435                                 /*----------------------------------*/
5436                                 /* ip points at the basr r13,0/j +4 */
5437                                 /* instruction the vtable value     */
5438                                 /* follows this (i.e. ip+6)         */
5439                                 /*----------------------------------*/
5440                                 S390_EMIT_LOAD (ip, target);
5441                                 continue;
5442                         case MONO_PATCH_INFO_METHODCONST:
5443                         case MONO_PATCH_INFO_CLASS:
5444                         case MONO_PATCH_INFO_IMAGE:
5445                         case MONO_PATCH_INFO_FIELD:
5446                         case MONO_PATCH_INFO_IID:
5447                         case MONO_PATCH_INFO_EXC_NAME:
5448                                 target = S390_RELATIVE(target, ip);
5449                                 s390_patch_rel (ip, (guint64) target);
5450                                 continue;
5451                         case MONO_PATCH_INFO_R4:
5452                         case MONO_PATCH_INFO_R8:
5453                         case MONO_PATCH_INFO_METHOD_REL:
5454                                 g_assert_not_reached ();
5455                                 continue;
5456                         default:
5457                                 target = S390_RELATIVE(target, ip);
5458                                 ip += 2;
5459                                 s390_patch_rel (ip, (guint64) target);
5460                 }
5461         }
5462 }
5463
5464 /*========================= End of Function ========================*/
5465
5466 /*------------------------------------------------------------------*/
5467 /*                                                                  */
5468 /* Name         - emit_load_volatile_arguments                      */
5469 /*                                                                  */
5470 /* Function     - Emit the instructions to reload parameter regist- */
5471 /*                registers for use with "tail" operations.         */
5472 /*                                                                  */
5473 /*                The register loading operations performed here    */
5474 /*                are the mirror of the store operations performed  */
5475 /*                in mono_arch_emit_prolog and need to be kept in   */
5476 /*                synchronization with it.                          */
5477 /*                                                                  */
5478 /*------------------------------------------------------------------*/
5479
5480 guint8 *
5481 emit_load_volatile_arguments (guint8 *code, MonoCompile *cfg)
5482 {
5483         MonoInst *inst;
5484         MonoMethod *method = cfg->method;
5485         MonoMethodSignature *sig = mono_method_signature(method);
5486         int pos = 0, i;
5487         CallInfo *cinfo;
5488
5489         cinfo = get_call_info (NULL, NULL, sig);
5490
5491         if (cinfo->struct_ret) {
5492                 ArgInfo *ainfo = &cinfo->ret;
5493                 inst         = cfg->vret_addr;
5494                 s390_lg (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5495         }
5496
5497         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
5498                 ArgInfo *ainfo = cinfo->args + i;
5499                 inst = cfg->args [pos];
5500
5501                 if (inst->opcode == OP_REGVAR) {
5502                         if (ainfo->regtype == RegTypeGeneral)
5503                                 s390_lgr (code, ainfo->reg, inst->dreg);
5504                         else if (ainfo->regtype == RegTypeFP) {
5505                                 if (inst->dreg != ainfo->reg) {
5506                                         if (ainfo->size == 4) {
5507                                                 s390_ldebr (code, ainfo->reg, inst->dreg);
5508                                         } else {
5509                                                 s390_ldr   (code, ainfo->reg, inst->dreg);
5510                                         }
5511                                 }
5512                         }
5513                         else if (ainfo->regtype == RegTypeBase) {
5514                         } else
5515                                 g_assert_not_reached ();
5516                 } else {
5517                         if (ainfo->regtype == RegTypeGeneral) {
5518                                 if (!((ainfo->reg >= 2) && (ainfo->reg <= 6)))
5519                                         g_assert_not_reached();
5520                                 switch (ainfo->size) {
5521                                 case 1:
5522                                         s390_llgc (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5523                                         break;
5524                                 case 2:
5525                                         s390_lgh  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5526                                         break;
5527                                 case 4:
5528                                         s390_lgf (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5529                                         break;
5530                                 case 8:
5531                                         s390_lg  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5532                                         break;
5533                                 }
5534                         } else if (ainfo->regtype == RegTypeBase) {
5535                         } else if (ainfo->regtype == RegTypeFP) {
5536                                 if (ainfo->size == 8)
5537                                         s390_ld  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5538                                 else if (ainfo->size == 4)
5539                                         s390_le  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5540                                 else
5541                                         g_assert_not_reached ();
5542                         } else if (ainfo->regtype == RegTypeStructByVal) {
5543                                 if (ainfo->reg != STK_BASE) {
5544                                         switch (ainfo->size) {
5545                                         case 1:
5546                                                 s390_llgc (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5547                                                 break;
5548                                         case 2:
5549                                                 s390_lgh (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5550                                                 break;
5551                                         case 4:
5552                                                 s390_lgf (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5553                                                 break;
5554                                         case 8:
5555                                                 s390_lg  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5556                                                 break;
5557                                         }
5558                                 }
5559                         } else if (ainfo->regtype == RegTypeStructByAddr) {
5560                                 if (ainfo->reg != STK_BASE) {
5561                                         s390_lg (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5562                                 }
5563                         } else
5564                                 g_assert_not_reached ();
5565                 }
5566                 pos++;
5567         }
5568
5569         return code;
5570 }
5571
5572 /*========================= End of Function ========================*/
5573
5574 /*------------------------------------------------------------------*/
5575 /*                                                                  */
5576 /* Name         - mono_arch_emit_prolog                             */
5577 /*                                                                  */
5578 /* Function     - Create the instruction sequence for a function    */
5579 /*                prolog.                                           */
5580 /*                                                                  */
5581 /*------------------------------------------------------------------*/
5582
5583 guint8 *
5584 mono_arch_emit_prolog (MonoCompile *cfg)
5585 {
5586         MonoMethod *method = cfg->method;
5587         MonoBasicBlock *bb;
5588         MonoMethodSignature *sig;
5589         MonoInst *inst;
5590         long alloc_size, pos, max_offset, i, cfa_offset = 0;
5591         guint8 *code;
5592         guint32 size;
5593         CallInfo *cinfo;
5594         int tracing = 0,
5595             argsClobbered = 0,
5596             lmfOffset,
5597             fpOffset;
5598
5599         cfg->code_size   = 512;
5600
5601         if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) {
5602                 tracing         = 1;
5603                 cfg->code_size += 256;
5604         } else if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
5605                 cfg->code_size += 256;
5606
5607         if (method->save_lmf)
5608                 cfg->code_size += 200;
5609
5610         cfg->native_code = code = g_malloc (cfg->code_size);
5611
5612         mono_emit_unwind_op_def_cfa (cfg, code, STK_BASE, 0);
5613         emit_unwind_regs(cfg, code, s390_r6, s390_r14, S390_REG_SAVE_OFFSET);
5614         s390_stmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
5615         mono_emit_unwind_op_offset (cfg, code, s390_r14, S390_RET_ADDR_OFFSET);
5616         mini_gc_set_slot_type_from_cfa (cfg, S390_RET_ADDR_OFFSET, SLOT_NOREF);
5617
5618         if (cfg->arch.bkchain_reg != -1)
5619                 s390_lgr (code, cfg->arch.bkchain_reg, STK_BASE);
5620
5621         if (cfg->flags & MONO_CFG_HAS_ALLOCA) {
5622                 cfg->used_int_regs |= 1 << 11;
5623         }
5624
5625         alloc_size = cfg->stack_offset;
5626
5627         cfg->stack_usage = cfa_offset = alloc_size;
5628         mono_emit_unwind_op_def_cfa_offset (cfg, code, alloc_size);
5629         s390_lgr  (code, s390_r11, STK_BASE);
5630         if (s390_is_imm16 (alloc_size)) {
5631                 s390_aghi (code, STK_BASE, -alloc_size);
5632         } else if (s390_is_imm32 (alloc_size)) {
5633                 s390_agfi (code, STK_BASE, -alloc_size);
5634         } else {
5635                 int stackSize = alloc_size;
5636                 while (stackSize > INT_MAX) {
5637                         s390_agfi (code, STK_BASE, -INT_MAX);
5638                         stackSize -= INT_MAX;
5639                 }
5640                 s390_agfi (code, STK_BASE, -stackSize);
5641         }
5642         s390_stg  (code, s390_r11, 0, STK_BASE, 0);
5643
5644         if (cfg->frame_reg != STK_BASE)
5645                 s390_lgr (code, s390_r11, STK_BASE);
5646
5647         mono_emit_unwind_op_def_cfa_reg (cfg, code, cfg->frame_reg);
5648
5649         /* store runtime generic context */
5650         if (cfg->rgctx_var) {
5651                 g_assert (cfg->rgctx_var->opcode == OP_REGOFFSET);
5652
5653                 s390_stg  (code, MONO_ARCH_RGCTX_REG, 0,
5654                            cfg->rgctx_var->inst_basereg,
5655                            cfg->rgctx_var->inst_offset);
5656         }
5657
5658         /* compute max_offset in order to use short forward jumps
5659          * we always do it on s390 because the immediate displacement
5660          * for jumps is too small
5661          */
5662         max_offset = 0;
5663         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
5664                 MonoInst *ins;
5665                 bb->max_offset = max_offset;
5666
5667                 if (cfg->prof_options & MONO_PROFILE_COVERAGE)
5668                         max_offset += 6;
5669
5670                 MONO_BB_FOR_EACH_INS (bb, ins)
5671                         max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
5672         }
5673
5674         /* load arguments allocated to register from the stack */
5675         sig = mono_method_signature (method);
5676         pos = 0;
5677
5678         cinfo = get_call_info (cfg, cfg->mempool, sig);
5679
5680         if (cinfo->struct_ret) {
5681                 ArgInfo *ainfo     = &cinfo->ret;
5682                 inst               = cfg->vret_addr;
5683                 inst->backend.size = ainfo->vtsize;
5684                 s390_stg (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5685         }
5686
5687         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
5688                 ArgInfo *ainfo = cinfo->args + i;
5689                 inst = cfg->args [pos];
5690
5691                 if (inst->opcode == OP_VTARG_ADDR)
5692                         inst = inst->inst_left;
5693
5694                 if (inst->opcode == OP_REGVAR) {
5695                         if (ainfo->regtype == RegTypeGeneral)
5696                                 s390_lgr (code, inst->dreg, ainfo->reg);
5697                         else if (ainfo->regtype == RegTypeFP) {
5698                                 if (inst->dreg != ainfo->reg) {
5699                                         if (ainfo->size == 4) {
5700                                                 s390_ledbr (code, inst->dreg, ainfo->reg);
5701                                         } else {
5702                                                 s390_ldr   (code, inst->dreg, ainfo->reg);
5703                                         }
5704                                 }
5705                         }
5706                         else if (ainfo->regtype == RegTypeBase) {
5707                                 s390_lgr  (code, s390_r13, STK_BASE);
5708                                 s390_aghi (code, s390_r13, alloc_size);
5709                                 s390_lg   (code, inst->dreg, 0, s390_r13, ainfo->offset);
5710                         } else
5711                                 g_assert_not_reached ();
5712
5713                         if (cfg->verbose_level > 2)
5714                                 g_print ("Argument %d assigned to register %s\n",
5715                                          pos, mono_arch_regname (inst->dreg));
5716                 } else {
5717                         if (ainfo->regtype == RegTypeGeneral) {
5718                                 if (!((ainfo->reg >= 2) && (ainfo->reg <= 6)))
5719                                         g_assert_not_reached();
5720                                 switch (ainfo->size) {
5721                                 case 1:
5722                                         s390_stc (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5723                                         break;
5724                                 case 2:
5725                                         s390_sth (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5726                                         break;
5727                                 case 4:
5728                                         s390_st (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5729                                         break;
5730                                 case 8:
5731                                         s390_stg (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5732                                         break;
5733                                 }
5734                         } else if (ainfo->regtype == RegTypeBase) {
5735                         } else if (ainfo->regtype == RegTypeFP) {
5736                                 if (ainfo->size == 8)
5737                                         s390_std (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5738                                 else if (ainfo->size == 4)
5739                                         s390_ste (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5740                                 else
5741                                         g_assert_not_reached ();
5742                         } else if (ainfo->regtype == RegTypeStructByVal) {
5743                                 int doffset = inst->inst_offset;
5744                                 int reg;
5745                                 if (ainfo->reg != STK_BASE)
5746                                         reg = ainfo->reg;
5747                                 else {
5748                                         reg = s390_r0;
5749                                         s390_lgr  (code, s390_r13, STK_BASE);
5750                                         s390_aghi (code, s390_r13, alloc_size);
5751                                 }
5752
5753                                 size = (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE
5754                                         ? mono_class_native_size(mono_class_from_mono_type(inst->inst_vtype), NULL)
5755                                         : ainfo->size);
5756
5757                                 switch (size) {
5758                                         case 1:
5759                                                 if (ainfo->reg == STK_BASE)
5760                                                         s390_ic (code, reg, 0, s390_r13, ainfo->offset+7);
5761                                                 s390_stc (code, reg, 0, inst->inst_basereg, doffset);
5762                                                 break;
5763                                         case 2:
5764                                                 if (ainfo->reg == STK_BASE)
5765                                                         s390_lh (code, reg, 0, s390_r13, ainfo->offset+6);
5766                                                 s390_sth (code, reg, 0, inst->inst_basereg, doffset);
5767                                                 break;
5768                                         case 4:
5769                                                 if (ainfo->reg == STK_BASE)
5770                                                         s390_l  (code, reg, 0, s390_r13, ainfo->offset+4);
5771                                                 s390_st (code, reg, 0, inst->inst_basereg, doffset);
5772                                                 break;
5773                                         case 8:
5774                                                 if (ainfo->reg == STK_BASE)
5775                                                         s390_lg  (code, reg, 0, s390_r13, ainfo->offset);
5776                                                 s390_stg (code, reg, 0, inst->inst_basereg, doffset);
5777                                                 break;
5778                                 }
5779                         } else if (ainfo->regtype == RegTypeStructByAddr) {
5780                                 s390_stg (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
5781                         } else if (ainfo->regtype == RegTypeStructByAddrOnStack) {
5782                         } else
5783                                 g_assert_not_reached ();
5784                 }
5785                 pos++;
5786         }
5787
5788         if (method->save_lmf) {
5789                 /*---------------------------------------------------------------*/
5790                 /* build the MonoLMF structure on the stack - see mini-s390x.h   */
5791                 /*---------------------------------------------------------------*/
5792                 lmfOffset = alloc_size - sizeof(MonoLMF);
5793
5794                 s390_lgr   (code, s390_r13, cfg->frame_reg);
5795                 s390_aghi  (code, s390_r13, lmfOffset);
5796
5797                 /*---------------------------------------------------------------*/
5798                 /* Preserve the parameter registers while we fix up the lmf      */
5799                 /*---------------------------------------------------------------*/
5800                 s390_stmg  (code, s390_r2, s390_r6, s390_r13,
5801                             G_STRUCT_OFFSET(MonoLMF, pregs[0]));
5802
5803                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, pregs[0]), SLOT_NOREF);
5804                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, pregs[1]), SLOT_NOREF);
5805                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, pregs[2]), SLOT_NOREF);
5806                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, pregs[3]), SLOT_NOREF);
5807                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, pregs[4]), SLOT_NOREF);
5808
5809                 /*---------------------------------------------------------------*/
5810                 /* On return from this call r2 have the address of the &lmf      */
5811                 /*---------------------------------------------------------------*/
5812                 if (lmf_addr_tls_offset == -1) {
5813                         mono_add_patch_info (cfg, code - cfg->native_code,
5814                                              MONO_PATCH_INFO_INTERNAL_METHOD,
5815                                              (gpointer)"mono_get_lmf_addr");
5816                         S390_CALL_TEMPLATE(code, s390_r1);
5817                 } else {
5818                         /*-------------------------------------------------------*/
5819                         /* Get LMF by getting value from thread level storage    */
5820                         /*-------------------------------------------------------*/
5821                         s390_ear (code, s390_r1, 0);
5822                         s390_sllg(code, s390_r1, s390_r1, 0, 32);
5823                         s390_ear (code, s390_r1, 1);
5824                         s390_lg  (code, s390_r2, 0, s390_r1, lmf_addr_tls_offset);
5825                 }
5826
5827                 /*---------------------------------------------------------------*/
5828                 /* Set lmf.lmf_addr = jit_tls->lmf                               */
5829                 /*---------------------------------------------------------------*/
5830                 s390_stg   (code, s390_r2, 0, s390_r13,
5831                             G_STRUCT_OFFSET(MonoLMF, lmf_addr));
5832                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, lmf_addr), SLOT_NOREF);
5833
5834                 /*---------------------------------------------------------------*/
5835                 /* Get current lmf                                               */
5836                 /*---------------------------------------------------------------*/
5837                 s390_lg    (code, s390_r0, 0, s390_r2, 0);
5838
5839                 /*---------------------------------------------------------------*/
5840                 /* Set our lmf as the current lmf                                */
5841                 /*---------------------------------------------------------------*/
5842                 s390_stg   (code, s390_r13, 0, s390_r2, 0);
5843
5844                 /*---------------------------------------------------------------*/
5845                 /* Have our lmf.previous_lmf point to the last lmf               */
5846                 /*---------------------------------------------------------------*/
5847                 s390_stg   (code, s390_r0, 0, s390_r13,
5848                             G_STRUCT_OFFSET(MonoLMF, previous_lmf));
5849                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), SLOT_NOREF);
5850
5851                 /*---------------------------------------------------------------*/
5852                 /* save method info                                              */
5853                 /*---------------------------------------------------------------*/
5854                 S390_SET   (code, s390_r1, method);
5855                 s390_stg   (code, s390_r1, 0, s390_r13,
5856                             G_STRUCT_OFFSET(MonoLMF, method));
5857                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, method), SLOT_NOREF);
5858
5859                 /*---------------------------------------------------------------*/
5860                 /* save the current IP                                           */
5861                 /*---------------------------------------------------------------*/
5862                 s390_stg   (code, STK_BASE, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, ebp));
5863                 s390_basr  (code, s390_r1, 0);
5864                 s390_stg   (code, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, eip));
5865                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, ebp), SLOT_NOREF);
5866                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, eip), SLOT_NOREF);
5867
5868                 /*---------------------------------------------------------------*/
5869                 /* Save general and floating point registers                     */
5870                 /*---------------------------------------------------------------*/
5871                 s390_stmg  (code, s390_r2, s390_r12, s390_r13,
5872                             G_STRUCT_OFFSET(MonoLMF, gregs[2]));
5873                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[0]), SLOT_NOREF);
5874                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[1]), SLOT_NOREF);
5875                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[2]), SLOT_NOREF);
5876                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[3]), SLOT_NOREF);
5877                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[4]), SLOT_NOREF);
5878                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[5]), SLOT_NOREF);
5879                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[6]), SLOT_NOREF);
5880                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[7]), SLOT_NOREF);
5881                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[8]), SLOT_NOREF);
5882                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[9]), SLOT_NOREF);
5883                 mini_gc_set_slot_type_from_fp (cfg, lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, gregs[10]), SLOT_NOREF);
5884
5885                 fpOffset = lmfOffset + MONO_STRUCT_OFFSET (MonoLMF, fregs[0]);
5886                 for (i = 0; i < 16; i++) {
5887                         s390_std  (code, i, 0, s390_r13,
5888                                    G_STRUCT_OFFSET(MonoLMF, fregs[i]));
5889                         mini_gc_set_slot_type_from_fp (cfg, fpOffset, SLOT_NOREF);
5890                         fpOffset += sizeof(double);
5891                 }
5892
5893                 /*---------------------------------------------------------------*/
5894                 /* Restore the parameter registers now that we've set up the lmf */
5895                 /*---------------------------------------------------------------*/
5896                 s390_lmg   (code, s390_r2, s390_r6, s390_r13,
5897                             G_STRUCT_OFFSET(MonoLMF, pregs[0]));
5898         }
5899
5900         if (cfg->method->save_lmf)
5901                 argsClobbered = TRUE;
5902
5903         if (tracing) {
5904                 argsClobbered = TRUE;
5905                 code = mono_arch_instrument_prolog (cfg, enter_method, code, TRUE);
5906         }
5907
5908         if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
5909                 argsClobbered = TRUE;
5910
5911         /*
5912          * Optimize the common case of the first bblock making a call with the same
5913          * arguments as the method. This works because the arguments are still in their
5914          * original argument registers.
5915          */
5916         if (!argsClobbered) {
5917                 MonoBasicBlock *first_bb = cfg->bb_entry;
5918                 MonoInst *next;
5919                 int filter = FILTER_IL_SEQ_POINT;
5920
5921                 next = mono_bb_first_inst (first_bb, filter);
5922                 if (!next && first_bb->next_bb) {
5923                         first_bb = first_bb->next_bb;
5924                         next = mono_bb_first_inst (first_bb, filter);
5925                 }
5926
5927                 if (first_bb->in_count > 1)
5928                         next = NULL;
5929
5930                 for (i = 0; next && i < sig->param_count + sig->hasthis; ++i) {
5931                         ArgInfo *ainfo = cinfo->args + i;
5932                         gboolean match = FALSE;
5933
5934                         inst = cfg->args [i];
5935                         if (inst->opcode != OP_REGVAR) {
5936                                 switch (ainfo->regtype) {
5937                                 case RegTypeGeneral: {
5938                                         if (((next->opcode == OP_LOAD_MEMBASE) ||
5939                                              (next->opcode == OP_LOADI4_MEMBASE)) &&
5940                                              next->inst_basereg == inst->inst_basereg &&
5941                                              next->inst_offset == inst->inst_offset) {
5942                                                 if (next->dreg == ainfo->reg) {
5943                                                         NULLIFY_INS (next);
5944                                                         match = TRUE;
5945                                                 } else {
5946                                                         next->opcode = OP_MOVE;
5947                                                         next->sreg1 = ainfo->reg;
5948                                                         /* Only continue if the instruction doesn't change argument regs */
5949                                                         if (next->dreg == ainfo->reg)
5950                                                                 match = TRUE;
5951                                                 }
5952                                         }
5953                                         break;
5954                                 }
5955                                 default:
5956                                         break;
5957                                 }
5958                         } else {
5959                                 /* Argument allocated to (non-volatile) register */
5960                                 switch (ainfo->regtype) {
5961                                 case RegTypeGeneral:
5962                                         if (next->opcode == OP_MOVE &&
5963                                             next->sreg1 == inst->dreg &&
5964                                             next->dreg == ainfo->reg) {
5965                                                 NULLIFY_INS (next);
5966                                                 match = TRUE;
5967                                         }
5968                                         break;
5969                                 default:
5970                                         break;
5971                                 }
5972                         }
5973
5974                         if (match) {
5975                                 next = mono_inst_next (next, filter);
5976                                 if (!next)
5977                                         break;
5978                         }
5979                 }
5980         }
5981
5982         cfg->code_len = code - cfg->native_code;
5983         g_assert (cfg->code_len < cfg->code_size);
5984
5985         return code;
5986 }
5987
5988 /*========================= End of Function ========================*/
5989
5990 /*------------------------------------------------------------------*/
5991 /*                                                                  */
5992 /* Name         - mono_arch_emit_epilog                             */
5993 /*                                                                  */
5994 /* Function     - Emit the instructions for a function epilog.      */
5995 /*                                                                  */
5996 /*------------------------------------------------------------------*/
5997
5998 void
5999 mono_arch_emit_epilog (MonoCompile *cfg)
6000 {
6001         MonoMethod *method = cfg->method;
6002         int tracing = 0;
6003         guint8 *code;
6004         int max_epilog_size = 96;
6005
6006         if (cfg->method->save_lmf)
6007                 max_epilog_size += 128;
6008
6009         if (mono_jit_trace_calls != NULL)
6010                 max_epilog_size += 128;
6011         else if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
6012                 max_epilog_size += 128;
6013
6014         while ((cfg->code_len + max_epilog_size) > (cfg->code_size - 16)) {
6015                 cfg->code_size  *= 2;
6016                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
6017                 cfg->stat_code_reallocs++;
6018         }
6019
6020         code = cfg->native_code + cfg->code_len;
6021
6022         if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) {
6023                 code = mono_arch_instrument_epilog (cfg, leave_method, code, TRUE);
6024                 tracing = 1;
6025         }
6026
6027         if (method->save_lmf)
6028                 restoreLMF(code, cfg->frame_reg, cfg->stack_usage);
6029
6030         if (cfg->flags & MONO_CFG_HAS_ALLOCA) {
6031                 s390_lg  (code, STK_BASE, 0, STK_BASE, 0);
6032         } else
6033                 code = backUpStackPtr(cfg, code);
6034
6035         s390_lmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
6036         s390_br  (code, s390_r14);
6037
6038         cfg->code_len = code - cfg->native_code;
6039
6040         g_assert (cfg->code_len < cfg->code_size);
6041
6042 }
6043
6044 /*========================= End of Function ========================*/
6045
6046 /*------------------------------------------------------------------*/
6047 /*                                                                  */
6048 /* Name         - mono_arch_emit_exceptions                         */
6049 /*                                                                  */
6050 /* Function     - Emit the blocks to handle exception conditions.   */
6051 /*                                                                  */
6052 /*------------------------------------------------------------------*/
6053
6054 void
6055 mono_arch_emit_exceptions (MonoCompile *cfg)
6056 {
6057         MonoJumpInfo    *patch_info;
6058         guint8          *code;
6059         int             nThrows = 0,
6060                         exc_count = 0,
6061                         iExc;
6062         guint32         code_size;
6063         MonoClass       *exc_classes [MAX_EXC];
6064         guint8          *exc_throw_start [MAX_EXC];
6065
6066         for (patch_info = cfg->patch_info;
6067              patch_info;
6068              patch_info = patch_info->next) {
6069                 if (patch_info->type == MONO_PATCH_INFO_EXC)
6070                         exc_count++;
6071         }
6072
6073         code_size = exc_count * 48;
6074
6075         while ((cfg->code_len + code_size) > (cfg->code_size - 16)) {
6076                 cfg->code_size  *= 2;
6077                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
6078                 cfg->stat_code_reallocs++;
6079         }
6080
6081         code = cfg->native_code + cfg->code_len;
6082
6083         /*---------------------------------------------------------------------*/
6084         /* Add code to raise exceptions                                        */
6085         /*---------------------------------------------------------------------*/
6086         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
6087                 switch (patch_info->type) {
6088                 case MONO_PATCH_INFO_EXC: {
6089                         guint8 *ip = patch_info->ip.i + cfg->native_code;
6090                         MonoClass *exc_class;
6091                         guint64 throw_ip;
6092
6093                         /*-----------------------------------------------------*/
6094                         /* Patch the branch in epilog to come here             */
6095                         /*-----------------------------------------------------*/
6096                         s390_patch_rel (ip + 2, (guint64) S390_RELATIVE(code,ip));
6097
6098                         exc_class = mono_class_load_from_name (mono_defaults.corlib,
6099                                                           "System",
6100                                                           patch_info->data.name);
6101                         throw_ip = patch_info->ip.i;
6102
6103                         for (iExc = 0; iExc < nThrows; ++iExc)
6104                                 if (exc_classes [iExc] == exc_class)
6105                                         break;
6106
6107                         if (iExc < nThrows) {
6108                                 s390_jcl (code, S390_CC_UN,
6109                                           (guint64) exc_throw_start [iExc]);
6110                                 patch_info->type = MONO_PATCH_INFO_NONE;
6111                         } else {
6112
6113                                 if (nThrows < MAX_EXC) {
6114                                         exc_classes [nThrows]     = exc_class;
6115                                         exc_throw_start [nThrows] = code;
6116                                 }
6117
6118                                 /*---------------------------------------------*/
6119                                 /* Patch the parameter passed to the handler   */
6120                                 /*---------------------------------------------*/
6121                                 S390_SET  (code, s390_r2, exc_class->type_token);
6122                                 /*---------------------------------------------*/
6123                                 /* Load return address & parameter register    */
6124                                 /*---------------------------------------------*/
6125                                 s390_larl (code, s390_r14, (guint64)S390_RELATIVE((patch_info->ip.i +
6126                                                            cfg->native_code + 8), code));
6127                                 /*---------------------------------------------*/
6128                                 /* Reuse the current patch to set the jump     */
6129                                 /*---------------------------------------------*/
6130                                 patch_info->type      = MONO_PATCH_INFO_INTERNAL_METHOD;
6131                                 patch_info->data.name = "mono_arch_throw_corlib_exception";
6132                                 patch_info->ip.i      = code - cfg->native_code;
6133                                 S390_BR_TEMPLATE (code, s390_r1);
6134                         }
6135                         break;
6136                 }
6137                 default:
6138                         /* do nothing */
6139                         break;
6140                 }
6141         }
6142
6143         cfg->code_len = code - cfg->native_code;
6144
6145         g_assert (cfg->code_len < cfg->code_size);
6146
6147 }
6148
6149 /*========================= End of Function ========================*/
6150
6151 /*------------------------------------------------------------------*/
6152 /*                                                                  */
6153 /* Name         - mono_arch_finish_init                                 */
6154 /*                                                                  */
6155 /* Function     - Setup the JIT's Thread Level Specific Data.       */
6156 /*                                                                  */
6157 /*------------------------------------------------------------------*/
6158
6159 void
6160 mono_arch_finish_init (void)
6161 {
6162         appdomain_tls_offset = mono_domain_get_tls_offset();
6163         lmf_tls_offset = mono_get_lmf_tls_offset();
6164         lmf_addr_tls_offset = mono_get_lmf_addr_tls_offset();
6165 }
6166
6167 /*========================= End of Function ========================*/
6168
6169 /*------------------------------------------------------------------*/
6170 /*                                                                  */
6171 /* Name         - mono_arch_free_jit_tls_data                       */
6172 /*                                                                  */
6173 /* Function     - Free tls data.                                    */
6174 /*                                                                  */
6175 /*------------------------------------------------------------------*/
6176
6177 void
6178 mono_arch_free_jit_tls_data (MonoJitTlsData *tls)
6179 {
6180 }
6181
6182 /*========================= End of Function ========================*/
6183
6184 /*------------------------------------------------------------------*/
6185 /*                                                                  */
6186 /* Name         - mono_arch_emit_inst_for_method                    */
6187 /*                                                                  */
6188 /*------------------------------------------------------------------*/
6189
6190 MonoInst*
6191 mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
6192 {
6193         return NULL;
6194 }
6195
6196 /*========================= End of Function ========================*/
6197
6198 /*------------------------------------------------------------------*/
6199 /*                                                                  */
6200 /* Name         - mono_arch_decompose_opts                          */
6201 /*                                                                  */
6202 /* Function     - Decompose opcode into a System z opcode.          */
6203 /*                                                                  */
6204 /*------------------------------------------------------------------*/
6205
6206 void
6207 mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins)
6208 {
6209         /*
6210          * Have to rename these to avoid being decomposed normally, since the normal
6211          * decomposition does not work on S390.
6212          */
6213         switch (ins->opcode) {
6214         case OP_ISUB_OVF:
6215                 ins->opcode = OP_S390_ISUB_OVF;
6216                 break;
6217         case OP_ISUB_OVF_UN:
6218                 ins->opcode = OP_S390_ISUB_OVF_UN;
6219                 break;
6220         case OP_IADD_OVF:
6221                 ins->opcode = OP_S390_IADD_OVF;
6222                 break;
6223         case OP_IADD_OVF_UN:
6224                 ins->opcode = OP_S390_IADD_OVF_UN;
6225                 break;
6226         case OP_LADD_OVF:
6227                 ins->opcode = OP_S390_LADD_OVF;
6228                 break;
6229         case OP_LADD_OVF_UN:
6230                 ins->opcode = OP_S390_LADD_OVF_UN;
6231                 break;
6232         case OP_LSUB_OVF:
6233                 ins->opcode = OP_S390_LSUB_OVF;
6234                 break;
6235         case OP_LSUB_OVF_UN:
6236                 ins->opcode = OP_S390_LSUB_OVF_UN;
6237                 break;
6238         default:
6239                 break;
6240         }
6241 }
6242
6243 /*========================= End of Function ========================*/
6244
6245 /*------------------------------------------------------------------*/
6246 /*                                                                  */
6247 /* Name         - mono_arch_print_tree                              */
6248 /*                                                                  */
6249 /* Function     - Print platform-specific opcode details.           */
6250 /*                                                                  */
6251 /* Returns      - 1 - opcode details have been printed              */
6252 /*                0 - opcode details have not been printed          */
6253 /*                                                                  */
6254 /*------------------------------------------------------------------*/
6255
6256 gboolean
6257 mono_arch_print_tree (MonoInst *tree, int arity)
6258 {
6259         gboolean done;
6260
6261         switch (tree->opcode) {
6262                 case OP_S390_LOADARG:
6263                 case OP_S390_ARGREG:
6264                 case OP_S390_ARGPTR:
6265                         printf ("[0x%lx(%s)]", tree->inst_offset,
6266                                 mono_arch_regname (tree->inst_basereg));
6267                         done = 1;
6268                         break;
6269                 case OP_S390_STKARG:
6270                         printf ("[0x%lx(previous_frame)]",
6271                                 tree->inst_offset);
6272                         done = 1;
6273                         break;
6274                 case OP_S390_MOVE:
6275                         printf ("[0x%lx(%d,%s),0x%lx(%s)]",
6276                                 tree->inst_offset, tree->backend.size,
6277                                 mono_arch_regname(tree->dreg),
6278                                 tree->inst_imm,
6279                                 mono_arch_regname(tree->sreg1));
6280                         done = 1;
6281                         break;
6282                 case OP_S390_SETF4RET:
6283                         printf ("[f%s,f%s]",
6284                                 mono_arch_regname (tree->dreg),
6285                                 mono_arch_regname (tree->sreg1));
6286                         done = 1;
6287                         break;
6288                 case OP_TLS_GET:
6289                         printf ("[0x%lx(0x%lx,%s)]", tree->inst_offset,
6290                                 tree->inst_imm,
6291                                 mono_arch_regname (tree->sreg1));
6292                         done = 1;
6293                         break;
6294                 case OP_S390_BKCHAIN:
6295                         printf ("[previous_frame(%s)]",
6296                                 mono_arch_regname (tree->sreg1));
6297                         done = 1;
6298                 default:
6299                         done = 0;
6300         }
6301         return (done);
6302 }
6303
6304 /*========================= End of Function ========================*/
6305
6306 /*------------------------------------------------------------------*/
6307 /*                                                                  */
6308 /* Name         - mono_arch_regalloc_cost                           */
6309 /*                                                                  */
6310 /* Function     - Determine the cost, in the number of memory       */
6311 /*                references, of the action of allocating the var-  */
6312 /*                iable VMV into a register during global register  */
6313 /*                allocation.                                       */
6314 /*                                                                  */
6315 /* Returns      - Cost                                              */
6316 /*                                                                  */
6317 /*------------------------------------------------------------------*/
6318
6319 guint32
6320 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
6321 {
6322         /* FIXME: */
6323         return 2;
6324 }
6325
6326 /*========================= End of Function ========================*/
6327
6328 /*------------------------------------------------------------------*/
6329 /*                                                                  */
6330 /* Name         - mono_arch_flush_register_windows                  */
6331 /*                                                                  */
6332 /* Function     -                                                   */
6333 /*                                                                  */
6334 /* Returns      -                                                   */
6335 /*                                                                  */
6336 /*------------------------------------------------------------------*/
6337
6338 void
6339 mono_arch_flush_register_windows (void)
6340 {
6341 }
6342
6343 /*========================= End of Function ========================*/
6344
6345 /*------------------------------------------------------------------*/
6346 /*                                                                  */
6347 /* Name         - mono_arch_is_inst_imm                             */
6348 /*                                                                  */
6349 /* Function     - Determine if operand qualifies as an immediate    */
6350 /*                value. For s390 this is a value -32768-32768      */
6351 /*                                                                  */
6352 /* Returns      - True|False - is [not] immediate value.            */
6353 /*                                                                  */
6354 /*------------------------------------------------------------------*/
6355
6356 gboolean
6357 mono_arch_is_inst_imm (gint64 imm)
6358 {
6359         return s390_is_imm32 (imm);
6360 }
6361
6362 /*========================= End of Function ========================*/
6363
6364 /*------------------------------------------------------------------*/
6365 /*                                                                  */
6366 /* Name         - mono_arch_get_patch_offset                        */
6367 /*                                                                  */
6368 /* Function     - Dummy entry point until s390x supports aot.       */
6369 /*                                                                  */
6370 /* Returns      - Offset for patch.                                 */
6371 /*                                                                  */
6372 /*------------------------------------------------------------------*/
6373
6374 guint32
6375 mono_arch_get_patch_offset (guint8 *code)
6376 {
6377         return 0;
6378 }
6379
6380 /*========================= End of Function ========================*/
6381
6382 /*------------------------------------------------------------------*/
6383 /*                                                                  */
6384 /* Name         - mono_arch_context_get_int_reg.                    */
6385 /*                                                                  */
6386 /* Function     -                                                   */
6387 /*                                                                  */
6388 /* Returns      - Return a register from the context.               */
6389 /*                                                                  */
6390 /*------------------------------------------------------------------*/
6391
6392 mgreg_t
6393 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
6394 {
6395         return ((mgreg_t) ctx->uc_mcontext.gregs[reg]);
6396 }
6397
6398 /*========================= End of Function ========================*/
6399
6400 /*------------------------------------------------------------------*/
6401 /*                                                                  */
6402 /* Name         - mono_arch_context_set_int_reg.                    */
6403 /*                                                                  */
6404 /* Function     - Set a value in a specified register.              */
6405 /*                                                                  */
6406 /*------------------------------------------------------------------*/
6407
6408 void
6409 mono_arch_context_set_int_reg (MonoContext *ctx, int reg, mgreg_t val)
6410 {
6411         ctx->uc_mcontext.gregs[reg] = val;
6412 }
6413
6414 /*========================= End of Function ========================*/
6415
6416 /*------------------------------------------------------------------*/
6417 /*                                                                  */
6418 /* Name         - mono_arch_get_this_arg_from_call.                 */
6419 /*                                                                  */
6420 /* Function     -                                                   */
6421 /*                                                                  */
6422 /*------------------------------------------------------------------*/
6423
6424 gpointer
6425 mono_arch_get_this_arg_from_call (mgreg_t *regs, guint8 *code)
6426 {
6427         return (gpointer) regs [s390_r2];
6428 }
6429
6430 /*========================= End of Function ========================*/
6431
6432 /*------------------------------------------------------------------*/
6433 /*                                                                  */
6434 /* Name         - mono_arch_install_handler_block_guard             */
6435 /*                                                                  */
6436 /* Function     -                                                   */
6437 /*                                                                  */
6438 /*------------------------------------------------------------------*/
6439
6440 gpointer
6441 mono_arch_install_handler_block_guard (MonoJitInfo *ji, MonoJitExceptionInfo *clause,
6442                                        MonoContext *ctx, gpointer new_value)
6443 {
6444         int offset;
6445         gpointer *sp, old_value;
6446         char *bp;
6447
6448         offset = clause->exvar_offset;
6449
6450         /*Load the spvar*/
6451         bp = MONO_CONTEXT_GET_BP (ctx);
6452         sp = *(gpointer*)(bp + offset);
6453
6454         old_value = *sp;
6455         if (old_value < ji->code_start || (char*)old_value > ((char*)ji->code_start + ji->code_size))
6456                 return old_value;
6457
6458         *sp = new_value;
6459
6460         return old_value;
6461 }
6462
6463 /*========================= End of Function ========================*/
6464
6465 /*------------------------------------------------------------------*/
6466 /*                                                                  */
6467 /* Name         - get_delegate_invoke_impl.                         */
6468 /*                                                                  */
6469 /* Function     -                                                   */
6470 /*                                                                  */
6471 /*------------------------------------------------------------------*/
6472
6473 static gpointer
6474 get_delegate_invoke_impl (MonoTrampInfo **info, gboolean has_target, guint32 param_count, gboolean aot)
6475 {
6476         guint8 *code, *start;
6477
6478         if (has_target) {
6479                 int size = 32;
6480
6481                 start = code = mono_global_codeman_reserve (size);
6482
6483                 /* Replace the this argument with the target */
6484                 s390_lg   (code, s390_r1, 0, s390_r2, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr));
6485                 s390_lg   (code, s390_r2, 0, s390_r2, MONO_STRUCT_OFFSET (MonoDelegate, target));
6486                 s390_br   (code, s390_r1);
6487                 g_assert ((code - start) <= size);
6488
6489                 mono_arch_flush_icache (start, size);
6490         } else {
6491                 int size, i;
6492
6493                 size = 32 + param_count * 8;
6494                 start = code = mono_global_codeman_reserve (size);
6495
6496                 s390_lg   (code, s390_r1, 0, s390_r2, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr));
6497                 /* slide down the arguments */
6498                 for (i = 0; i < param_count; ++i) {
6499                         s390_lgr (code, (s390_r2 + i), (s390_r2 + i + 1));
6500                 }
6501                 s390_br   (code, s390_r1);
6502
6503                 g_assert ((code - start) <= size);
6504
6505                 mono_arch_flush_icache (start, size);
6506         }
6507
6508         mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL);
6509
6510         if (has_target) {
6511                 *info = mono_tramp_info_create ("delegate_invoke_impl_has_target", start, code - start, NULL, NULL);
6512         } else {
6513                 char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", param_count);
6514                 *info = mono_tramp_info_create (name, start, code - start, NULL, NULL);
6515                 g_free (name);
6516         }
6517
6518         return start;
6519 }
6520
6521 /*========================= End of Function ========================*/
6522
6523 /*------------------------------------------------------------------*/
6524 /*                                                                  */
6525 /* Name         - mono_arch_get_delegate_invoke_impls.              */
6526 /*                                                                  */
6527 /* Function     -                                                   */
6528 /*                                                                  */
6529 /*------------------------------------------------------------------*/
6530
6531 GSList*
6532 mono_arch_get_delegate_invoke_impls (void)
6533 {
6534         GSList *res = NULL;
6535         MonoTrampInfo *info;
6536         int i;
6537
6538         get_delegate_invoke_impl (&info, TRUE, 0, TRUE);
6539         res = g_slist_prepend (res, info);
6540
6541         for (i = 0; i <= MAX_ARCH_DELEGATE_PARAMS; ++i) {
6542                 get_delegate_invoke_impl (&info, FALSE, i, TRUE);
6543                 res = g_slist_prepend (res, info);
6544         }
6545
6546         return res;
6547 }
6548
6549 /*========================= End of Function ========================*/
6550
6551 /*------------------------------------------------------------------*/
6552 /*                                                                  */
6553 /* Name         - mono_arch_get_delegate_invoke_impl.               */
6554 /*                                                                  */
6555 /* Function     -                                                   */
6556 /*                                                                  */
6557 /*------------------------------------------------------------------*/
6558
6559 gpointer
6560 mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target)
6561 {
6562         guint8 *code, *start;
6563
6564         /* FIXME: Support more cases */
6565         if (MONO_TYPE_ISSTRUCT (sig->ret))
6566                 return NULL;
6567
6568         if (has_target) {
6569                 static guint8* cached = NULL;
6570
6571                 if (cached)
6572                         return cached;
6573
6574                 if (mono_aot_only) {
6575                         start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
6576                 } else {
6577                         MonoTrampInfo *info;
6578                         start = get_delegate_invoke_impl (&info, TRUE, 0, FALSE);
6579                         mono_tramp_info_register (info, NULL);
6580                 }
6581
6582                 mono_memory_barrier ();
6583
6584                 cached = start;
6585         } else {
6586                 static guint8* cache [MAX_ARCH_DELEGATE_PARAMS + 1] = {NULL};
6587                 int i;
6588
6589                 if (sig->param_count > MAX_ARCH_DELEGATE_PARAMS)
6590                         return NULL;
6591                 for (i = 0; i < sig->param_count; ++i)
6592                         if (!mono_is_regsize_var (sig->params [i]))
6593                                 return NULL;
6594
6595
6596                 code = cache [sig->param_count];
6597                 if (code)
6598                         return code;
6599
6600                 if (mono_aot_only) {
6601                         char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", sig->param_count);
6602                         start = mono_aot_get_trampoline (name);
6603                         g_free (name);
6604                 } else {
6605                         MonoTrampInfo *info;
6606                         start = get_delegate_invoke_impl (&info, FALSE, sig->param_count, FALSE);
6607                         mono_tramp_info_register (info, NULL);
6608                 }
6609
6610                 mono_memory_barrier ();
6611
6612                 cache [sig->param_count] = start;
6613         }
6614         return start;
6615 }
6616
6617 /*========================= End of Function ========================*/
6618
6619 /*------------------------------------------------------------------*/
6620 /*                                                                  */
6621 /* Name         - mono_arch_get_delegate_virtual_invoke_impl.       */
6622 /*                                                                  */
6623 /* Function     -                                                   */
6624 /*                                                                  */
6625 /*------------------------------------------------------------------*/
6626
6627 gpointer
6628 mono_arch_get_delegate_virtual_invoke_impl (MonoMethodSignature *sig, MonoMethod *method,
6629                                             int offset, gboolean load_imt_reg)
6630 {
6631         guint8 *code, *start;
6632         int size = 40;
6633
6634         start = code = mono_global_codeman_reserve (size);
6635
6636         /*
6637         * Replace the "this" argument with the target
6638         */
6639         s390_lgr  (code, s390_r1, s390_r2);
6640         s390_lg   (code, s390_r2, 0, s390_r1, MONO_STRUCT_OFFSET(MonoDelegate, target));
6641
6642         /*
6643         * Load the IMT register, if needed
6644         */
6645         if (load_imt_reg) {
6646                 s390_lg  (code, MONO_ARCH_IMT_REG, 0, s390_r1, MONO_STRUCT_OFFSET(MonoDelegate, method));
6647         }
6648
6649         /*
6650         * Load the vTable
6651         */
6652         s390_lg  (code, s390_r1, 0, s390_r2, MONO_STRUCT_OFFSET(MonoObject, vtable));
6653         if (offset != 0) {
6654                 s390_agfi(code, s390_r1, offset);
6655         }
6656         s390_lg  (code, s390_r1, 0, s390_r1, 0);
6657         s390_br  (code, s390_r1);
6658
6659         return(start);
6660 }
6661
6662 /*========================= End of Function ========================*/
6663
6664 /*------------------------------------------------------------------*/
6665 /*                                                                  */
6666 /* Name         - mono_arch_build_imt_trampoline.                       */
6667 /*                                                                  */
6668 /* Function     -                                                   */
6669 /*                                                                  */
6670 /*------------------------------------------------------------------*/
6671
6672 gpointer
6673 mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain,
6674                                                                 MonoIMTCheckItem **imt_entries, int count,
6675                                                                 gpointer fail_tramp)
6676 {
6677         int i;
6678         int size = 0;
6679         guchar *code, *start;
6680         char trampName[64];
6681
6682         for (i = 0; i < count; ++i) {
6683                 MonoIMTCheckItem *item = imt_entries [i];
6684                 if (item->is_equals) {
6685                         if (item->check_target_idx) {
6686                                 if (!item->compare_done)
6687                                         item->chunk_size += CMP_SIZE + JUMP_SIZE;
6688                                 if (item->has_target_code)
6689                                         item->chunk_size += BR_SIZE + JUMP_SIZE + LOADCON_SIZE;
6690                                 else
6691                                         item->chunk_size += BR_SIZE + JUMP_SIZE + LOADCON_SIZE +
6692                                                             LOAD_SIZE;
6693                         } else {
6694                                 if (fail_tramp) {
6695                                         item->chunk_size += CMP_SIZE + 2 * BR_SIZE + JUMP_SIZE +
6696                                                             2 * LOADCON_SIZE;
6697                                         if (!item->has_target_code)
6698                                                 item->chunk_size += LOAD_SIZE;
6699                                 } else {
6700                                         item->chunk_size += LOADCON_SIZE + LOAD_SIZE + BR_SIZE;
6701 #if ENABLE_WRONG_METHOD_CHECK
6702                                         item->chunk_size += CMP_SIZE + JUMP_SIZE;
6703 #endif
6704                                 }
6705                         }
6706                 } else {
6707                         item->chunk_size += CMP_SIZE + JUMP_SIZE;
6708                         imt_entries [item->check_target_idx]->compare_done = TRUE;
6709                 }
6710                 size += item->chunk_size;
6711         }
6712
6713         if (fail_tramp)
6714                 code = mono_method_alloc_generic_virtual_trampoline (domain, size);
6715         else
6716                 code = mono_domain_code_reserve (domain, size);
6717
6718         start = code;
6719
6720         for (i = 0; i < count; ++i) {
6721                 MonoIMTCheckItem *item = imt_entries [i];
6722                 item->code_target = (guint8 *) code;
6723                 if (item->is_equals) {
6724                         if (item->check_target_idx) {
6725                                 if (!item->compare_done) {
6726                                         S390_SET  (code, s390_r0, item->key);
6727                                         s390_cgr  (code, s390_r0, MONO_ARCH_IMT_REG);
6728                                 }
6729                                 item->jmp_code = (guint8*) code;
6730                                 s390_jcl (code, S390_CC_NE, 0);
6731
6732                                 if (item->has_target_code) {
6733                                         S390_SET (code, s390_r1, item->value.target_code);
6734                                 } else {
6735                                         S390_SET (code, s390_r1, (&(vtable->vtable [item->value.vtable_slot])));
6736                                         s390_lg  (code, s390_r1, 0, s390_r1, 0);
6737                                 }
6738                                 s390_br   (code, s390_r1);
6739                         } else {
6740                                 if (fail_tramp) {
6741                                         gint64  target;
6742
6743                                         S390_SET  (code, s390_r0, item->key);
6744                                         s390_cgr  (code, s390_r0, MONO_ARCH_IMT_REG);
6745                                         item->jmp_code = (guint8*) code;
6746                                         s390_jcl  (code, S390_CC_NE, 0);
6747                                         if (item->has_target_code) {
6748                                                 S390_SET (code, s390_r1, item->value.target_code);
6749                                         } else {
6750                                                 g_assert (vtable);
6751                                                 S390_SET  (code, s390_r1,
6752                                                            (&(vtable->vtable [item->value.vtable_slot])));
6753                                                 s390_lg   (code, s390_r1, 0, s390_r1, 0);
6754                                         }
6755                                         s390_br   (code, s390_r1);
6756                                         target = (gint64) S390_RELATIVE(code, item->jmp_code);
6757                                         s390_patch_rel(item->jmp_code+2, target);
6758                                         S390_SET  (code, s390_r1, fail_tramp);
6759                                         s390_br   (code, s390_r1);
6760                                         item->jmp_code = NULL;
6761                                 } else {
6762                                 /* enable the commented code to assert on wrong method */
6763 #if ENABLE_WRONG_METHOD_CHECK
6764                                         g_assert_not_reached ();
6765 #endif
6766                                         S390_SET (code, s390_r1, (&(vtable->vtable [item->value.vtable_slot])));
6767                                         s390_lg   (code, s390_r1, 0, s390_r1, 0);
6768                                         s390_br   (code, s390_r1);
6769                                 }
6770                         }
6771                 } else {
6772                         S390_SET  (code, s390_r0, item->key);
6773                         s390_cgr  (code, MONO_ARCH_IMT_REG, s390_r0);
6774                         item->jmp_code = (guint8 *) code;
6775                         s390_jcl  (code, S390_CC_GE, 0);
6776                 }
6777         }
6778         /*
6779          * patch the branches to get to the target items
6780          */
6781         for (i = 0; i < count; ++i) {
6782                 MonoIMTCheckItem *item = imt_entries [i];
6783                 if (item->jmp_code) {
6784                         if (item->check_target_idx) {
6785                                 gint64 offset;
6786                                 offset = (gint64) S390_RELATIVE(imt_entries [item->check_target_idx]->code_target,
6787                                                        item->jmp_code);
6788                                 s390_patch_rel ((guchar *) item->jmp_code + 2, (guint64) offset);
6789                         }
6790                 }
6791         }
6792
6793         mono_arch_flush_icache ((guint8*)start, (code - start));
6794         mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL);
6795
6796         if (!fail_tramp)
6797                 mono_stats.imt_trampolines_size += (code - start);
6798
6799         g_assert (code - start <= size);
6800
6801         snprintf(trampName, sizeof(trampName), "%d_imt_trampoline", domain->domain_id);
6802         mono_tramp_info_register (mono_tramp_info_create (trampName, start, code - start, NULL, NULL), domain);
6803
6804         return (start);
6805 }
6806
6807 /*========================= End of Function ========================*/
6808
6809 /*------------------------------------------------------------------*/
6810 /*                                                                  */
6811 /* Name         - mono_arch_find_imt_method.                        */
6812 /*                                                                  */
6813 /* Function     - Get the method address from MONO_ARCH_IMT_REG     */
6814 /*                found in the save area.                           */
6815 /*                                                                  */
6816 /*------------------------------------------------------------------*/
6817
6818 MonoMethod*
6819 mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
6820 {
6821         return ((MonoMethod *) regs [MONO_ARCH_IMT_REG]);
6822 }
6823
6824 /*========================= End of Function ========================*/
6825
6826 /*------------------------------------------------------------------*/
6827 /*                                                                  */
6828 /* Name         - mono_arch_find_static_call_vtable                 */
6829 /*                                                                  */
6830 /* Function     - Find the static call vtable.                      */
6831 /*                                                                  */
6832 /*------------------------------------------------------------------*/
6833
6834 MonoVTable*
6835 mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
6836 {
6837         mgreg_t *r = (mgreg_t*)regs;
6838
6839         return (MonoVTable*)(gsize) r [MONO_ARCH_RGCTX_REG];
6840 }
6841
6842 /*========================= End of Function ========================*/
6843
6844 /*------------------------------------------------------------------*/
6845 /*                                                                  */
6846 /* Name         - mono_arch_get_cie_program                         */
6847 /*                                                                  */
6848 /* Function     - Find the static call vtable.                      */
6849 /*                                                                  */
6850 /*------------------------------------------------------------------*/
6851
6852 GSList*
6853 mono_arch_get_cie_program (void)
6854 {
6855         GSList *l = NULL;
6856
6857         mono_add_unwind_op_def_cfa (l, 0, 0, STK_BASE, 0);
6858
6859         return(l);
6860 }
6861
6862 /*========================= End of Function ========================*/
6863
6864 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
6865
6866 /*------------------------------------------------------------------*/
6867 /*                                                                  */
6868 /* Name         - mono_arch_set_breakpoint.                         */
6869 /*                                                                  */
6870 /* Function     - Set a breakpoint at the native code corresponding */
6871 /*                to JI at NATIVE_OFFSET.  The location should      */
6872 /*                contain code emitted by OP_SEQ_POINT.             */
6873 /*                                                                  */
6874 /*------------------------------------------------------------------*/
6875
6876 void
6877 mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip)
6878 {
6879         guint8 *code = ip;
6880
6881         breakpointCode.pTrigger = bp_trigger_page;
6882         memcpy(code, (void *) &breakpointCode, BREAKPOINT_SIZE);
6883         code += BREAKPOINT_SIZE;
6884 }
6885
6886 /*========================= End of Function ========================*/
6887
6888 /*------------------------------------------------------------------*/
6889 /*                                                                  */
6890 /* Name         - mono_arch_clear_breakpoint.                       */
6891 /*                                                                  */
6892 /* Function     - Clear the breakpoint at IP.                       */
6893 /*                                                                  */
6894 /*------------------------------------------------------------------*/
6895
6896 void
6897 mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip)
6898 {
6899         guint8 *code = ip;
6900         int i;
6901
6902         for (i = 0; i < (BREAKPOINT_SIZE / S390X_NOP_SIZE); i++)
6903                 s390_nop(code);
6904 }
6905
6906 /*========================= End of Function ========================*/
6907
6908 /*------------------------------------------------------------------*/
6909 /*                                                                  */
6910 /* Name         - mono_arch_is_breakpoint_event.                    */
6911 /*                                                                  */
6912 /* Function     -                                                   */
6913 /*                                                                  */
6914 /*------------------------------------------------------------------*/
6915
6916 gboolean
6917 mono_arch_is_breakpoint_event (void *info, void *sigctx)
6918 {
6919         siginfo_t* sinfo = (siginfo_t*) info;
6920
6921         /*
6922          * Sometimes the address is off by 4
6923          */
6924         if (sinfo->si_addr >= bp_trigger_page && (guint8*)sinfo->si_addr <= (guint8*)bp_trigger_page + 128)
6925                 return TRUE;
6926         else
6927                 return FALSE;
6928 }
6929
6930 /*========================= End of Function ========================*/
6931
6932 /*------------------------------------------------------------------*/
6933 /*                                                                  */
6934 /* Name         - mono_arch_skip_breakpoint.                        */
6935 /*                                                                  */
6936 /* Function     - Modify the CTX so the IP is placed after the      */
6937 /*                breakpoint instruction, so when we resume, the    */
6938 /*                instruction is not executed again.                */
6939 /*                                                                  */
6940 /*------------------------------------------------------------------*/
6941
6942 void
6943 mono_arch_skip_breakpoint (MonoContext *ctx, MonoJitInfo *ji)
6944 {
6945         MONO_CONTEXT_SET_IP (ctx, ((guint8*)MONO_CONTEXT_GET_IP (ctx) + sizeof(RXY_Format)));
6946 }
6947
6948 /*========================= End of Function ========================*/
6949
6950 /*------------------------------------------------------------------*/
6951 /*                                                                  */
6952 /* Name         - mono_arch_start_single_stepping.                  */
6953 /*                                                                  */
6954 /* Function     - Start single stepping.                            */
6955 /*                                                                  */
6956 /*------------------------------------------------------------------*/
6957
6958 void
6959 mono_arch_start_single_stepping (void)
6960 {
6961         mono_mprotect (ss_trigger_page, mono_pagesize (), 0);
6962 }
6963
6964 /*========================= End of Function ========================*/
6965
6966 /*------------------------------------------------------------------*/
6967 /*                                                                  */
6968 /* Name         - mono_arch_stop_single_stepping.                   */
6969 /*                                                                  */
6970 /* Function     - Stop single stepping.                             */
6971 /*                                                                  */
6972 /*------------------------------------------------------------------*/
6973
6974 void
6975 mono_arch_stop_single_stepping (void)
6976 {
6977         mono_mprotect (ss_trigger_page, mono_pagesize (), MONO_MMAP_READ);
6978 }
6979
6980 /*========================= End of Function ========================*/
6981
6982 /*------------------------------------------------------------------*/
6983 /*                                                                  */
6984 /* Name         - mono_arch_is_single_step_event.                   */
6985 /*                                                                  */
6986 /* Function     - Return whether the machine state in sigctx cor-   */
6987 /*                responds to a single step event.                  */
6988 /*                                                                  */
6989 /*------------------------------------------------------------------*/
6990
6991 gboolean
6992 mono_arch_is_single_step_event (void *info, void *sigctx)
6993 {
6994         siginfo_t* sinfo = (siginfo_t*) info;
6995
6996         /*
6997          * Sometimes the address is off by 4
6998          */
6999         if (sinfo->si_addr >= ss_trigger_page && (guint8*)sinfo->si_addr <= (guint8*)ss_trigger_page + 128)
7000                 return TRUE;
7001         else
7002                 return FALSE;
7003 }
7004
7005 /*========================= End of Function ========================*/
7006
7007 /*------------------------------------------------------------------*/
7008 /*                                                                  */
7009 /* Name         - mono_arch_skip_single_step.                       */
7010 /*                                                                  */
7011 /* Function     - Modify the ctx so the IP is placed after the      */
7012 /*                single step trigger instruction, so that the      */
7013 /*                instruction is not executed again.                */
7014 /*                                                                  */
7015 /*------------------------------------------------------------------*/
7016
7017 void
7018 mono_arch_skip_single_step (MonoContext *ctx)
7019 {
7020         MONO_CONTEXT_SET_IP (ctx, (guint8*)MONO_CONTEXT_GET_IP (ctx) + BREAKPOINT_SIZE);
7021 }
7022
7023 /*========================= End of Function ========================*/
7024
7025 /*------------------------------------------------------------------*/
7026 /*                                                                  */
7027 /* Name         - mono_arch_create_seq_point_info.                  */
7028 /*                                                                  */
7029 /* Function     - Return a pointer to a data struction which is     */
7030 /*                used by the sequence point implementation in      */
7031 /*                AOTed code.                                       */
7032 /*                                                                  */
7033 /*------------------------------------------------------------------*/
7034
7035 gpointer
7036 mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code)
7037 {
7038         NOT_IMPLEMENTED;
7039         return NULL;
7040 }
7041
7042 /*========================= End of Function ========================*/
7043
7044 /*------------------------------------------------------------------*/
7045 /*                                                                  */
7046 /* Name         - mono_arch_init_lmf_ext.                           */
7047 /*                                                                  */
7048 /* Function -                                                       */
7049 /*                                                                  */
7050 /*------------------------------------------------------------------*/
7051
7052 void
7053 mono_arch_init_lmf_ext (MonoLMFExt *ext, gpointer prev_lmf)
7054 {
7055         ext->lmf.previous_lmf = prev_lmf;
7056         /* Mark that this is a MonoLMFExt */
7057         ext->lmf.previous_lmf = (gpointer)(((gssize)ext->lmf.previous_lmf) | 2);
7058         ext->lmf.ebp = (gssize)ext;
7059 }
7060
7061 /*========================= End of Function ========================*/
7062
7063 #endif
7064
7065 /*------------------------------------------------------------------*/
7066 /*                                                                  */
7067 /* Name     - mono_arch_cpu_enumerate_simd_versions.                */
7068 /*                                                                  */
7069 /* Function - If this CPU supports vector operations then it        */
7070 /*            supports the equivalent of SSE1-4.                    */
7071 /*                                                                  */
7072 /*------------------------------------------------------------------*/
7073
7074 guint32
7075 mono_arch_cpu_enumerate_simd_versions (void)
7076 {
7077         guint32 sseOpts = 0;
7078
7079         if (mono_hwcap_s390x_has_vec)
7080                 sseOpts = (SIMD_VERSION_SSE1  | SIMD_VERSION_SSE2 |
7081                            SIMD_VERSION_SSE3  | SIMD_VERSION_SSSE3 |
7082                            SIMD_VERSION_SSE41 | SIMD_VERSION_SSE42 |
7083                            SIMD_VERSION_SSE4a);
7084
7085         return (sseOpts);
7086 }
7087
7088 /*========================= End of Function ========================*/
7089
7090 /*------------------------------------------------------------------*/
7091 /*                                                                  */
7092 /* Name     - mono_arch_opcode_supported.                           */
7093 /*                                                                  */
7094 /* Function - Check if a given return code is supported.            */
7095 /*                                                                  */
7096 /*------------------------------------------------------------------*/
7097
7098 gboolean
7099 mono_arch_opcode_supported (int opcode)
7100 {
7101         switch (opcode) {
7102         case OP_ATOMIC_ADD_I4:
7103         case OP_ATOMIC_ADD_I8:
7104         case OP_ATOMIC_EXCHANGE_I4:
7105         case OP_ATOMIC_EXCHANGE_I8:
7106                 return TRUE;
7107         default:
7108                 return FALSE;
7109         }
7110 }
7111
7112 /*========================= End of Function ========================*/