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