mono/mini/mini-s390.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 NOT_IMPLEMENTED(x) \
  22         g_error ("FIXME: %s is not yet implemented.", x);
  23
  24 #define EMIT_COND_BRANCH(ins,cond)                                                      \
  25 {                                                                                       \
  26 if (ins->flags & MONO_INST_BRLABEL) {                                                   \
  27         if (ins->inst_i0->inst_c0) {                                                    \
  28                 int displace;                                                           \
  29                 displace = ((cfg->native_code + ins->inst_i0->inst_c0) - code) / 2;     \
  30                 if (s390_is_uimm16(displace)) {                                         \
  31                         s390_brc (code, cond, displace);                                \
  32                 } else {                                                                \
  33                         s390_jcl (code, cond, displace);                                \
  34                 }                                                                       \
  35         } else {                                                                        \
  36                 mono_add_patch_info (cfg, code - cfg->native_code,                      \
  37                                      MONO_PATCH_INFO_LABEL, ins->inst_i0);              \
  38                 s390_jcl (code, cond, 0);                                               \
  39         }                                                                               \
  40 } else {                                                                                \
  41         if (ins->inst_true_bb->native_offset) {                                         \
  42                 int displace;                                                           \
  43                 displace = ((cfg->native_code +                                         \
  44                             ins->inst_true_bb->native_offset) - code) / 2;              \
  45                 if (s390_is_uimm16(displace)) {                                         \
  46                         s390_brc (code, cond, displace);                                \
  47                 } else {                                                                \
  48                         s390_jcl (code, cond, displace);                                \
  49                 }                                                                       \
  50         } else {                                                                        \
  51                 mono_add_patch_info (cfg, code - cfg->native_code,                      \
  52                                      MONO_PATCH_INFO_BB, ins->inst_true_bb);            \
  53                 s390_jcl (code, cond, 0);                                               \
  54         }                                                                               \
  55 }                                                                                       \
  56 }
  57
  58 #define EMIT_UNCOND_BRANCH(ins)                                                         \
  59 {                                                                                       \
  60 if (ins->flags & MONO_INST_BRLABEL) {                                                   \
  61         if (ins->inst_i0->inst_c0) {                                                    \
  62                 int displace;                                                           \
  63                 displace = ((cfg->native_code + ins->inst_i0->inst_c0) - code) / 2;     \
  64                 if (s390_is_uimm16(displace)) {                                         \
  65                         s390_brc (code, S390_CC_UN, displace);                          \
  66                 } else {                                                                \
  67                         s390_jcl (code, S390_CC_UN, displace);                          \
  68                 }                                                                       \
  69         } else {                                                                        \
  70                 mono_add_patch_info (cfg, code - cfg->native_code,                      \
  71                                      MONO_PATCH_INFO_LABEL, ins->inst_i0);              \
  72                 s390_jcl (code, S390_CC_UN, 0);                                         \
  73         }                                                                               \
  74 } else {                                                                                \
  75         if (ins->inst_target_bb->native_offset) {                                       \
  76                 int displace;                                                           \
  77                 displace = ((cfg->native_code +                                         \
  78                             ins->inst_target_bb->native_offset) - code) / 2;            \
  79                 if (s390_is_uimm16(displace)) {                                         \
  80                         s390_brc (code, S390_CC_UN, displace);                          \
  81                 } else {                                                                \
  82                         s390_jcl (code, S390_CC_UN, displace);                          \
  83                 }                                                                       \
  84         } else {                                                                        \
  85                 mono_add_patch_info (cfg, code - cfg->native_code,                      \
  86                                      MONO_PATCH_INFO_BB, ins->inst_target_bb);          \
  87                 s390_jcl (code, S390_CC_UN, 0);                                         \
  88         }                                                                               \
  89 }                                                                                       \
  90 }
  91
  92 #define EMIT_COND_SYSTEM_EXCEPTION(cond,exc_name)                       \
  93         do {                                                            \
  94                 mono_add_patch_info (cfg, code - cfg->native_code,      \
  95                                     MONO_PATCH_INFO_EXC, exc_name);     \
  96                 s390_jcl (code, cond, 0);                               \
  97         } while (0);
  98
  99 #define CHECK_SRCDST_COM                                                \
 100         if (ins->dreg == ins->sreg2) {                                  \
 101                 src2 = ins->sreg1;                                      \
 102         } else {                                                        \
 103                 src2 = ins->sreg2;                                      \
 104                 if (ins->dreg != ins->sreg1) {                          \
 105                         s390_lr  (code, ins->dreg, ins->sreg1);         \
 106                 }                                                       \
 107         }
 108
 109 #define CHECK_SRCDST_NCOM                                               \
 110         if (ins->dreg == ins->sreg2) {                                  \
 111                 src2 = s390_r13;                                        \
 112                 s390_lr  (code, s390_r13, ins->sreg2);                  \
 113         } else {                                                        \
 114                 src2 = ins->sreg2;                                      \
 115         }                                                               \
 116         if (ins->dreg != ins->sreg1) {                                  \
 117                 s390_lr  (code, ins->dreg, ins->sreg1);                 \
 118         }
 119
 120 #define CHECK_SRCDST_NCOM_F                                             \
 121         if (ins->dreg == ins->sreg2) {                                  \
 122                 src2 = s390_f15;                                        \
 123                 s390_ldr (code, s390_r13, ins->sreg2);                  \
 124         } else {                                                        \
 125                 src2 = ins->sreg2;                                      \
 126         }                                                               \
 127         if (ins->dreg != ins->sreg1) {                                  \
 128                 s390_ldr (code, ins->dreg, ins->sreg1);                 \
 129         }
 130
 131 #undef DEBUG
 132 #define DEBUG(a) if (cfg->verbose_level > 1) a
 133
 134 #define MAX_EXC 16
 135
 136 #define S390_TRACE_STACK_SIZE (5*sizeof(gint32)+3*sizeof(gdouble))
 137
 138 #define MAX (a, b) ((a) > (b) ? (a) : (b))
 139
 140 /*========================= End of Defines =========================*/
 141
 142 /*------------------------------------------------------------------*/
 143 /*                 I n c l u d e s                                  */
 144 /*------------------------------------------------------------------*/
 145
 146 #include "mini.h"
 147 #include <string.h>
 148
 149 #include <mono/metadata/appdomain.h>
 150 #include <mono/metadata/debug-helpers.h>
 151 #include <mono/metadata/profiler-private.h>
 152 #include <mono/utils/mono-math.h>
 153
 154 #include "mini-s390.h"
 155 #include "inssel.h"
 156 #include "cpu-s390.h"
 157
 158 /*========================= End of Includes ========================*/
 159
 160 /*------------------------------------------------------------------*/
 161 /*                 T y p e d e f s                                  */
 162 /*------------------------------------------------------------------*/
 163
 164 typedef struct {
 165         guint stack_size,
 166               local_size,
 167               code_size,
 168               parm_size,
 169               retStruct;
 170 } size_data;
 171
 172 /*------------------------------------------------------------------*/
 173 /* Used by the instrument_emit_epilog                               */
 174 /*------------------------------------------------------------------*/
 175
 176 enum {
 177         SAVE_NONE,
 178         SAVE_STRUCT,
 179         SAVE_ONE,
 180         SAVE_TWO,
 181         SAVE_FP
 182 };
 183
 184 typedef struct InstList InstList;
 185
 186 struct InstList {
 187         InstList *prev;
 188         InstList *next;
 189         MonoInst *data;
 190 };
 191
 192 enum {
 193         RegTypeGeneral,
 194         RegTypeBase,
 195         RegTypeFP,
 196         RegTypeStructByVal,
 197         RegTypeStructByAddr
 198 };
 199
 200 typedef struct {
 201         gint32  offset;         /* offset from caller's stack */
 202         gint32  offparm;        /* offset from callee's stack */
 203         guint16 vtsize;         /* in param area */
 204         guint8  reg;
 205         guint8  regtype;        /* See RegType* */
 206         guint32 size;           /* Size of structure used by RegTypeStructByVal */
 207 } ArgInfo;
 208
 209 typedef struct {
 210         int nargs;
 211         guint32 stack_usage;
 212         guint32 struct_ret;
 213         guint32 offStruct;
 214         ArgInfo ret;
 215         ArgInfo sigCookie;
 216         ArgInfo args [1];
 217 } CallInfo;
 218
 219 typedef struct {
 220         gint32  gr[5];          /* R2-R6                            */
 221         gdouble fp[3];          /* F0-F2                            */
 222 } __attribute__ ((packed)) RegParm;
 223
 224 /*========================= End of Typedefs ========================*/
 225
 226 /*------------------------------------------------------------------*/
 227 /*                   P r o t o t y p e s                            */
 228 /*------------------------------------------------------------------*/
 229
 230 static guint32 * emit_memcpy (guint8 *, int, int, int, int, int);
 231 static void indent (int);
 232 static guint8 * backUpStackPtr(MonoCompile *, guint8 *);
 233 static void decodeParm (MonoType *, void *, int);
 234 static void enter_method (MonoMethod *, RegParm *, char *);
 235 static void leave_method (MonoMethod *, ...);
 236 static gboolean is_regsize_var (MonoType *);
 237 static inline void add_general (guint *, size_data *, ArgInfo *, gboolean);
 238 static inline void add_stackParm (guint *, size_data *, ArgInfo *, gint);
 239 static inline void add_float (guint *, size_data *, ArgInfo *);
 240 static CallInfo * calculate_sizes (MonoMethodSignature *, size_data *, gboolean);
 241 static void peephole_pass (MonoCompile *, MonoBasicBlock *);
 242 static guchar * emit_float_to_int (MonoCompile *, guchar *, int, int, int, gboolean);
 243 static unsigned char * mono_emit_stack_alloc (guchar *, MonoInst *);
 244 static void mono_arch_break(void);
 245 gpointer mono_arch_get_lmf_addr (void);
 246
 247 /*========================= End of Prototypes ======================*/
 248
 249 /*------------------------------------------------------------------*/
 250 /*                 G l o b a l   V a r i a b l e s                  */
 251 /*------------------------------------------------------------------*/
 252
 253 int mono_exc_esp_offset = 0;
 254
 255 static int indent_level = 0;
 256
 257 static const char*const * ins_spec = s390_cpu_desc;
 258
 259 static gboolean tls_offset_inited = FALSE;
 260
 261 static int appdomain_tls_offset = -1,
 262            lmf_tls_offset = -1,
 263            thread_tls_offset = -1;
 264
 265 pthread_key_t lmf_addr_key;
 266
 267 gboolean lmf_addr_key_inited = FALSE;
 268
 269 #if 0
 270
 271 extern __thread MonoDomain *tls_appdomain;
 272 extern __thread MonoThread *tls_current_object;
 273 extern __thread gpointer   mono_lmf_addr;
 274
 275 #endif
 276
 277 /*====================== End of Global Variables ===================*/
 278
 279 /*------------------------------------------------------------------*/
 280 /*                                                                  */
 281 /* Name         - mono_arch_regname                                 */
 282 /*                                                                  */
 283 /* Function     - Returns the name of the register specified by     */
 284 /*                the input parameter.                              */
 285 /*                                                                  */
 286 /*------------------------------------------------------------------*/
 287
 288 const char*
 289 mono_arch_regname (int reg) {
 290         static const char * rnames[] = {
 291                 "s390_r0", "s390_sp", "s390_r2", "s390_r3", "s390_r4",
 292                 "s390_r5", "s390_r6", "s390_r7", "s390_r8", "s390_r9",
 293                 "s390_r10", "s390_r11", "s390_r12", "s390_r13", "s390_r14",
 294                 "s390_r15"
 295         };
 296
 297         if (reg >= 0 && reg < 16)
 298                 return rnames [reg];
 299         else
 300                 return "unknown";
 301 }
 302
 303 /*========================= End of Function ========================*/
 304
 305 /*------------------------------------------------------------------*/
 306 /*                                                                  */
 307 /* Name         - mono_arch_fregname                                */
 308 /*                                                                  */
 309 /* Function     - Returns the name of the register specified by     */
 310 /*                the input parameter.                              */
 311 /*                                                                  */
 312 /*------------------------------------------------------------------*/
 313
 314 const char*
 315 mono_arch_fregname (int reg) {
 316         static const char * rnames[] = {
 317                 "s390_f0", "s390_f1", "s390_f2", "s390_f3", "s390_f4",
 318                 "s390_f5", "s390_f6", "s390_f7", "s390_f8", "s390_f9",
 319                 "s390_f10", "s390_f11", "s390_f12", "s390_f13", "s390_f14",
 320                 "s390_f15"
 321         };
 322
 323         if (reg >= 0 && reg < 16)
 324                 return rnames [reg];
 325         else
 326                 return "unknown";
 327 }
 328
 329 /*========================= End of Function ========================*/
 330
 331 /*------------------------------------------------------------------*/
 332 /*                                                                  */
 333 /* Name         - emit_memcpy                                       */
 334 /*                                                                  */
 335 /* Function     - Emit code to move from memory-to-memory based on  */
 336 /*                the size of the variable. r0 is overwritten.      */
 337 /*                                                                  */
 338 /*------------------------------------------------------------------*/
 339
 340 static guint32*
 341 emit_memcpy (guint8 *code, int size, int dreg, int doffset, int sreg, int soffset)
 342 {
 343         switch (size) {
 344                 case 4 :
 345                         s390_l  (code, s390_r0, 0, sreg, soffset);
 346                         s390_st (code, s390_r0, 0, dreg, doffset);
 347                         break;
 348
 349                 case 3 :
 350                         s390_icm  (code, s390_r0, 14, sreg, soffset);
 351                         s390_stcm (code, s390_r0, 14, dreg, doffset);
 352                         break;
 353
 354                 case 2 :
 355                         s390_lh  (code, s390_r0, 0, sreg, soffset);
 356                         s390_sth (code, s390_r0, 0, dreg, doffset);
 357                         break;
 358
 359                 case 1 :
 360                         s390_ic  (code, s390_r0, 0, sreg, soffset);
 361                         s390_stc (code, s390_r0, 0, dreg, doffset);
 362                         break;
 363
 364                 default :
 365                         while (size > 0) {
 366                                 int len;
 367
 368                                 if (size > 256)
 369                                         len = 256;
 370                                 else
 371                                         len = size;
 372                                 s390_mvc (code, len, dreg, doffset, sreg, soffset);
 373                                 size -= len;
 374                         }
 375         }
 376         return code;
 377 }
 378
 379 /*========================= End of Function ========================*/
 380
 381 /*------------------------------------------------------------------*/
 382 /*                                                                  */
 383 /* Name         - arch_get_argument_info                            */
 384 /*                                                                  */
 385 /* Function     - Gathers information on parameters such as size,   */
 386 /*                alignment, and padding. arg_info should be large  */
 387 /*                enough to hold param_count + 1 entries.           */
 388 /*                                                                  */
 389 /* Parameters   - @csig - Method signature                          */
 390 /*                @param_count - No. of parameters to consider      */
 391 /*                @arg_info - An array to store the result info     */
 392 /*                                                                  */
 393 /* Returns      - Size of the activation frame                      */
 394 /*                                                                  */
 395 /*------------------------------------------------------------------*/
 396
 397 int
 398 mono_arch_get_argument_info (MonoMethodSignature *csig,
 399                              int param_count,
 400                              MonoJitArgumentInfo *arg_info)
 401 {
 402         int k, frame_size = 0;
 403         int size, align, pad;
 404         int offset = 8;
 405
 406         if (MONO_TYPE_ISSTRUCT (csig->ret)) {
 407                 frame_size += sizeof (gpointer);
 408                 offset += 4;
 409         }
 410
 411         arg_info [0].offset = offset;
 412
 413         if (csig->hasthis) {
 414                 frame_size += sizeof (gpointer);
 415                 offset += 4;
 416         }
 417
 418         arg_info [0].size = frame_size;
 419
 420         for (k = 0; k < param_count; k++) {
 421
 422                 if (csig->pinvoke)
 423                         size = mono_type_native_stack_size (csig->params [k], &align);
 424                 else
 425                         size = mono_type_stack_size (csig->params [k], &align);
 426
 427                 frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 428                 arg_info [k].pad = pad;
 429                 frame_size += size;
 430                 arg_info [k + 1].pad = 0;
 431                 arg_info [k + 1].size = size;
 432                 offset += pad;
 433                 arg_info [k + 1].offset = offset;
 434                 offset += size;
 435         }
 436
 437         align = MONO_ARCH_FRAME_ALIGNMENT;
 438         frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 439         arg_info [k].pad = pad;
 440
 441         return frame_size;
 442 }
 443
 444 /*========================= End of Function ========================*/
 445
 446 /*------------------------------------------------------------------*/
 447 /*                                                                  */
 448 /* Name         - retFitsInReg.                                     */
 449 /*                                                                  */
 450 /* Function     - Determines if a value can be returned in one or   */
 451 /*                two registers.                                    */
 452 /*                                                                  */
 453 /*------------------------------------------------------------------*/
 454
 455 static inline gboolean
 456 retFitsInReg(guint32 size)
 457 {
 458         switch (size) {
 459                 case 0:
 460                 case 1:
 461                 case 2:
 462                 case 4:
 463                 case 8:
 464                         return (TRUE);
 465                 break;
 466                 default:
 467                         return (FALSE);
 468         }
 469 }
 470
 471 /*========================= End of Function ========================*/
 472
 473 /*------------------------------------------------------------------*/
 474 /*                                                                  */
 475 /* Name         - backStackPtr.                                     */
 476 /*                                                                  */
 477 /* Function     - Restore Stack Pointer to previous frame.          */
 478 /*                                                                  */
 479 /*------------------------------------------------------------------*/
 480
 481 static inline guint8 *
 482 backUpStackPtr(MonoCompile *cfg, guint8 *code)
 483 {
 484         int stackSize = cfg->stack_usage;
 485
 486         if (s390_is_uimm16 (cfg->stack_usage)) {
 487                 s390_ahi  (code, STK_BASE, cfg->stack_usage);
 488         } else {
 489                 while (stackSize > 32767) {
 490                         s390_ahi  (code, STK_BASE, 32767);
 491                         stackSize -= 32767;
 492                 }
 493                 s390_ahi  (code, STK_BASE, stackSize);
 494         }
 495         return (code);
 496 }
 497
 498 /*========================= End of Function ========================*/
 499
 500 /*------------------------------------------------------------------*/
 501 /*                                                                  */
 502 /* Name         - indent                                            */
 503 /*                                                                  */
 504 /* Function     - Perform nice indenting to current level           */
 505 /*                                                                  */
 506 /*------------------------------------------------------------------*/
 507
 508 static void
 509 indent (int diff) {
 510         int v;
 511         if (diff < 0)
 512                 indent_level += diff;
 513         v = indent_level;
 514         printf("[%3d] ",v);
 515         while (v-- > 0) {
 516                 printf (". ");
 517         }
 518         if (diff > 0)
 519                 indent_level += diff;
 520 }
 521
 522 /*========================= End of Function ========================*/
 523
 524 /*------------------------------------------------------------------*/
 525 /*                                                                  */
 526 /* Name         - decodeParm                                        */
 527 /*                                                                  */
 528 /* Function     - Decode a parameter for the trace.                 */
 529 /*                                                                  */
 530 /*------------------------------------------------------------------*/
 531
 532 static void
 533 decodeParm(MonoType *type, void *curParm, int size)
 534 {
 535         guint32 simpleType;
 536
 537         if (type->byref) {
 538                 printf("[BYREF:%p], ", *((char **) curParm));
 539         } else {
 540                 simpleType = mono_type_get_underlying_type(type)->type;
 541 enum_parmtype:
 542                 switch (simpleType) {
 543                         case MONO_TYPE_I :
 544                                 printf ("[INTPTR:%p], ", *((int **) curParm));
 545                                 break;
 546                         case MONO_TYPE_U :
 547                                 printf ("[UINTPTR:%p], ", *((int **) curParm));
 548                                 break;
 549                         case MONO_TYPE_BOOLEAN :
 550                                 printf ("[BOOL:%p], ", *((int *) curParm));
 551                                 break;
 552                         case MONO_TYPE_CHAR :
 553                                 printf ("[CHAR:%p], ", *((int *) curParm));
 554                                 break;
 555                         case MONO_TYPE_I1 :
 556                                 printf ("[INT1:%d], ", *((int *) curParm));
 557                                 break;
 558                         case MONO_TYPE_I2 :
 559                                 printf ("[INT2:%d], ", *((int *) curParm));
 560                                 break;
 561                         case MONO_TYPE_I4 :
 562                                 printf ("[INT4:%d], ", *((int *) curParm));
 563                                 break;
 564                         case MONO_TYPE_U1 :
 565                                 printf ("[UINT1:%u], ", *((unsigned int *) curParm));
 566                                 break;
 567                         case MONO_TYPE_U2 :
 568                                 printf ("[UINT2:%u], ", *((guint16 *) curParm));
 569                                 break;
 570                         case MONO_TYPE_U4 :
 571                                 printf ("[UINT4:%u], ", *((guint32 *) curParm));
 572                                 break;
 573                         case MONO_TYPE_U8 :
 574                                 printf ("[UINT8:%llu], ", *((guint64 *) curParm));
 575                                 break;
 576                         case MONO_TYPE_STRING : {
 577                                 MonoString *s = *((MonoString **) curParm);
 578                                 if (s) {
 579                                         g_assert (((MonoObject *) s)->vtable->klass == mono_defaults.string_class);
 580                                         printf("[STRING:%p:%s], ", s, mono_string_to_utf8(s));
 581                                 } else {
 582                                         printf("[STRING:null], ");
 583                                 }
 584                                 break;
 585                         }
 586                         case MONO_TYPE_CLASS :
 587                         case MONO_TYPE_OBJECT : {
 588                                 MonoObject *obj = *((MonoObject **) curParm);
 589                                 MonoClass *class;
 590                                 if ((obj) && (obj->vtable)) {
 591                                         printf("[CLASS/OBJ:");
 592                                         class = obj->vtable->klass;
 593                                         printf("%p [%p] ",obj,curParm);
 594 //                                      if (class == mono_defaults.string_class) {
 595 //                                              printf("[STRING:%p:%s]",
 596 //                                                     *obj, mono_string_to_utf8 (obj));
 597 //                                      } else if (class == mono_defaults.int32_class) {
 598 //                                              printf("[INT32:%p:%d]",
 599 //                                                      obj, *(gint32 *)((char *)obj + sizeof (MonoObject)));
 600 //                                      } else
 601 //                                              printf("[%s.%s:%p]",
 602 //                                                     class->name_space, class->name, obj);
 603                                         printf("], ");
 604                                 } else {
 605                                         printf("[OBJECT:null], ");
 606                                 }
 607                                 break;
 608                         }
 609                         case MONO_TYPE_PTR :
 610                                 printf("[PTR:%p], ", *((gpointer **) (curParm)));
 611                                 break;
 612                         case MONO_TYPE_FNPTR :
 613                                 printf("[FNPTR:%p], ", *((gpointer **) (curParm)));
 614                                 break;
 615                         case MONO_TYPE_ARRAY :
 616                                 printf("[ARRAY:%p], ", *((gpointer **) (curParm)));
 617                                 break;
 618                         case MONO_TYPE_SZARRAY :
 619                                 printf("[SZARRAY:%p], ", *((gpointer **) (curParm)));
 620                                 break;
 621                         case MONO_TYPE_I8 :
 622                                 printf("[INT8:%lld], ", *((gint64 *) (curParm)));
 623                                 break;
 624                         case MONO_TYPE_R4 :
 625                                 printf("[FLOAT4:%g], ", *((double *) (curParm)));
 626                                 break;
 627                         case MONO_TYPE_R8 :
 628                                 printf("[FLOAT8:%g], ", *((double *) (curParm)));
 629                                 break;
 630                         case MONO_TYPE_VALUETYPE : {
 631                                 int i;
 632                                 MonoMarshalType *info;
 633
 634                                 if (type->data.klass->enumtype) {
 635                                         simpleType = type->data.klass->enum_basetype->type;
 636                                         printf("{VALUETYPE} - ");
 637                                         goto enum_parmtype;
 638                                 }
 639
 640                                 info = mono_marshal_load_type_info (type->data.klass);
 641
 642                                 if ((info->native_size == sizeof(float)) &&
 643                                     (info->num_fields  == 1) &&
 644                                     (info->fields[0].field->type->type == MONO_TYPE_R4)) {
 645                                                 printf("[FLOAT4:%f], ", *((float *) (curParm)));
 646                                         break;
 647                                 }
 648
 649                                 if ((info->native_size == sizeof(double)) &&
 650                                     (info->num_fields  == 1) &&
 651                                     (info->fields[0].field->type->type == MONO_TYPE_R8)) {
 652                                         printf("[FLOAT8:%g], ", *((double *) (curParm)));
 653                                         break;
 654                                 }
 655
 656                                 printf("[VALUETYPE:");
 657                                 for (i = 0; i < size; i++)
 658                                         printf("%02x,", *((guint8 *)curParm+i));
 659                                 printf("]");
 660                                 break;
 661                         }
 662                         case MONO_TYPE_TYPEDBYREF: {
 663                                 int i;
 664                                 printf("[TYPEDBYREF:");
 665                                 for (i = 0; i < size; i++)
 666                                         printf("%02x,", *((guint8 *)curParm+i));
 667                                 printf("]");
 668                                 break;
 669                         }
 670                         default :
 671                                 printf("[?? - %d], ",simpleType);
 672                 }
 673         }
 674 }
 675
 676 /*========================= End of Function ========================*/
 677
 678 static int lc = 0;
 679 /*------------------------------------------------------------------*/
 680 /*                                                                  */
 681 /* Name         - enter_method                                      */
 682 /*                                                                  */
 683 /* Function     - Perform tracing of the entry to the current       */
 684 /*                method.                                           */
 685 /*                                                                  */
 686 /*------------------------------------------------------------------*/
 687
 688 static void
 689 enter_method (MonoMethod *method, RegParm *rParm, char *sp)
 690 {
 691         int i, oParm = 0, iParm = 0;
 692         MonoClass *class;
 693         MonoObject *obj;
 694         MonoMethodSignature *sig;
 695         char *fname;
 696         guint32 ip;
 697         CallInfo *cinfo;
 698         ArgInfo *ainfo;
 699         size_data sz;
 700         void *curParm;
 701
 702
 703 lc++;
 704 if (lc > 50000) {
 705 fseek(stdout, 0L, SEEK_SET);
 706 lc = 0;
 707 }
 708         fname = mono_method_full_name (method, TRUE);
 709         indent (1);
 710         printf ("ENTER: %s(", fname);
 711         g_free (fname);
 712
 713         ip  = (*(guint32 *) (sp+S390_RET_ADDR_OFFSET)) & 0x7fffffff;
 714         printf (") ip: %p sp: %p - ", ip, sp);
 715
 716         if (rParm == NULL)
 717                 return;
 718
 719         sig = mono_method_signature (method);
 720
 721         cinfo = calculate_sizes (sig, &sz, sig->pinvoke);
 722
 723         if (cinfo->struct_ret) {
 724                 printf ("[VALUERET:%p], ", rParm->gr[0]);
 725                 iParm = 1;
 726         }
 727
 728         if (sig->hasthis) {
 729                 gpointer *this = (gpointer *) rParm->gr[iParm];
 730                 obj = (MonoObject *) this;
 731                 if (method->klass->valuetype) {
 732                         if (obj) {
 733                                 printf("this:[value:%p:%08x], ",
 734                                        this, *((guint32 *)(this+sizeof(MonoObject))));
 735                         } else
 736                                 printf ("this:[NULL], ");
 737                 } else {
 738                         if (obj) {
 739 //                              class = obj->vtable->klass;
 740 //                              if (class == mono_defaults.string_class) {
 741 //                                      printf ("this:[STRING:%p:%s], ",
 742 //                                              obj, mono_string_to_utf8 ((MonoString *)obj));
 743 //                              } else {
 744 //                                      printf ("this:%p[%s.%s], ",
 745 //                                              obj, class->name_space, class->name);
 746 //                              }
 747 printf("this:%p, ",obj);
 748                         } else
 749                                 printf ("this:NULL, ");
 750                 }
 751                 oParm++;
 752         }
 753
 754         for (i = 0; i < sig->param_count; ++i) {
 755                 ainfo = &cinfo->args[i + oParm];
 756                 switch (ainfo->regtype) {
 757                         case RegTypeGeneral :
 758                                 decodeParm(sig->params[i], &(rParm->gr[ainfo->reg-2]), ainfo->size);
 759                                 break;
 760                         case RegTypeFP :
 761                                 decodeParm(sig->params[i], &(rParm->fp[ainfo->reg]), ainfo->size);
 762                                 break;
 763                         case RegTypeBase :
 764                                 decodeParm(sig->params[i], sp+ainfo->offset, ainfo->size);
 765                                 break;
 766                         case RegTypeStructByVal :
 767                                 if (ainfo->reg != STK_BASE)
 768                                         curParm = &(rParm->gr[ainfo->reg-2]);
 769                                 else
 770                                         curParm = sp+ainfo->offset;
 771
 772                                 if (retFitsInReg (ainfo->vtsize))
 773                                         decodeParm(sig->params[i],
 774                                                    curParm,
 775                                                    ainfo->size);
 776                                 else
 777                                         decodeParm(sig->params[i],
 778                                                    *((char **) curParm),
 779                                                    ainfo->vtsize);
 780                                 break;
 781                         case RegTypeStructByAddr :
 782                                 if (ainfo->reg != STK_BASE)
 783                                         curParm = &(rParm->gr[ainfo->reg-2]);
 784                                 else
 785                                         curParm = sp+ainfo->offset;
 786
 787                                 decodeParm(sig->params[i],
 788                                            *((char **) curParm),
 789                                            ainfo->vtsize);
 790                                 break;
 791
 792                         default :
 793                                 printf("???, ");
 794                 }
 795         }
 796         printf("\n");
 797         g_free(cinfo);
 798 }
 799
 800 /*========================= End of Function ========================*/
 801
 802 /*------------------------------------------------------------------*/
 803 /*                                                                  */
 804 /* Name         - leave_method                                      */
 805 /*                                                                  */
 806 /* Function     -                                                   */
 807 /*                                                                  */
 808 /*------------------------------------------------------------------*/
 809
 810 static void
 811 leave_method (MonoMethod *method, ...)
 812 {
 813         MonoType *type;
 814         char *fname;
 815         guint32 ip;
 816         va_list ap;
 817
 818         va_start(ap, method);
 819
 820         fname = mono_method_full_name (method, TRUE);
 821         indent (-1);
 822         printf ("LEAVE: %s", fname);
 823         g_free (fname);
 824
 825         type = mono_method_signature (method)->ret;
 826
 827 handle_enum:
 828         switch (type->type) {
 829         case MONO_TYPE_VOID:
 830                 break;
 831         case MONO_TYPE_BOOLEAN: {
 832                 int val = va_arg (ap, int);
 833                 if (val)
 834                         printf ("[TRUE:%d]", val);
 835                 else
 836                         printf ("[FALSE]");
 837
 838                 break;
 839         }
 840         case MONO_TYPE_CHAR: {
 841                 int val = va_arg (ap, int);
 842                 printf ("[CHAR:%d]", val);
 843                 break;
 844         }
 845         case MONO_TYPE_I1: {
 846                 int val = va_arg (ap, int);
 847                 printf ("[INT1:%d]", val);
 848                 break;
 849         }
 850         case MONO_TYPE_U1: {
 851                 int val = va_arg (ap, int);
 852                 printf ("[UINT1:%d]", val);
 853                 break;
 854         }
 855         case MONO_TYPE_I2: {
 856                 int val = va_arg (ap, int);
 857                 printf ("[INT2:%d]", val);
 858                 break;
 859         }
 860         case MONO_TYPE_U2: {
 861                 int val = va_arg (ap, int);
 862                 printf ("[UINT2:%d]", val);
 863                 break;
 864         }
 865         case MONO_TYPE_I4: {
 866                 int val = va_arg (ap, int);
 867                 printf ("[INT4:%d]", val);
 868                 break;
 869         }
 870         case MONO_TYPE_U4: {
 871                 int val = va_arg (ap, int);
 872                 printf ("[UINT4:%d]", val);
 873                 break;
 874         }
 875         case MONO_TYPE_I: {
 876                 int *val = va_arg (ap, int*);
 877                 printf ("[INT:%d]", val);
 878                 printf("]");
 879                 break;
 880         }
 881         case MONO_TYPE_U: {
 882                 int *val = va_arg (ap, int*);
 883                 printf ("[UINT:%d]", val);
 884                 printf("]");
 885                 break;
 886         }
 887         case MONO_TYPE_STRING: {
 888                 MonoString *s = va_arg (ap, MonoString *);
 889 ;
 890                 if (s) {
 891                         g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class);
 892                         printf ("[STRING:%p:%s]", s, mono_string_to_utf8 (s));
 893                 } else
 894                         printf ("[STRING:null], ");
 895                 break;
 896         }
 897         case MONO_TYPE_CLASS:
 898         case MONO_TYPE_OBJECT: {
 899                 MonoObject *o = va_arg (ap, MonoObject *);
 900
 901 //              if ((o) && (o->vtable)) {
 902 //                      if (o->vtable->klass == mono_defaults.boolean_class) {
 903 //                              printf ("[BOOLEAN:%p:%d]", o, *((guint8 *)o + sizeof (MonoObject)));
 904 //                      } else if  (o->vtable->klass == mono_defaults.int32_class) {
 905 //                              printf ("[INT32:%p:%d]", o, *((gint32 *)((char *)o + sizeof (MonoObject))));
 906 //                      } else if  (o->vtable->klass == mono_defaults.int64_class) {
 907 //                              printf ("[INT64:%p:%lld]", o, *((gint64 *)((char *)o + sizeof (MonoObject))));
 908 //                      } else
 909 //                              printf ("[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o);
 910 //              } else
 911                         printf ("[OBJECT:%p]", o);
 912
 913                 break;
 914         }
 915         case MONO_TYPE_PTR:
 916         case MONO_TYPE_FNPTR:
 917         case MONO_TYPE_ARRAY:
 918         case MONO_TYPE_SZARRAY: {
 919                 gpointer p = va_arg (ap, gpointer);
 920                 printf ("[result=%p]", p);
 921                 break;
 922         }
 923         case MONO_TYPE_I8: {
 924                 gint64 l =  va_arg (ap, gint64);
 925                 printf ("[LONG:%lld]", l);
 926                 break;
 927         }
 928         case MONO_TYPE_U8: {
 929                 guint64 l =  va_arg (ap, guint64);
 930                 printf ("[ULONG:%llu]", l);
 931                 break;
 932         }
 933         case MONO_TYPE_R4: {
 934                 float f;
 935                 f = va_arg (ap, double);
 936                 printf ("[FLOAT4:%f]\n", f);
 937                 break;
 938         }
 939         case MONO_TYPE_R8: {
 940                 double f = va_arg (ap, double);
 941                 printf ("[FLOAT8:%g]\n", f);
 942                 break;
 943         }
 944         case MONO_TYPE_VALUETYPE: {
 945                 MonoMarshalType *info;
 946                 if (type->data.klass->enumtype) {
 947                         type = type->data.klass->enum_basetype;
 948                         goto handle_enum;
 949                 } else {
 950                         guint8 *p = va_arg (ap, gpointer);
 951                         int j, size, align;
 952
 953                         info = mono_marshal_load_type_info (type->data.klass);
 954
 955                         if ((info->native_size == sizeof(float)) &&
 956                             (info->num_fields  == 1) &&
 957                             (info->fields[0].field->type->type == MONO_TYPE_R4)) {
 958                                 double f = va_arg (ap, double);
 959                                 printf("[FLOAT4:%g]\n", (double) f);
 960                                 break;
 961                         }
 962
 963                         if ((info->native_size == sizeof(double)) &&
 964                             (info->num_fields  == 1) &&
 965                             (info->fields[0].field->type->type == MONO_TYPE_R8)) {
 966                                 double f = va_arg (ap, double);
 967                                 printf("[FLOAT8:%g]\n", f);
 968                                 break;
 969                         }
 970
 971                         size = mono_type_size (type, &align);
 972                         printf ("[");
 973                         for (j = 0; p && j < size; j++)
 974                                 printf ("%02x,", p [j]);
 975                         printf ("]");
 976                 }
 977                 break;
 978         }
 979         case MONO_TYPE_TYPEDBYREF: {
 980                 guint8 *p = va_arg (ap, gpointer);
 981                 int j, size, align;
 982                 size = mono_type_size (type, &align);
 983                 printf ("[");
 984                 for (j = 0; p && j < size; j++)
 985                         printf ("%02x,", p [j]);
 986                 printf ("]");
 987         }
 988                 break;
 989         default:
 990                 printf ("(unknown return type %x)",
 991                         mono_method_signature (method)->ret->type);
 992         }
 993
 994         ip = ((gint32) __builtin_return_address (0)) & 0x7fffffff;
 995         printf (" ip: %p\n", ip);
 996 }
 997
 998 /*========================= End of Function ========================*/
 999
