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