1000 /*------------------------------------------------------------------*/
1001 /*                                                                  */
1002 /* Name         - mono_arch_cpu_init                                */
1003 /*                                                                  */
1004 /* Function     - Perform CPU specific initialization to execute    */
1005 /*                managed code.                                     */
1006 /*                                                                  */
1007 /*------------------------------------------------------------------*/
1008
1009 void
1010 mono_arch_cpu_init (void)
1011 {
1012         guint mode = 1;
1013
1014         /*--------------------------------------*/
1015         /* Set default rounding mode for FP     */
1016         /*--------------------------------------*/
1017         __asm__ ("SRNM\t%0\n\t"
1018                 : : "m" (mode));
1019 }
1020
1021 /*========================= End of Function ========================*/
1022
1023 /*------------------------------------------------------------------*/
1024 /*                                                                  */
1025 /* Name         - mono_arch_cpu_optimizazions                       */
1026 /*                                                                  */
1027 /* Function     - Returns the optimizations supported on this CPU   */
1028 /*                                                                  */
1029 /*------------------------------------------------------------------*/
1030
1031 guint32
1032 mono_arch_cpu_optimizazions (guint32 *exclude_mask)
1033 {
1034         guint32 opts = 0;
1035
1036         /*----------------------------------------------------------*/
1037         /* no s390-specific optimizations yet                       */
1038         /*----------------------------------------------------------*/
1039         *exclude_mask = MONO_OPT_INLINE|MONO_OPT_LINEARS;
1040 //      *exclude_mask = MONO_OPT_INLINE;
1041         return opts;
1042 }
1043
1044 /*========================= End of Function ========================*/
1045
1046 /*------------------------------------------------------------------*/
1047 /*                                                                  */
1048 /* Name         -                                                   */
1049 /*                                                                  */
1050 /* Function     -                                                   */
1051 /*                                                                  */
1052 /*------------------------------------------------------------------*/
1053
1054 static gboolean
1055 is_regsize_var (MonoType *t) {
1056         if (t->byref)
1057                 return TRUE;
1058         switch (mono_type_get_underlying_type (t)->type) {
1059         case MONO_TYPE_I4:
1060         case MONO_TYPE_U4:
1061         case MONO_TYPE_I:
1062         case MONO_TYPE_U:
1063                 return TRUE;
1064         case MONO_TYPE_OBJECT:
1065         case MONO_TYPE_STRING:
1066         case MONO_TYPE_CLASS:
1067         case MONO_TYPE_SZARRAY:
1068         case MONO_TYPE_ARRAY:
1069                 return FALSE;
1070         case MONO_TYPE_VALUETYPE:
1071                 if (t->data.klass->enumtype)
1072                         return is_regsize_var (t->data.klass->enum_basetype);
1073                 return FALSE;
1074         }
1075         return FALSE;
1076 }
1077
1078 /*========================= End of Function ========================*/
1079
1080 /*------------------------------------------------------------------*/
1081 /*                                                                  */
1082 /* Name         - mono_arch_get_allocatable_int_vars                */
1083 /*                                                                  */
1084 /* Function     -                                                   */
1085 /*                                                                  */
1086 /*------------------------------------------------------------------*/
1087
1088 GList *
1089 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
1090 {
1091         GList *vars = NULL;
1092         int i;
1093
1094         for (i = 0; i < cfg->num_varinfo; i++) {
1095                 MonoInst *ins = cfg->varinfo [i];
1096                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
1097
1098                 /* unused vars */
1099                 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
1100                         continue;
1101
1102                 if (ins->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) ||
1103                     (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
1104                         continue;
1105
1106                 /* we can only allocate 32 bit values */
1107                 if (is_regsize_var (ins->inst_vtype)) {
1108                         g_assert (MONO_VARINFO (cfg, i)->reg == -1);
1109                         g_assert (i == vmv->idx);
1110                         vars = mono_varlist_insert_sorted (cfg, vars, vmv, FALSE);
1111                 }
1112         }
1113
1114         return vars;
1115 }
1116
1117 /*========================= End of Function ========================*/
1118
1119 /*------------------------------------------------------------------*/
1120 /*                                                                  */
1121 /* Name         - mono_arch_global_int_regs                         */
1122 /*                                                                  */
1123 /* Function     - Return a list of usable integer registers.        */
1124 /*                                                                  */
1125 /*------------------------------------------------------------------*/
1126
1127 GList *
1128 mono_arch_get_global_int_regs (MonoCompile *cfg)
1129 {
1130         GList *regs = NULL;
1131         MonoMethodHeader *header;
1132         int i, top = 13;
1133
1134         header = mono_method_get_header (cfg->method);
1135         if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
1136                 cfg->frame_reg = s390_r11;
1137
1138         for (i = 8; i < top; ++i) {
1139                 if (cfg->frame_reg != i)
1140                         regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
1141         }
1142
1143         return regs;
1144 }
1145
1146 /*========================= End of Function ========================*/
1147
1148 /*------------------------------------------------------------------*/
1149 /*                                                                  */
1150 /* Name         -  mono_arch_flush_icache                           */
1151 /*                                                                  */
1152 /* Function     -  Flush the CPU icache.                            */
1153 /*                                                                  */
1154 /*------------------------------------------------------------------*/
1155
1156 void
1157 mono_arch_flush_icache (guint8 *code, gint size)
1158 {
1159 }
1160
1161 /*========================= End of Function ========================*/
1162
1163 /*------------------------------------------------------------------*/
1164 /*                                                                  */
1165 /* Name         - add_general                                       */
1166 /*                                                                  */
1167 /* Function     - Determine code and stack size incremements for a  */
1168 /*                parameter.                                        */
1169 /*                                                                  */
1170 /*------------------------------------------------------------------*/
1171
1172 static void inline
1173 add_general (guint *gr, size_data *sz, ArgInfo *ainfo, gboolean simple)
1174 {
1175         if (simple) {
1176                 if (*gr > S390_LAST_ARG_REG) {
1177                         sz->stack_size  = S390_ALIGN(sz->stack_size, sizeof(long));
1178                         ainfo->offset   = sz->stack_size;
1179                         ainfo->reg      = STK_BASE;
1180                         ainfo->regtype  = RegTypeBase;
1181                         sz->stack_size += sizeof(int);
1182                         sz->local_size += sizeof(int);
1183                         sz->code_size  += 12;
1184                 } else {
1185                         ainfo->reg      = *gr;
1186                         sz->code_size  += 8;
1187                 }
1188         } else {
1189                 if (*gr > S390_LAST_ARG_REG - 1) {
1190                         sz->stack_size  = S390_ALIGN(sz->stack_size, S390_STACK_ALIGNMENT);
1191                         ainfo->offset   = sz->stack_size;
1192                         ainfo->reg      = STK_BASE;
1193                         ainfo->regtype  = RegTypeBase;
1194                         sz->stack_size += sizeof(long long);
1195                         sz->local_size += sizeof(long long);
1196                         sz->code_size  += 10;
1197                 } else {
1198                         ainfo->reg      = *gr;
1199                         sz->code_size  += 8;
1200                 }
1201                 (*gr) ++;
1202         }
1203         (*gr) ++;
1204 }
1205
1206 /*========================= End of Function ========================*/
1207
1208 /*------------------------------------------------------------------*/
1209 /*                                                                  */
1210 /* Name         - add_stackParm                                     */
1211 /*                                                                  */
1212 /* Function     - Determine code and stack size incremements for a  */
1213 /*                parameter.                                        */
1214 /*                                                                  */
1215 /*------------------------------------------------------------------*/
1216
1217 static void inline
1218 add_stackParm (guint *gr, size_data *sz, ArgInfo *ainfo, gint size)
1219 {
1220         if (*gr > S390_LAST_ARG_REG) {
1221                 sz->stack_size  = S390_ALIGN(sz->stack_size, sizeof(long));
1222                 ainfo->offset   = sz->stack_size;
1223                 ainfo->reg      = STK_BASE;
1224 //              sz->parm_size  += sizeof(gpointer);
1225         } else {
1226                 ainfo->reg      = *gr;
1227 //              sz->parm_size  += size;
1228         }
1229         (*gr) ++;
1230         ainfo->offparm  = sz->parm_size;
1231         ainfo->size     = sizeof(gpointer);
1232         ainfo->regtype  = RegTypeStructByAddr;
1233         ainfo->vtsize   = size;
1234         sz->local_size += (size + sizeof(gpointer));
1235         sz->parm_size  += size;
1236 }
1237
1238 /*========================= End of Function ========================*/
1239
1240 /*------------------------------------------------------------------*/
1241 /*                                                                  */
1242 /* Name         - add_float                                         */
1243 /*                                                                  */
1244 /* Function     - Determine code and stack size incremements for a  */
1245 /*                float parameter.                                  */
1246 /*                                                                  */
1247 /*------------------------------------------------------------------*/
1248
1249 static void inline
1250 add_float (guint *fr,  size_data *sz, ArgInfo *ainfo)
1251 {
1252         if ((*fr) <= S390_LAST_FPARG_REG) {
1253                 ainfo->regtype = RegTypeFP;
1254                 ainfo->reg     = *fr;
1255                 sz->code_size += 4;
1256                 (*fr) += 2;
1257         }
1258         else {
1259                 ainfo->offset   = sz->stack_size;
1260                 ainfo->reg      = STK_BASE;
1261                 ainfo->regtype  = RegTypeBase;
1262                 sz->code_size  += 4;
1263                 sz->stack_size += ainfo->size;
1264                 sz->local_size += ainfo->size;
1265         }
1266 }
1267
1268 /*========================= End of Function ========================*/
1269
1270 /*------------------------------------------------------------------*/
1271 /*                                                                  */
1272 /* Name         - calculate_sizes                                   */
1273 /*                                                                  */
1274 /* Function     - Determine the amount of space required for code   */
1275 /*                and stack. In addition determine starting points  */
1276 /*                for stack-based parameters, and area for struct-  */
1277 /*                ures being returned on the stack.                 */
1278 /*                                                                  */
1279 /*------------------------------------------------------------------*/
1280
1281 static CallInfo *
1282 calculate_sizes (MonoMethodSignature *sig, size_data *sz,
1283                  gboolean string_ctor)
1284 {
1285         guint i, fr, gr, size;
1286         int nParm = sig->hasthis + sig->param_count;
1287         guint32 simpletype, align;
1288         CallInfo *cinfo = g_malloc0 (sizeof (CallInfo) + sizeof (ArgInfo) * nParm);
1289
1290         fr                = 0;
1291         gr                = s390_r2;
1292         nParm             = 0;
1293         cinfo->struct_ret = 0;
1294         cinfo->offStruct  = 0;
1295         sz->retStruct     = 0;
1296         sz->stack_size    = S390_MINIMAL_STACK_SIZE;
1297         sz->code_size     = 0;
1298         sz->parm_size     = 0;
1299         sz->local_size    = 0;
1300
1301         /*----------------------------------------------------------*/
1302         /* We determine the size of the return code/stack in case we*/
1303         /* need to reserve a register to be used to address a stack */
1304         /* area that the callee will use.                           */
1305         /*----------------------------------------------------------*/
1306
1307         simpletype = mono_type_get_underlying_type (sig->ret)->type;
1308 enum_retvalue:
1309         switch (simpletype) {
1310                 case MONO_TYPE_BOOLEAN:
1311                 case MONO_TYPE_I1:
1312                 case MONO_TYPE_U1:
1313                 case MONO_TYPE_I2:
1314                 case MONO_TYPE_U2:
1315                 case MONO_TYPE_CHAR:
1316                 case MONO_TYPE_I4:
1317                 case MONO_TYPE_U4:
1318                 case MONO_TYPE_I:
1319                 case MONO_TYPE_U:
1320                 case MONO_TYPE_CLASS:
1321                 case MONO_TYPE_OBJECT:
1322                 case MONO_TYPE_SZARRAY:
1323                 case MONO_TYPE_ARRAY:
1324                 case MONO_TYPE_PTR:
1325                 case MONO_TYPE_FNPTR:
1326                 case MONO_TYPE_STRING:
1327                         cinfo->ret.reg = s390_r2;
1328                         sz->code_size += 4;
1329                         break;
1330                 case MONO_TYPE_R4:
1331                 case MONO_TYPE_R8:
1332                         cinfo->ret.reg = s390_f0;
1333                         sz->code_size += 4;
1334                         break;
1335                 case MONO_TYPE_I8:
1336                 case MONO_TYPE_U8:
1337                         cinfo->ret.reg = s390_r2;
1338                         sz->code_size += 4;
1339                         break;
1340                 case MONO_TYPE_VALUETYPE: {
1341                         MonoClass *klass = mono_class_from_mono_type (sig->ret);
1342                         if (sig->ret->data.klass->enumtype) {
1343                                 simpletype = sig->ret->data.klass->enum_basetype->type;
1344                                 goto enum_retvalue;
1345                         }
1346                         if (sig->pinvoke)
1347                                 size = mono_class_native_size (klass, &align);
1348                         else
1349                                 size = mono_class_value_size (klass, &align);
1350
1351                         cinfo->ret.reg    = s390_r2;
1352                         cinfo->struct_ret = 1;
1353                         cinfo->ret.size   = size;
1354                         cinfo->ret.vtsize = size;
1355                         gr++;
1356                         break;
1357                 }
1358                 case MONO_TYPE_TYPEDBYREF:
1359                         size = sizeof (MonoTypedRef);
1360                         cinfo->ret.reg    = s390_r2;
1361                         cinfo->struct_ret = 1;
1362                         cinfo->ret.size   = size;
1363                         cinfo->ret.vtsize = size;
1364                         gr++;
1365                         break;
1366                 case MONO_TYPE_VOID:
1367                         break;
1368                 default:
1369                         g_error ("Can't handle as return value 0x%x", sig->ret->type);
1370         }
1371
1372         if (sig->hasthis) {
1373                 add_general (&gr, sz, cinfo->args+nParm, TRUE);
1374                 cinfo->args[nParm].size = sizeof(gpointer);
1375                 nParm++;
1376         }
1377
1378         /*----------------------------------------------------------*/
1379         /* We determine the size of the parameter code and stack    */
1380         /* requirements by checking the types and sizes of the      */
1381         /* parameters.                                              */
1382         /*----------------------------------------------------------*/
1383
1384         for (i = 0; i < sig->param_count; ++i) {
1385                 /*--------------------------------------------------*/
1386                 /* Handle vararg type calls. All args are put on    */
1387                 /* the stack.                                       */
1388                 /*--------------------------------------------------*/
1389                 if ((sig->call_convention == MONO_CALL_VARARG) &&
1390                     (i == sig->sentinelpos)) {
1391                         gr = S390_LAST_ARG_REG + 1;
1392                         add_general (&gr, sz, &cinfo->sigCookie, TRUE);
1393                 }
1394
1395                 if (sig->params [i]->byref) {
1396                         add_general (&gr, sz, cinfo->args+nParm, TRUE);
1397                         cinfo->args[nParm].size = sizeof(gpointer);
1398                         nParm++;
1399                         continue;
1400                 }
1401
1402                 simpletype = mono_type_get_underlying_type(sig->params [i])->type;
1403                 switch (simpletype) {
1404                 case MONO_TYPE_BOOLEAN:
1405                 case MONO_TYPE_I1:
1406                 case MONO_TYPE_U1:
1407                         cinfo->args[nParm].size = sizeof(char);
1408                         add_general (&gr, sz, cinfo->args+nParm, TRUE);
1409                         nParm++;
1410                         break;
1411                 case MONO_TYPE_I2:
1412                 case MONO_TYPE_U2:
1413                 case MONO_TYPE_CHAR:
1414                         cinfo->args[nParm].size = sizeof(short);
1415                         add_general (&gr, sz, cinfo->args+nParm, TRUE);
1416                         nParm++;
1417                         break;
1418                 case MONO_TYPE_I4:
1419                 case MONO_TYPE_U4:
1420                         cinfo->args[nParm].size = sizeof(int);
1421                         add_general (&gr, sz, cinfo->args+nParm, TRUE);
1422                         nParm++;
1423                         break;
1424                 case MONO_TYPE_I:
1425                 case MONO_TYPE_U:
1426                 case MONO_TYPE_PTR:
1427                 case MONO_TYPE_FNPTR:
1428                 case MONO_TYPE_CLASS:
1429                 case MONO_TYPE_OBJECT:
1430                 case MONO_TYPE_STRING:
1431                 case MONO_TYPE_SZARRAY:
1432                 case MONO_TYPE_ARRAY:
1433                         cinfo->args[nParm].size = sizeof(gpointer);
1434                         add_general (&gr, sz, cinfo->args+nParm, TRUE);
1435                         nParm++;
1436                         break;
1437                 case MONO_TYPE_I8:
1438                 case MONO_TYPE_U8:
1439                         cinfo->args[nParm].size = sizeof(long long);
1440                         add_general (&gr, sz, cinfo->args+nParm, FALSE);
1441                         nParm++;
1442                         break;
1443                 case MONO_TYPE_R4:
1444                         cinfo->args[nParm].size = sizeof(float);
1445                         add_float (&fr, sz, cinfo->args+nParm);
1446                         nParm++;
1447                         break;
1448                 case MONO_TYPE_R8:
1449                         cinfo->args[nParm].size = sizeof(double);
1450                         add_float (&fr, sz, cinfo->args+nParm);
1451                         nParm++;
1452                         break;
1453                 case MONO_TYPE_VALUETYPE: {
1454                         MonoMarshalType *info;
1455                         MonoClass *klass = mono_class_from_mono_type (sig->params [i]);
1456                         if (sig->pinvoke)
1457                                 size = mono_class_native_size (klass, &align);
1458                         else
1459                                 size = mono_class_value_size (klass, &align);
1460
1461                         info = mono_marshal_load_type_info (klass);
1462
1463                         if ((info->native_size == sizeof(float)) &&
1464                             (info->num_fields  == 1) &&
1465                             (info->fields[0].field->type->type == MONO_TYPE_R4)) {
1466                                 cinfo->args[nParm].size = sizeof(float);
1467                                 add_float(&fr, sz, cinfo->args+nParm);
1468                                 break;
1469                         }
1470
1471                         if ((info->native_size == sizeof(double)) &&
1472                             (info->num_fields  == 1) &&
1473                             (info->fields[0].field->type->type == MONO_TYPE_R8)) {
1474                                 cinfo->args[nParm].size = sizeof(double);
1475                                 add_float(&fr, sz, cinfo->args+nParm);
1476                                 break;
1477                         }
1478
1479                         cinfo->args[nParm].vtsize  = 0;
1480                         cinfo->args[nParm].size    = 0;
1481
1482                         switch (size) {
1483                                 /*----------------------------------*/
1484                                 /* On S/390, structures of size 1,  */
1485                                 /* 2, 4, and 8 bytes are passed in  */
1486                                 /* (a) register(s).                 */
1487                                 /*----------------------------------*/
1488                                 case 0:
1489                                 case 1:
1490                                 case 2:
1491                                 case 4:
1492                                         add_general(&gr, sz, cinfo->args+nParm, TRUE);
1493                                         cinfo->args[nParm].size    = size;
1494                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1495                                         nParm++;
1496                                         sz->local_size            += sizeof(long);
1497                                         break;
1498                                 case 8:
1499                                         add_general(&gr, sz, cinfo->args+nParm, FALSE);
1500                                         cinfo->args[nParm].size    = sizeof(long long);
1501                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1502                                         nParm++;
1503                                         sz->local_size            += sizeof(long);
1504                                         break;
1505                                 default:
1506                                         add_stackParm(&gr, sz, cinfo->args+nParm, size);
1507                                         nParm++;
1508                         }
1509                 }
1510                         break;
1511                 case MONO_TYPE_TYPEDBYREF: {
1512                         int size = sizeof (MonoTypedRef);
1513
1514                         cinfo->args[nParm].vtsize  = 0;
1515                         cinfo->args[nParm].size    = 0;
1516
1517                         switch (size) {
1518                                 /*----------------------------------*/
1519                                 /* On S/390, structures of size 1,  */
1520                                 /* 2, 4, and 8 bytes are passed in  */
1521                                 /* (a) register(s).                 */
1522                                 /*----------------------------------*/
1523                                 case 0:
1524                                 case 1:
1525                                 case 2:
1526                                 case 4:
1527                                         add_general(&gr, sz, cinfo->args+nParm, TRUE);
1528                                         cinfo->args[nParm].size    = size;
1529                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1530                                         nParm++;
1531                                         sz->local_size            += sizeof(long);
1532                                         break;
1533                                 case 8:
1534                                         add_general(&gr, sz, cinfo->args+nParm, FALSE);
1535                                         cinfo->args[nParm].size    = sizeof(long long);
1536                                         cinfo->args[nParm].regtype = RegTypeStructByVal;
1537                                         nParm++;
1538                                         sz->local_size            += sizeof(long);
1539                                         break;
1540                                 default:
1541                                         add_stackParm(&gr, sz, cinfo->args+nParm, size);
1542                                         nParm++;
1543                         }
1544                 }
1545                         break;
1546                 default:
1547                         g_error ("Can't trampoline 0x%x", sig->params [i]->type);
1548                 }
1549         }
1550
1551         /*----------------------------------------------------------*/
1552         /* If we are passing a structure back then if it won't be   */
1553         /* in a register(s) then we make room at the end of the     */
1554         /* parameters that may have been placed on the stack        */
1555         /*----------------------------------------------------------*/
1556         if (cinfo->struct_ret) {
1557                 cinfo->ret.offset = sz->stack_size;
1558                 switch (cinfo->ret.size) {
1559                 case 0:
1560                 case 1:
1561                 case 2:
1562                 case 4:
1563                 case 8:
1564                         break;
1565                 default:
1566                         sz->stack_size   += S390_ALIGN(cinfo->ret.size, align);
1567                 }
1568         }
1569
1570         cinfo->offStruct   = sz->stack_size;
1571 //      cinfo->stack_usage = S390_ALIGN(sz->stack_size+sz->local_size,
1572 //                                      S390_STACK_ALIGNMENT);
1573         return (cinfo);
1574 }
1575
1576 /*========================= End of Function ========================*/
1577
1578 /*------------------------------------------------------------------*/
1579 /*                                                                  */
1580 /* Name         - mono_arch_allocate_vars                           */
1581 /*                                                                  */
1582 /* Function     - Set var information according to the calling      */
1583 /*                convention for S/390. The local var stuff should  */
1584 /*                most likely be split in another method.           */
1585 /*                                                                  */
1586 /* Parameter    - @m - Compile unit.                                */
1587 /*                                                                  */
1588 /*------------------------------------------------------------------*/
1589
1590 void
1591 mono_arch_allocate_vars (MonoCompile *cfg)
1592 {
1593         MonoMethodSignature *sig;
1594         MonoMethodHeader *header;
1595         MonoInst *inst;
1596         CallInfo *cinfo;
1597         size_data sz;
1598         int iParm, iVar, offset, size, align, curinst;
1599         int frame_reg = STK_BASE;
1600         int sArg, eArg;
1601
1602         header  = mono_method_get_header (cfg->method);
1603
1604         /*---------------------------------------------------------*/
1605         /* We use the frame register also for any method that has  */
1606         /* filter clauses. This way, when the handlers are called, */
1607         /* the code will reference local variables using the frame */
1608         /* reg instead of the stack pointer: if we had to restore  */
1609         /* the stack pointer, we'd corrupt the method frames that  */
1610         /* are already on the stack (since filters get called      */
1611         /* before stack unwinding happens) when the filter code    */
1612         /* would call any method.                                  */
1613         /*---------------------------------------------------------*/
1614         if ((cfg->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
1615                 frame_reg = s390_r11;
1616
1617         cfg->frame_reg = frame_reg;
1618
1619         if (frame_reg != STK_BASE)
1620                 cfg->used_int_regs |= 1 << frame_reg;
1621
1622         sig     = mono_method_signature (cfg->method);
1623
1624         cinfo   = calculate_sizes (sig, &sz, sig->pinvoke);
1625
1626         if (cinfo->struct_ret) {
1627                 cfg->ret->opcode = OP_REGVAR;
1628                 cfg->ret->inst_c0 = s390_r2;
1629         } else {
1630                 switch (mono_type_get_underlying_type (sig->ret)->type) {
1631                 case MONO_TYPE_VOID:
1632                         break;
1633                 default:
1634                         cfg->ret->opcode = OP_REGVAR;
1635                         cfg->ret->dreg   = s390_r2;
1636                         break;
1637                 }
1638         }
1639
1640         /*--------------------------------------------------------------*/
1641         /* local vars are at a positive offset from the stack pointer   */
1642         /* also note that if the function uses alloca, we use s390_r11  */
1643         /* to point at the local variables.                             */
1644         /* add parameter area size for called functions                 */
1645         /*--------------------------------------------------------------*/
1646         offset          = (cfg->param_area + S390_MINIMAL_STACK_SIZE);
1647         cfg->sig_cookie = 0;
1648
1649         if (cinfo->struct_ret) {
1650                 inst               = cfg->ret;
1651                 offset             = S390_ALIGN(offset, sizeof(gpointer));
1652                 inst->inst_offset  = offset;
1653                 inst->opcode       = OP_REGOFFSET;
1654                 inst->inst_basereg = frame_reg;
1655                 offset            += sizeof(gpointer);
1656                 if ((sig->call_convention == MONO_CALL_VARARG) &&
1657                     (!retFitsInReg (cinfo->ret.size)))
1658                         cfg->sig_cookie += cinfo->ret.size;
1659         }
1660
1661         if (sig->hasthis) {
1662                 inst = cfg->varinfo [0];
1663                 if (inst->opcode != OP_REGVAR) {
1664                         inst->opcode       = OP_REGOFFSET;
1665                         inst->inst_basereg = frame_reg;
1666                         offset             = S390_ALIGN(offset, sizeof(gpointer));
1667                         inst->inst_offset  = offset;
1668                         offset            += sizeof (gpointer);
1669                 }
1670                 curinst = sArg = 1;
1671         } else {
1672                 curinst = sArg = 0;
1673         }
1674
1675         eArg = sig->param_count + sArg;
1676
1677         if (sig->call_convention == MONO_CALL_VARARG)
1678                 cfg->sig_cookie += S390_MINIMAL_STACK_SIZE;
1679
1680         for (iParm = sArg; iParm < eArg; ++iParm) {
1681                 inst = cfg->varinfo [curinst];
1682                 if (inst->opcode != OP_REGVAR) {
1683                         switch (cinfo->args[iParm].regtype) {
1684                                 case RegTypeStructByAddr :
1685                                 if (cinfo->args[iParm].reg == STK_BASE) {
1686                                         inst->opcode       = OP_S390_LOADARG;
1687                                         inst->inst_basereg = frame_reg;
1688                                         size               = abs(cinfo->args[iParm].vtsize);
1689                                         offset             = S390_ALIGN(offset, sizeof(long));
1690                                         inst->inst_offset  = offset;
1691                                 } else {
1692                                         inst->opcode       = OP_S390_ARGREG;
1693                                         inst->inst_basereg = frame_reg;
1694                                         size               = sizeof(gpointer);
1695                                         offset             = S390_ALIGN(offset, size);
1696                                         inst->inst_offset  = offset;
1697                                 }
1698                                         break;
1699                                 case RegTypeStructByVal :
1700                                         inst->opcode       = OP_S390_ARGPTR;
1701                                         inst->inst_basereg = frame_reg;
1702                                         size               = cinfo->args[iParm].size;
1703                                         offset             = S390_ALIGN(offset, size);
1704                                         inst->inst_offset  = offset;
1705                                         break;
1706                                 default :
1707                                 if (cinfo->args[iParm].reg != STK_BASE) {
1708                                         inst->opcode       = OP_REGOFFSET;
1709                                         inst->inst_basereg = frame_reg;
1710                                         size               = (cinfo->args[iParm].size < 8
1711                                                               ? sizeof(long)
1712                                                               : sizeof(long long));
1713                                         offset             = S390_ALIGN(offset, size);
1714                                         inst->inst_offset  = offset;
1715                                 } else {
1716                                         inst->opcode       = OP_S390_STKARG;
1717                                         inst->inst_basereg = frame_reg;
1718                                         size               = (cinfo->args[iParm].size < 4
1719                                                               ? 4 - cinfo->args[iParm].size
1720                                                               : 0);
1721                                         inst->inst_offset  = cinfo->args[iParm].offset +
1722                                                              size;
1723                                         inst->unused       = 0;
1724                                         size               = sizeof(long);
1725                                 }
1726                         }
1727                         if ((sig->call_convention == MONO_CALL_VARARG) &&
1728                             (cinfo->args[iParm].regtype != RegTypeGeneral) &&
1729                             (iParm < sig->sentinelpos))
1730                                 cfg->sig_cookie += size;
1731
1732                         offset += size;
1733                 }
1734                 curinst++;
1735         }
1736
1737         curinst = cfg->locals_start;
1738         for (iVar = curinst; iVar < cfg->num_varinfo; ++iVar) {
1739                 inst = cfg->varinfo [iVar];
1740                 if ((inst->flags & MONO_INST_IS_DEAD) ||
1741                     (inst->opcode == OP_REGVAR))
1742                         continue;
1743
1744                 /*--------------------------------------------------*/
1745                 /* inst->unused indicates native sized value types, */
1746                 /* this is used by the pinvoke wrappers when they   */
1747                 /* call functions returning structure               */
1748                 /*--------------------------------------------------*/
1749                 if (inst->unused && MONO_TYPE_ISSTRUCT (inst->inst_vtype))
1750                         size = mono_class_native_size (mono_class_from_mono_type(inst->inst_vtype), &align);
1751                 else
1752                         size = mono_type_size (inst->inst_vtype, &align);
1753
1754                 offset             = S390_ALIGN(offset, align);
1755                 inst->inst_offset  = offset;
1756                 inst->opcode       = OP_REGOFFSET;
1757                 inst->inst_basereg = frame_reg;
1758                 offset            += size;
1759                 DEBUG (g_print("allocating local %d to %d\n", iVar, inst->inst_offset));
1760         }
1761
1762         /*------------------------------------------------------*/
1763         /* Allow space for the trace method stack area if needed*/
1764         /*------------------------------------------------------*/
1765         if (mono_jit_trace_calls != NULL && mono_trace_eval (cfg))
1766                 offset += S390_TRACE_STACK_SIZE;
1767
1768         /*------------------------------------------------------*/
1769         /* Reserve space to save LMF and caller saved registers */
1770         /*------------------------------------------------------*/
1771         if (cfg->method->save_lmf)
1772                 offset += sizeof (MonoLMF);
1773
1774         /*------------------------------------------------------*/
1775         /* align the offset                                     */
1776         /*------------------------------------------------------*/
1777         cfg->stack_offset = S390_ALIGN(offset, S390_STACK_ALIGNMENT);
1778
1779 }
1780
1781 /*========================= End of Function ========================*/
1782
1783 /*------------------------------------------------------------------*/
1784 /*                                                                  */
1785 /* Name         - mono_arch_call_opcode                             */
1786 /*                                                                  */
1787 /* Function     - Take the arguments and generate the arch-specific */
1788 /*                instructions to properly call the function. This  */
1789 /*                includes pushing, moving argments to the correct  */
1790 /*                etc.                                              */
1791 /*                                                                  */
1792 /*------------------------------------------------------------------*/
1793
1794 MonoCallInst*
1795 mono_arch_call_opcode (MonoCompile *cfg, MonoBasicBlock* bb,
1796                        MonoCallInst *call, int is_virtual) {
1797         MonoInst *arg, *in;
1798         MonoMethodSignature *sig;
1799         MonoS390ArgParm *argParm;
1800         int i, n, lParamArea;
1801         CallInfo *cinfo;
1802         ArgInfo *ainfo;
1803         size_data sz;
1804
1805         sig = call->signature;
1806         n = sig->param_count + sig->hasthis;
1807         DEBUG (g_print ("Call requires: %d parameters\n",n));
1808
1809         cinfo = calculate_sizes (sig, &sz, sig->pinvoke);
1810
1811 //      call->stack_usage = cinfo->stack_usage;
1812 //      lParamArea        = MAX((cinfo->stack_usage - S390_MINIMAL_STACK_SIZE), 0);
1813         call->stack_usage = MAX((sz.stack_size + sz.local_size), call->stack_usage);
1814         lParamArea        = MAX((call->stack_usage - S390_MINIMAL_STACK_SIZE), 0);
1815         cfg->param_area   = MAX (((signed) cfg->param_area), lParamArea);
1816         cfg->flags       |= MONO_CFG_HAS_CALLS;
1817
1818         if (cinfo->struct_ret)
1819                 call->used_iregs |= 1 << cinfo->ret.reg;
1820
1821         for (i = 0; i < n; ++i) {
1822                 ainfo = cinfo->args + i;
1823
1824                 if ((sig->call_convention == MONO_CALL_VARARG) &&
1825                     (i == sig->sentinelpos)) {
1826                         MonoInst *sigArg;
1827
1828                         cfg->disable_aot = TRUE;
1829                         MONO_INST_NEW (cfg, sigArg, OP_ICONST);
1830                         sigArg->inst_p0 = call->signature;
1831
1832                         MONO_INST_NEW (cfg, arg, OP_OUTARG_MEMBASE);
1833                         arg->inst_left  = sigArg;
1834                         arg->inst_right = (MonoInst *) call;
1835                         argParm         = g_malloc(sizeof(MonoS390ArgParm));
1836                         argParm->size   = ainfo->size;
1837                         argParm->offset = cinfo->sigCookie.offset;
1838                         arg->unused     = (gint32) argParm;
1839                         call->used_iregs |= 1 << ainfo->reg;
1840
1841                         arg->next      = call->out_args;
1842                         call->out_args = arg;
1843                 }
1844
1845                 if (is_virtual && i == 0) {
1846                         /* the argument will be attached to the call instrucion */
1847                         in = call->args [i];
1848                         call->used_iregs |= 1 << ainfo->reg;
1849                 } else {
1850                         MONO_INST_NEW (cfg, arg, OP_OUTARG);
1851                         in = call->args [i];
1852                         arg->cil_code   = in->cil_code;
1853                         arg->inst_left  = in;
1854                         arg->type       = in->type;
1855                         /* prepend, we'll need to reverse them later */
1856                         arg->next       = call->out_args;
1857                         call->out_args  = arg;
1858                         arg->inst_right = (MonoInst *) call;
1859                         if (ainfo->regtype == RegTypeGeneral) {
1860                                 arg->unused = ainfo->reg;
1861                                 call->used_iregs |= 1 << ainfo->reg;
1862                                 if (arg->type == STACK_I8)
1863                                         call->used_iregs |= 1 << (ainfo->reg + 1);
1864                         } else if (ainfo->regtype == RegTypeStructByAddr) {
1865                                 call->used_iregs |= 1 << ainfo->reg;
1866                                 arg->sreg1      = ainfo->reg;
1867                                 arg->opcode     = OP_OUTARG_VT;
1868                                 argParm         = g_malloc(sizeof(MonoS390ArgParm));
1869                                 argParm->size   = -ainfo->vtsize;
1870                                 argParm->offset = ainfo->offset;
1871                                 argParm->offPrm = ainfo->offparm + cinfo->offStruct;
1872                                 arg->unused     = (gint32) argParm;
1873                         } else if (ainfo->regtype == RegTypeStructByVal) {
1874                                 if (ainfo->reg != STK_BASE) {
1875                                         switch (ainfo->size) {
1876                                         case 0:
1877                                         case 1:
1878                                         case 2:
1879                                         case 4:
1880                                                 call->used_iregs |= 1 << ainfo->reg;
1881                                                 break;
1882                                         case 8:
1883                                                 call->used_iregs |= 1 << ainfo->reg;
1884                                                 call->used_iregs |= 1 << (ainfo->reg+1);
1885                                                 break;
1886                                         default:
1887                                                 call->used_iregs |= 1 << ainfo->reg;
1888                                         }
1889                                 }
1890                                 arg->sreg1      = ainfo->reg;
1891                                 arg->opcode     = OP_OUTARG_VT;
1892                                 argParm         = g_malloc(sizeof(MonoS390ArgParm));
1893                                 argParm->size   = ainfo->size;
1894                                 argParm->offset = ainfo->offset;
1895                                 argParm->offPrm = ainfo->offparm + cinfo->offStruct;
1896                                 arg->unused     = (gint32) argParm;
1897                         } else if (ainfo->regtype == RegTypeBase) {
1898                                 arg->opcode = OP_OUTARG_MEMBASE;
1899                                 arg->sreg1      = ainfo->reg;
1900                                 argParm         = g_malloc(sizeof(MonoS390ArgParm));
1901                                 argParm->size   = ainfo->size;
1902                                 argParm->offset = ainfo->offset;
1903                                 arg->unused     = (gint32) argParm;
1904                                 call->used_iregs |= 1 << ainfo->reg;
1905                         } else if (ainfo->regtype == RegTypeFP) {
1906                                 arg->unused = ainfo->reg;
1907                                 call->used_fregs |= 1 << ainfo->reg;
1908                                 if (ainfo->size == 4)
1909                                         arg->opcode     = OP_OUTARG_R4;
1910                                 else
1911                                         arg->opcode = OP_OUTARG_R8;
1912                         } else {
1913                                 g_assert_not_reached ();
1914                         }
1915                 }
1916         }
1917         /*
1918          * Reverse the call->out_args list.
1919          */
1920         {
1921                 MonoInst *prev = NULL, *list = call->out_args, *next;
1922                 while (list) {
1923                         next = list->next;
1924                         list->next = prev;
1925                         prev = list;
1926                         list = next;
1927                 }
1928                 call->out_args = prev;
1929         }
1930
1931         g_free (cinfo);
1932         return call;
1933 }
1934
1935 /*========================= End of Function ========================*/
1936
1937 /*------------------------------------------------------------------*/
1938 /*                                                                  */
1939 /* Name         - mono_arch_instrument_mem_needs                    */
1940 /*                                                                  */
1941 /* Function     - Allow tracing to work with this interface (with   */
1942 /*                an optional argument).                            */
1943 /*                                                                  */
1944 /*------------------------------------------------------------------*/
1945
1946 void
1947 mono_arch_instrument_mem_needs (MonoMethod *method, int *stack, int *code)
1948 {
1949         /* no stack room needed now (may be needed for FASTCALL-trace support) */
1950         *stack = 0;
1951         /* split prolog-epilog requirements? */
1952         *code = 50; /* max bytes needed: check this number */
1953 }
1954
1955 /*========================= End of Function ========================*/
1956
1957 /*------------------------------------------------------------------*/
1958 /*                                                                  */
1959 /* Name         - mono_arch_instrument_prolog                       */
1960 /*                                                                  */
1961 /* Function     - Create an "instrumented" prolog.                  */
1962 /*                                                                  */
1963 /*------------------------------------------------------------------*/
1964
1965 void*
1966 mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p,
1967                              gboolean enable_arguments)
1968 {
1969         guchar  *code = p;
1970         int     parmOffset,
1971                 fpOffset;
1972
1973         parmOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE;
1974         if (cfg->method->save_lmf)
1975                 parmOffset -= sizeof(MonoLMF);
1976         fpOffset   = parmOffset + (5*sizeof(gint32));
1977
1978         s390_stm  (code, s390_r2, s390_r6, STK_BASE, parmOffset);
1979         s390_std  (code, s390_f0, 0, STK_BASE, fpOffset);
1980         s390_std  (code, s390_f1, 0, STK_BASE, fpOffset+sizeof(gdouble));
1981         s390_std  (code, s390_f2, 0, STK_BASE, fpOffset+2*sizeof(gdouble));
1982         s390_basr (code, s390_r13, 0);
1983         s390_j    (code, 6);
1984         s390_word (code, cfg->method);
1985         s390_word (code, func);
1986         s390_l    (code, s390_r2, 0, s390_r13, 4);
1987         s390_la   (code, s390_r3, 0, STK_BASE, parmOffset);
1988         s390_lr   (code, s390_r4, STK_BASE);
1989         s390_ahi  (code, s390_r4, cfg->stack_usage);
1990         s390_l    (code, s390_r1, 0, s390_r13, 8);
1991         s390_basr (code, s390_r14, s390_r1);
1992         s390_ld   (code, s390_f2, 0, STK_BASE, fpOffset+2*sizeof(gdouble));
1993         s390_ld   (code, s390_f1, 0, STK_BASE, fpOffset+sizeof(gdouble));
1994         s390_ld   (code, s390_f0, 0, STK_BASE, fpOffset);
1995         s390_lm   (code, s390_r2, s390_r6, STK_BASE, parmOffset);
1996
1997         return code;
1998 }
1999
2000 /*========================= End of Function ========================*/
2001
2002 /*------------------------------------------------------------------*/
2003 /*                                                                  */
2004 /* Name         - mono_arch_instrument_epilog                       */
2005 /*                                                                  */
2006 /* Function     - Create an epilog that will handle the returned    */
2007 /*                values used in instrumentation.                   */
2008 /*                                                                  */
2009 /*------------------------------------------------------------------*/
2010
2011 void*
2012 mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
2013 {
2014         guchar     *code = p;
2015         int        save_mode = SAVE_NONE,
2016                    saveOffset;
2017         MonoMethod *method = cfg->method;
2018         int        rtype = mono_type_get_underlying_type (mono_method_signature (method)->ret)->type;
2019
2020         saveOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE;
2021         if (method->save_lmf)
2022                 saveOffset -= sizeof(MonoLMF);
2023
2024 handle_enum:
2025         switch (rtype) {
2026         case MONO_TYPE_VOID:
2027                 /* special case string .ctor icall */
2028                 if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
2029                         save_mode = SAVE_ONE;
2030                 else
2031                         save_mode = SAVE_NONE;
2032                 break;
2033         case MONO_TYPE_I8:
2034         case MONO_TYPE_U8:
2035                 save_mode = SAVE_TWO;
2036                 break;
2037         case MONO_TYPE_R4:
2038         case MONO_TYPE_R8:
2039                 save_mode = SAVE_FP;
2040                 break;
2041         case MONO_TYPE_VALUETYPE:
2042                 if (mono_method_signature (method)->ret->data.klass->enumtype) {
2043                         rtype = mono_method_signature (method)->ret->data.klass->enum_basetype->type;
2044                         goto handle_enum;
2045                 }
2046                 save_mode = SAVE_STRUCT;
2047                 break;
2048         default:
2049                 save_mode = SAVE_ONE;
2050                 break;
2051         }
2052
2053         switch (save_mode) {
2054         case SAVE_TWO:
2055                 s390_stm (code, s390_r2, s390_r3, cfg->frame_reg, saveOffset);
2056                 if (enable_arguments) {
2057                         s390_lr (code, s390_r4, s390_r3);
2058                         s390_lr (code, s390_r3, s390_r2);
2059                 }
2060                 break;
2061         case SAVE_ONE:
2062                 s390_st (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2063                 if (enable_arguments) {
2064                         s390_lr (code, s390_r3, s390_r2);
2065                 }
2066                 break;
2067         case SAVE_FP:
2068                 s390_std (code, s390_f0, 0, cfg->frame_reg, saveOffset);
2069                 if (enable_arguments) {
2070                         /* FIXME: what reg?  */
2071                         s390_ldr (code, s390_f2, s390_f0);
2072                         s390_lm  (code, s390_r3, s390_r4, cfg->frame_reg, saveOffset);
2073                 }
2074                 break;
2075         case SAVE_STRUCT:
2076                 s390_st (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2077                 if (enable_arguments) {
2078                         s390_l (code, s390_r3, 0, cfg->frame_reg,
2079                                 S390_MINIMAL_STACK_SIZE+cfg->param_area);
2080                 }
2081                 break;
2082         case SAVE_NONE:
2083         default:
2084                 break;
2085         }
2086
2087         s390_basr (code, s390_r13, 0);
2088         s390_j    (code, 6);
2089         s390_word (code, cfg->method);
2090         s390_word (code, func);
2091         s390_l    (code, s390_r2, 0, s390_r13, 4);
2092         s390_l    (code, s390_r1, 0, s390_r13, 8);
2093         s390_basr (code, s390_r14, s390_r1);
2094
2095         switch (save_mode) {
2096         case SAVE_TWO:
2097                 s390_lm  (code, s390_r2, s390_r3, cfg->frame_reg, saveOffset);
2098                 break;
2099         case SAVE_ONE:
2100                 s390_l   (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2101                 break;
2102         case SAVE_FP:
2103                 s390_ld  (code, s390_f0, 0, cfg->frame_reg, saveOffset);
2104                 break;
2105         case SAVE_STRUCT:
2106                 s390_l   (code, s390_r2, 0, cfg->frame_reg, saveOffset);
2107                 break;
2108         case SAVE_NONE:
2109         default:
2110                 break;
2111         }
2112
2113         return code;
2114 }
2115
2116 /*========================= End of Function ========================*/
2117
2118 /*------------------------------------------------------------------*/
2119 /*                                                                  */
2120 /* Name         - peephole_pass                                     */
2121 /*                                                                  */
2122 /* Function     - Form a peephole pass at the code looking for      */
2123 /*                simple optimizations.                             */
2124 /*                                                                  */
2125 /*------------------------------------------------------------------*/
2126
2127 static void
2128 peephole_pass (MonoCompile *cfg, MonoBasicBlock *bb)
2129 {
2130         MonoInst *ins, *last_ins = NULL;
2131         ins = bb->code;
2132
2133         while (ins) {
2134
2135                 switch (ins->opcode) {
2136                 case OP_MUL_IMM:
2137                         /* remove unnecessary multiplication with 1 */
2138                         if (ins->inst_imm == 1) {
2139                                 if (ins->dreg != ins->sreg1) {
2140                                         ins->opcode = OP_MOVE;
2141                                 } else {
2142                                         last_ins->next = ins->next;
2143                                         ins = ins->next;
2144                                         continue;
2145                                 }
2146                         }
2147                         break;
2148                 case OP_LOAD_MEMBASE:
2149                 case OP_LOADI4_MEMBASE:
2150                         /*
2151                          * OP_STORE_MEMBASE_REG reg, offset(basereg)
2152                          * OP_LOAD_MEMBASE offset(basereg), reg
2153                          */
2154                         if (last_ins && (last_ins->opcode == OP_STOREI4_MEMBASE_REG
2155                                          || last_ins->opcode == OP_STORE_MEMBASE_REG) &&
2156                             ins->inst_basereg == last_ins->inst_destbasereg &&
2157                             ins->inst_offset == last_ins->inst_offset) {
2158                                 if (ins->dreg == last_ins->sreg1) {
2159                                         last_ins->next = ins->next;
2160                                         ins = ins->next;
2161                                         continue;
2162                                 } else {
2163                                         ins->opcode = OP_MOVE;
2164                                         ins->sreg1 = last_ins->sreg1;
2165                                 }
2166
2167                         /*
2168                          * Note: reg1 must be different from the basereg in the second load
2169                          * OP_LOAD_MEMBASE offset(basereg), reg1
2170                          * OP_LOAD_MEMBASE offset(basereg), reg2
2171                          * -->
2172                          * OP_LOAD_MEMBASE offset(basereg), reg1
2173                          * OP_MOVE reg1, reg2
2174                          */
2175                         } if (last_ins && (last_ins->opcode == OP_LOADI4_MEMBASE
2176                                            || last_ins->opcode == OP_LOAD_MEMBASE) &&
2177                               ins->inst_basereg != last_ins->dreg &&
2178                               ins->inst_basereg == last_ins->inst_basereg &&
2179                               ins->inst_offset == last_ins->inst_offset) {
2180
2181                                 if (ins->dreg == last_ins->dreg) {
2182                                         last_ins->next = ins->next;
2183                                         ins = ins->next;
2184                                         continue;
2185                                 } else {
2186                                         ins->opcode = OP_MOVE;
2187                                         ins->sreg1 = last_ins->dreg;
2188                                 }
2189
2190                                 //g_assert_not_reached ();
2191
2192 #if 0
2193                         /*
2194                          * OP_STORE_MEMBASE_IMM imm, offset(basereg)
2195                          * OP_LOAD_MEMBASE offset(basereg), reg
2196                          * -->
2197                          * OP_STORE_MEMBASE_IMM imm, offset(basereg)
2198                          * OP_ICONST reg, imm
2199                          */
2200                         } else if (last_ins && (last_ins->opcode == OP_STOREI4_MEMBASE_IMM
2201                                                 || last_ins->opcode == OP_STORE_MEMBASE_IMM) &&
2202                                    ins->inst_basereg == last_ins->inst_destbasereg &&
2203                                    ins->inst_offset == last_ins->inst_offset) {
2204                                 //static int c = 0; printf ("MATCHX %s %d\n", cfg->method->name,c++);
2205                                 ins->opcode = OP_ICONST;
2206                                 ins->inst_c0 = last_ins->inst_imm;
2207                                 g_assert_not_reached (); // check this rule
2208 #endif
2209                         }
2210                         break;
2211                 case OP_LOADU1_MEMBASE:
2212                 case OP_LOADI1_MEMBASE:
2213                         if (last_ins && (last_ins->opcode == OP_STOREI1_MEMBASE_REG) &&
2214                                         ins->inst_basereg == last_ins->inst_destbasereg &&
2215                                         ins->inst_offset == last_ins->inst_offset) {
2216                                 if (ins->dreg == last_ins->sreg1) {
2217                                         last_ins->next = ins->next;
2218                                         ins = ins->next;
2219                                         continue;
2220                                 } else {
2221                                         //static int c = 0; printf ("MATCHX %s %d\n", cfg->method->name,c++);
2222                                         ins->opcode = OP_MOVE;
2223                                         ins->sreg1 = last_ins->sreg1;
2224                                 }
2225                         }
2226                         break;
2227                 case OP_LOADU2_MEMBASE:
2228                 case OP_LOADI2_MEMBASE:
2229                         if (last_ins && (last_ins->opcode == OP_STOREI2_MEMBASE_REG) &&
2230                                         ins->inst_basereg == last_ins->inst_destbasereg &&
2231                                         ins->inst_offset == last_ins->inst_offset) {
2232                                 if (ins->dreg == last_ins->sreg1) {
2233                                         last_ins->next = ins->next;
2234                                         ins = ins->next;
2235                                         continue;
2236                                 } else {
2237                                         ins->opcode = OP_MOVE;
2238                                         ins->sreg1 = last_ins->sreg1;
2239                                 }
2240                         }
2241                         break;
2242                 case CEE_CONV_I4:
2243                 case CEE_CONV_U4:
2244                 case OP_MOVE:
2245                         /*
2246                          * OP_MOVE reg, reg
2247                          */
2248                         if (ins->dreg == ins->sreg1) {
2249                                 if (last_ins)
2250                                         last_ins->next = ins->next;
2251                                 ins = ins->next;
2252                                 continue;
2253                         }
2254                         /*
2255                          * OP_MOVE sreg, dreg
2256                          * OP_MOVE dreg, sreg
2257                          */
2258                         if (last_ins && last_ins->opcode == OP_MOVE &&
2259                             ins->sreg1 == last_ins->dreg &&
2260                             ins->dreg == last_ins->sreg1) {
2261                                 last_ins->next = ins->next;
2262                                 ins = ins->next;
2263                                 continue;
2264                         }
2265                         break;
2266                 }
2267                 last_ins = ins;
2268                 ins = ins->next;
2269         }
2270         bb->last_ins = last_ins;
2271 }
2272
2273 /*========================= End of Function ========================*/
2274
2275 /*------------------------------------------------------------------*/
2276 /*                                                                  */
2277 /* Name         - mono_arch_local_regalloc.                         */
2278 /*                                                                  */
2279 /* Function     - We first scan the list of instructions and we     */
2280 /*                save the liveness information of each register    */
2281 /*                (when the register is first used, when its value  */
2282 /*                is set etc.). We also reverse the list of instr-  */
2283 /*                uctions (in the InstList list) because assigning  */
2284 /*                registers backwards allows for more tricks to be  */
2285 /*                used.                                             */
2286 /*                                                                  */
2287 /*------------------------------------------------------------------*/
2288
2289 void
2290 mono_arch_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb)
2291 {
2292         mono_local_regalloc(cfg, bb);
2293 }
2294
2295 /*========================= End of Function ========================*/
2296
2297 /*------------------------------------------------------------------*/
2298 /*                                                                  */
2299 /* Name         - emit_float_to_int                                 */
2300 /*                                                                  */
2301 /* Function     - Create instructions which will convert a floating */
2302 /*                point value to integer.                           */
2303 /*                                                                  */
2304 /*------------------------------------------------------------------*/
2305
2306 static guchar*
2307 emit_float_to_int (MonoCompile *cfg, guchar *code, int dreg, int sreg, int size, gboolean is_signed)
2308 {
2309         /* sreg is a float, dreg is an integer reg. */
2310         if (is_signed) {
2311                 s390_cfdbr (code, dreg, 5, sreg);
2312                 switch (size) {
2313                         case 1:
2314                                 s390_lhi  (code, s390_r0, 0);
2315                                 s390_lhi  (code, s390_r13, 0xff);
2316                                 s390_ltr  (code, dreg, dreg);
2317                                 s390_jnl  (code, 4);
2318                                 s390_lhi  (code, s390_r0, 0x80);
2319                                 s390_nr   (code, dreg, s390_r13);
2320                                 s390_or   (code, dreg, s390_r0);
2321                                 break;
2322                 }
2323         } else {
2324                 s390_basr   (code, s390_r13, 0);
2325                 s390_j      (code, 10);
2326                 s390_llong  (code, 0x41e0000000000000);
2327                 s390_llong  (code, 0x41f0000000000000);
2328                 s390_ldr    (code, s390_f15, sreg);
2329                 s390_cdb    (code, s390_f15, 0, s390_r13, 0);
2330                 s390_jl     (code, 10);
2331                 s390_sdb    (code, s390_f15, 0, s390_r13, 8);
2332                 s390_cfdbr  (code, dreg, 7, s390_f15);
2333                 s390_j      (code, 4);
2334                 s390_cfdbr  (code, dreg, 5, sreg);
2335                 switch (size) {
2336                         case 1:
2337                                 s390_lhi  (code, s390_r0, 0xff);
2338                                 s390_nr   (code, dreg, s390_r0);
2339                                 break;
2340                         case 2:
2341                                 s390_lhi  (code, s390_r0, -1);
2342                                 s390_srl  (code, s390_r0, 0, 16);
2343                                 s390_nr   (code, dreg, s390_r0);
2344                                 break;
2345                 }
2346         }
2347         return code;
2348 }
2349
2350 /*========================= End of Function ========================*/
2351
2352 /*------------------------------------------------------------------*/
2353 /*                                                                  */
2354 /* Name         - mono_emit_stack_alloc                             */
2355 /*                                                                  */
2356 /* Function     -                                                   */
2357 /*                                                                  */
2358 /*------------------------------------------------------------------*/
2359
2360 static unsigned char*
2361 mono_emit_stack_alloc (guchar *code, MonoInst* tree)
2362 {
2363         return code;
2364 }
2365
2366 /*========================= End of Function ========================*/
2367
2368 /*------------------------------------------------------------------*/
2369 /*                                                                  */
2370 /* Name         - mono_arch_output_basic_block                      */
2371 /*                                                                  */
2372 /* Function     - Perform the "real" work of emitting instructions  */
2373 /*                that will do the work of in the basic block.      */
2374 /*                                                                  */
2375 /*------------------------------------------------------------------*/
2376
2377 void
2378 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
2379 {
2380         MonoInst *ins;
2381         MonoCallInst *call;
2382         guint offset;
2383         guint8 *code = cfg->native_code + cfg->code_len;
2384         MonoInst *last_ins = NULL;
2385         guint last_offset = 0;
2386         int max_len, cpos, src2;
2387
2388         if (cfg->opt & MONO_OPT_PEEPHOLE)
2389                 peephole_pass (cfg, bb);
2390
2391         /* we don't align basic blocks of loops on s390 */
2392
2393         if (cfg->verbose_level > 2)
2394                 g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset);
2395
2396         cpos = bb->max_offset;
2397
2398         if (cfg->prof_options & MONO_PROFILE_COVERAGE) {
2399                 //MonoCoverageInfo *cov = mono_get_coverage_info (cfg->method);
2400                 //g_assert (!mono_compile_aot);
2401                 //cpos += 6;
2402                 //if (bb->cil_code)
2403                 //      cov->data [bb->dfn].iloffset = bb->cil_code - cfg->cil_code;
2404                 /* this is not thread save, but good enough */
2405                 /* fixme: howto handle overflows? */
2406                 //x86_inc_mem (code, &cov->data [bb->dfn].count);
2407         }
2408
2409         ins = bb->code;
2410         while (ins) {
2411                 offset = code - cfg->native_code;
2412
2413                 max_len = ((guint8 *)ins_spec [ins->opcode])[MONO_INST_LEN];
2414
2415                 if (offset > (cfg->code_size - max_len - 16)) {
2416                         cfg->code_size *= 2;
2417                         cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2418                         code = cfg->native_code + offset;
2419                 }
2420
2421                 mono_debug_record_line_number (cfg, ins, offset);
2422
2423                 switch (ins->opcode) {
2424                 case OP_STOREI1_MEMBASE_IMM: {
2425                         s390_lhi (code, s390_r0, ins->inst_imm);
2426                         if (s390_is_uimm12(ins->inst_offset))
2427                                 s390_stc (code, s390_r0, 0, ins->inst_destbasereg, ins->inst_offset);
2428                         else {
2429                                 s390_basr (code, s390_r13, 0);
2430                                 s390_j    (code, 4);
2431                                 s390_word (code, ins->inst_offset);
2432                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2433                                 s390_stc  (code, s390_r0, s390_r13, ins->inst_destbasereg, 0);
2434                         }
2435                 }
2436                         break;
2437                 case OP_STOREI2_MEMBASE_IMM: {
2438                         s390_lhi (code, s390_r0, ins->inst_imm);
2439                         if (s390_is_uimm12(ins->inst_offset)) {
2440                                 s390_sth (code, s390_r0, 0, ins->inst_destbasereg, ins->inst_offset);
2441                         } else {
2442                                 s390_basr (code, s390_r13, 0);
2443                                 s390_j    (code, 4);
2444                                 s390_word (code, ins->inst_offset);
2445                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2446                                 s390_sth  (code, s390_r0, s390_r13, ins->inst_destbasereg, 0);
2447                         }
2448                 }
2449                         break;
2450                 case OP_STORE_MEMBASE_IMM:
2451                 case OP_STOREI4_MEMBASE_IMM: {
2452                         if (s390_is_uimm16(ins->inst_imm)) {
2453                                 s390_lhi  (code, s390_r0, ins->inst_imm);
2454                         } else {
2455                                 s390_basr (code, s390_r13, 0);
2456                                 s390_j    (code, 4);
2457                                 s390_word (code, ins->inst_imm);
2458                                 s390_l    (code, s390_r0, 0, s390_r13, 4);
2459                         }
2460                         if (s390_is_uimm12(ins->inst_offset)) {
2461                                 s390_st  (code, s390_r0, 0, ins->inst_destbasereg, ins->inst_offset);
2462                         } else {
2463                                 s390_basr (code, s390_r13, 0);
2464                                 s390_j    (code, 4);
2465                                 s390_word (code, ins->inst_offset);
2466                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2467                                 s390_st   (code, s390_r0, s390_r13, ins->inst_destbasereg, 0);
2468                         }
2469                 }
2470                         break;
2471                 case OP_STOREI1_MEMBASE_REG: {
2472                         if (s390_is_uimm12(ins->inst_offset)) {
2473                                 s390_stc  (code, ins->sreg1, 0, ins->inst_destbasereg, ins->inst_offset);
2474                         } else {
2475                                 s390_basr (code, s390_r13, 0);
2476                                 s390_j    (code, 4);
2477                                 s390_word (code, ins->inst_offset);
2478                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2479                                 s390_stc  (code, ins->sreg1, s390_r13, ins->inst_destbasereg, 0);
2480                         }
2481                 }
2482                         break;
2483                 case OP_STOREI2_MEMBASE_REG: {
2484                         if (s390_is_uimm12(ins->inst_offset)) {
2485                                 s390_sth  (code, ins->sreg1, 0, ins->inst_destbasereg, ins->inst_offset);
2486                         } else {
2487                                 s390_basr (code, s390_r13, 0);
2488                                 s390_j    (code, 4);
2489                                 s390_word (code, ins->inst_offset);
2490                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2491                                 s390_sth  (code, ins->sreg1, s390_r13, ins->inst_destbasereg, 0);
2492                         }
2493                 }
2494                         break;
2495                 case OP_STORE_MEMBASE_REG:
2496                 case OP_STOREI4_MEMBASE_REG: {
2497                         if (s390_is_uimm12(ins->inst_offset)) {
2498                                 s390_st   (code, ins->sreg1, 0, ins->inst_destbasereg, ins->inst_offset);
2499                         } else {
2500                                 s390_basr (code, s390_r13, 0);
2501                                 s390_j    (code, 4);
2502                                 s390_word (code, ins->inst_offset);
2503                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2504                                 s390_st   (code, ins->sreg1, s390_r13, ins->inst_destbasereg, 0);
2505                         }
2506                 }
2507                         break;
2508                 case CEE_LDIND_I:
2509                 case CEE_LDIND_I4:
2510                 case CEE_LDIND_U4: {
2511                         s390_basr (code, s390_r13, 0);
2512                         s390_j    (code, 4);
2513                         s390_word (code, ins->inst_p0);
2514                         s390_l    (code, s390_r13, 0, s390_r13, 4);
2515                         s390_l    (code, ins->dreg, 0, s390_r13, 0);
2516                 }
2517                         break;
2518                 case OP_LOADU4_MEM:
2519                         g_assert_not_reached ();
2520                         break;
2521                 case OP_LOAD_MEMBASE:
2522                 case OP_LOADI4_MEMBASE:
2523                 case OP_LOADU4_MEMBASE: {
2524                         if (s390_is_uimm12(ins->inst_offset))
2525                                 s390_l    (code, ins->dreg, 0, ins->inst_basereg, ins->inst_offset);
2526                         else {
2527                                 if (s390_is_uimm16(ins->inst_offset)) {
2528                                         s390_lhi (code, s390_r13, ins->inst_offset);
2529                                         s390_l   (code, ins->dreg, s390_r13, ins->inst_basereg, 0);
2530                                 } else {
2531                                         s390_basr (code, s390_r13, 0);
2532                                         s390_j    (code, 4);
2533                                         s390_word (code, ins->inst_offset);
2534                                         s390_l    (code, s390_r13, 0, s390_r13, 4);
2535                                         s390_l    (code, ins->dreg, s390_r13, ins->inst_basereg, 0);
2536                                 }
2537                         }
2538                 }
2539                         break;
2540                 case OP_LOADU1_MEMBASE: {
2541                         s390_lhi (code, s390_r0, 0);
2542                         if (s390_is_uimm12(ins->inst_offset))
2543                                 s390_ic   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
2544                         else {
2545                                 s390_basr (code, s390_r13, 0);
2546                                 s390_j    (code, 4);
2547                                 s390_word (code, ins->inst_offset);
2548                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2549                                 s390_ic   (code, s390_r0, s390_r13, ins->inst_basereg, 0);
2550                         }
2551                         s390_lr   (code, ins->dreg, s390_r0);
2552                 }
2553                         break;
2554                 case OP_LOADI1_MEMBASE: {
2555                         s390_lhi (code, s390_r0, 0);
2556                         if (s390_is_uimm12(ins->inst_offset))
2557                                 s390_ic   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
2558                         else {
2559                                 s390_basr (code, s390_r13, 0);
2560                                 s390_j    (code, 4);
2561                                 s390_word (code, ins->inst_offset);
2562                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2563                                 s390_ic   (code, s390_r0, s390_r13, ins->inst_basereg, 0);
2564                         }
2565                         s390_lhi  (code, s390_r13, 0x80);
2566                         s390_nr   (code, s390_r13, s390_r0);
2567                         s390_jz   (code, 5);
2568                         s390_lhi  (code, s390_r13, 0xff00);
2569                         s390_or   (code, s390_r0, s390_r13);
2570                         s390_lr   (code, ins->dreg, s390_r0);
2571                 }
2572                         break;
2573                 case OP_LOADU2_MEMBASE: {
2574                         s390_lhi (code, s390_r0, 0);
2575                         if (s390_is_uimm12(ins->inst_offset))
2576                                 s390_icm  (code, s390_r0, 3, ins->inst_basereg, ins->inst_offset);
2577                         else {
2578                                 s390_basr (code, s390_r13, 0);
2579                                 s390_j    (code, 4);
2580                                 s390_word (code, ins->inst_offset);
2581                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2582                                 s390_ar   (code, s390_r13, ins->inst_basereg);
2583                                 s390_icm  (code, s390_r0, 3, s390_r13, 0);
2584                         }
2585                         s390_lr  (code, ins->dreg, s390_r0);
2586                 }
2587                         break;
2588                 case OP_LOADI2_MEMBASE: {
2589                         s390_lhi (code, s390_r0, 0);
2590                         if (s390_is_uimm12(ins->inst_offset))
2591                                 s390_lh   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
2592                         else {
2593                                 s390_basr (code, s390_r13, 0);
2594                                 s390_j    (code, 4);
2595                                 s390_word (code, ins->inst_offset);
2596                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2597                                 s390_lh   (code, s390_r0, s390_r13, ins->inst_basereg, 0);
2598                         }
2599                         s390_lr  (code, ins->dreg, s390_r0);
2600                 }
2601                         break;
2602                 case CEE_CONV_I1: {
2603                         s390_lhi  (code, s390_r0, 0x80);
2604                         if (ins->dreg != ins->sreg1) {
2605                                 s390_lr   (code, ins->dreg, ins->sreg1);
2606                         }
2607                         s390_nr   (code, s390_r0, ins->sreg1);
2608                         s390_jz   (code, 7);
2609                         s390_lhi  (code, s390_r13, -1);
2610                         s390_sll  (code, s390_r13, 0, 8);
2611                         s390_or   (code, ins->dreg, s390_r13);
2612                 }
2613                         break;
2614                 case CEE_CONV_I2: {
2615                         s390_lhi  (code, s390_r0, 0x80);
2616                         s390_sll  (code, s390_r0, 0, 8);
2617                         if (ins->dreg != ins->sreg1) {
2618                                 s390_lr   (code, ins->dreg, ins->sreg1);
2619                         }
2620                         s390_nr   (code, s390_r0, ins->sreg1);
2621                         s390_jz   (code, 7);
2622                         s390_lhi  (code, s390_r13, -1);
2623                         s390_sll  (code, s390_r13, 0, 16);
2624                         s390_or   (code, ins->dreg, s390_r13);
2625                 }
2626                         break;
2627                 case CEE_CONV_U1: {
2628                         s390_lhi  (code, s390_r0, 0xff);
2629                         if (ins->dreg != ins->sreg1) {
2630                                 s390_lr   (code, ins->dreg, ins->sreg1);
2631                         }
2632                         s390_nr   (code, ins->dreg, s390_r0);
2633                 }
2634                         break;
2635                 case CEE_CONV_U2: {
2636                         s390_lhi  (code, s390_r0, -1);
2637                         s390_sll  (code, s390_r0, 0, 16);
2638                         s390_srl  (code, s390_r0, 0, 16);
2639                         if (ins->dreg != ins->sreg1) {
2640                                 s390_lr   (code, ins->dreg, ins->sreg1);
2641                         }
2642                         s390_nr   (code, ins->dreg, s390_r0);
2643                 }
2644                         break;
2645                 case OP_COMPARE: {
2646                         if ((ins->next) &&
2647                             ((ins->next->opcode >= CEE_BNE_UN) &&
2648                              (ins->next->opcode <= CEE_BLT_UN)) ||
2649                             ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
2650                              (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
2651                             ((ins->next->opcode == OP_CLT_UN) ||
2652                              (ins->next->opcode == OP_CGT_UN)))
2653                                 s390_clr  (code, ins->sreg1, ins->sreg2);
2654                         else
2655                                 s390_cr   (code, ins->sreg1, ins->sreg2);
2656                 }
2657                         break;
2658                 case OP_COMPARE_IMM: {
2659                         if (s390_is_uimm16 (ins->inst_imm)) {
2660                                 s390_lhi  (code, s390_r0, ins->inst_imm);
2661                                 if ((ins->next) &&
2662                                     ((ins->next->opcode >= CEE_BNE_UN) &&
2663                                      (ins->next->opcode <= CEE_BLT_UN)) ||
2664                                     ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
2665                                      (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
2666                                     ((ins->next->opcode == OP_CLT_UN) ||
2667                                      (ins->next->opcode == OP_CGT_UN)))
2668                                         s390_clr  (code, ins->sreg1, s390_r0);
2669                                 else
2670                                         s390_cr   (code, ins->sreg1, s390_r0);
2671                         }
2672                         else {
2673                                 s390_basr (code, s390_r13, 0);
2674                                 s390_j    (code, 4);
2675                                 s390_word (code, ins->inst_imm);
2676                                 if ((ins->next) &&
2677                                     ((ins->next->opcode >= CEE_BNE_UN) &&
2678                                      (ins->next->opcode <= CEE_BLT_UN)) ||
2679                                     ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
2680                                      (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
2681                                     ((ins->next->opcode == OP_CLT_UN) &&
2682                                      (ins->next->opcode == OP_CGT_UN)))
2683                                         s390_cl   (code, ins->sreg1, 0, s390_r13, 4);
2684                                 else
2685                                         s390_c    (code, ins->sreg1, 0, s390_r13, 4);
2686                         }
2687                 }
2688                         break;
2689                 case OP_X86_TEST_NULL: {
2690                         s390_ltr (code, ins->sreg1, ins->sreg1);
2691                 }
2692                         break;
2693                 case CEE_BREAK: {
2694                         mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, mono_arch_break);
2695                         s390_brasl (code, s390_r14, 0);
2696                 }
2697                         break;
2698                 case OP_ADDCC: {
2699                         CHECK_SRCDST_COM;
2700                         s390_alr  (code, ins->dreg, src2);
2701                 }
2702                         break;
2703                 case CEE_ADD: {
2704                         CHECK_SRCDST_COM;
2705                         s390_ar   (code, ins->dreg, src2);
2706                 }
2707                         break;
2708                 case OP_ADC: {
2709                         CHECK_SRCDST_COM;
2710                         s390_alcr (code, ins->dreg, src2);
2711                 }
2712                         break;
2713                 case OP_ADDCC_IMM:
2714                 case OP_ADD_IMM: {
2715                         if ((ins->next) &&
2716                             (ins->next->opcode == OP_ADC_IMM)) {
2717                                 s390_basr (code, s390_r13, 0);
2718                                 s390_j    (code, 4);
2719                                 s390_word (code, ins->inst_imm);
2720                                 if (ins->dreg != ins->sreg1) {
2721                                         s390_lr   (code, ins->dreg, ins->sreg1);
2722                                 }
2723                                 s390_al   (code, ins->dreg, 0, s390_r13, 4);
2724                         } else {
2725                                 if (s390_is_uimm16 (ins->inst_imm)) {
2726                                         if (ins->dreg != ins->sreg1) {
2727                                                 s390_lr   (code, ins->dreg, ins->sreg1);
2728                                         }
2729                                         s390_ahi (code, ins->dreg, ins->inst_imm);
2730                                 } else {
2731                                         s390_basr (code, s390_r13, 0);
2732                                         s390_j    (code, 4);
2733                                         s390_word (code, ins->inst_imm);
2734                                         if (ins->dreg != ins->sreg1) {
2735                                                 s390_lr   (code, ins->dreg, ins->sreg1);
2736                                         }
2737                                         s390_a    (code, ins->dreg, 0, s390_r13, 4);
2738                                 }
2739                         }
2740                 }
2741                         break;
2742                 case OP_ADC_IMM: {
2743                         if (s390_is_uimm16 (ins->inst_imm)) {
2744                                 if (ins->dreg != ins->sreg1) {
2745                                         s390_lr   (code, ins->dreg, ins->sreg1);
2746                                 }
2747                                 s390_lhi  (code, s390_r0, ins->inst_imm);
2748                                 s390_alcr (code, ins->dreg, s390_r0);
2749                         } else {
2750                                 s390_basr (code, s390_r13, 0);
2751                                 s390_j    (code, 4);
2752                                 s390_word (code, ins->inst_imm);
2753                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2754                                 s390_alcr (code, ins->dreg, s390_r13);
2755                         }
2756                 }
2757                         break;
2758                 case CEE_ADD_OVF: {
2759                         CHECK_SRCDST_COM;
2760                         s390_ar   (code, ins->dreg, src2);
2761                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2762                 }
2763                         break;
2764                 case CEE_ADD_OVF_UN: {
2765                         CHECK_SRCDST_COM;
2766                         s390_alr  (code, ins->dreg, src2);
2767                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
2768                 }
2769                         break;
2770                 case OP_LADD_OVF: {
2771                         short int *o[1];
2772                         CHECK_SRCDST_COM;
2773                         s390_alr  (code, ins->dreg, src2);
2774                         s390_jnc  (code, 0); CODEPTR(code, o[0]);
2775                         s390_ahi  (code, ins->dreg+1, 1);
2776                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2777                         PTRSLOT   (code, o[0]);
2778                         s390_ar   (code, ins->dreg+1, src2+1);
2779                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2780                 }
2781                         break;
2782                 case OP_LADD_OVF_UN: {
2783                         CHECK_SRCDST_COM;
2784                         s390_alr  (code, ins->dreg, src2);
2785                         s390_alcr (code, ins->dreg+1, src2+1);
2786                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
2787                 }
2788                         break;
2789                 case OP_ADD_OVF_CARRY: {
2790                         CHECK_SRCDST_COM;
2791                         s390_lhi  (code, s390_r0, 0);
2792                         s390_lr   (code, s390_r1, s390_r0);
2793                         s390_alcr (code, s390_r0, s390_r1);
2794                         s390_ar   (code, ins->dreg, src2);
2795                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2796                         s390_ar   (code, ins->dreg, s390_r0);
2797                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2798                 }
2799                         break;
2800                 case OP_ADD_OVF_UN_CARRY: {
2801                         CHECK_SRCDST_COM;
2802                         s390_alcr (code, ins->dreg, src2);
2803                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, "OverflowException");
2804                 }
2805                         break;
2806                 case OP_SUBCC: {
2807                         CHECK_SRCDST_NCOM;
2808                         s390_slr (code, ins->dreg, src2);
2809                 }
2810                         break;
2811                 case CEE_SUB: {
2812                         CHECK_SRCDST_NCOM;
2813                         s390_sr   (code, ins->dreg, src2);
2814                 }
2815                         break;
2816                 case OP_SBB: {
2817                         CHECK_SRCDST_NCOM;
2818                         s390_slbr (code, ins->dreg, src2);
2819                 }
2820                         break;
2821                 case OP_SUBCC_IMM: {
2822                         if (s390_is_uimm16 (-ins->inst_imm)) {
2823                                 if (ins->dreg != ins->sreg1) {
2824                                         s390_lr   (code, ins->dreg, ins->sreg1);
2825                                 }
2826                                 s390_ahi  (code, ins->dreg, -ins->inst_imm);
2827                         } else {
2828                                 s390_basr (code, s390_r13, 0);
2829                                 s390_j    (code, 4);
2830                                 s390_word (code, ins->inst_imm);
2831                                 if (ins->dreg != ins->sreg1) {
2832                                         s390_lr   (code, ins->dreg, ins->sreg1);
2833                                 }
2834                                 s390_sl   (code, ins->dreg, 0, s390_r13, 4);
2835                         }
2836                 }
2837                         break;
2838                 case OP_SUB_IMM: {
2839                         if (s390_is_uimm16 (-ins->inst_imm)) {
2840                                 if (ins->dreg != ins->sreg1) {
2841                                         s390_lr   (code, ins->dreg, ins->sreg1);
2842                                 }
2843                                 s390_ahi  (code, ins->dreg, -ins->inst_imm);
2844                         } else {
2845                                 s390_basr (code, s390_r13, 0);
2846                                 s390_j    (code, 4);
2847                                 s390_word (code, ins->inst_imm);
2848                                 if (ins->dreg != ins->sreg1) {
2849                                         s390_lr   (code, ins->dreg, ins->sreg1);
2850                                 }
2851                                 s390_s    (code, ins->dreg, 0, s390_r13, 4);
2852                         }
2853                 }
2854                         break;
2855                 case OP_SBB_IMM: {
2856                         if (ins->dreg != ins->sreg1) {
2857                                 s390_lr    (code, ins->dreg, ins->sreg1);
2858                         }
2859                         if (s390_is_uimm16 (-ins->inst_imm)) {
2860                                 s390_lhi   (code, s390_r0, ins->inst_imm);
2861                                 s390_slbr  (code, ins->dreg, s390_r0);
2862                         } else {
2863                                 s390_basr (code, s390_r13, 0);
2864                                 s390_j    (code, 4);
2865                                 s390_word (code, ins->inst_imm);
2866                                 s390_slb  (code, ins->dreg, 0, s390_r13, 4);
2867                         }
2868                 }
2869                         break;
2870                 case CEE_SUB_OVF: {
2871                         CHECK_SRCDST_NCOM;
2872                         s390_sr   (code, ins->dreg, src2);
2873                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2874                 }
2875                         break;
2876                 case CEE_SUB_OVF_UN: {
2877                         CHECK_SRCDST_NCOM;
2878                         s390_slr  (code, ins->dreg, src2);
2879                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, "OverflowException");
2880                 }
2881                         break;
2882                 case OP_LSUB_OVF: {
2883                         short int *o[3];
2884                         CHECK_SRCDST_COM;
2885                         s390_lr   (code, s390_r1, src2+1);
2886                         s390_slr  (code, ins->dreg, src2);
2887                         s390_jnl  (code, 0); CODEPTR(code, o[0]);
2888                         s390_ahi  (code, s390_r1, 1);
2889                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2890                         PTRSLOT   (code, o[0]);
2891                         s390_sr   (code, ins->dreg+1, s390_r1);
2892                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2893                 }
2894                         break;
2895                 case OP_LSUB_OVF_UN: {
2896                         CHECK_SRCDST_COM;
2897                         s390_slr  (code, ins->dreg, src2);
2898                         s390_slbr (code, ins->dreg+1, src2+1);
2899                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT, "OverflowException");
2900                 }
2901                         break;
2902                 case OP_SUB_OVF_CARRY: {
2903                         CHECK_SRCDST_NCOM;
2904                         s390_lhi  (code, s390_r0, 0);
2905                         s390_lr   (code, s390_r1, s390_r0);
2906                         s390_slbr (code, s390_r0, s390_r1);
2907                         s390_sr   (code, ins->dreg, src2);
2908                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2909                         s390_ar   (code, ins->dreg, s390_r0);
2910                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
2911                 }
2912                         break;
2913                 case OP_SUB_OVF_UN_CARRY: {
2914                         CHECK_SRCDST_NCOM;
2915                         s390_slbr (code, ins->dreg, src2);
2916                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, "OverflowException");
2917                 }
2918                         break;
2919                 case CEE_AND: {
2920                         if (ins->sreg1 == ins->dreg) {
2921                                 s390_nr   (code, ins->dreg, ins->sreg2);
2922                         }
2923                         else {
2924                                 if (ins->sreg2 == ins->dreg) {
2925                                         s390_nr  (code, ins->dreg, ins->sreg1);
2926                                 }
2927                                 else {
2928                                         s390_lr  (code, ins->dreg, ins->sreg1);
2929                                         s390_nr  (code, ins->dreg, ins->sreg2);
2930                                 }
2931                         }
2932                 }
2933                         break;
2934                 case OP_AND_IMM: {
2935                         if (s390_is_uimm16 (ins->inst_imm)) {
2936                                 s390_lhi  (code, s390_r0, ins->inst_imm);
2937                                 if (ins->dreg != ins->sreg1) {
2938                                         s390_lr   (code, ins->dreg, ins->sreg1);
2939                                 }
2940                                 s390_nr   (code, ins->dreg, s390_r0);
2941                         } else {
2942                                 s390_basr (code, s390_r13, 0);
2943                                 s390_j    (code, 4);
2944                                 s390_word (code, ins->inst_imm);
2945                                 if (ins->dreg != ins->sreg1) {
2946                                         s390_lr   (code, ins->dreg, ins->sreg1);
2947                                 }
2948                                 s390_n    (code, ins->dreg, 0, s390_r13, 4);
2949                         }
2950                 }
2951                         break;
2952                 case CEE_DIV: {
2953                         s390_lr   (code, s390_r0, ins->sreg1);
2954                         s390_srda (code, s390_r0, 0, 32);
2955                         s390_dr   (code, s390_r0, ins->sreg2);
2956                         s390_lr   (code, ins->dreg, s390_r1);
2957                 }
2958                         break;
2959                 case CEE_DIV_UN: {
2960                         s390_lr   (code, s390_r0, ins->sreg1);
2961                         s390_srdl (code, s390_r0, 0, 32);
2962                         s390_dlr  (code, s390_r0, ins->sreg2);
2963                         s390_lr   (code, ins->dreg, s390_r1);
2964                 }
2965                         break;
2966                 case OP_DIV_IMM: {
2967                         if (s390_is_uimm16 (ins->inst_imm)) {
2968                                 s390_lhi  (code, s390_r13, ins->inst_imm);
2969                                 s390_lr   (code, s390_r0, ins->sreg1);
2970                         } else {
2971                                 s390_basr (code, s390_r13, 0);
2972                                 s390_j    (code, 4);
2973                                 s390_word (code, ins->inst_imm);
2974                                 s390_lr   (code, s390_r0, ins->sreg1);
2975                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
2976                         }
2977                         s390_srda (code, s390_r0, 0, 32);
2978                         s390_dr   (code, s390_r0, s390_r13);
2979                         s390_lr   (code, ins->dreg, s390_r1);
2980                 }
2981                         break;
2982                 case CEE_REM: {
2983                         s390_lr   (code, s390_r0, ins->sreg1);
2984                         s390_srda (code, s390_r0, 0, 32);
2985                         s390_dr   (code, s390_r0, ins->sreg2);
2986                         s390_lr   (code, ins->dreg, s390_r0);
2987                         break;
2988                 case CEE_REM_UN:
2989                         s390_lr   (code, s390_r0, ins->sreg1);
2990                         s390_srdl (code, s390_r0, 0, 32);
2991                         s390_dlr  (code, s390_r0, ins->sreg2);
2992                         s390_lr   (code, ins->dreg, s390_r0);
2993                 }
2994                         break;
2995                 case OP_REM_IMM: {
2996                         if (s390_is_uimm16 (ins->inst_imm)) {
2997                                 s390_lhi  (code, s390_r13, ins->inst_imm);
2998                                 s390_lr   (code, s390_r0, ins->sreg1);
2999                         } else {
3000                                 s390_basr (code, s390_r13, 0);
3001                                 s390_j    (code, 4);
3002                                 s390_word (code, ins->inst_imm);
3003                                 s390_lr   (code, s390_r0, ins->sreg1);
3004                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3005                         }
3006                         s390_srda (code, s390_r0, 0, 32);
3007                         s390_dr   (code, s390_r0, s390_r13);
3008                         s390_lr   (code, ins->dreg, s390_r0);
3009                 }
3010                         break;
3011                 case CEE_OR: {
3012                         if (ins->sreg1 == ins->dreg) {
3013                                 s390_or   (code, ins->dreg, ins->sreg2);
3014                         }
3015                         else {
3016                                 if (ins->sreg2 == ins->dreg) {
3017                                         s390_or  (code, ins->dreg, ins->sreg1);
3018                                 }
3019                                 else {
3020                                         s390_lr  (code, ins->dreg, ins->sreg1);
3021                                         s390_or  (code, ins->dreg, ins->sreg2);
3022                                 }
3023                         }
3024                 }
3025                         break;
3026                 case OP_OR_IMM: {
3027                         if (s390_is_uimm16 (ins->inst_imm)) {
3028                                 s390_lhi  (code, s390_r0, ins->inst_imm);
3029                                 if (ins->dreg != ins->sreg1) {
3030                                         s390_lr   (code, ins->dreg, ins->sreg1);
3031                                 }
3032                                 s390_or   (code, ins->dreg, s390_r0);
3033                         } else {
3034                                 s390_basr (code, s390_r13, 0);
3035                                 s390_j    (code, 4);
3036                                 s390_word (code, ins->inst_imm);
3037                                 if (ins->dreg != ins->sreg1) {
3038                                         s390_lr   (code, ins->dreg, ins->sreg1);
3039                                 }
3040                                 s390_o    (code, ins->dreg, 0, s390_r13, 4);
3041                         }
3042                 }
3043                         break;
3044                 case CEE_XOR: {
3045                         if (ins->sreg1 == ins->dreg) {
3046                                 s390_xr   (code, ins->dreg, ins->sreg2);
3047                         }
3048                         else {
3049                                 if (ins->sreg2 == ins->dreg) {
3050                                         s390_xr  (code, ins->dreg, ins->sreg1);
3051                                 }
3052                                 else {
3053                                         s390_lr  (code, ins->dreg, ins->sreg1);
3054                                         s390_xr  (code, ins->dreg, ins->sreg2);
3055                                 }
3056                         }
3057                 }
3058                         break;
3059                 case OP_XOR_IMM: {
3060                         if (s390_is_uimm16 (ins->inst_imm)) {
3061                                 s390_lhi  (code, s390_r0, ins->inst_imm);
3062                                 if (ins->dreg != ins->sreg1) {
3063                                         s390_lr   (code, ins->dreg, ins->sreg1);
3064                                 }
3065                                 s390_xr   (code, ins->dreg, s390_r0);
3066                         } else {
3067                                 s390_basr (code, s390_r13, 0);
3068                                 s390_j    (code, 4);
3069                                 s390_word (code, ins->inst_imm);
3070                                 if (ins->dreg != ins->sreg1) {
3071                                         s390_lr   (code, ins->dreg, ins->sreg1);
3072                                 }
3073                                 s390_x    (code, ins->dreg, 0, s390_r13, 4);
3074                         }
3075                 }
3076                         break;
3077                 case CEE_SHL: {
3078                         CHECK_SRCDST_NCOM;
3079                         s390_sll  (code, ins->dreg, src2, 0);
3080                 }
3081                         break;
3082                 case OP_SHL_IMM: {
3083                         if (ins->sreg1 != ins->dreg) {
3084                                 s390_lr   (code, ins->dreg, ins->sreg1);
3085                         }
3086                         s390_sll  (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3087                 }
3088                         break;
3089                 case CEE_SHR: {
3090                         CHECK_SRCDST_NCOM;
3091                         s390_sra  (code, ins->dreg, src2, 0);
3092                 }
3093                         break;
3094                 case OP_SHR_IMM: {
3095                         if (ins->sreg1 != ins->dreg) {
3096                                 s390_lr   (code, ins->dreg, ins->sreg1);
3097                         }
3098                         s390_sra  (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3099                 }
3100                         break;
3101                 case OP_SHR_UN_IMM: {
3102                         if (ins->sreg1 != ins->dreg) {
3103                                 s390_lr   (code, ins->dreg, ins->sreg1);
3104                         }
3105                         s390_srl  (code, ins->dreg, 0, (ins->inst_imm & 0x1f));
3106                 }
3107                         break;
3108                 case CEE_SHR_UN: {
3109                         CHECK_SRCDST_NCOM;
3110                         s390_srl  (code, ins->dreg, src2, 0);
3111                 }
3112                         break;
3113                 case CEE_NOT: {
3114                         if (ins->sreg1 != ins->dreg) {
3115                                 s390_lr   (code, ins->dreg, ins->sreg1);
3116                         }
3117                         s390_lhi (code, s390_r0, -1);
3118                         s390_xr  (code, ins->dreg, s390_r0);
3119                 }
3120                         break;
3121                 case CEE_NEG: {
3122                         s390_lcr (code, ins->dreg, ins->sreg1);
3123                 }
3124                         break;
3125                 case CEE_MUL: {
3126                         if (ins->sreg1 == ins->dreg) {
3127                                 s390_msr  (code, ins->dreg, ins->sreg2);
3128                         }
3129                         else {
3130                                 if (ins->sreg2 == ins->dreg) {
3131                                         s390_msr (code, ins->dreg, ins->sreg1);
3132                                 }
3133                                 else {
3134                                         s390_lr  (code, ins->dreg, ins->sreg1);
3135                                         s390_msr (code, ins->dreg, ins->sreg2);
3136                                 }
3137                         }
3138                 }
3139                         break;
3140                 case OP_MUL_IMM: {
3141                         if (s390_is_uimm16 (ins->inst_imm)) {
3142                                 s390_lhi  (code, s390_r13, ins->inst_imm);
3143                         } else {
3144                                 s390_basr (code, s390_r13, 0);
3145                                 s390_j    (code, 4);
3146                                 s390_word (code, ins->inst_imm);
3147 //                              if (ins->dreg != ins->sreg1) {
3148 //                                      s390_lr   (code, ins->dreg, ins->sreg1);
3149 //                              }
3150                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3151                         }
3152                         if (ins->dreg != ins->sreg1) {
3153                                 s390_lr   (code, ins->dreg, ins->sreg1);
3154                         }
3155                         s390_msr  (code, ins->dreg, s390_r13);
3156                 }
3157                         break;
3158                 case CEE_MUL_OVF: {
3159                         short int *o[2];
3160                         s390_ltr  (code, s390_r1, ins->sreg1);
3161                         s390_jz   (code, 0); CODEPTR(code, o[0]);
3162                         s390_ltr  (code, s390_r0, ins->sreg2);
3163                         s390_jnz  (code, 6);
3164                         s390_lhi  (code, s390_r1, 0);
3165                         s390_j    (code, 0); CODEPTR(code, o[1]);
3166                         s390_xr   (code, s390_r0, s390_r1);
3167                         s390_msr  (code, s390_r1, ins->sreg2);
3168                         s390_xr   (code, s390_r0, s390_r1);
3169                         s390_srl  (code, s390_r0, 0, 31);
3170                         s390_ltr  (code, s390_r0, s390_r0);
3171                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3172                         PTRSLOT   (code, o[0]);
3173                         PTRSLOT   (code, o[1]);
3174                         s390_lr   (code, ins->dreg, s390_r1);
3175                 }
3176                         break;
3177                 case CEE_MUL_OVF_UN: {
3178                         s390_lhi  (code, s390_r0, 0);
3179                         s390_lr   (code, s390_r1, ins->sreg1);
3180                         s390_mlr  (code, s390_r0, ins->sreg2);
3181                         s390_ltr  (code, s390_r0, s390_r0);
3182                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ, "OverflowException");
3183                         s390_lr   (code, ins->dreg, s390_r1);
3184                 }
3185                         break;
3186                 case OP_LMUL: {
3187                         s390_l    (code, s390_r0, 0, ins->sreg1, 4);
3188                         s390_srda (code, s390_r0, 0, 32);
3189                         s390_m    (code, s390_r0, 0, ins->sreg2, 4);
3190                         s390_l    (code, s390_r0, 0, ins->sreg1, 4);
3191                         s390_srl  (code, s390_r0, 0, 31);
3192                         s390_a    (code, s390_r0, 0, ins->sreg1, 0);
3193                         s390_l    (code, s390_r13, 0, ins->sreg2, 0);
3194                         s390_srl  (code, s390_r13, 0, 31);
3195                         s390_ms   (code, s390_r13, 0, ins->sreg1, 4);
3196                         s390_ar   (code, s390_r0, s390_r13);
3197                         s390_st   (code, s390_r0, 0, ins->dreg, 0);
3198                         s390_st   (code, s390_r1, 0, ins->dreg, 4);
3199                 }
3200                         break;
3201                 case OP_ICONST:
3202                 case OP_SETREGIMM: {
3203                         if (s390_is_uimm16(ins->inst_c0)) {
3204                                 s390_lhi  (code, ins->dreg, ins->inst_c0);
3205                         } else {
3206                                 s390_basr (code, s390_r13, 0);
3207                                 s390_j    (code, 4);
3208                                 s390_word (code, ins->inst_c0);
3209                                 s390_l    (code, ins->dreg, 0, s390_r13, 4);
3210                         }
3211                 }
3212                         break;
3213                 case OP_AOTCONST: {
3214                         s390_basr (code, s390_r13, 0);
3215                         s390_j    (code, 4);
3216                         mono_add_patch_info (cfg, code - cfg->native_code,
3217                                 (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3218                         s390_word (code, 0);
3219                         s390_l    (code,ins->dreg, 0, s390_r13, 4);
3220                 }
3221                         break;
3222                 case CEE_CONV_I4:
3223                 case CEE_CONV_U4:
3224                 case OP_MOVE:
3225                 case OP_SETREG: {
3226                         if (ins->dreg != ins->sreg1) {
3227                                 s390_lr (code, ins->dreg, ins->sreg1);
3228                         }
3229                 }
3230                         break;
3231                 case OP_SETLRET: {
3232                         int saved = ins->sreg1;
3233                         if (ins->sreg1 == s390_r2) {
3234                                 s390_lr (code, s390_r0, ins->sreg1);
3235                                 saved = s390_r0;
3236                         }
3237                         if (ins->sreg2 != s390_r2)
3238                                 s390_lr (code, s390_r2, ins->sreg2);
3239                         if (saved != s390_r3)
3240                                 s390_lr (code, s390_r3, saved);
3241                         break;
3242                 }
3243                 case OP_SETFREG:
3244                 case OP_FMOVE: {
3245                         if (ins->dreg != ins->sreg1) {
3246                                 s390_ldr   (code, ins->dreg, ins->sreg1);
3247                         }
3248                 }
3249                         break;
3250                 case OP_S390_SETF4RET: {
3251                         s390_ledbr (code, ins->dreg, ins->sreg1);
3252                 }
3253                         break;
3254                 case OP_TLS_GET: {
3255                         if (s390_is_uimm16 (ins->inst_offset)) {
3256                                 s390_lhi (code, s390_r13, ins->inst_offset);
3257                         } else {
3258                                 s390_bras (code, s390_r13, 0);
3259                                 s390_j    (code, 4);
3260                                 s390_word (code, ins->inst_offset);
3261                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3262                         }
3263                         s390_ear (code, s390_r1, 0);
3264                         s390_l   (code, ins->dreg, s390_r13, s390_r1, 0);
3265                 }
3266                         break;
3267                 case OP_FCONV_TO_R4: {
3268                         if ((ins->next) &&
3269                              (ins->next->opcode != OP_FMOVE) &&
3270                              (ins->next->opcode != OP_STORER4_MEMBASE_REG))
3271                                 s390_ledbr (code, ins->dreg, ins->sreg1);
3272                 }
3273                         break;
3274                 case CEE_JMP: {
3275                         int iParm, fParm, pOffset;
3276                         if (cfg->method->save_lmf)
3277                                 restoreLMF(code, cfg->frame_reg, cfg->stack_usage);
3278
3279                         if (cfg->flags & MONO_CFG_HAS_TAIL) {
3280                                 pOffset = S390_PARM_SAVE_OFFSET;
3281                                 s390_l  (code, s390_r13, 0, STK_BASE, 0);
3282                                 for (iParm = s390_r2;
3283                                      iParm <= s390_r5;
3284                                      iParm++, pOffset+sizeof(gint32)) {
3285                                         if (cfg->used_int_regs & (1 << iParm))
3286                                                 s390_l (code, iParm, 0, s390_r13, pOffset);
3287                                 }
3288                                 pOffset = S390_FLOAT_SAVE_OFFSET;
3289                                 for (fParm = 0;
3290                                      fParm < 4;
3291                                      fParm++, pOffset+sizeof(double))
3292                                         s390_ld (code, fParm, 0, s390_r13, pOffset);
3293                         }
3294
3295                         code = backUpStackPtr(cfg, code);
3296                         s390_l   (code, s390_r14, 0, STK_BASE, S390_RET_ADDR_OFFSET);
3297                         mono_add_patch_info (cfg, code - cfg->native_code,
3298                                              MONO_PATCH_INFO_METHOD_JUMP,
3299                                              ins->inst_p0);
3300                         s390_jcl (code, S390_CC_UN, 0);
3301                 }
3302                         break;
3303                 case OP_CHECK_THIS: {
3304                         /* ensure ins->sreg1 is not NULL */
3305                         s390_icm (code, s390_r0, 15, ins->sreg1, 0);
3306                 }
3307                         break;
3308                 case OP_ARGLIST: {
3309                         int offset = cfg->sig_cookie + cfg->stack_usage;
3310
3311                         if (s390_is_uimm16 (offset))
3312                                 s390_lhi  (code, s390_r0, offset);
3313                         else {
3314                                 s390_basr (code, s390_r13, 0);
3315                                 s390_j    (code, 4);
3316                                 s390_word (code, offset);
3317                                 s390_l    (code, s390_r0, 0, s390_r13, 0);
3318                         }
3319                         s390_ar   (code, s390_r0, cfg->frame_reg);
3320                         s390_st   (code, s390_r0, 0, ins->sreg1, 0);
3321                 }
3322                         break;
3323                 case OP_FCALL: {
3324                         call = (MonoCallInst*)ins;
3325                         if (ins->flags & MONO_INST_HAS_METHOD)
3326                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_METHOD,
3327                                                      call->method);
3328                         else
3329                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS,
3330                                                      call->fptr);
3331                         s390_brasl (code, s390_r14, 0);
3332                         if (call->signature->ret->type == MONO_TYPE_R4)
3333                                 s390_ldebr (code, s390_f0, s390_f0);
3334                 }
3335                         break;
3336                 case OP_LCALL:
3337                 case OP_VCALL:
3338                 case OP_VOIDCALL:
3339                 case CEE_CALL: {
3340                         call = (MonoCallInst*)ins;
3341                         if (ins->flags & MONO_INST_HAS_METHOD)
3342                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_METHOD, call->method);
3343                         else
3344                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, call->fptr);
3345                         s390_brasl (code, s390_r14, 0);
3346                 }
3347                         break;
3348                 case OP_FCALL_REG: {
3349                         call = (MonoCallInst*)ins;
3350                         s390_lr   (code, s390_r1, ins->sreg1);
3351                         s390_basr (code, s390_r14, s390_r1);
3352                         if (call->signature->ret->type == MONO_TYPE_R4)
3353                                 s390_ldebr (code, s390_f0, s390_f0);
3354                 }
3355                         break;
3356                 case OP_LCALL_REG:
3357                 case OP_VCALL_REG:
3358                 case OP_VOIDCALL_REG:
3359                 case OP_CALL_REG: {
3360                         s390_lr   (code, s390_r1, ins->sreg1);
3361                         s390_basr (code, s390_r14, s390_r1);
3362                 }
3363                         break;
3364                 case OP_FCALL_MEMBASE: {
3365                         call = (MonoCallInst*)ins;
3366                         s390_l    (code, s390_r1, 0, ins->sreg1, ins->inst_offset);
3367                         s390_basr (code, s390_r14, s390_r1);
3368                         if (call->signature->ret->type == MONO_TYPE_R4)
3369                                 s390_ldebr (code, s390_f0, s390_f0);
3370                 }
3371                         break;
3372                 case OP_LCALL_MEMBASE:
3373                 case OP_VCALL_MEMBASE:
3374                 case OP_VOIDCALL_MEMBASE:
3375                 case OP_CALL_MEMBASE: {
3376                         s390_l    (code, s390_r1, 0, ins->sreg1, ins->inst_offset);
3377                         s390_basr (code, s390_r14, s390_r1);
3378                 }
3379                         break;
3380                 case OP_OUTARG:
3381                         g_assert_not_reached ();
3382                         break;
3383                 case OP_LOCALLOC: {
3384 //                      int alloca_skip = S390_MINIMAL_STACK_SIZE + cfg->param_area +
3385 //                                        S390_STACK_ALIGNMENT - 1;
3386 //                      int area_offset = S390_ALIGN(alloca_skip, S390_STACK_ALIGNMENT);
3387                         int area_offset = S390_MINIMAL_STACK_SIZE;
3388                         s390_lr   (code, s390_r1, ins->sreg1);
3389                         if (ins->flags & MONO_INST_INIT)
3390                                 s390_lr   (code, s390_r0, ins->sreg1);
3391                         s390_ahi  (code, s390_r1, 14);
3392                         s390_srl  (code, s390_r1, 0, 3);
3393                         s390_sll  (code, s390_r1, 0, 3);
3394                         s390_l    (code, s390_r13, 0, STK_BASE, 0);
3395                         s390_sr   (code, STK_BASE, s390_r1);
3396                         s390_st   (code, s390_r13, 0, STK_BASE, 0);
3397                         s390_la   (code, ins->dreg, 0, STK_BASE, area_offset);
3398                         s390_srl  (code, ins->dreg, 0, 3);
3399                         s390_sll  (code, ins->dreg, 0, 3);
3400                         if (ins->flags & MONO_INST_INIT) {
3401                                 s390_lr   (code, s390_r1, s390_r0);
3402                                 s390_lr   (code, s390_r0, ins->dreg);
3403                                 s390_lr   (code, s390_r14, s390_r12);
3404                                 s390_lhi  (code, s390_r13, 0);
3405                                 s390_mvcle(code, s390_r0, s390_r12, 0, 0);
3406                                 s390_jo   (code, -2);
3407                                 s390_lr   (code, s390_r12, s390_r14);
3408                         }
3409                 }
3410                         break;
3411                 case CEE_RET: {
3412                         s390_br  (code, s390_r14);
3413                 }
3414                         break;
3415                 case CEE_THROW: {
3416                         s390_lr (code, s390_r2, ins->sreg1);
3417                         mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
3418                                              (gpointer)"mono_arch_throw_exception");
3419                         s390_brasl (code, s390_r14, 0);
3420                 }
3421                         break;
3422                 case OP_RETHROW: {
3423                         s390_lr (code, s390_r2, ins->sreg1);
3424                         mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
3425                                              (gpointer)"mono_arch_rethrow_exception");
3426                         s390_brasl (code, s390_r14, 0);
3427                 }
3428                         break;
3429                 case OP_START_HANDLER: {
3430                         if (s390_is_uimm12 (ins->inst_left->inst_offset)) {
3431                                 s390_st   (code, s390_r14, 0,
3432                                            ins->inst_left->inst_basereg,
3433                                            ins->inst_left->inst_offset);
3434                         } else {
3435                                 s390_basr (code, s390_r13, 0);
3436                                 s390_j    (code, 4);
3437                                 s390_word (code, ins->inst_left->inst_offset);
3438                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3439                                 s390_st   (code, s390_r14, s390_r13,
3440                                            ins->inst_left->inst_basereg, 0);
3441                         }
3442                 }
3443                         break;
3444                 case OP_ENDFILTER: {
3445                         if (ins->sreg1 != s390_r2)
3446                                 s390_lr (code, s390_r2, ins->sreg1);
3447                         if (s390_is_uimm12 (ins->inst_left->inst_offset)) {
3448                                 s390_l  (code, s390_r14, 0, ins->inst_left->inst_basereg,
3449                                          ins->inst_left->inst_offset);
3450                         } else {
3451                                 s390_basr (code, s390_r13, 0);
3452                                 s390_j    (code, 4);
3453                                 s390_word (code, ins->inst_left->inst_offset);
3454                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3455                                 s390_l    (code, s390_r14, s390_r13,
3456                                            ins->inst_left->inst_basereg, 0);
3457                         }
3458                         s390_br  (code, s390_r14);
3459                 }
3460                         break;
3461                 case CEE_ENDFINALLY: {
3462                         if (s390_is_uimm12 (ins->inst_left->inst_offset)) {
3463                                 s390_l  (code, s390_r14, 0, ins->inst_left->inst_basereg,
3464                                          ins->inst_left->inst_offset);
3465                         } else {
3466                                 s390_basr (code, s390_r13, 0);
3467                                 s390_j    (code, 4);
3468                                 s390_word (code, ins->inst_left->inst_offset);
3469                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3470                                 s390_l    (code, s390_r14, s390_r13,
3471                                            ins->inst_left->inst_basereg, 0);
3472                         }
3473                         s390_br  (code, s390_r14);
3474                 }
3475                         break;
3476                 case OP_CALL_HANDLER: {
3477                         mono_add_patch_info (cfg, code-cfg->native_code,
3478                                              MONO_PATCH_INFO_BB, ins->inst_target_bb);
3479                         s390_brasl (code, s390_r14, 0);
3480                 }
3481                         break;
3482                 case OP_LABEL: {
3483                         ins->inst_c0 = code - cfg->native_code;
3484                 }
3485                         break;
3486                 case CEE_BR:
3487                         EMIT_UNCOND_BRANCH(ins);
3488                         break;
3489                 case OP_BR_REG: {
3490                         s390_br  (code, ins->sreg1);
3491                 }
3492                         break;
3493                 case OP_CEQ: {
3494                         s390_lhi (code, ins->dreg, 1);
3495                         s390_jz  (code, 4);
3496                         s390_lhi (code, ins->dreg, 0);
3497                 }
3498                         break;
3499                 case OP_CLT: {
3500                         s390_lhi (code, ins->dreg, 1);
3501                         s390_jl  (code, 4);
3502                         s390_lhi (code, ins->dreg, 0);
3503                 }
3504                         break;
3505                 case OP_CLT_UN: {
3506                         s390_lhi (code, ins->dreg, 1);
3507                         s390_jlo (code, 4);
3508                         s390_lhi (code, ins->dreg, 0);
3509                 }
3510                         break;
3511                 case OP_CGT: {
3512                         s390_lhi (code, ins->dreg, 1);
3513                         s390_jh  (code, 4);
3514                         s390_lhi (code, ins->dreg, 0);
3515                 }
3516                         break;
3517                 case OP_CGT_UN: {
3518                         s390_lhi (code, ins->dreg, 1);
3519                         s390_jho (code, 4);
3520                         s390_lhi (code, ins->dreg, 0);
3521                 }
3522                         break;
3523                 case OP_COND_EXC_EQ:
3524                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_EQ, ins->inst_p1);
3525                         break;
3526                 case OP_COND_EXC_NE_UN:
3527                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NE, ins->inst_p1);
3528                         break;
3529                 case OP_COND_EXC_LT:
3530                 case OP_COND_EXC_LT_UN:
3531                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT, ins->inst_p1);
3532                         break;
3533                 case OP_COND_EXC_GT:
3534                 case OP_COND_EXC_GT_UN:
3535                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT, ins->inst_p1);
3536                         break;
3537                 case OP_COND_EXC_GE:
3538                 case OP_COND_EXC_GE_UN:
3539                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GE, ins->inst_p1);
3540                         break;
3541                 case OP_COND_EXC_LE:
3542                 case OP_COND_EXC_LE_UN:
3543                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LE, ins->inst_p1);
3544                         break;
3545                 case OP_COND_EXC_OV:
3546                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, ins->inst_p1);
3547                         break;
3548                 case OP_COND_EXC_NO:
3549                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NO, ins->inst_p1);
3550                         break;
3551                 case OP_COND_EXC_C:
3552                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY, ins->inst_p1);
3553                         break;
3554                 case OP_COND_EXC_NC:
3555                         EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC, ins->inst_p1);
3556                         break;
3557                 case CEE_BEQ:
3558                         EMIT_COND_BRANCH (ins, S390_CC_EQ);
3559                         break;
3560                 case CEE_BNE_UN:
3561                         EMIT_COND_BRANCH (ins, S390_CC_NE);
3562                         break;
3563                 case CEE_BLT:
3564                 case CEE_BLT_UN:
3565                         EMIT_COND_BRANCH (ins, S390_CC_LT);
3566                         break;
3567                 case CEE_BGT:
3568                 case CEE_BGT_UN:
3569                         EMIT_COND_BRANCH (ins, S390_CC_GT);
3570                         break;
3571                 case CEE_BGE:
3572                 case CEE_BGE_UN:
3573                         EMIT_COND_BRANCH (ins, S390_CC_GE);
3574                         break;
3575                 case CEE_BLE:
3576                 case CEE_BLE_UN:
3577                         EMIT_COND_BRANCH (ins, S390_CC_LE);
3578                         break;
3579
3580                 /* floating point opcodes */
3581                 case OP_R8CONST: {
3582                         if (*((float *) ins->inst_p0) == 0) {
3583                                 s390_lzdr (code, ins->dreg);
3584                         } else {
3585                                 s390_basr  (code, s390_r13, 0);
3586                                 s390_j     (code, 4);
3587                                 s390_word  (code, ins->inst_p0);
3588                                 s390_l     (code, s390_r13, 0, s390_r13, 4);
3589                                 s390_ld    (code, ins->dreg, 0, s390_r13, 0);
3590                         }
3591                 }
3592                         break;
3593                 case OP_R4CONST: {
3594                         if (*((float *) ins->inst_p0) == 0) {
3595                                 s390_lzdr (code, ins->dreg);
3596                         } else {
3597                                 s390_basr (code, s390_r13, 0);
3598                                 s390_j    (code, 4);
3599                                 s390_word (code, ins->inst_p0);
3600                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3601                                 s390_ldeb (code, ins->dreg, 0, s390_r13, 0);
3602                         }
3603                 }
3604                         break;
3605                 case OP_STORER8_MEMBASE_REG: {
3606                         if (s390_is_uimm12(ins->inst_offset)) {
3607                                 s390_std  (code, ins->sreg1, 0, ins->inst_destbasereg, ins->inst_offset);
3608                         } else {
3609                                 s390_basr (code, s390_r13, 0);
3610                                 s390_j    (code, 4);
3611                                 s390_word (code, ins->inst_offset);
3612                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3613                                 s390_std  (code, ins->sreg1, s390_r13, ins->inst_destbasereg, 0);
3614                         }
3615                 }
3616                         break;
3617                 case OP_LOADR8_MEMBASE: {
3618                         if (s390_is_uimm12(ins->inst_offset)) {
3619                                 s390_ld   (code, ins->dreg, 0, ins->inst_basereg, ins->inst_offset);
3620                         } else {
3621                                 s390_basr (code, s390_r13, 0);
3622                                 s390_j    (code, 4);
3623                                 s390_word (code, ins->inst_offset);
3624                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3625                                 s390_ld   (code, ins->dreg, s390_r13, ins->inst_basereg, 0);
3626                         }
3627                 }
3628                         break;
3629                 case OP_STORER4_MEMBASE_REG: {
3630                         if (s390_is_uimm12(ins->inst_offset)) {
3631                                 s390_ledbr(code, s390_f15, ins->sreg1);
3632                                 s390_ste  (code, s390_f15, 0, ins->inst_destbasereg, ins->inst_offset);
3633                         } else {
3634                                 s390_basr (code, s390_r13, 0);
3635                                 s390_j    (code, 4);
3636                                 s390_word (code, ins->inst_offset);
3637                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3638                                 s390_ledbr(code, s390_f15, ins->sreg1);
3639                                 s390_ste  (code, s390_f15, s390_r13, ins->inst_destbasereg, 0);
3640                         }
3641                 }
3642                         break;
3643                 case OP_LOADR4_MEMBASE: {
3644                         if (s390_is_uimm12(ins->inst_offset)) {
3645                                 s390_ldeb (code, ins->dreg, 0, ins->inst_basereg, ins->inst_offset);
3646                         } else {
3647                                 s390_basr (code, s390_r13, 0);
3648                                 s390_j    (code, 4);
3649                                 s390_word (code, ins->inst_offset);
3650                                 s390_l    (code, s390_r13, 0, s390_r13, 4);
3651                                 s390_ldeb (code, ins->dreg, s390_r13, ins->inst_basereg, 0);
3652                         }
3653                 }
3654                         break;
3655                 case CEE_CONV_R_UN: {
3656                         s390_cdfbr (code, ins->dreg, ins->sreg1);
3657                         s390_ltr   (code, ins->sreg1, ins->sreg1);
3658                         s390_jnl   (code, 12);
3659                         s390_basr  (code, s390_r13, 0);
3660                         s390_j     (code, 6);
3661                         s390_word  (code, 0x41f00000);
3662                         s390_word  (code, 0);
3663                         s390_adb   (code, ins->dreg, 0, s390_r13, 4);
3664                 }
3665                         break;
3666                 case CEE_CONV_R4: {
3667                         s390_cdfbr (code, ins->dreg, ins->sreg1);
3668                 }
3669                         break;
3670                 case CEE_CONV_R8: {
3671                         s390_cdfbr (code, ins->dreg, ins->sreg1);
3672                 }
3673                         break;
3674                 case OP_FCONV_TO_I1:
3675                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, TRUE);
3676                         break;
3677                 case OP_FCONV_TO_U1:
3678                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, FALSE);
3679                         break;
3680                 case OP_FCONV_TO_I2:
3681                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, TRUE);
3682                         break;
3683                 case OP_FCONV_TO_U2:
3684                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, FALSE);
3685                         break;
3686                 case OP_FCONV_TO_I4:
3687                 case OP_FCONV_TO_I:
3688                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, TRUE);
3689                         break;
3690                 case OP_FCONV_TO_U4:
3691                 case OP_FCONV_TO_U:
3692                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
3693                         break;
3694                 case OP_FCONV_TO_I8:
3695                 case OP_FCONV_TO_U8:
3696                         g_assert_not_reached ();
3697                         /* Implemented as helper calls */
3698                         break;
3699                 case OP_LCONV_TO_R_UN:
3700                         g_assert_not_reached ();
3701                         /* Implemented as helper calls */
3702                         break;
3703                 case OP_LCONV_TO_OVF_I: {
3704                         /* Valid ints: 0xffffffff:8000000 to 00000000:0x7f000000 */
3705                         short int *o[5];
3706                         s390_ltr  (code, ins->sreg1, ins->sreg1);
3707                         s390_jnl  (code, 0); CODEPTR(code, o[0]);
3708                         s390_ltr  (code, ins->sreg2, ins->sreg2);
3709                         s390_jnl  (code, 0); CODEPTR(code, o[1]);
3710                         s390_lhi  (code, s390_r13, -1);
3711                         s390_cr   (code, ins->sreg2, s390_r13);
3712                         s390_jnz  (code, 0); CODEPTR(code, o[2]);
3713                         if (ins->dreg != ins->sreg1)
3714                                 s390_lr   (code, ins->dreg, ins->sreg1);
3715                         s390_j    (code, 0); CODEPTR(code, o[3]);
3716                         PTRSLOT(code, o[0]);
3717                         s390_ltr  (code, ins->sreg2, ins->sreg2);
3718                         s390_jz   (code, 0); CODEPTR(code, o[4]);
3719                         PTRSLOT(code, o[1]);
3720                         PTRSLOT(code, o[2]);
3721                         mono_add_patch_info (cfg, code - cfg->native_code,
3722                                              MONO_PATCH_INFO_EXC, "OverflowException");
3723                         s390_brasl (code, s390_r14, 0);
3724                         PTRSLOT(code, o[3]);
3725                         PTRSLOT(code, o[4]);
3726                 }
3727                         break;
3728                 case OP_SQRT: {
3729                         s390_sqdbr (code, ins->dreg, ins->sreg1);
3730                 }
3731                         break;
3732                 case OP_FADD: {
3733                         if (ins->dreg == ins->sreg1)
3734                                 s390_adbr (code, ins->dreg, ins->sreg2);
3735                         else {
3736                                 if (ins->dreg == ins->sreg2)
3737                                         s390_adbr (code, ins->dreg, ins->sreg1);
3738                                 else {
3739                                         s390_ldr  (code, ins->dreg, ins->sreg1);
3740                                         s390_adbr (code, ins->dreg, ins->sreg2);
3741                                 }
3742                         }
3743                 }
3744                         break;
3745                 case OP_FSUB: {
3746                         CHECK_SRCDST_NCOM_F;
3747                         s390_sdbr (code, ins->dreg, src2);
3748                 }
3749                         break;
3750                 case OP_FMUL: {
3751                         if (ins->dreg == ins->sreg1)
3752                                 s390_mdbr (code, ins->dreg, ins->sreg2);
3753                         else {
3754                                 if (ins->dreg == ins->sreg2)
3755                                         s390_mdbr (code, ins->dreg, ins->sreg1);
3756                                 else {
3757                                         s390_ldr  (code, ins->dreg, ins->sreg1);
3758                                         s390_mdbr (code, ins->dreg, ins->sreg2);
3759                                 }
3760                         }
3761                 }
3762                         break;
3763                 case OP_FDIV: {
3764                         CHECK_SRCDST_NCOM_F;
3765                         s390_ddbr (code, ins->dreg, src2);
3766                 }
3767                         break;
3768                 case OP_FNEG: {
3769                         s390_lcdbr (code, ins->dreg, ins->sreg1);
3770                 }
3771                         break;
3772                 case OP_FREM: {
3773                         CHECK_SRCDST_NCOM_F;
3774                         s390_didbr (code, ins->dreg, ins->sreg2, 5, s390_f15);
3775                 }
3776                         break;
3777                 case OP_FCOMPARE: {
3778                         s390_cdbr (code, ins->sreg1, ins->sreg2);
3779                 }
3780                         break;
3781                 case OP_FCEQ: {
3782                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
3783                         s390_lhi   (code, ins->dreg, 1);
3784                         s390_je    (code, 4);
3785                         s390_lhi   (code, ins->dreg, 0);
3786                 }
3787                         break;
3788                 case OP_FCLT: {
3789                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
3790                         s390_lhi   (code, ins->dreg, 1);
3791                         s390_jl    (code, 4);
3792                         s390_lhi   (code, ins->dreg, 0);
3793                 }
3794                         break;
3795                 case OP_FCLT_UN: {
3796                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
3797                         s390_lhi   (code, ins->dreg, 1);
3798                         s390_jlo   (code, 4);
3799                         s390_lhi   (code, ins->dreg, 0);
3800                 }
3801                         break;
3802                 case OP_FCGT: {
3803                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
3804                         s390_lhi   (code, ins->dreg, 1);
3805                         s390_jh    (code, 4);
3806                         s390_lhi   (code, ins->dreg, 0);
3807                 }
3808                         break;
3809                 case OP_FCGT_UN: {
3810                         s390_cdbr  (code, ins->sreg1, ins->sreg2);
3811                         s390_lhi   (code, ins->dreg, 1);
3812                         s390_jho   (code, 4);
3813                         s390_lhi   (code, ins->dreg, 0);
3814                 }
3815                         break;
3816                 case OP_FBEQ:
3817                         EMIT_COND_BRANCH (ins, S390_CC_EQ|S390_CC_OV);
3818                         break;
3819                 case OP_FBNE_UN:
3820                         EMIT_COND_BRANCH (ins, S390_CC_NE|S390_CC_OV);
3821                         break;
3822                 case OP_FBLT:
3823                         EMIT_COND_BRANCH (ins, S390_CC_LT);
3824                         break;
3825                 case OP_FBLT_UN:
3826                         EMIT_COND_BRANCH (ins, S390_CC_LT|S390_CC_OV);
3827                         break;
3828                 case OP_FBGT:
3829                         EMIT_COND_BRANCH (ins, S390_CC_GT);
3830                         break;
3831                 case OP_FBGT_UN:
3832                         EMIT_COND_BRANCH (ins, S390_CC_GT|S390_CC_OV);
3833                         break;
3834                 case OP_FBGE:
3835                         EMIT_COND_BRANCH (ins, S390_CC_GE);
3836                         break;
3837                 case OP_FBGE_UN:
3838                         EMIT_COND_BRANCH (ins, S390_CC_GE|S390_CC_OV);
3839                         break;
3840                 case OP_FBLE:
3841                         EMIT_COND_BRANCH (ins, S390_CC_LE);
3842                         break;
3843                 case OP_FBLE_UN:
3844                         EMIT_COND_BRANCH (ins, S390_CC_LE|S390_CC_OV);
3845                         break;
3846                 case CEE_CKFINITE: {
3847                         short *o;
3848                         s390_lhi  (code, s390_r13, 0x7f);
3849                         s390_tcdb (code, ins->sreg1, 0, s390_r13, 0);
3850                         s390_jz   (code, 0); CODEPTR(code, o);
3851                         mono_add_patch_info (cfg, code - cfg->native_code,
3852                                              MONO_PATCH_INFO_EXC, "ArithmeticException");
3853                         s390_brasl (code, s390_r14,0);
3854                         PTRSLOT(code, o);
3855                 }
3856                         break;
3857                 case OP_S390_MOVE: {
3858                         if (ins->unused > 0) {
3859                                 if (ins->unused <= 256) {
3860                                         s390_mvc  (code, ins->unused, ins->dreg,
3861                                                    ins->inst_offset, ins->sreg1, ins->inst_imm);
3862                                 } else {
3863                                         s390_lr   (code, s390_r0, ins->dreg);
3864                                         if (s390_is_uimm16 (ins->inst_offset)) {
3865                                                 s390_ahi  (code, s390_r0, ins->inst_offset);
3866                                         } else {
3867                                                 s390_basr (code, s390_r13, 0);
3868                                                 s390_j    (code, 4);
3869                                                 s390_word (code, ins->inst_offset);
3870                                                 s390_a    (code, s390_r0, 0, s390_r13, 4);
3871                                         }
3872                                         s390_lr   (code, s390_r14, s390_r12);
3873                                         s390_lr   (code, s390_r12, ins->sreg1);
3874                                         if (s390_is_uimm16 (ins->inst_imm)) {
3875                                                 s390_ahi  (code, s390_r12, ins->inst_imm);
3876                                         } else {
3877                                                 s390_basr (code, s390_r13, 0);
3878                                                 s390_j    (code, 4);
3879                                                         s390_word (code, ins->inst_imm);
3880                                                 s390_a    (code, s390_r12, 0, s390_r13, 4);
3881                                         }
3882                                         s390_lr   (code, s390_r1, ins->sreg1);
3883                                         s390_lr   (code, s390_r13, s390_r1);
3884                                         s390_mvcle(code, s390_r0, s390_r12, 0, 0);
3885                                         s390_jo   (code, -2);
3886                                         s390_lr   (code, s390_r12, s390_r14);
3887                                 }
3888                         }
3889                 }
3890                         break;
3891                 case OP_ATOMIC_ADD_I4: {
3892                         s390_lr  (code, s390_r1, ins->sreg2);
3893                         s390_l   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
3894                         s390_a   (code, s390_r1, 0, ins->inst_basereg, ins->inst_offset);
3895                         s390_cs  (code, s390_r0, s390_r1, ins->inst_basereg, ins->inst_offset);
3896                         s390_jnz (code, -7);
3897                         s390_lr  (code, ins->dreg, s390_r1);
3898                 }
3899                         break;
3900                 case OP_ATOMIC_ADD_NEW_I4: {
3901                         s390_lr  (code, s390_r1, ins->sreg2);
3902                         s390_l   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
3903                         s390_a   (code, s390_r1, 0, ins->inst_basereg, ins->inst_offset);
3904                         s390_cs  (code, s390_r0, s390_r1, ins->inst_basereg, ins->inst_offset);
3905                         s390_jnz (code, -7);
3906                         s390_lr  (code, ins->dreg, s390_r1);
3907                 }
3908                         break;
3909                 case OP_ATOMIC_EXCHANGE_I4: {
3910                         s390_l   (code, s390_r0, 0, ins->inst_basereg, ins->inst_offset);
3911                         s390_cs  (code, s390_r0, ins->sreg2, ins->inst_basereg, ins->inst_offset);
3912                         s390_jnz (code, -4);
3913                         s390_lr  (code, ins->dreg, s390_r0);
3914                 }
3915                         break;
3916                 default:
3917                         g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
3918                         g_assert_not_reached ();
3919                 }
3920
3921                 if ((cfg->opt & MONO_OPT_BRANCH) && ((code - cfg->native_code - offset) > max_len)) {
3922                         g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %d)",
3923                                    mono_inst_name (ins->opcode), max_len, code - cfg->native_code - offset);
3924                         g_assert_not_reached ();
3925                 }
3926
3927                 cpos += max_len;
3928
3929                 last_ins = ins;
3930                 last_offset = offset;
3931
3932                 ins = ins->next;
3933         }
3934
3935         cfg->code_len = code - cfg->native_code;
3936 }
3937
3938 /*========================= End of Function ========================*/
3939
3940 /*------------------------------------------------------------------*/
3941 /*                                                                  */
3942 /* Name         - mono_arch_register_lowlevel_calls                 */
3943 /*                                                                  */
3944 /* Function     - Register routines to help with --trace operation. */
3945 /*                                                                  */
3946 /*------------------------------------------------------------------*/
3947
3948 void
3949 mono_arch_register_lowlevel_calls (void)
3950 {
3951         mono_register_jit_icall (mono_arch_break, "mono_arch_break", NULL, TRUE);
3952         mono_register_jit_icall (mono_arch_get_lmf_addr, "mono_arch_get_lmf_addr", NULL, TRUE);
3953 }
3954
3955 /*========================= End of Function ========================*/
3956
3957 /*------------------------------------------------------------------*/
3958 /*                                                                  */
3959 /* Name         - mono_arch_patch_code                              */
3960 /*                                                                  */
3961 /* Function     - Process the patch data created during the         */
3962 /*                instruction build process. This resolves jumps,   */
3963 /*                calls, variables etc.                             */
3964 /*                                                                  */
3965 /*------------------------------------------------------------------*/
3966
3967 static void
3968 mono_arch_break(void) {
3969 }
3970
3971 /*========================= End of Function ========================*/
3972
3973 /*------------------------------------------------------------------*/
3974 /*                                                                  */
3975 /* Name         - mono_arch_patch_code                              */
3976 /*                                                                  */
3977 /* Function     - Process the patch data created during the         */
3978 /*                instruction build process. This resolves jumps,   */
3979 /*                calls, variables etc.                             */
3980 /*                                                                  */
3981 /*------------------------------------------------------------------*/
3982
3983 void
3984 mono_arch_patch_code (MonoMethod *method, MonoDomain *domain,
3985                       guint8 *code, MonoJumpInfo *ji, gboolean run_cctors)
3986 {
3987         MonoJumpInfo *patch_info;
3988
3989         for (patch_info = ji; patch_info; patch_info = patch_info->next) {
3990                 unsigned char *ip = patch_info->ip.i + code;
3991                 gconstpointer target = NULL;
3992
3993                 target = mono_resolve_patch_target (method, domain, code,
3994                                                     patch_info, run_cctors);
3995
3996                 switch (patch_info->type) {
3997                         case MONO_PATCH_INFO_IP:
3998                         case MONO_PATCH_INFO_EXC_NAME:
3999                         case MONO_PATCH_INFO_LDSTR:
4000                         case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
4001                         case MONO_PATCH_INFO_LDTOKEN:
4002                         case MONO_PATCH_INFO_EXC:
4003                                 continue;
4004                         case MONO_PATCH_INFO_SWITCH:
4005                                 /*----------------------------------*/
4006                                 /* ip points at the basr r13,0/j +4 */
4007                                 /* instruction the vtable value     */
4008                                 /* follows this (i.e. ip+6)         */
4009                                 /*----------------------------------*/
4010                                 *((gconstpointer *)(ip+6)) = target;
4011                                 target = NULL;
4012                                 continue;
4013                         case MONO_PATCH_INFO_METHODCONST:
4014                         case MONO_PATCH_INFO_CLASS:
4015                         case MONO_PATCH_INFO_IMAGE:
4016                         case MONO_PATCH_INFO_FIELD:
4017                         case MONO_PATCH_INFO_IID:
4018                                 target = S390_RELATIVE(target, ip);
4019                                 continue;
4020                         case MONO_PATCH_INFO_R4:
4021                         case MONO_PATCH_INFO_R8:
4022                         case MONO_PATCH_INFO_METHOD_REL:
4023                                 g_assert_not_reached ();
4024                                 continue;
4025                         default:
4026                                 target = S390_RELATIVE(target, ip);
4027                                 ip += 2;
4028                 }
4029                 s390_patch (ip, target);
4030         }
4031 }
4032
4033 /*========================= End of Function ========================*/
4034
4035 /*------------------------------------------------------------------*/
4036 /*                                                                  */
4037 /* Name         - mono_arch_emit_prolog                             */
4038 /*                                                                  */
4039 /* Function     - Create the instruction sequence for a function    */
4040 /*                prolog.                                           */
4041 /*                                                                  */
4042 /*------------------------------------------------------------------*/
4043
4044 guint8 *
4045 mono_arch_emit_prolog (MonoCompile *cfg)
4046 {
4047         MonoMethod *method = cfg->method;
4048         MonoBasicBlock *bb;
4049         MonoMethodSignature *sig;
4050         MonoInst *inst;
4051         int alloc_size, pos, max_offset, i;
4052         guint8 *code;
4053         CallInfo *cinfo;
4054         size_data sz;
4055         int tracing = 0;
4056         int lmfOffset;                                                          \
4057         int     lFname,
4058                 lJump;
4059         char    *fname;
4060
4061         if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
4062                 tracing = 1;
4063
4064         cfg->code_size   = 512;
4065         cfg->native_code = code = g_malloc (cfg->code_size);
4066
4067         fname = mono_method_full_name (method, TRUE);
4068         lFname = strlen(fname);
4069         lJump  = (((lFname + 1) >> 1) << 1);
4070         s390_j (code, lJump/2+2);
4071         memcpy (code, fname, lFname);
4072         code  += lJump;
4073         g_free (fname);
4074
4075         if (cfg->flags & MONO_CFG_HAS_TAIL) {
4076                 s390_stm (code, s390_r2, s390_r14, STK_BASE, S390_PARM_SAVE_OFFSET);
4077                 for (pos = 0; pos < 4; pos++)
4078                         s390_std (code, pos, 0, STK_BASE,
4079                                   S390_FLOAT_SAVE_OFFSET+pos*sizeof(double));
4080         } else {
4081                 s390_stm  (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
4082         }
4083
4084         if (cfg->flags & MONO_CFG_HAS_ALLOCA) {
4085                 cfg->used_int_regs |= 1 << 11;
4086         }
4087
4088         alloc_size = cfg->stack_offset;
4089
4090         cfg->stack_usage = alloc_size;
4091         s390_lr   (code, s390_r11, STK_BASE);
4092         if (s390_is_uimm16 (alloc_size)) {
4093                 s390_ahi  (code, STK_BASE, -alloc_size);
4094         } else {
4095                 int stackSize = alloc_size;
4096                 while (stackSize > 32767) {
4097                         s390_ahi  (code, STK_BASE, -32767);
4098                         stackSize -= 32767;
4099                 }
4100                 s390_ahi  (code, STK_BASE, -stackSize);
4101         }
4102         s390_st   (code, s390_r11, 0, STK_BASE, 0);
4103
4104         if (cfg->frame_reg != STK_BASE)
4105                 s390_lr (code, s390_r11, STK_BASE);
4106
4107         /* compute max_offset in order to use short forward jumps
4108          * we always do it on s390 because the immediate displacement
4109          * for jumps is too small
4110          */
4111         max_offset = 0;
4112         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4113                 MonoInst *ins = bb->code;
4114                 bb->max_offset = max_offset;
4115
4116                 if (cfg->prof_options & MONO_PROFILE_COVERAGE)
4117                         max_offset += 6;
4118
4119                 while (ins) {
4120                         max_offset += ((guint8 *)ins_spec [ins->opcode])[MONO_INST_LEN];
4121                         ins = ins->next;
4122                 }
4123         }
4124
4125         /* load arguments allocated to register from the stack */
4126         sig = mono_method_signature (method);
4127         pos = 0;
4128
4129         cinfo = calculate_sizes (sig, &sz, sig->pinvoke);
4130
4131         if (cinfo->struct_ret) {
4132                 ArgInfo *ainfo = &cinfo->ret;
4133                 inst         = cfg->ret;
4134                 inst->unused = ainfo->vtsize;
4135                 s390_st (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4136         }
4137
4138         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
4139                 ArgInfo *ainfo = cinfo->args + i;
4140                 inst = cfg->varinfo [pos];
4141
4142                 if (inst->opcode == OP_REGVAR) {
4143                         if (ainfo->regtype == RegTypeGeneral)
4144                                 s390_lr (code, inst->dreg, ainfo->reg);
4145                         else if (ainfo->regtype == RegTypeFP) {
4146                                 if (inst->dreg != ainfo->reg) {
4147                                         if (ainfo->size == 4) {
4148                                                 s390_ledbr (code, inst->dreg, ainfo->reg);
4149                                         } else {
4150                                                 s390_ldr   (code, inst->dreg, ainfo->reg);
4151                                         }
4152                                 }
4153                         }
4154                         else if (ainfo->regtype == RegTypeBase) {
4155                                 s390_lr  (code, s390_r13, STK_BASE);
4156                                 s390_ahi (code, s390_r13, alloc_size);
4157                                 s390_l   (code, inst->dreg, 0, s390_r13, ainfo->offset);
4158                         } else
4159                                 g_assert_not_reached ();
4160
4161                         if (cfg->verbose_level > 2)
4162                                 g_print ("Argument %d assigned to register %s\n",
4163                                          pos, mono_arch_regname (inst->dreg));
4164                 } else {
4165                         if (ainfo->regtype == RegTypeGeneral) {
4166                                 if (!((ainfo->reg >= 2) && (ainfo->reg <= 6)))
4167                                         g_assert_not_reached();
4168                                 switch (ainfo->size) {
4169                                 case 1:
4170                                         s390_stc (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4171                                         break;
4172                                 case 2:
4173                                         s390_sth (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4174                                         break;
4175                                 case 8:
4176                                         s390_stm (code, ainfo->reg, ainfo->reg + 1,
4177                                                   inst->inst_basereg, inst->inst_offset);
4178                                         break;
4179                                 default:
4180                                         s390_st  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4181                                 }
4182                         } else if (ainfo->regtype == RegTypeBase) {
4183                         } else if (ainfo->regtype == RegTypeFP) {
4184                                 if (ainfo->size == 8)
4185                                         s390_std (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4186                                 else if (ainfo->size == 4)
4187                                         s390_ste (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4188                                 else
4189                                         g_assert_not_reached ();
4190                         } else if (ainfo->regtype == RegTypeStructByVal) {
4191                                 int doffset = inst->inst_offset;
4192                                 int reg;
4193                                 if (ainfo->reg != STK_BASE)
4194                                         reg = ainfo->reg;
4195                                 else {
4196                                         reg = s390_r0;
4197                                         s390_lr  (code, s390_r13, STK_BASE);
4198                                         s390_ahi (code, s390_r13, alloc_size);
4199                                 }
4200                                 switch (ainfo->size) {
4201                                         case 1:
4202                                                 if (ainfo->reg == STK_BASE)
4203                                                         s390_ic  (code, reg, 0, s390_r13, ainfo->offset+3);
4204                                                 s390_stc (code, reg, 0, inst->inst_basereg, doffset);
4205                                                 break;
4206                                         case 2:
4207                                                 if (ainfo->reg == STK_BASE)
4208                                                         s390_lh  (code, reg, 0, s390_r13, ainfo->offset+2);
4209                                                 s390_sth (code, reg, 0, inst->inst_basereg, doffset);
4210                                                 break;
4211                                         case 4:
4212                                                 if (ainfo->reg == STK_BASE)
4213                                                         s390_l   (code, reg, 0, s390_r13, ainfo->offset);
4214                                                 s390_st  (code, reg, 0, inst->inst_basereg, doffset);
4215                                                 break;
4216                                         case 8:
4217                                                 if (ainfo->reg == STK_BASE)
4218                                                         s390_lm  (code, s390_r0, s390_r1, s390_r13, ainfo->offset);
4219                                                 s390_stm (code, reg, reg+1, inst->inst_basereg, doffset);
4220                                                 break;
4221                                 }
4222                         } else if (ainfo->regtype == RegTypeStructByAddr) {
4223                                 if (ainfo->reg == STK_BASE) {
4224                                         s390_lr  (code, s390_r13, ainfo->reg);
4225                                         s390_ahi (code, s390_r13, alloc_size);
4226                                         s390_l   (code, s390_r13, 0, s390_r13,
4227                                                   ainfo->offparm + cinfo->offStruct);
4228                                         code = emit_memcpy (code, abs(ainfo->vtsize),
4229                                                             inst->inst_basereg,
4230                                                             inst->inst_offset, s390_r13, 0);
4231                                 } else {
4232                                         s390_st  (code, ainfo->reg, 0, inst->inst_basereg, inst->inst_offset);
4233 //                                      code = emit_memcpy (code, abs(ainfo->vtsize),
4234 //                                                          inst->inst_basereg,
4235 //                                                          inst->inst_offset,
4236 //                                                          ainfo->reg, 0);
4237                                 }
4238                         } else
4239                                 g_assert_not_reached ();
4240                 }
4241                 pos++;
4242         }
4243
4244         if (method->save_lmf) {
4245                 /*---------------------------------------------------------------*/
4246                 /* we build the MonoLMF structure on the stack - see mini-s390.h */
4247                 /*---------------------------------------------------------------*/
4248                 lmfOffset = alloc_size - sizeof(MonoLMF);
4249
4250                 s390_lr    (code, s390_r13, cfg->frame_reg);
4251                 s390_ahi   (code, s390_r13, lmfOffset);
4252
4253                 /*---------------------------------------------------------------*/
4254                 /* Preserve the parameter registers while we fix up the lmf      */
4255                 /*---------------------------------------------------------------*/
4256                 s390_stm   (code, s390_r2, s390_r6, s390_r13,
4257                             G_STRUCT_OFFSET(MonoLMF, pregs[0]));
4258
4259                 /*---------------------------------------------------------------*/
4260                 /* On return from this call r2 have the address of the &lmf      */
4261                 /*---------------------------------------------------------------*/
4262                 mono_add_patch_info (cfg, code - cfg->native_code,
4263                                      MONO_PATCH_INFO_INTERNAL_METHOD,
4264                                      (gpointer)"mono_get_lmf_addr");
4265                 s390_brasl (code, s390_r14, 0);
4266
4267                 /*---------------------------------------------------------------*/
4268                 /* Set lmf.lmf_addr = jit_tls->lmf                               */
4269                 /*---------------------------------------------------------------*/
4270                 s390_st    (code, s390_r2, 0, s390_r13,
4271                             G_STRUCT_OFFSET(MonoLMF, lmf_addr));
4272
4273                 /*---------------------------------------------------------------*/
4274                 /* Get current lmf                                               */
4275                 /*---------------------------------------------------------------*/
4276                 s390_l     (code, s390_r0, 0, s390_r2, 0);
4277
4278                 /*---------------------------------------------------------------*/
4279                 /* Set our lmf as the current lmf                                */
4280                 /*---------------------------------------------------------------*/
4281                 s390_st    (code, s390_r13, 0, s390_r2, 0);
4282
4283                 /*---------------------------------------------------------------*/
4284                 /* Have our lmf.previous_lmf point to the last lmf               */
4285                 /*---------------------------------------------------------------*/
4286                 s390_st    (code, s390_r0, 0, s390_r13,
4287                             G_STRUCT_OFFSET(MonoLMF, previous_lmf));
4288
4289                 /*---------------------------------------------------------------*/
4290                 /* save method info                                              */
4291                 /*---------------------------------------------------------------*/
4292                 s390_basr  (code, s390_r1, 0);
4293                 s390_j     (code, 4);
4294                 s390_word  (code, method);
4295                 s390_l     (code, s390_r1, 0, s390_r1, 4);
4296                 s390_st    (code, s390_r1, 0, s390_r13,
4297                             G_STRUCT_OFFSET(MonoLMF, method));
4298
4299                 /*---------------------------------------------------------------*/
4300                 /* save the current IP                                           */
4301                 /*---------------------------------------------------------------*/
4302                 s390_lr    (code, s390_r1, cfg->frame_reg);
4303                 s390_st    (code, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, ebp));
4304                 s390_basr  (code, s390_r1, 0);
4305                 s390_la    (code, s390_r1, 0, s390_r1, 0);
4306                 s390_st    (code, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, eip));
4307
4308                 /*---------------------------------------------------------------*/
4309                 /* Save general and floating point registers                     */
4310                 /*---------------------------------------------------------------*/
4311                 s390_stm   (code, s390_r2, s390_r12, s390_r13,
4312                             G_STRUCT_OFFSET(MonoLMF, gregs[2]));
4313                 for (i = 0; i < 16; i++) {
4314                         s390_std  (code, i, 0, s390_r13,
4315                                    G_STRUCT_OFFSET(MonoLMF, fregs[i]));
4316                 }
4317
4318                 /*---------------------------------------------------------------*/
4319                 /* Restore the parameter registers now that we've set up the lmf */
4320                 /*---------------------------------------------------------------*/
4321                 s390_lm    (code, s390_r2, s390_r6, s390_r13,
4322                             G_STRUCT_OFFSET(MonoLMF, pregs[0]));
4323         }
4324
4325         if (tracing)
4326                 code = mono_arch_instrument_prolog(cfg, enter_method, code, TRUE);
4327
4328         cfg->code_len = code - cfg->native_code;
4329         g_free (cinfo);
4330
4331         return code;
4332 }
4333
4334 /*========================= End of Function ========================*/
4335
4336 /*------------------------------------------------------------------*/
4337 /*                                                                  */
4338 /* Name         - mono_arch_emit_epilog                             */
4339 /*                                                                  */
4340 /* Function     - Emit the instructions for a function epilog.      */
4341 /*                                                                  */
4342 /*------------------------------------------------------------------*/
4343
4344 void
4345 mono_arch_emit_epilog (MonoCompile *cfg)
4346 {
4347         MonoJumpInfo *patch_info;
4348         MonoMethod *method = cfg->method;
4349         int tracing = 0;
4350         guint8 *code;
4351         int max_epilog_size = 96;
4352
4353         if (cfg->method->save_lmf)
4354                 max_epilog_size += 128;
4355
4356         if (mono_jit_trace_calls != NULL)
4357                 max_epilog_size += 128;
4358
4359         if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
4360                 max_epilog_size += 128;
4361
4362         while ((cfg->code_len + max_epilog_size) > (cfg->code_size - 16)) {
4363                 cfg->code_size  *= 2;
4364                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
4365                 mono_jit_stats.code_reallocs++;
4366         }
4367
4368         code = cfg->native_code + cfg->code_len;
4369
4370         if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) {
4371                 code = mono_arch_instrument_epilog (cfg, leave_method, code, TRUE);
4372                 tracing = 1;
4373         }
4374
4375         if (method->save_lmf)
4376                 restoreLMF(code, cfg->frame_reg, cfg->stack_usage);
4377
4378         if (cfg->flags & MONO_CFG_HAS_ALLOCA)
4379                 s390_l   (code, STK_BASE, 0, STK_BASE, 0);
4380         else
4381                 code = backUpStackPtr(cfg, code);
4382
4383         s390_lm  (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
4384         s390_br  (code, s390_r14);
4385
4386         cfg->code_len = code - cfg->native_code;
4387
4388         g_assert (cfg->code_len < cfg->code_size);
4389
4390 }
4391
4392 /*========================= End of Function ========================*/
4393
4394 /*------------------------------------------------------------------*/
4395 /*                                                                  */
4396 /* Name         - mono_arch_emit_exceptions                         */
4397 /*                                                                  */
4398 /* Function     - Emit the blocks to handle exception conditions.   */
4399 /*                                                                  */
4400 /*------------------------------------------------------------------*/
4401
4402 void
4403 mono_arch_emit_exceptions (MonoCompile *cfg)
4404 {
4405         MonoJumpInfo    *patch_info;
4406         guint8          *code;
4407         int             nThrows = 0,
4408                         exc_count = 0,
4409                         iExc;
4410         guint32         code_size;
4411         MonoClass       *exc_classes [MAX_EXC];
4412         guint8          *exc_throw_start [MAX_EXC],
4413                         *exc_throw_end [MAX_EXC];
4414
4415         for (patch_info = cfg->patch_info;
4416              patch_info;
4417              patch_info = patch_info->next) {
4418                 if (patch_info->type == MONO_PATCH_INFO_EXC)
4419                         exc_count++;
4420         }
4421
4422         code_size = exc_count * 26;
4423
4424         while ((cfg->code_len + code_size) > (cfg->code_size - 16)) {
4425                 cfg->code_size  *= 2;
4426                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
4427                 mono_jit_stats.code_reallocs++;
4428         }
4429
4430         code = cfg->native_code + cfg->code_len;
4431
4432         /*---------------------------------------------------------------------*/
4433         /* Add code to raise exceptions                                        */
4434         /*---------------------------------------------------------------------*/
4435         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
4436                 switch (patch_info->type) {
4437                 case MONO_PATCH_INFO_EXC: {
4438                         guint8 *ip = patch_info->ip.i + cfg->native_code;
4439                         MonoClass *exc_class;
4440                         guint32 throw_ip;
4441
4442                         /*-----------------------------------------------------*/
4443                         /* Patch the branch in epilog to come here             */
4444                         /*-----------------------------------------------------*/
4445                         s390_patch (ip + 2, S390_RELATIVE(code,ip));
4446
4447                         exc_class = mono_class_from_name (mono_defaults.corlib,
4448                                                           "System",
4449                                                           patch_info->data.name);
4450                         g_assert (exc_class);
4451                         throw_ip = patch_info->ip.i;
4452
4453                         for (iExc = 0; iExc < nThrows; ++iExc)
4454                                 if (exc_classes [iExc] == exc_class)
4455                                         break;
4456
4457                         if (iExc < nThrows) {
4458                                 s390_jcl (code, S390_CC_UN, exc_throw_start [iExc]);
4459                                 patch_info->type = MONO_PATCH_INFO_NONE;
4460                         } else {
4461
4462                                 if (nThrows < MAX_EXC) {
4463                                         exc_classes [nThrows]     = exc_class;
4464                                         exc_throw_start [nThrows] = code;
4465                                 }
4466
4467                                 /*---------------------------------------------*/
4468                                 /* Patch the parameter passed to the handler   */
4469                                 /*---------------------------------------------*/
4470                                 s390_basr (code, s390_r13, 0);
4471                                 s390_j    (code, 4);
4472                                 s390_word (code, patch_info->data.target);
4473                                 /*---------------------------------------------*/
4474                                 /* Load return address & parameter register    */
4475                                 /*---------------------------------------------*/
4476                                 s390_larl (code, s390_r14, S390_RELATIVE((patch_info->ip.i +
4477                                                            cfg->native_code + 8), code));
4478                                 s390_l    (code, s390_r2, 0, s390_r13, 4);
4479                                 /*---------------------------------------------*/
4480                                 /* Reuse the current patch to set the jump     */
4481                                 /*---------------------------------------------*/
4482                                 patch_info->type      = MONO_PATCH_INFO_INTERNAL_METHOD;
4483                                 patch_info->data.name = "mono_arch_throw_exception_by_name";
4484                                 patch_info->ip.i      = code - cfg->native_code;
4485                                 s390_jcl  (code, S390_CC_UN, 0);
4486                         }
4487                         break;
4488                 }
4489                 default:
4490                         /* do nothing */
4491                         break;
4492                 }
4493         }
4494
4495         cfg->code_len = code - cfg->native_code;
4496
4497         g_assert (cfg->code_len < cfg->code_size);
4498
4499 }
4500
4501 /*========================= End of Function ========================*/
4502
4503 /*------------------------------------------------------------------*/
4504 /*                                                                  */
4505 /* Name         - mono_arch_setup_jit_tls_data                      */
4506 /*                                                                  */
4507 /* Function     - Setup the JIT's Thread Level Specific Data.       */
4508 /*                                                                  */
4509 /*------------------------------------------------------------------*/
4510
4511 void
4512 mono_arch_setup_jit_tls_data (MonoJitTlsData *tls)
4513 {
4514 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
4515         pthread_t       self = pthread_self();
4516         pthread_attr_t  attr;
4517         void            *stAddr = NULL;
4518         size_t          stSize  = 0;
4519         struct sigaltstack sa;
4520 #endif
4521
4522         if (!tls_offset_inited) {
4523                 tls_offset_inited = TRUE;
4524
4525 #if HAVE_KW_THREAD
4526 # if 0
4527         __asm__ ("\tear\t%r1,0\n"
4528                  "\tlr\t%0,%3\n"
4529                  "\tsr\t%0,%r1\n"
4530                  "\tlr\t%1,%4\n"
4531                  "\tsr\t%1,%r1\n"
4532                  "\tlr\t%2,%5\n"
4533                  "\tsr\t%2,%r1\n"
4534                  : "=r" (appdomain_tls_offset),
4535                    "=r" (thread_tls_offset),
4536                    "=r" (lmf_tls_offset)
4537                  : "r" (&tls_appdomain),
4538                    "r" (&tls_current_object),
4539                    "r" (&mono_lmf_addr)
4540                  : "1", "cc");
4541 # endif
4542 #endif
4543         }
4544
4545 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
4546
4547         /*----------------------------------------------------------*/
4548         /* Determine stack boundaries                               */
4549         /*----------------------------------------------------------*/
4550         if (!mono_running_on_valgrind ()) {
4551 #ifdef HAVE_PTHREAD_GETATTR_NP
4552                 pthread_getattr_np( self, &attr );
4553 #elif HAVE_PTHREAD_ATTR_GET_NP
4554                 pthread_attr_get_np( self, &attr );
4555 #endif
4556                 pthread_attr_getstack( &attr, &stAddr, &stSize );
4557         }
4558
4559
4560         /*----------------------------------------------------------*/
4561         /* Setup an alternate signal stack                          */
4562         /*----------------------------------------------------------*/
4563         tls->stack_size        = stSize;
4564         tls->signal_stack      = mmap (0, SIGNAL_STACK_SIZE,
4565                                        PROT_READ|PROT_WRITE|PROT_EXEC,
4566                                        MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
4567         tls->signal_stack_size = SIGNAL_STACK_SIZE;
4568
4569         sa.ss_sp    = tls->signal_stack;
4570         sa.ss_size  = SIGNAL_STACK_SIZE;
4571         sa.ss_flags = SS_ONSTACK;
4572         sigaltstack (&sa, NULL);
4573 #endif
4574         if (!lmf_addr_key_inited) {
4575                 lmf_addr_key_inited = TRUE;
4576                 pthread_key_create (&lmf_addr_key, NULL);
4577         }
4578         pthread_setspecific (lmf_addr_key, &tls->lmf);
4579
4580 }
4581
4582 /*========================= End of Function ========================*/
4583
4584 /*------------------------------------------------------------------*/
4585 /*                                                                  */
4586 /* Name         - mono_arch_free_jit_tls_data                       */
4587 /*                                                                  */
4588 /* Function     - Free tls data.                                    */
4589 /*                                                                  */
4590 /*------------------------------------------------------------------*/
4591
4592 void
4593 mono_arch_free_jit_tls_data (MonoJitTlsData *tls)
4594 {
4595 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
4596         struct sigaltstack sa;
4597
4598         sa.ss_sp    = tls->signal_stack;
4599         sa.ss_size  = SIGNAL_STACK_SIZE;
4600         sa.ss_flags = SS_DISABLE;
4601         sigaltstack (&sa, NULL);
4602
4603         if (tls->signal_stack)
4604                 munmap(tls->signal_stack, SIGNAL_STACK_SIZE);
4605 #endif
4606
4607 }
4608
4609 /*========================= End of Function ========================*/
4610
4611 /*------------------------------------------------------------------*/
4612 /*                                                                  */
4613 /* Name         - mono_arch_emit_this_vret_args                     */
4614 /*                                                                  */
4615 /* Function     -                                                   */
4616 /*                                                                  */
4617 /*------------------------------------------------------------------*/
4618
4619 void
4620 mono_arch_emit_this_vret_args (MonoCompile *cfg, MonoCallInst *inst, int this_reg, int this_type, int vt_reg)
4621 {
4622         int this_dreg = s390_r2;
4623
4624         if (vt_reg != -1)
4625                 this_dreg = s390_r3;
4626
4627         /* add the this argument */
4628         if (this_reg != -1) {
4629                 MonoInst *this;
4630                 MONO_INST_NEW (cfg, this, OP_SETREG);
4631                 this->type  = this_type;
4632                 this->sreg1 = this_reg;
4633                 this->dreg  = mono_regstate_next_int (cfg->rs);
4634                 mono_bblock_add_inst (cfg->cbb, this);
4635                 mono_call_inst_add_outarg_reg (inst, this->dreg, this_dreg, FALSE);
4636         }
4637
4638         if (vt_reg != -1) {
4639                 MonoInst *vtarg;
4640                 MONO_INST_NEW (cfg, vtarg, OP_SETREG);
4641                 vtarg->type  = STACK_MP;
4642                 vtarg->sreg1 = vt_reg;
4643                 vtarg->dreg  = mono_regstate_next_int (cfg->rs);
4644                 mono_bblock_add_inst (cfg->cbb, vtarg);
4645                 mono_call_inst_add_outarg_reg (inst, vtarg->dreg, s390_r2, FALSE);
4646         }
4647 }
4648
4649 /*========================= End of Function ========================*/
4650
4651 /*------------------------------------------------------------------*/
4652 /*                                                                  */
4653 /* Name         - mono_arch_get_inst_for_method                   */
4654 /*                                                                  */
4655 /* Function     - Check for opcodes we can handle directly in       */
4656 /*                hardware.                                         */
4657 /*                                                                  */
4658 /*------------------------------------------------------------------*/
4659
4660 MonoInst*
4661 mono_arch_get_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod,
4662                                MonoMethodSignature *fsig, MonoInst **args)
4663 {
4664         MonoInst *ins = NULL;
4665
4666         if (cmethod->klass == mono_defaults.math_class) {
4667                 if (strcmp (cmethod->name, "Sqrt") == 0) {
4668                         MONO_INST_NEW (cfg, ins, OP_SQRT);
4669                         ins->inst_i0 = args [0];
4670                 }
4671         } else if(cmethod->klass->image == mono_defaults.corlib &&
4672                            (strcmp (cmethod->klass->name_space, "System.Threading") == 0) &&
4673                            (strcmp (cmethod->klass->name, "Interlocked") == 0)) {
4674
4675                 if (strcmp (cmethod->name, "Increment") == 0 &&
4676                     fsig->params [0]->type == MONO_TYPE_I4) {
4677                         MonoInst *ins_iconst;
4678
4679                         MONO_INST_NEW (cfg, ins, OP_ATOMIC_ADD_NEW_I4);
4680                         MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
4681                         ins_iconst->inst_c0 = 1;
4682
4683                         ins->inst_i0 = args [0];
4684                         ins->inst_i1 = ins_iconst;
4685                 } else if (strcmp (cmethod->name, "Decrement") == 0 &&
4686                            fsig->params [0]->type == MONO_TYPE_I4) {
4687                         MonoInst *ins_iconst;
4688
4689                         MONO_INST_NEW (cfg, ins, OP_ATOMIC_ADD_NEW_I4);
4690                         MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
4691                         ins_iconst->inst_c0 = -1;
4692
4693                         ins->inst_i0 = args [0];
4694                         ins->inst_i1 = ins_iconst;
4695                 } else if (strcmp (cmethod->name, "Exchange") == 0 &&
4696                            fsig->params [0]->type == MONO_TYPE_I4) {
4697                         MONO_INST_NEW (cfg, ins, OP_ATOMIC_EXCHANGE_I4);
4698
4699                         ins->inst_i0 = args [0];
4700                         ins->inst_i1 = args [1];
4701                 } else if (strcmp (cmethod->name, "Add") == 0 &&
4702                            fsig->params [0]->type == MONO_TYPE_I4) {
4703                         MONO_INST_NEW (cfg, ins, OP_ATOMIC_ADD_I4);
4704
4705                         ins->inst_i0 = args [0];
4706                         ins->inst_i1 = args [1];
4707                 }
4708         }
4709         return ins;
4710 }
4711
4712 /*========================= End of Function ========================*/
4713
4714 /*------------------------------------------------------------------*/
4715 /*                                                                  */
4716 /* Name         - mono_arch_print_tree                              */
4717 /*                                                                  */
4718 /* Function     - Print platform-specific opcode details.           */
4719 /*                                                                  */
4720 /* Returns      - 1 - opcode details have been printed              */
4721 /*                0 - opcode details have not been printed          */
4722 /*                                                                  */
4723 /*------------------------------------------------------------------*/
4724
4725 gboolean
4726 mono_arch_print_tree (MonoInst *tree, int arity)
4727 {
4728         gboolean done;
4729
4730         switch (tree->opcode) {
4731                 case OP_S390_LOADARG:
4732                 case OP_S390_ARGREG:
4733                 case OP_S390_ARGPTR:
4734                         printf ("[0x%x(%s)]", tree->inst_offset,
4735                                 mono_arch_regname (tree->inst_basereg));
4736                         done = 1;
4737                         break;
4738                 case OP_S390_STKARG:
4739                         printf ("[0x%x(previous_frame)]",
4740                                 tree->inst_offset);
4741                         done = 1;
4742                         break;
4743                 case OP_S390_MOVE:
4744                         printf ("[0x%x(%d,%s),0x%x(%s)]",
4745                                 tree->inst_offset, tree->unused,
4746                                 tree->dreg, tree->inst_imm,
4747                                 tree->sreg1);
4748                         done = 1;
4749                         break;
4750                 case OP_S390_SETF4RET:
4751                         printf ("[f%d,f%d]",
4752                                 mono_arch_regname (tree->dreg),
4753                                 mono_arch_regname (tree->sreg1));
4754                         done = 1;
4755                         break;
4756                 case OP_TLS_GET:
4757                         printf ("[0x%x(0x%x,%s)]", tree->inst_offset,
4758                                 tree->inst_imm,
4759                                 mono_arch_regname (tree->sreg1));
4760                         done = 1;
4761                 default:
4762                         done = 0;
4763         }
4764         return (done);
4765 }
4766
4767 /*========================= End of Function ========================*/
4768
4769 /*------------------------------------------------------------------*/
4770 /*                                                                  */
4771 /* Name         - mono_arch_regalloc_cost                           */
4772 /*                                                                  */
4773 /* Function     - Determine the cost, in the number of memory       */
4774 /*                references, of the action of allocating the var-  */
4775 /*                iable VMV into a register during global register  */
4776 /*                allocation.                                       */
4777 /*                                                                  */
4778 /* Returns      - Cost                                              */
4779 /*                                                                  */
4780 /*------------------------------------------------------------------*/
4781
4782 guint32
4783 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
4784 {
4785         /* FIXME: */
4786         return 2;
4787 }
4788
4789 /*========================= End of Function ========================*/
4790
4791 /*------------------------------------------------------------------*/
4792 /*                                                                  */
4793 /* Name         - mono_arch_get_domain_intrinsic                    */
4794 /*                                                                  */
4795 /* Function     -                                                   */
4796 /*                                                                  */
4797 /* Returns      -                                                   */
4798 /*                                                                  */
4799 /*------------------------------------------------------------------*/
4800
4801 MonoInst *
4802 mono_arch_get_domain_intrinsic (MonoCompile* cfg)
4803 {
4804         MonoInst *ins;
4805
4806         if (appdomain_tls_offset == -1)
4807                 return NULL;
4808
4809         MONO_INST_NEW (cfg, ins, OP_TLS_GET);
4810         ins->inst_offset = appdomain_tls_offset;
4811         return (ins);
4812 }
4813
4814 /*========================= End of Function ========================*/
4815
4816 /*------------------------------------------------------------------*/
4817 /*                                                                  */
4818 /* Name         - mono_arch_get_thread_intrinsic                    */
4819 /*                                                                  */
4820 /* Function     -                                                   */
4821 /*                                                                  */
4822 /* Returns      -                                                   */
4823 /*                                                                  */
4824 /*------------------------------------------------------------------*/
4825
4826 MonoInst *
4827 mono_arch_get_thread_intrinsic (MonoCompile* cfg)
4828 {
4829         MonoInst *ins;
4830
4831         if (thread_tls_offset == -1)
4832                 return NULL;
4833
4834         MONO_INST_NEW (cfg, ins, OP_TLS_GET);
4835         ins->inst_offset = thread_tls_offset;
4836         return (ins);
4837 }
4838
4839 /*========================= End of Function ========================*/
4840
4841 /*------------------------------------------------------------------*/
4842 /*                                                                  */
4843 /* Name         - mono_arch_flush_register_windows                  */
4844 /*                                                                  */
4845 /* Function     -                                                   */
4846 /*                                                                  */
4847 /* Returns      -                                                   */
4848 /*                                                                  */
4849 /*------------------------------------------------------------------*/
4850
4851 void
4852 mono_arch_flush_register_windows (void)
4853 {
4854 }
4855
4856 /*========================= End of Function ========================*/
4857
4858 /*------------------------------------------------------------------*/
4859 /*                                                                  */
4860 /* Name         - mono_arch_get_lmf_addr                            */
4861 /*                                                                  */
4862 /* Function     -                                                   */
4863 /*                                                                  */
4864 /* Returns      -                                                   */
4865 /*                                                                  */
4866 /*------------------------------------------------------------------*/
4867
4868 gpointer
4869 mono_arch_get_lmf_addr (void)
4870 {
4871         return pthread_getspecific (lmf_addr_key);
4872 }
4873
4874
4875 /*========================= End of Function ========================*/