1 /*------------------------------------------------------------------*/
3 /* Name - mini-s390.c */
5 /* Function - S/390 backend for the Mono code generator. */
7 /* Name - Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com) */
9 /* Date - January, 2004 */
11 /* Derivation - From mini-x86 & mini-ppc by - */
12 /* Paolo Molaro (lupus@ximian.com) */
13 /* Dietmar Maurer (dietmar@ximian.com) */
15 /*------------------------------------------------------------------*/
17 /*------------------------------------------------------------------*/
19 /*------------------------------------------------------------------*/
21 #define EMIT_COND_BRANCH(ins,cond) \
23 if (ins->flags & MONO_INST_BRLABEL) { \
24 if (ins->inst_i0->inst_c0) { \
26 displace = ((cfg->native_code + ins->inst_i0->inst_c0) - code) / 2; \
27 if (s390_is_imm16(displace)) { \
28 s390_brc (code, cond, displace); \
30 s390_jcl (code, cond, displace); \
33 mono_add_patch_info (cfg, code - cfg->native_code, \
34 MONO_PATCH_INFO_LABEL, ins->inst_i0); \
35 s390_jcl (code, cond, 0); \
38 if (ins->inst_true_bb->native_offset) { \
40 displace = ((cfg->native_code + \
41 ins->inst_true_bb->native_offset) - code) / 2; \
42 if (s390_is_imm16(displace)) { \
43 s390_brc (code, cond, displace); \
45 s390_jcl (code, cond, displace); \
48 mono_add_patch_info (cfg, code - cfg->native_code, \
49 MONO_PATCH_INFO_BB, ins->inst_true_bb); \
50 s390_jcl (code, cond, 0); \
55 #define EMIT_UNCOND_BRANCH(ins) \
57 if (ins->flags & MONO_INST_BRLABEL) { \
58 if (ins->inst_i0->inst_c0) { \
60 displace = ((cfg->native_code + ins->inst_i0->inst_c0) - code) / 2; \
61 if (s390_is_imm16(displace)) { \
62 s390_brc (code, S390_CC_UN, displace); \
64 s390_jcl (code, S390_CC_UN, displace); \
67 mono_add_patch_info (cfg, code - cfg->native_code, \
68 MONO_PATCH_INFO_LABEL, ins->inst_i0); \
69 s390_jcl (code, S390_CC_UN, 0); \
72 if (ins->inst_target_bb->native_offset) { \
74 displace = ((cfg->native_code + \
75 ins->inst_target_bb->native_offset) - code) / 2; \
76 if (s390_is_imm16(displace)) { \
77 s390_brc (code, S390_CC_UN, displace); \
79 s390_jcl (code, S390_CC_UN, displace); \
82 mono_add_patch_info (cfg, code - cfg->native_code, \
83 MONO_PATCH_INFO_BB, ins->inst_target_bb); \
84 s390_jcl (code, S390_CC_UN, 0); \
89 #define EMIT_COND_SYSTEM_EXCEPTION(cond,exc_name) \
91 mono_add_patch_info (cfg, code - cfg->native_code, \
92 MONO_PATCH_INFO_EXC, exc_name); \
93 s390_jcl (code, cond, 0); \
96 #define CHECK_SRCDST_COM \
97 if (ins->dreg == ins->sreg2) { \
101 if (ins->dreg != ins->sreg1) { \
102 s390_lgr (code, ins->dreg, ins->sreg1); \
106 #define CHECK_SRCDST_NCOM \
107 if (ins->dreg == ins->sreg2) { \
109 s390_lgr (code, s390_r13, ins->sreg2); \
113 if (ins->dreg != ins->sreg1) { \
114 s390_lgr (code, ins->dreg, ins->sreg1); \
117 #define CHECK_SRCDST_COM_I \
118 if (ins->dreg == ins->sreg2) { \
122 if (ins->dreg != ins->sreg1) { \
123 s390_lgfr (code, ins->dreg, ins->sreg1); \
127 #define CHECK_SRCDST_NCOM_I \
128 if (ins->dreg == ins->sreg2) { \
130 s390_lgfr (code, s390_r13, ins->sreg2); \
134 if (ins->dreg != ins->sreg1) { \
135 s390_lgfr (code, ins->dreg, ins->sreg1); \
138 #define CHECK_SRCDST_COM_F \
139 if (ins->dreg == ins->sreg2) { \
143 if (ins->dreg != ins->sreg1) { \
144 s390_ldr (code, ins->dreg, ins->sreg1); \
148 #define CHECK_SRCDST_NCOM_F \
149 if (ins->dreg == ins->sreg2) { \
151 s390_ldr (code, s390_r13, ins->sreg2); \
155 if (ins->dreg != ins->sreg1) { \
156 s390_ldr (code, ins->dreg, ins->sreg1); \
159 #define MONO_EMIT_NEW_MOVE2(cfg,dest,offset,src,imm,size) do { \
163 MONO_INST_NEW (cfg, inst, OP_NOP); \
165 tmpr = mono_alloc_preg (cfg); \
166 MONO_EMIT_NEW_ICONST(cfg,tmpr,size); \
168 inst->inst_offset = offset; \
170 inst->inst_imm = imm; \
171 inst->sreg2 = tmpr; \
173 if (s390_is_uimm12(offset)) { \
175 inst->inst_offset = offset; \
177 dReg = mono_alloc_preg (cfg); \
178 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM, \
179 dReg, dest, offset); \
181 inst->inst_offset = 0; \
183 if (s390_is_uimm12(imm)) { \
185 inst->inst_imm = imm; \
187 sReg = mono_alloc_preg (cfg); \
188 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM, \
190 inst->sreg1 = sReg; \
191 inst->inst_imm = 0; \
194 inst->opcode = OP_S390_MOVE; \
195 inst->backend.size = size; \
196 MONO_ADD_INS (cfg->cbb, inst); \
199 #define MONO_OUTPUT_VTR2(cfg, size, dr, sr, so) do { \
200 int reg = mono_alloc_preg (cfg); \
203 MONO_EMIT_NEW_ICONST(cfg, reg, 0); \
206 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE, \
210 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE, \
214 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI4_MEMBASE, \
218 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI8_MEMBASE, \
222 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
225 #define MONO_OUTPUT_VTS2(cfg, size, dr, dx, sr, so) do { \
229 tmpr = mono_alloc_preg (cfg); \
230 MONO_EMIT_NEW_ICONST(cfg, tmpr, 0); \
231 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
235 tmpr = mono_alloc_preg (cfg); \
236 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE, \
238 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
242 tmpr = mono_alloc_preg (cfg); \
243 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE, \
245 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
249 tmpr = mono_alloc_preg (cfg); \
250 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADI4_MEMBASE, \
252 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
256 MONO_EMIT_NEW_MOVE2 (cfg, dr, dx, sr, so, size); \
262 #define DEBUG(a) if (cfg->verbose_level > 1) a
266 #define S390_TRACE_STACK_SIZE (5*sizeof(gpointer)+4*sizeof(gdouble))
268 #define MAX(a, b) ((a) > (b) ? (a) : (b))
270 /*========================= End of Defines =========================*/
272 /*------------------------------------------------------------------*/
273 /* I n c l u d e s */
274 /*------------------------------------------------------------------*/
279 #include <mono/metadata/appdomain.h>
280 #include <mono/metadata/debug-helpers.h>
281 #include <mono/metadata/profiler-private.h>
282 #include <mono/utils/mono-math.h>
284 #include "mini-s390x.h"
286 #include "cpu-s390x.h"
287 #include "jit-icalls.h"
289 /*========================= End of Includes ========================*/
291 /*------------------------------------------------------------------*/
292 /* T y p e d e f s */
293 /*------------------------------------------------------------------*/
305 /*------------------------------------------------------------------*/
306 /* Used by the instrument_emit_epilog */
307 /*------------------------------------------------------------------*/
318 typedef struct InstList InstList
;
332 RegTypeStructByValInFP
,
337 gint32 offset
; /* offset from caller's stack */
338 gint32 offparm
; /* offset from callee's stack */
339 guint16 vtsize
; /* in param area */
342 guint32 size
; /* Size of structure used by RegTypeStructByVal */
343 gint32 type
; /* Data type of argument */
358 gint64 gr
[5]; /* R2-R6 */
359 gdouble fp
[3]; /* F0-F2 */
360 } __attribute__ ((packed
)) RegParm
;
362 /*========================= End of Typedefs ========================*/
364 /*------------------------------------------------------------------*/
365 /* P r o t o t y p e s */
366 /*------------------------------------------------------------------*/
368 static void indent (int);
369 static guint8
* backUpStackPtr(MonoCompile
*, guint8
*);
370 static void decodeParm (MonoType
*, void *, int);
371 static void enter_method (MonoMethod
*, RegParm
*, char *);
372 static void leave_method (MonoMethod
*, ...);
373 static gboolean
is_regsize_var (MonoType
*);
374 static inline void add_general (guint
*, size_data
*, ArgInfo
*);
375 static inline void add_stackParm (guint
*, size_data
*, ArgInfo
*, gint
);
376 static inline void add_float (guint
*, size_data
*, ArgInfo
*);
377 static CallInfo
* get_call_info (MonoCompile
*, MonoMemPool
*, MonoMethodSignature
*, gboolean
);
378 static guchar
* emit_float_to_int (MonoCompile
*, guchar
*, int, int, int, gboolean
);
379 gpointer
mono_arch_get_lmf_addr (void);
380 static guint8
* emit_load_volatile_arguments (guint8
*, MonoCompile
*);
381 static void catch_SIGILL(int, siginfo_t
*, void *);
382 static void emit_sig_cookie (MonoCompile
*, MonoCallInst
*, CallInfo
*, int);
384 /*========================= End of Prototypes ======================*/
386 /*------------------------------------------------------------------*/
387 /* G l o b a l V a r i a b l e s */
388 /*------------------------------------------------------------------*/
390 int mono_exc_esp_offset
= 0;
392 static int indent_level
= 0;
396 static gboolean tls_offset_inited
= FALSE
;
398 static int appdomain_tls_offset
= -1,
399 thread_tls_offset
= -1;
401 pthread_key_t lmf_addr_key
;
403 gboolean lmf_addr_key_inited
= FALSE
;
407 extern __thread MonoDomain
*tls_appdomain
;
408 extern __thread MonoThread
*tls_current_object
;
409 extern __thread gpointer mono_lmf_addr
;
413 /*====================== End of Global Variables ===================*/
415 /*------------------------------------------------------------------*/
417 /* Name - mono_arch_regname */
419 /* Function - Returns the name of the register specified by */
420 /* the input parameter. */
422 /*------------------------------------------------------------------*/
425 mono_arch_regname (int reg
) {
426 static const char * rnames
[] = {
427 "s390_r0", "s390_sp", "s390_r2", "s390_r3", "s390_r4",
428 "s390_r5", "s390_r6", "s390_r7", "s390_r8", "s390_r9",
429 "s390_r10", "s390_r11", "s390_r12", "s390_r13", "s390_r14",
433 if (reg
>= 0 && reg
< 16)
439 /*========================= End of Function ========================*/
441 /*------------------------------------------------------------------*/
443 /* Name - mono_arch_fregname */
445 /* Function - Returns the name of the register specified by */
446 /* the input parameter. */
448 /*------------------------------------------------------------------*/
451 mono_arch_fregname (int reg
) {
452 static const char * rnames
[] = {
453 "s390_f0", "s390_f1", "s390_f2", "s390_f3", "s390_f4",
454 "s390_f5", "s390_f6", "s390_f7", "s390_f8", "s390_f9",
455 "s390_f10", "s390_f11", "s390_f12", "s390_f13", "s390_f14",
459 if (reg
>= 0 && reg
< 16)
465 /*========================= End of Function ========================*/
467 /*------------------------------------------------------------------*/
469 /* Name - arch_get_argument_info */
471 /* Function - Gathers information on parameters such as size, */
472 /* alignment, and padding. arg_info should be large */
473 /* enough to hold param_count + 1 entries. */
475 /* Parameters - @csig - Method signature */
476 /* @param_count - No. of parameters to consider */
477 /* @arg_info - An array to store the result info */
479 /* Returns - Size of the activation frame */
481 /*------------------------------------------------------------------*/
484 mono_arch_get_argument_info (MonoMethodSignature
*csig
,
486 MonoJitArgumentInfo
*arg_info
)
488 int k
, frame_size
= 0;
489 int size
, align
, pad
;
492 if (MONO_TYPE_ISSTRUCT (csig
->ret
)) {
493 frame_size
+= sizeof (gpointer
);
497 arg_info
[0].offset
= offset
;
500 frame_size
+= sizeof (gpointer
);
504 arg_info
[0].size
= frame_size
;
506 for (k
= 0; k
< param_count
; k
++) {
509 size
= mono_type_native_stack_size (csig
->params
[k
], &align
);
511 size
= mini_type_stack_size (NULL
, csig
->params
[k
], &align
);
513 frame_size
+= pad
= (align
- (frame_size
& (align
- 1))) & (align
- 1);
514 arg_info
[k
].pad
= pad
;
516 arg_info
[k
+ 1].pad
= 0;
517 arg_info
[k
+ 1].size
= size
;
519 arg_info
[k
+ 1].offset
= offset
;
523 align
= MONO_ARCH_FRAME_ALIGNMENT
;
524 frame_size
+= pad
= (align
- (frame_size
& (align
- 1))) & (align
- 1);
525 arg_info
[k
].pad
= pad
;
530 /*========================= End of Function ========================*/
532 /*------------------------------------------------------------------*/
534 /* Name - retFitsInReg. */
536 /* Function - Determines if a value can be returned in one or */
539 /*------------------------------------------------------------------*/
541 static inline gboolean
542 retFitsInReg(guint32 size
)
557 /*========================= End of Function ========================*/
559 /*------------------------------------------------------------------*/
561 /* Name - backStackPtr. */
563 /* Function - Restore Stack Pointer to previous frame. */
565 /*------------------------------------------------------------------*/
567 static inline guint8
*
568 backUpStackPtr(MonoCompile
*cfg
, guint8
*code
)
570 int stackSize
= cfg
->stack_usage
;
572 if (s390_is_imm16 (stackSize
)) {
573 s390_aghi (code
, STK_BASE
, stackSize
);
575 while (stackSize
> 32767) {
576 s390_aghi (code
, STK_BASE
, 32767);
579 s390_aghi (code
, STK_BASE
, stackSize
);
584 /*========================= End of Function ========================*/
586 /*------------------------------------------------------------------*/
590 /* Function - Perform nice indenting to current level */
592 /*------------------------------------------------------------------*/
598 indent_level
+= diff
;
605 indent_level
+= diff
;
608 /*========================= End of Function ========================*/
610 /*------------------------------------------------------------------*/
612 /* Name - decodeParm */
614 /* Function - Decode a parameter for the trace. */
616 /*------------------------------------------------------------------*/
619 decodeParm(MonoType
*type
, void *curParm
, int size
)
624 printf("[BYREF:%p], ", *((char **) curParm
));
626 simpleType
= mono_type_get_underlying_type(type
)->type
;
628 switch (simpleType
) {
630 printf ("[INTPTR:%p], ", *((int **) curParm
));
633 printf ("[UINTPTR:%p], ", *((int **) curParm
));
635 case MONO_TYPE_BOOLEAN
:
636 printf ("[BOOL:%ld], ", *((gint64
*) curParm
));
638 case MONO_TYPE_CHAR
:
639 printf ("[CHAR:%c], ", *((int *) curParm
));
642 printf ("[INT1:%ld], ", *((gint64
*) curParm
));
645 printf ("[INT2:%ld], ", *((gint64
*) curParm
));
648 printf ("[INT4:%ld], ", *((gint64
*) curParm
));
651 printf ("[UINT1:%lu], ", *((guint64
*) curParm
));
654 printf ("[UINT2:%lu], ", *((guint64
*) curParm
));
657 printf ("[UINT4:%lu], ", *((guint64
*) curParm
));
660 printf ("[UINT8:%lu], ", *((guint64
*) curParm
));
662 case MONO_TYPE_STRING
: {
663 MonoString
*s
= *((MonoString
**) curParm
);
665 g_assert (((MonoObject
*) s
)->vtable
->klass
== mono_defaults
.string_class
);
666 printf("[STRING:%p:%s], ", s
, mono_string_to_utf8(s
));
668 printf("[STRING:null], ");
672 case MONO_TYPE_CLASS
:
673 case MONO_TYPE_OBJECT
: {
674 MonoObject
*obj
= *((MonoObject
**) curParm
);
676 if ((obj
) && (obj
->vtable
)) {
677 printf("[CLASS/OBJ:");
678 class = obj
->vtable
->klass
;
679 printf("%p [%p] ",obj
,curParm
);
680 if (class == mono_defaults
.string_class
) {
681 printf("[STRING:%p:%s]",
682 obj
, mono_string_to_utf8 ((MonoString
*) obj
));
683 } else if (class == mono_defaults
.int32_class
) {
684 printf("[INT32:%p:%d]",
685 obj
, *(gint32
*)((char *)obj
+ sizeof (MonoObject
)));
688 class->name_space
, class->name
, obj
);
691 printf("[OBJECT:null], ");
696 printf("[PTR:%p], ", *((gpointer
**) (curParm
)));
698 case MONO_TYPE_FNPTR
:
699 printf("[FNPTR:%p], ", *((gpointer
**) (curParm
)));
701 case MONO_TYPE_ARRAY
:
702 printf("[ARRAY:%p], ", *((gpointer
**) (curParm
)));
704 case MONO_TYPE_SZARRAY
:
705 printf("[SZARRAY:%p], ", *((gpointer
**) (curParm
)));
708 printf("[INT8:%ld], ", *((gint64
*) (curParm
)));
711 printf("[FLOAT4:%g], ", *((float *) (curParm
)));
714 printf("[FLOAT8:%g], ", *((double *) (curParm
)));
716 case MONO_TYPE_VALUETYPE
: {
718 MonoMarshalType
*info
;
720 if (type
->data
.klass
->enumtype
) {
721 simpleType
= type
->data
.klass
->enum_basetype
->type
;
722 printf("{VALUETYPE} - ");
726 info
= mono_marshal_load_type_info (type
->data
.klass
);
728 if ((info
->native_size
== sizeof(float)) &&
729 (info
->num_fields
== 1) &&
730 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
731 printf("[FLOAT4:%f], ", *((float *) (curParm
)));
735 if ((info
->native_size
== sizeof(double)) &&
736 (info
->num_fields
== 1) &&
737 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
738 printf("[FLOAT8:%g], ", *((double *) (curParm
)));
742 printf("[VALUETYPE:");
743 for (i
= 0; i
< size
; i
++)
744 printf("%02x,", *((guint8
*)curParm
+i
));
748 case MONO_TYPE_TYPEDBYREF
: {
750 printf("[TYPEDBYREF:");
751 for (i
= 0; i
< size
; i
++)
752 printf("%02x,", *((guint8
*)curParm
+i
));
757 printf("[?? - %d], ",simpleType
);
762 /*========================= End of Function ========================*/
764 /*------------------------------------------------------------------*/
766 /* Name - enter_method */
768 /* Function - Perform tracing of the entry to the current */
771 /*------------------------------------------------------------------*/
774 enter_method (MonoMethod
*method
, RegParm
*rParm
, char *sp
)
776 int i
, oParm
= 0, iParm
= 0;
779 MonoMethodSignature
*sig
;
786 fname
= mono_method_full_name (method
, TRUE
);
788 printf ("ENTER: %s ", fname
);
791 ip
= (*(guint64
*) (sp
+S390_RET_ADDR_OFFSET
));
792 printf ("ip: %p sp: %p - ", (gpointer
) ip
, sp
);
797 sig
= mono_method_signature (method
);
799 cinfo
= get_call_info (NULL
, NULL
, sig
, sig
->pinvoke
);
801 if (cinfo
->struct_ret
) {
802 printf ("[STRUCTRET:%p], ", (gpointer
) rParm
->gr
[0]);
807 gpointer
*this = (gpointer
*) rParm
->gr
[iParm
];
808 obj
= (MonoObject
*) this;
809 if (method
->klass
->valuetype
) {
811 printf("this:[value:%p:%016lx], ",
812 this, *((guint64
*)(this+sizeof(MonoObject
))));
814 printf ("this:[NULL], ");
817 class = obj
->vtable
->klass
;
818 if (class == mono_defaults
.string_class
) {
819 printf ("this:[STRING:%p:%s], ",
820 obj
, mono_string_to_utf8 ((MonoString
*)obj
));
822 printf ("this:%p[%s.%s], ",
823 obj
, class->name_space
, class->name
);
826 printf ("this:NULL, ");
831 for (i
= 0; i
< sig
->param_count
; ++i
) {
832 ainfo
= &cinfo
->args
[i
+ oParm
];
833 switch (ainfo
->regtype
) {
834 case RegTypeGeneral
:
835 decodeParm(sig
->params
[i
], &(rParm
->gr
[ainfo
->reg
-2]), ainfo
->size
);
838 decodeParm(sig
->params
[i
], &(rParm
->fp
[ainfo
->reg
]), ainfo
->size
);
841 decodeParm(sig
->params
[i
], sp
+ainfo
->offset
, ainfo
->size
);
843 case RegTypeStructByVal
:
844 if (ainfo
->reg
!= STK_BASE
) {
845 int offset
= sizeof(glong
) - ainfo
->size
;
846 curParm
= &(rParm
->gr
[ainfo
->reg
-2])+offset
;
849 curParm
= sp
+ainfo
->offset
;
851 if (retFitsInReg (ainfo
->vtsize
))
852 decodeParm(sig
->params
[i
],
856 decodeParm(sig
->params
[i
],
857 *((char **) curParm
),
860 case RegTypeStructByAddr
:
861 if (ainfo
->reg
!= STK_BASE
)
862 curParm
= &(rParm
->gr
[ainfo
->reg
-2]);
864 curParm
= sp
+ainfo
->offset
;
866 decodeParm(sig
->params
[i
],
867 *((char **) curParm
),
879 /*========================= End of Function ========================*/
881 /*------------------------------------------------------------------*/
883 /* Name - leave_method */
887 /*------------------------------------------------------------------*/
890 leave_method (MonoMethod
*method
, ...)
897 va_start(ap
, method
);
899 fname
= mono_method_full_name (method
, TRUE
);
901 printf ("LEAVE: %s", fname
);
904 type
= mono_method_signature (method
)->ret
;
907 switch (type
->type
) {
910 case MONO_TYPE_BOOLEAN
: {
911 int val
= va_arg (ap
, int);
913 printf ("[TRUE:%d]", val
);
919 case MONO_TYPE_CHAR
: {
920 int val
= va_arg (ap
, int);
921 printf ("[CHAR:%d]", val
);
925 int val
= va_arg (ap
, int);
926 printf ("[INT1:%d]", val
);
930 int val
= va_arg (ap
, int);
931 printf ("[UINT1:%d]", val
);
935 int val
= va_arg (ap
, int);
936 printf ("[INT2:%d]", val
);
940 int val
= va_arg (ap
, int);
941 printf ("[UINT2:%d]", val
);
945 int val
= va_arg (ap
, int);
946 printf ("[INT4:%d]", val
);
950 int val
= va_arg (ap
, int);
951 printf ("[UINT4:%d]", val
);
955 gint64 val
= va_arg (ap
, gint64
);
956 printf ("[INT:%ld]", val
);
961 gint64 val
= va_arg (ap
, gint64
);
962 printf ("[UINT:%lu]", val
);
966 case MONO_TYPE_STRING
: {
967 MonoString
*s
= va_arg (ap
, MonoString
*);
970 g_assert (((MonoObject
*)s
)->vtable
->klass
== mono_defaults
.string_class
);
971 printf ("[STRING:%p:%s]", s
, mono_string_to_utf8 (s
));
973 printf ("[STRING:null], ");
976 case MONO_TYPE_CLASS
:
977 case MONO_TYPE_OBJECT
: {
978 MonoObject
*o
= va_arg (ap
, MonoObject
*);
980 if ((o
) && (o
->vtable
)) {
981 if (o
->vtable
->klass
== mono_defaults
.boolean_class
) {
982 printf ("[BOOLEAN:%p:%d]", o
, *((guint8
*)o
+ sizeof (MonoObject
)));
983 } else if (o
->vtable
->klass
== mono_defaults
.int32_class
) {
984 printf ("[INT32:%p:%d]", o
, *((gint32
*)((char *)o
+ sizeof (MonoObject
))));
985 } else if (o
->vtable
->klass
== mono_defaults
.int64_class
) {
986 printf ("[INT64:%p:%ld]", o
, *((gint64
*)((char *)o
+ sizeof (MonoObject
))));
988 printf ("[%s.%s:%p]", o
->vtable
->klass
->name_space
, o
->vtable
->klass
->name
, o
);
990 printf ("[OBJECT:%p]", o
);
995 case MONO_TYPE_FNPTR
:
996 case MONO_TYPE_ARRAY
:
997 case MONO_TYPE_SZARRAY
: {
998 gpointer p
= va_arg (ap
, gpointer
);
999 printf ("[result=%p]", p
);
1002 case MONO_TYPE_I8
: {
1003 gint64 l
= va_arg (ap
, gint64
);
1004 printf ("[LONG:%ld]", l
);
1007 case MONO_TYPE_U8
: {
1008 guint64 l
= va_arg (ap
, guint64
);
1009 printf ("[ULONG:%lu]", l
);
1012 case MONO_TYPE_R4
: {
1013 double f
= va_arg (ap
, double);
1014 printf ("[FLOAT4:%g]\n", f
);
1017 case MONO_TYPE_R8
: {
1018 double f
= va_arg (ap
, double);
1019 printf ("[FLOAT8:%g]\n", f
);
1022 case MONO_TYPE_VALUETYPE
: {
1023 MonoMarshalType
*info
;
1024 if (type
->data
.klass
->enumtype
) {
1025 type
= type
->data
.klass
->enum_basetype
;
1028 guint8
*p
= va_arg (ap
, gpointer
);
1031 info
= mono_marshal_load_type_info (type
->data
.klass
);
1033 if ((info
->native_size
== sizeof(float)) &&
1034 (info
->num_fields
== 1) &&
1035 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
1036 double f
= va_arg (ap
, double);
1037 printf("[FLOAT4:%g]\n", (double) f
);
1041 if ((info
->native_size
== sizeof(double)) &&
1042 (info
->num_fields
== 1) &&
1043 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
1044 double f
= va_arg (ap
, double);
1045 printf("[FLOAT8:%g]\n", f
);
1049 size
= mono_type_size (type
, &align
);
1056 for (j
= 0; p
&& j
< size
; j
++)
1057 printf ("%02x,", p
[j
]);
1061 printf ("[VALUETYPE]\n");
1066 case MONO_TYPE_TYPEDBYREF
: {
1067 guint8
*p
= va_arg (ap
, gpointer
);
1069 size
= mono_type_size (type
, &align
);
1076 for (j
= 0; p
&& j
< size
; j
++)
1077 printf ("%02x,", p
[j
]);
1081 printf ("[TYPEDBYREF]\n");
1086 printf ("(unknown return type %x)",
1087 mono_method_signature (method
)->ret
->type
);
1090 ip
= ((gint64
) __builtin_return_address (0));
1091 printf (" ip: %p\n", (gpointer
) ip
);
1094 /*========================= End of Function ========================*/
1096 /*------------------------------------------------------------------*/
1098 /* Name - catch_SIGILL */
1100 /* Function - Catch SIGILL as a result of testing for long */
1101 /* displacement facility. */
1103 /*------------------------------------------------------------------*/
1106 catch_SIGILL(int sigNo
, siginfo_t
*info
, void *act
) {
1112 /*========================= End of Function ========================*/
1114 /*------------------------------------------------------------------*/
1116 /* Name - mono_arch_cpu_init */
1118 /* Function - Perform CPU specific initialization to execute */
1121 /*------------------------------------------------------------------*/
1124 mono_arch_cpu_init (void)
1126 struct sigaction sa
,
1130 /*--------------------------------------*/
1131 /* Set default rounding mode for FP */
1132 /*--------------------------------------*/
1133 __asm__ ("SRNM\t%0\n\t"
1136 /*--------------------------------------*/
1137 /* Determine if we have long displace- */
1138 /* ment facility on this processor */
1139 /*--------------------------------------*/
1140 sa
.sa_sigaction
= catch_SIGILL
;
1141 sigemptyset (&sa
.sa_mask
);
1142 sa
.sa_flags
= SA_SIGINFO
;
1144 sigaction (SIGILL
, &sa
, oldSa
);
1146 /*--------------------------------------*/
1147 /* We test by executing the STY inst */
1148 /*--------------------------------------*/
1149 __asm__ ("LGHI\t0,1\n\t"
1151 ".byte\t0xe3,0x00,0x10,0x00,0x00,0x50\n\t"
1152 : "=m" (has_ld
) : : "0", "1");
1154 sigaction (SIGILL
, oldSa
, NULL
);
1157 /*========================= End of Function ========================*/
1161 * Initialize architecture specific code.
1164 mono_arch_init (void)
1169 * Cleanup architecture specific code.
1172 mono_arch_cleanup (void)
1176 /*------------------------------------------------------------------*/
1178 /* Name - mono_arch_cpu_optimizazions */
1180 /* Function - Returns the optimizations supported on this CPU */
1182 /*------------------------------------------------------------------*/
1185 mono_arch_cpu_optimizazions (guint32
*exclude_mask
)
1189 /*----------------------------------------------------------*/
1190 /* No s390-specific optimizations yet */
1191 /*----------------------------------------------------------*/
1192 *exclude_mask
= MONO_OPT_INLINE
|MONO_OPT_LINEARS
;
1193 // *exclude_mask = MONO_OPT_INLINE;
1197 /*========================= End of Function ========================*/
1199 /*------------------------------------------------------------------*/
1205 /*------------------------------------------------------------------*/
1208 is_regsize_var (MonoType
*t
) {
1211 switch (mono_type_get_underlying_type (t
)->type
) {
1219 case MONO_TYPE_FNPTR
:
1221 case MONO_TYPE_OBJECT
:
1222 case MONO_TYPE_STRING
:
1223 case MONO_TYPE_CLASS
:
1224 case MONO_TYPE_SZARRAY
:
1225 case MONO_TYPE_ARRAY
:
1227 case MONO_TYPE_VALUETYPE
:
1228 if (t
->data
.klass
->enumtype
)
1229 return is_regsize_var (t
->data
.klass
->enum_basetype
);
1235 /*========================= End of Function ========================*/
1237 /*------------------------------------------------------------------*/
1239 /* Name - mono_arch_get_allocatable_int_vars */
1243 /*------------------------------------------------------------------*/
1246 mono_arch_get_allocatable_int_vars (MonoCompile
*cfg
)
1251 for (i
= 0; i
< cfg
->num_varinfo
; i
++) {
1252 MonoInst
*ins
= cfg
->varinfo
[i
];
1253 MonoMethodVar
*vmv
= MONO_VARINFO (cfg
, i
);
1256 if (vmv
->range
.first_use
.abs_pos
>= vmv
->range
.last_use
.abs_pos
)
1259 if (ins
->flags
& (MONO_INST_VOLATILE
|MONO_INST_INDIRECT
) ||
1260 (ins
->opcode
!= OP_LOCAL
&& ins
->opcode
!= OP_ARG
))
1263 /* we can only allocate 32 bit values */
1264 if (is_regsize_var (ins
->inst_vtype
)) {
1265 g_assert (MONO_VARINFO (cfg
, i
)->reg
== -1);
1266 g_assert (i
== vmv
->idx
);
1267 vars
= mono_varlist_insert_sorted (cfg
, vars
, vmv
, FALSE
);
1274 /*========================= End of Function ========================*/
1276 /*------------------------------------------------------------------*/
1278 /* Name - mono_arch_global_int_regs */
1280 /* Function - Return a list of usable integer registers. */
1282 /*------------------------------------------------------------------*/
1285 mono_arch_get_global_int_regs (MonoCompile
*cfg
)
1288 MonoMethodHeader
*header
;
1291 header
= mono_method_get_header (cfg
->method
);
1292 if ((cfg
->flags
& MONO_CFG_HAS_ALLOCA
) || header
->num_clauses
)
1293 cfg
->frame_reg
= s390_r11
;
1296 /* FIXME: s390_r12 is reserved for bkchain_reg. Only reserve it if needed */
1298 for (i
= 8; i
< top
; ++i
) {
1299 if (cfg
->frame_reg
!= i
)
1300 regs
= g_list_prepend (regs
, GUINT_TO_POINTER (i
));
1306 /*========================= End of Function ========================*/
1308 /*------------------------------------------------------------------*/
1310 /* Name - mono_arch_flush_icache */
1312 /* Function - Flush the CPU icache. */
1314 /*------------------------------------------------------------------*/
1317 mono_arch_flush_icache (guint8
*code
, gint size
)
1321 /*========================= End of Function ========================*/
1323 /*------------------------------------------------------------------*/
1325 /* Name - add_general */
1327 /* Function - Determine code and stack size incremements for a */
1330 /*------------------------------------------------------------------*/
1333 add_general (guint
*gr
, size_data
*sz
, ArgInfo
*ainfo
)
1335 if (*gr
> S390_LAST_ARG_REG
) {
1336 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1337 ainfo
->offset
= sz
->stack_size
;
1338 ainfo
->reg
= STK_BASE
;
1339 ainfo
->regtype
= RegTypeBase
;
1340 sz
->stack_size
+= sizeof(long);
1341 sz
->local_size
+= sizeof(long);
1342 sz
->offStruct
+= sizeof(long);
1343 sz
->code_size
+= 12;
1351 /*========================= End of Function ========================*/
1353 /*------------------------------------------------------------------*/
1355 /* Name - add_stackParm */
1357 /* Function - Determine code and stack size incremements for a */
1360 /*------------------------------------------------------------------*/
1363 add_stackParm (guint
*gr
, size_data
*sz
, ArgInfo
*ainfo
, gint size
)
1365 if (*gr
> S390_LAST_ARG_REG
) {
1366 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1367 ainfo
->reg
= STK_BASE
;
1368 ainfo
->offset
= sz
->stack_size
;
1369 sz
->stack_size
+= sizeof (gpointer
);
1370 sz
->parm_size
+= sizeof(gpointer
);
1371 sz
->offStruct
+= sizeof(gpointer
);
1374 ainfo
->offset
= sz
->stack_size
;
1377 ainfo
->offparm
= sz
->offset
;
1378 sz
->offset
= S390_ALIGN(sz
->offset
+size
, sizeof(long));
1380 ainfo
->regtype
= RegTypeStructByAddr
;
1381 ainfo
->vtsize
= size
;
1382 sz
->parm_size
+= size
;
1385 /*========================= End of Function ========================*/
1387 /*------------------------------------------------------------------*/
1389 /* Name - add_float */
1391 /* Function - Determine code and stack size incremements for a */
1392 /* float parameter. */
1394 /*------------------------------------------------------------------*/
1397 add_float (guint
*fr
, size_data
*sz
, ArgInfo
*ainfo
)
1399 if ((*fr
) <= S390_LAST_FPARG_REG
) {
1400 ainfo
->regtype
= RegTypeFP
;
1406 ainfo
->offset
= sz
->stack_size
;
1407 ainfo
->reg
= STK_BASE
;
1408 ainfo
->regtype
= RegTypeBase
;
1410 sz
->stack_size
+= sizeof(double);
1411 sz
->local_size
+= sizeof(double);
1412 sz
->offStruct
+= sizeof(double);
1416 /*========================= End of Function ========================*/
1418 /*------------------------------------------------------------------*/
1420 /* Name - get_call_info */
1422 /* Function - Determine the amount of space required for code */
1423 /* and stack. In addition determine starting points */
1424 /* for stack-based parameters, and area for struct- */
1425 /* ures being returned on the stack. */
1427 /*------------------------------------------------------------------*/
1430 get_call_info (MonoCompile
*cfg
, MonoMemPool
*mp
, MonoMethodSignature
*sig
, gboolean is_pinvoke
)
1432 guint i
, fr
, gr
, size
;
1433 int nParm
= sig
->hasthis
+ sig
->param_count
;
1435 guint32 simpletype
, align
;
1438 MonoGenericSharingContext
*gsctx
= cfg
? cfg
->generic_sharing_context
: NULL
;
1441 cinfo
= mono_mempool_alloc0 (mp
, sizeof (CallInfo
) + sizeof (ArgInfo
) * nParm
);
1443 cinfo
= g_malloc0 (sizeof (CallInfo
) + sizeof (ArgInfo
) * nParm
);
1448 cinfo
->struct_ret
= 0;
1452 sz
->offStruct
= S390_MINIMAL_STACK_SIZE
;
1453 sz
->stack_size
= S390_MINIMAL_STACK_SIZE
;
1458 /*----------------------------------------------------------*/
1459 /* We determine the size of the return code/stack in case we*/
1460 /* need to reserve a register to be used to address a stack */
1461 /* area that the callee will use. */
1462 /*----------------------------------------------------------*/
1464 ret_type
= mono_type_get_underlying_type (sig
->ret
);
1465 ret_type
= mini_get_basic_type_from_generic (gsctx
, ret_type
);
1466 simpletype
= ret_type
->type
;
1468 switch (simpletype
) {
1469 case MONO_TYPE_BOOLEAN
:
1474 case MONO_TYPE_CHAR
:
1479 case MONO_TYPE_CLASS
:
1480 case MONO_TYPE_OBJECT
:
1481 case MONO_TYPE_SZARRAY
:
1482 case MONO_TYPE_ARRAY
:
1484 case MONO_TYPE_FNPTR
:
1485 case MONO_TYPE_STRING
:
1486 cinfo
->ret
.reg
= s390_r2
;
1491 cinfo
->ret
.reg
= s390_f0
;
1496 cinfo
->ret
.reg
= s390_r2
;
1499 case MONO_TYPE_GENERICINST
:
1500 if (!mono_type_generic_inst_is_valuetype (sig
->ret
)) {
1501 cinfo
->ret
.reg
= s390_r2
;
1506 case MONO_TYPE_VALUETYPE
: {
1507 MonoClass
*klass
= mono_class_from_mono_type (sig
->ret
);
1508 if (klass
->enumtype
) {
1509 simpletype
= klass
->enum_basetype
->type
;
1513 size
= mono_class_native_size (klass
, &align
);
1515 size
= mono_class_value_size (klass
, &align
);
1517 cinfo
->ret
.reg
= s390_r2
;
1518 cinfo
->struct_ret
= 1;
1519 cinfo
->ret
.size
= size
;
1520 cinfo
->ret
.vtsize
= size
;
1524 case MONO_TYPE_TYPEDBYREF
:
1525 size
= sizeof (MonoTypedRef
);
1526 cinfo
->ret
.reg
= s390_r2
;
1527 cinfo
->struct_ret
= 1;
1528 cinfo
->ret
.size
= size
;
1529 cinfo
->ret
.vtsize
= size
;
1532 case MONO_TYPE_VOID
:
1535 g_error ("Can't handle as return value 0x%x", sig
->ret
->type
);
1539 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1540 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1544 /*----------------------------------------------------------*/
1545 /* We determine the size of the parameter code and stack */
1546 /* requirements by checking the types and sizes of the */
1548 /*----------------------------------------------------------*/
1550 for (i
= 0; i
< sig
->param_count
; ++i
) {
1553 /*--------------------------------------------------*/
1554 /* Handle vararg type calls. All args are put on */
1556 /*--------------------------------------------------*/
1557 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1558 (i
== sig
->sentinelpos
)) {
1559 gr
= S390_LAST_ARG_REG
+ 1;
1560 add_general (&gr
, sz
, &cinfo
->sigCookie
);
1563 if (sig
->params
[i
]->byref
) {
1564 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1565 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1570 ptype
= mono_type_get_underlying_type (sig
->params
[i
]);
1571 ptype
= mini_get_basic_type_from_generic (gsctx
, ptype
);
1572 simpletype
= ptype
->type
;
1573 cinfo
->args
[nParm
].type
= simpletype
;
1574 switch (simpletype
) {
1575 case MONO_TYPE_BOOLEAN
:
1578 cinfo
->args
[nParm
].size
= sizeof(char);
1579 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1584 case MONO_TYPE_CHAR
:
1585 cinfo
->args
[nParm
].size
= sizeof(short);
1586 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1591 cinfo
->args
[nParm
].size
= sizeof(int);
1592 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1598 case MONO_TYPE_FNPTR
:
1599 case MONO_TYPE_CLASS
:
1600 case MONO_TYPE_OBJECT
:
1601 case MONO_TYPE_STRING
:
1602 case MONO_TYPE_SZARRAY
:
1603 case MONO_TYPE_ARRAY
:
1604 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1605 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1610 cinfo
->args
[nParm
].size
= sizeof(long long);
1611 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1615 cinfo
->args
[nParm
].size
= sizeof(float);
1616 add_float (&fr
, sz
, cinfo
->args
+nParm
);
1620 cinfo
->args
[nParm
].size
= sizeof(double);
1621 add_float (&fr
, sz
, cinfo
->args
+nParm
);
1624 case MONO_TYPE_GENERICINST
:
1625 if (!mono_type_generic_inst_is_valuetype (sig
->params
[i
])) {
1626 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1627 add_general (&gr
, sz
, cinfo
->args
+nParm
);
1632 case MONO_TYPE_VALUETYPE
: {
1633 MonoMarshalType
*info
;
1634 MonoClass
*klass
= mono_class_from_mono_type (sig
->params
[i
]);
1636 size
= mono_class_native_size (klass
, &align
);
1638 size
= mono_class_value_size (klass
, &align
);
1640 info
= mono_marshal_load_type_info (klass
);
1642 if ((info
->native_size
== sizeof(float)) &&
1643 (info
->num_fields
== 1) &&
1644 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
1645 cinfo
->args
[nParm
].size
= sizeof(float);
1646 add_float(&fr
, sz
, cinfo
->args
+nParm
);
1651 if ((info
->native_size
== sizeof(double)) &&
1652 (info
->num_fields
== 1) &&
1653 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
1654 cinfo
->args
[nParm
].size
= sizeof(double);
1655 add_float(&fr
, sz
, cinfo
->args
+nParm
);
1660 cinfo
->args
[nParm
].vtsize
= 0;
1661 cinfo
->args
[nParm
].size
= 0;
1664 /*----------------------------------*/
1665 /* On S/390, structures of size 1, */
1666 /* 2, 4, and 8 bytes are passed in */
1667 /* (a) register(s). */
1668 /*----------------------------------*/
1674 add_general(&gr
, sz
, cinfo
->args
+nParm
);
1675 cinfo
->args
[nParm
].size
= size
;
1676 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1678 sz
->local_size
+= sizeof(long);
1681 add_stackParm(&gr
, sz
, cinfo
->args
+nParm
, size
);
1686 case MONO_TYPE_TYPEDBYREF
: {
1687 int size
= sizeof (MonoTypedRef
);
1689 cinfo
->args
[nParm
].vtsize
= 0;
1690 cinfo
->args
[nParm
].size
= 0;
1693 /*----------------------------------*/
1694 /* On S/390, structures of size 1, */
1695 /* 2, 4, and 8 bytes are passed in */
1696 /* (a) register(s). */
1697 /*----------------------------------*/
1703 add_general(&gr
, sz
, cinfo
->args
+nParm
);
1704 cinfo
->args
[nParm
].size
= size
;
1705 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1707 sz
->local_size
+= sizeof(long);
1710 add_stackParm(&gr
, sz
, cinfo
->args
+nParm
, size
);
1716 g_error ("Can't trampoline 0x%x", sig
->params
[i
]->type
);
1720 /*----------------------------------------------------------*/
1721 /* Handle the case where there are no implicit arguments */
1722 /*----------------------------------------------------------*/
1723 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1724 (sig
->param_count
== sig
->sentinelpos
)) {
1725 gr
= S390_LAST_ARG_REG
+ 1;
1726 add_general (&gr
, sz
, &cinfo
->sigCookie
);
1729 /*----------------------------------------------------------*/
1730 /* If we are passing a structure back then if it won't be */
1731 /* in a register(s) then we make room at the end of the */
1732 /* parameters that may have been placed on the stack */
1733 /*----------------------------------------------------------*/
1734 if (cinfo
->struct_ret
) {
1735 cinfo
->ret
.offset
= sz
->stack_size
;
1736 switch (cinfo
->ret
.size
) {
1744 sz
->stack_size
+= S390_ALIGN(cinfo
->ret
.size
, align
);
1749 sz
->stack_size
= sz
->stack_size
+ sz
->local_size
+ sz
->parm_size
+
1751 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1756 /*========================= End of Function ========================*/
1758 /*------------------------------------------------------------------*/
1760 /* Name - mono_arch_allocate_vars */
1762 /* Function - Set var information according to the calling */
1763 /* convention for S/390. The local var stuff should */
1764 /* most likely be split in another method. */
1766 /* Parameter - @m - Compile unit. */
1768 /*------------------------------------------------------------------*/
1771 mono_arch_allocate_vars (MonoCompile
*cfg
)
1773 MonoMethodSignature
*sig
;
1774 MonoMethodHeader
*header
;
1777 int iParm
, iVar
, offset
, size
, align
, curinst
;
1778 int frame_reg
= STK_BASE
;
1781 header
= mono_method_get_header (cfg
->method
);
1783 cfg
->flags
|= MONO_CFG_HAS_SPILLUP
;
1785 /*---------------------------------------------------------*/
1786 /* We use the frame register also for any method that has */
1787 /* filter clauses. This way, when the handlers are called, */
1788 /* the code will reference local variables using the frame */
1789 /* reg instead of the stack pointer: if we had to restore */
1790 /* the stack pointer, we'd corrupt the method frames that */
1791 /* are already on the stack (since filters get called */
1792 /* before stack unwinding happens) when the filter code */
1793 /* would call any method. */
1794 /*---------------------------------------------------------*/
1795 if ((cfg
->flags
& MONO_CFG_HAS_ALLOCA
) || header
->num_clauses
)
1796 frame_reg
= s390_r11
;
1798 cfg
->frame_reg
= frame_reg
;
1800 cfg
->arch
.bkchain_reg
= -1;
1802 if (frame_reg
!= STK_BASE
)
1803 cfg
->used_int_regs
|= 1 << frame_reg
;
1805 sig
= mono_method_signature (cfg
->method
);
1807 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
1809 if (cinfo
->struct_ret
) {
1811 cfg
->vret_addr
->opcode
= OP_REGVAR
;
1812 cfg
->vret_addr
->inst_c0
= s390_r2
;
1815 switch (mono_type_get_underlying_type (sig
->ret
)->type
) {
1816 case MONO_TYPE_VOID
:
1819 cfg
->ret
->opcode
= OP_REGVAR
;
1820 cfg
->ret
->dreg
= s390_r2
;
1825 /*--------------------------------------------------------------*/
1826 /* local vars are at a positive offset from the stack pointer */
1827 /* also note that if the function uses alloca, we use s390_r11 */
1828 /* to point at the local variables. */
1829 /* add parameter area size for called functions */
1830 /*--------------------------------------------------------------*/
1831 offset
= (cfg
->param_area
+ S390_MINIMAL_STACK_SIZE
);
1832 cfg
->sig_cookie
= 0;
1834 if (cinfo
->struct_ret
) {
1835 inst
= cfg
->vret_addr
;
1836 offset
= S390_ALIGN(offset
, sizeof(gpointer
));
1837 inst
->inst_offset
= offset
;
1838 inst
->opcode
= OP_REGOFFSET
;
1839 inst
->inst_basereg
= frame_reg
;
1840 offset
+= sizeof(gpointer
);
1841 if (!cfg
->new_ir
&& (sig
->call_convention
== MONO_CALL_VARARG
) &&
1842 (!retFitsInReg (cinfo
->ret
.size
)))
1843 cfg
->sig_cookie
+= cinfo
->ret
.size
;
1844 if (G_UNLIKELY (cfg
->verbose_level
> 1)) {
1845 printf ("vret_addr =");
1846 mono_print_ins (cfg
->vret_addr
);
1851 inst
= cfg
->args
[0];
1852 if (inst
->opcode
!= OP_REGVAR
) {
1853 inst
->opcode
= OP_REGOFFSET
;
1854 inst
->inst_basereg
= frame_reg
;
1855 offset
= S390_ALIGN(offset
, sizeof(gpointer
));
1856 inst
->inst_offset
= offset
;
1857 offset
+= sizeof (gpointer
);
1864 eArg
= sig
->param_count
+ sArg
;
1866 if (sig
->call_convention
== MONO_CALL_VARARG
)
1867 cfg
->sig_cookie
+= S390_MINIMAL_STACK_SIZE
;
1869 for (iParm
= sArg
; iParm
< eArg
; ++iParm
) {
1870 inst
= cfg
->args
[curinst
];
1871 if (inst
->opcode
!= OP_REGVAR
) {
1872 switch (cinfo
->args
[iParm
].regtype
) {
1873 case RegTypeStructByAddr
:
1877 size
= sizeof (gpointer
);
1879 inst
->opcode
= OP_REGOFFSET
;
1880 inst
->inst_basereg
= frame_reg
;
1881 offset
= S390_ALIGN (offset
, sizeof (gpointer
));
1882 inst
->inst_offset
= offset
;
1884 /* Add a level of indirection */
1885 MONO_INST_NEW (cfg
, indir
, 0);
1887 inst
->opcode
= OP_VTARG_ADDR
;
1888 inst
->inst_left
= indir
;
1890 if (cinfo
->args
[iParm
].reg
== STK_BASE
) {
1891 inst
->opcode
= OP_S390_LOADARG
;
1892 inst
->inst_basereg
= frame_reg
;
1893 offset
= S390_ALIGN(offset
, sizeof(long));
1894 inst
->inst_offset
= offset
;
1895 size
= abs(cinfo
->args
[iParm
].vtsize
);
1896 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1898 inst
->opcode
= OP_S390_ARGREG
;
1899 inst
->inst_basereg
= frame_reg
;
1900 size
= sizeof(gpointer
);
1901 offset
= S390_ALIGN(offset
, size
);
1902 inst
->inst_offset
= offset
;
1903 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1907 case RegTypeStructByVal
:
1909 size
= cinfo
->args
[iParm
].size
;
1910 offset
= S390_ALIGN(offset
, size
);
1911 inst
->opcode
= OP_REGOFFSET
;
1912 inst
->inst_basereg
= frame_reg
;
1913 inst
->inst_offset
= offset
;
1915 inst
->opcode
= OP_S390_ARGPTR
;
1916 inst
->inst_basereg
= frame_reg
;
1917 size
= cinfo
->args
[iParm
].size
;
1918 offset
= S390_ALIGN(offset
, size
);
1919 inst
->inst_offset
= offset
;
1920 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1925 if (cinfo
->args
[iParm
].reg
== STK_BASE
) {
1927 * These arguments are in the previous frame, so we can't
1928 * compute their offset from the current frame pointer right
1929 * now, since cfg->stack_offset is not yet known, so dedicate a
1930 * register holding the previous frame pointer.
1932 cfg
->arch
.bkchain_reg
= s390_r12
;
1933 cfg
->used_int_regs
|= 1 << cfg
->arch
.bkchain_reg
;
1935 inst
->opcode
= OP_REGOFFSET
;
1936 inst
->inst_basereg
= cfg
->arch
.bkchain_reg
;
1937 size
= (cinfo
->args
[iParm
].size
< 8
1938 ? 8 - cinfo
->args
[iParm
].size
1940 inst
->inst_offset
= cinfo
->args
[iParm
].offset
+ size
;
1941 size
= sizeof (long);
1943 inst
->opcode
= OP_REGOFFSET
;
1944 inst
->inst_basereg
= frame_reg
;
1945 size
= (cinfo
->args
[iParm
].size
< 8
1948 offset
= S390_ALIGN(offset
, size
);
1949 inst
->inst_offset
= offset
;
1952 if (cinfo
->args
[iParm
].reg
!= STK_BASE
) {
1953 inst
->opcode
= OP_REGOFFSET
;
1954 inst
->inst_basereg
= frame_reg
;
1955 size
= (cinfo
->args
[iParm
].size
< 8
1958 offset
= S390_ALIGN(offset
, size
);
1959 inst
->inst_offset
= offset
;
1961 inst
->opcode
= OP_S390_STKARG
;
1962 inst
->inst_basereg
= frame_reg
;
1963 size
= ((cinfo
->args
[iParm
].size
< 8)
1964 ? 8 - cinfo
->args
[iParm
].size
1966 inst
->inst_offset
= cinfo
->args
[iParm
].offset
+
1968 inst
->backend
.arg_info
= 0;
1969 size
= sizeof(long);
1974 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1975 (cinfo
->args
[iParm
].regtype
!= RegTypeGeneral
) &&
1976 (iParm
< sig
->sentinelpos
))
1977 cfg
->sig_cookie
+= size
;
1984 curinst
= cfg
->locals_start
;
1985 for (iVar
= curinst
; iVar
< cfg
->num_varinfo
; ++iVar
) {
1986 inst
= cfg
->varinfo
[iVar
];
1987 if ((inst
->flags
& MONO_INST_IS_DEAD
) ||
1988 (inst
->opcode
== OP_REGVAR
))
1991 /*--------------------------------------------------*/
1992 /* inst->backend.is_pinvoke indicates native sized value types, */
1993 /* this is used by the pinvoke wrappers when they */
1994 /* call functions returning structure */
1995 /*--------------------------------------------------*/
1996 if (inst
->backend
.is_pinvoke
&& MONO_TYPE_ISSTRUCT (inst
->inst_vtype
))
1997 size
= mono_class_native_size (mono_class_from_mono_type(inst
->inst_vtype
), &align
);
1999 size
= mono_type_size (inst
->inst_vtype
, &align
);
2001 offset
= S390_ALIGN(offset
, align
);
2002 inst
->inst_offset
= offset
;
2003 inst
->opcode
= OP_REGOFFSET
;
2004 inst
->inst_basereg
= frame_reg
;
2006 DEBUG (g_print("allocating local %d to %ld, size: %d\n",
2007 iVar
, inst
->inst_offset
, size
));
2010 /*------------------------------------------------------*/
2011 /* Allow space for the trace method stack area if needed*/
2012 /*------------------------------------------------------*/
2013 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (cfg
->method
))
2014 offset
+= S390_TRACE_STACK_SIZE
;
2016 /*------------------------------------------------------*/
2017 /* Reserve space to save LMF and caller saved registers */
2018 /*------------------------------------------------------*/
2019 if (cfg
->method
->save_lmf
)
2020 offset
+= sizeof (MonoLMF
);
2022 /*------------------------------------------------------*/
2023 /* align the offset */
2024 /*------------------------------------------------------*/
2025 cfg
->stack_offset
= S390_ALIGN(offset
, S390_STACK_ALIGNMENT
);
2029 /*========================= End of Function ========================*/
2031 /*------------------------------------------------------------------*/
2033 /* Name - mono_arch_create_vars */
2034 /*------------------------------------------------------------------*/
2037 mono_arch_create_vars (MonoCompile
*cfg
)
2039 MonoMethodSignature
*sig
;
2042 sig
= mono_method_signature (cfg
->method
);
2044 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2046 if (cinfo
->struct_ret
) {
2047 cfg
->vret_addr
= mono_compile_create_var (cfg
, &mono_defaults
.int_class
->byval_arg
, OP_ARG
);
2048 if (G_UNLIKELY (cfg
->verbose_level
> 1)) {
2049 printf ("vret_addr = ");
2050 mono_print_ins (cfg
->vret_addr
);
2055 /*========================= End of Function ========================*/
2057 /*------------------------------------------------------------------*/
2059 /* Name - mono_arch_call_opcode */
2061 /* Function - Take the arguments and generate the arch-specific */
2062 /* instructions to properly call the function. This */
2063 /* includes pushing, moving argments to the correct */
2066 /*------------------------------------------------------------------*/
2069 mono_arch_call_opcode (MonoCompile
*cfg
, MonoBasicBlock
* bb
,
2070 MonoCallInst
*call
, int is_virtual
)
2073 MonoCallArgParm
*arg
;
2074 MonoMethodSignature
*sig
;
2075 int i
, n
, lParamArea
;
2079 sig
= call
->signature
;
2080 n
= sig
->param_count
+ sig
->hasthis
;
2081 DEBUG (g_print ("Call requires: %d parameters\n",n
));
2083 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2085 call
->stack_usage
= MAX(cinfo
->sz
.stack_size
, call
->stack_usage
);
2086 lParamArea
= MAX((call
->stack_usage
- S390_MINIMAL_STACK_SIZE
- cinfo
->sz
.parm_size
), 0);
2087 cfg
->param_area
= MAX (((signed) cfg
->param_area
), lParamArea
);
2088 cfg
->flags
|= MONO_CFG_HAS_CALLS
;
2090 if (cinfo
->struct_ret
)
2091 call
->used_iregs
|= 1 << cinfo
->ret
.reg
;
2093 for (i
= 0; i
< n
; ++i
) {
2094 ainfo
= cinfo
->args
+ i
;
2096 if (!(sig
->pinvoke
) &&
2097 (sig
->call_convention
== MONO_CALL_VARARG
) &&
2098 (i
== sig
->sentinelpos
)) {
2099 emit_sig_cookie (cfg
, call
, cinfo
, ainfo
->size
);
2102 if (is_virtual
&& i
== 0) {
2103 /* the argument will be attached to the call instrucion */
2104 in
= call
->args
[i
];
2105 call
->used_iregs
|= 1 << ainfo
->reg
;
2107 MONO_INST_NEW_CALL_ARG (cfg
, arg
, OP_OUTARG
);
2108 in
= call
->args
[i
];
2109 arg
->ins
.cil_code
= in
->cil_code
;
2110 arg
->ins
.inst_left
= in
;
2111 arg
->ins
.type
= in
->type
;
2112 /* prepend, we'll need to reverse them later */
2113 arg
->ins
.next
= call
->out_args
;
2114 call
->out_args
= (MonoInst
*) arg
;
2115 arg
->ins
.inst_right
= (MonoInst
*) call
;
2116 if (ainfo
->regtype
== RegTypeGeneral
) {
2117 arg
->ins
.backend
.reg3
= ainfo
->reg
;
2118 call
->used_iregs
|= 1 << ainfo
->reg
;
2119 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
2120 call
->used_iregs
|= 1 << ainfo
->reg
;
2121 arg
->ins
.sreg1
= ainfo
->reg
;
2122 arg
->ins
.opcode
= OP_OUTARG_VT
;
2123 arg
->size
= -ainfo
->vtsize
;
2124 arg
->offset
= ainfo
->offset
;
2125 arg
->offPrm
= ainfo
->offparm
+ cinfo
->sz
.offStruct
;
2126 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
2127 if (ainfo
->reg
!= STK_BASE
)
2128 call
->used_iregs
|= 1 << ainfo
->reg
;
2129 arg
->ins
.sreg1
= ainfo
->reg
;
2130 arg
->ins
.opcode
= OP_OUTARG_VT
;
2131 arg
->size
= ainfo
->size
;
2132 arg
->offset
= ainfo
->offset
;
2133 arg
->offPrm
= ainfo
->offparm
+ cinfo
->sz
.offStruct
;
2134 } else if (ainfo
->regtype
== RegTypeBase
) {
2135 arg
->ins
.opcode
= OP_OUTARG_MEMBASE
;
2136 arg
->ins
.sreg1
= ainfo
->reg
;
2137 arg
->size
= ainfo
->size
;
2138 arg
->offset
= ainfo
->offset
;
2139 call
->used_iregs
|= 1 << ainfo
->reg
;
2140 } else if (ainfo
->regtype
== RegTypeFP
) {
2141 arg
->ins
.backend
.reg3
= ainfo
->reg
;
2142 call
->used_fregs
|= 1 << ainfo
->reg
;
2143 if (ainfo
->size
== 4)
2144 arg
->ins
.opcode
= OP_OUTARG_R4
;
2146 arg
->ins
.opcode
= OP_OUTARG_R8
;
2148 g_assert_not_reached ();
2154 * Handle the case where there are no implicit arguments
2156 if (!(sig
->pinvoke
) &&
2157 (sig
->call_convention
== MONO_CALL_VARARG
) &&
2158 (n
== sig
->sentinelpos
)) {
2159 emit_sig_cookie (cfg
, call
, cinfo
, sizeof(MonoType
*));
2163 * Reverse the call->out_args list.
2166 MonoInst
*prev
= NULL
, *list
= call
->out_args
, *next
;
2173 call
->out_args
= prev
;
2179 /*========================= End of Function ========================*/
2182 add_outarg_reg2 (MonoCompile
*cfg
, MonoCallInst
*call
, ArgStorage storage
, int reg
, MonoInst
*tree
)
2187 case RegTypeGeneral
:
2188 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2189 ins
->dreg
= mono_alloc_ireg (cfg
);
2190 ins
->sreg1
= tree
->dreg
;
2191 MONO_ADD_INS (cfg
->cbb
, ins
);
2192 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, FALSE
);
2195 MONO_INST_NEW (cfg
, ins
, OP_FMOVE
);
2196 ins
->dreg
= mono_alloc_freg (cfg
);
2197 ins
->sreg1
= tree
->dreg
;
2198 MONO_ADD_INS (cfg
->cbb
, ins
);
2199 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, TRUE
);
2202 MONO_INST_NEW (cfg
, ins
, OP_S390_SETF4RET
);
2203 ins
->dreg
= mono_alloc_freg (cfg
);
2204 ins
->sreg1
= tree
->dreg
;
2205 MONO_ADD_INS (cfg
->cbb
, ins
);
2206 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, TRUE
);
2209 g_assert_not_reached ();
2214 emit_sig_cookie2 (MonoCompile
*cfg
, MonoCallInst
*call
, CallInfo
*cinfo
)
2216 MonoMethodSignature
*tmpSig
;
2219 cfg
->disable_aot
= TRUE
;
2221 /*----------------------------------------------------------*/
2222 /* mono_ArgIterator_Setup assumes the signature cookie is */
2223 /* passed first and all the arguments which were before it */
2224 /* passed on the stack after the signature. So compensate */
2225 /* by passing a different signature. */
2226 /*----------------------------------------------------------*/
2227 tmpSig
= mono_metadata_signature_dup (call
->signature
);
2228 tmpSig
->param_count
-= call
->signature
->sentinelpos
;
2229 tmpSig
->sentinelpos
= 0;
2230 if (tmpSig
->param_count
> 0)
2231 memcpy (tmpSig
->params
,
2232 call
->signature
->params
+ call
->signature
->sentinelpos
,
2233 tmpSig
->param_count
* sizeof(MonoType
*));
2235 MONO_INST_NEW (cfg
, sig_arg
, OP_ICONST
);
2236 sig_arg
->dreg
= mono_alloc_ireg (cfg
);
2237 sig_arg
->inst_p0
= tmpSig
;
2238 MONO_ADD_INS (cfg
->cbb
, sig_arg
);
2240 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORE_MEMBASE_REG
, STK_BASE
,
2241 cinfo
->sigCookie
.offset
, sig_arg
->dreg
);
2244 /*------------------------------------------------------------------*/
2246 /* Name - mono_arch_emit_call */
2248 /*------------------------------------------------------------------*/
2251 mono_arch_emit_call (MonoCompile
*cfg
, MonoCallInst
*call
)
2254 MonoMethodSignature
*sig
;
2256 int i
, n
, lParamArea
;
2258 ArgInfo
*ainfo
= NULL
;
2261 sig
= call
->signature
;
2262 n
= sig
->param_count
+ sig
->hasthis
;
2263 DEBUG (g_print ("Call requires: %d parameters\n",n
));
2265 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2267 stackSize
= cinfo
->sz
.stack_size
+ cinfo
->sz
.local_size
+ cinfo
->sz
.parm_size
+ cinfo
->sz
.offset
;
2268 call
->stack_usage
= MAX(stackSize
, call
->stack_usage
);
2269 lParamArea
= MAX((call
->stack_usage
-S390_MINIMAL_STACK_SIZE
-cinfo
->sz
.parm_size
), 0);
2270 cfg
->param_area
= MAX(((signed) cfg
->param_area
), lParamArea
);
2271 cfg
->flags
|= MONO_CFG_HAS_CALLS
;
2273 if (cinfo
->struct_ret
) {
2274 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2275 ins
->sreg1
= call
->vret_var
->dreg
;
2276 ins
->dreg
= mono_alloc_preg (cfg
);
2277 MONO_ADD_INS (cfg
->cbb
, ins
);
2278 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, cinfo
->ret
.reg
, FALSE
);
2281 for (i
= 0; i
< n
; ++i
) {
2282 ainfo
= cinfo
->args
+ i
;
2285 if (i
>= sig
->hasthis
)
2286 t
= sig
->params
[i
- sig
->hasthis
];
2288 t
= &mono_defaults
.int_class
->byval_arg
;
2289 t
= mono_type_get_underlying_type (t
);
2291 in
= call
->args
[i
];
2293 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2294 (i
== sig
->sentinelpos
)) {
2295 emit_sig_cookie2 (cfg
, call
, cinfo
);
2298 switch (ainfo
->regtype
) {
2299 case RegTypeGeneral
:
2300 add_outarg_reg2 (cfg
, call
, ainfo
->regtype
, ainfo
->reg
, in
);
2303 if (MONO_TYPE_ISSTRUCT (t
)) {
2304 /* Valuetype passed in one fp register */
2305 ainfo
->regtype
= RegTypeStructByValInFP
;
2308 if (ainfo
->size
== 4)
2309 ainfo
->regtype
= RegTypeFPR4
;
2310 add_outarg_reg2 (cfg
, call
, ainfo
->regtype
, ainfo
->reg
, in
);
2313 case RegTypeStructByVal
:
2314 case RegTypeStructByAddr
: {
2318 if (sig
->params
[i
- sig
->hasthis
]->type
== MONO_TYPE_TYPEDBYREF
) {
2319 size
= sizeof (MonoTypedRef
);
2320 align
= sizeof (gpointer
);
2324 size
= mono_type_native_stack_size (&in
->klass
->byval_arg
, &align
);
2327 * Other backends use mono_type_stack_size (), but that
2328 * aligns the size to 8, which is larger than the size of
2329 * the source, leading to reads of invalid memory if the
2330 * source is at the end of address space.
2332 size
= mono_class_value_size (in
->klass
, &align
);
2335 g_assert (in
->klass
);
2337 ainfo
->offparm
+= cinfo
->sz
.offStruct
;
2339 MONO_INST_NEW (cfg
, ins
, OP_OUTARG_VT
);
2340 ins
->sreg1
= in
->dreg
;
2341 ins
->klass
= in
->klass
;
2342 ins
->backend
.size
= ainfo
->size
;
2343 ins
->inst_p0
= call
;
2344 ins
->inst_p1
= mono_mempool_alloc (cfg
->mempool
, sizeof (ArgInfo
));
2345 memcpy (ins
->inst_p1
, ainfo
, sizeof (ArgInfo
));
2347 MONO_ADD_INS (cfg
->cbb
, ins
);
2349 if (ainfo
->regtype
== RegTypeStructByAddr
) {
2351 * We use OP_OUTARG_VT to copy the valuetype to a stack location, then
2352 * use the normal OUTARG opcodes to pass the address of the location to
2355 int treg
= mono_alloc_preg (cfg
);
2356 MONO_EMIT_NEW_BIALU_IMM (cfg
, OP_ADD_IMM
, treg
,
2357 STK_BASE
, ainfo
->offparm
);
2358 mono_call_inst_add_outarg_reg (cfg
, call
, treg
, ainfo
->reg
, FALSE
);
2363 if (!t
->byref
&& t
->type
== MONO_TYPE_R4
) {
2364 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORER4_MEMBASE_REG
,
2365 STK_BASE
, ainfo
->offset
+ 4,
2367 } else if (!t
->byref
&& (t
->type
== MONO_TYPE_R8
)) {
2368 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORER8_MEMBASE_REG
,
2369 STK_BASE
, ainfo
->offset
,
2372 MONO_INST_NEW (cfg
, ins
, OP_STORE_MEMBASE_REG
);
2373 ins
->inst_destbasereg
= STK_BASE
;
2374 ins
->inst_offset
= ainfo
->offset
;
2375 ins
->sreg1
= in
->dreg
;
2377 /* This is needed by MonoTypedRef->value to point to the correct data */
2378 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2379 (i
>= sig
->sentinelpos
)) {
2380 switch (ainfo
->size
) {
2382 ins
->opcode
= OP_STOREI1_MEMBASE_REG
;
2385 ins
->opcode
= OP_STOREI2_MEMBASE_REG
;
2388 ins
->opcode
= OP_STOREI4_MEMBASE_REG
;
2395 MONO_ADD_INS (cfg
->cbb
, ins
);
2399 g_assert_not_reached ();
2405 * Handle the case where there are no implicit arguments
2407 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2408 (i
== sig
->sentinelpos
)) {
2409 emit_sig_cookie2 (cfg
, call
, cinfo
);
2413 /*========================= End of Function ========================*/
2415 /*------------------------------------------------------------------*/
2417 /* Name - mono_arch_emit_outarg_vt */
2419 /*------------------------------------------------------------------*/
2422 mono_arch_emit_outarg_vt (MonoCompile
*cfg
, MonoInst
*ins
, MonoInst
*src
)
2424 MonoCallInst
*call
= (MonoCallInst
*)ins
->inst_p0
;
2425 ArgInfo
*ainfo
= (ArgInfo
*)ins
->inst_p1
;
2426 int size
= ins
->backend
.size
;
2428 if (ainfo
->regtype
== RegTypeStructByVal
) {
2430 arg->ins.sreg1 = ainfo->reg;
2431 arg->ins.opcode = OP_OUTARG_VT;
2432 arg->size = ainfo->size;
2433 arg->offset = ainfo->offset;
2434 arg->offPrm = ainfo->offparm + cinfo->sz.offStruct;
2436 if (ainfo
->reg
!= STK_BASE
) {
2437 MONO_OUTPUT_VTR2 (cfg
, size
, ainfo
->reg
, src
->dreg
, 0);
2439 MONO_OUTPUT_VTS2 (cfg
, size
, ainfo
->reg
, ainfo
->offset
,
2442 } else if (ainfo
->regtype
== RegTypeStructByValInFP
) {
2443 int dreg
= mono_alloc_freg (cfg
);
2445 if (ainfo
->size
== 4) {
2446 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg
, OP_LOADR4_MEMBASE
, dreg
, src
->dreg
, 0);
2447 MONO_EMIT_NEW_UNALU (cfg
, OP_S390_SETF4RET
, dreg
, dreg
);
2449 g_assert (ainfo
->size
== 8);
2451 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg
, OP_LOADR8_MEMBASE
, dreg
, src
->dreg
, 0);
2454 mono_call_inst_add_outarg_reg (cfg
, call
, dreg
, ainfo
->reg
, TRUE
);
2456 MONO_EMIT_NEW_MOVE2 (cfg
, STK_BASE
, ainfo
->offparm
,
2457 src
->dreg
, 0, size
);
2461 /*------------------------------------------------------------------*/
2463 /* Name - mono_arch_emit_setret */
2465 /*------------------------------------------------------------------*/
2468 mono_arch_emit_setret (MonoCompile
*cfg
, MonoMethod
*method
, MonoInst
*val
)
2470 MonoType
*ret
= mono_type_get_underlying_type (mono_method_signature (method
)->ret
);
2473 if (ret
->type
== MONO_TYPE_R4
) {
2474 MONO_EMIT_NEW_UNALU (cfg
, OP_S390_SETF4RET
, s390_f0
, val
->dreg
);
2476 } else if (ret
->type
== MONO_TYPE_R8
) {
2477 MONO_EMIT_NEW_UNALU (cfg
, OP_FMOVE
, s390_f0
, val
->dreg
);
2482 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, cfg
->ret
->dreg
, val
->dreg
);
2485 /*========================= End of Function ========================*/
2487 /*------------------------------------------------------------------*/
2489 /* Name - emit_sig_cookie. */
2491 /* Function - For variable length parameter lists construct a */
2492 /* signature cookie and emit it. */
2494 /*------------------------------------------------------------------*/
2497 emit_sig_cookie (MonoCompile
*cfg
, MonoCallInst
*call
,
2498 CallInfo
*cinfo
, int argSize
)
2500 MonoCallArgParm
*arg
;
2501 MonoMethodSignature
*tmpSig
;
2504 cfg
->disable_aot
= TRUE
;
2506 /*----------------------------------------------------------*/
2507 /* mono_ArgIterator_Setup assumes the signature cookie is */
2508 /* passed first and all the arguments which were before it */
2509 /* passed on the stack after the signature. So compensate */
2510 /* by passing a different signature. */
2511 /*----------------------------------------------------------*/
2512 tmpSig
= mono_metadata_signature_dup (call
->signature
);
2513 tmpSig
->param_count
-= call
->signature
->sentinelpos
;
2514 tmpSig
->sentinelpos
= 0;
2515 if (tmpSig
->param_count
> 0)
2516 memcpy (tmpSig
->params
,
2517 call
->signature
->params
+ call
->signature
->sentinelpos
,
2518 tmpSig
->param_count
* sizeof(MonoType
*));
2520 MONO_INST_NEW (cfg
, sigArg
, OP_ICONST
);
2521 sigArg
->inst_p0
= tmpSig
;
2523 MONO_INST_NEW_CALL_ARG (cfg
, arg
, OP_OUTARG_MEMBASE
);
2524 arg
->ins
.inst_left
= sigArg
;
2525 arg
->ins
.inst_right
= (MonoInst
*) call
;
2526 arg
->size
= argSize
;
2527 arg
->offset
= cinfo
->sigCookie
.offset
;
2528 arg
->ins
.next
= call
->out_args
;
2529 call
->out_args
= (MonoInst
*) arg
;
2532 /*========================= End of Function ========================*/
2534 /*------------------------------------------------------------------*/
2536 /* Name - mono_arch_instrument_mem_needs */
2538 /* Function - Allow tracing to work with this interface (with */
2539 /* an optional argument). */
2541 /*------------------------------------------------------------------*/
2544 mono_arch_instrument_mem_needs (MonoMethod
*method
, int *stack
, int *code
)
2546 /* no stack room needed now (may be needed for FASTCALL-trace support) */
2548 /* split prolog-epilog requirements? */
2549 *code
= 50; /* max bytes needed: check this number */
2552 /*========================= End of Function ========================*/
2554 /*------------------------------------------------------------------*/
2556 /* Name - mono_arch_instrument_prolog */
2558 /* Function - Create an "instrumented" prolog. */
2560 /*------------------------------------------------------------------*/
2563 mono_arch_instrument_prolog (MonoCompile
*cfg
, void *func
, void *p
,
2564 gboolean enable_arguments
)
2571 parmOffset
= cfg
->stack_usage
- S390_TRACE_STACK_SIZE
;
2572 if (cfg
->method
->save_lmf
)
2573 parmOffset
-= sizeof(MonoLMF
);
2574 fpOffset
= parmOffset
+ (5*sizeof(gpointer
));
2575 if ((!has_ld
) && (fpOffset
> 4096)) {
2576 s390_lgr (code
, s390_r12
, STK_BASE
);
2578 while (fpOffset
> 4096) {
2579 s390_aghi (code
, baseReg
, 4096);
2587 s390_stmg (code
, s390_r2
, s390_r6
, STK_BASE
, parmOffset
);
2589 s390_stdy (code
, s390_f0
, 0, STK_BASE
, fpOffset
);
2590 s390_stdy (code
, s390_f2
, 0, STK_BASE
, fpOffset
+sizeof(gdouble
));
2591 s390_stdy (code
, s390_f4
, 0, STK_BASE
, fpOffset
+2*sizeof(gdouble
));
2592 s390_stdy (code
, s390_f6
, 0, STK_BASE
, fpOffset
+3*sizeof(gdouble
));
2594 s390_std (code
, s390_f0
, 0, baseReg
, fpOffset
);
2595 s390_std (code
, s390_f2
, 0, baseReg
, fpOffset
+sizeof(gdouble
));
2596 s390_std (code
, s390_f4
, 0, baseReg
, fpOffset
+2*sizeof(gdouble
));
2597 s390_std (code
, s390_f6
, 0, baseReg
, fpOffset
+3*sizeof(gdouble
));
2599 s390_basr (code
, s390_r13
, 0);
2601 s390_llong(code
, cfg
->method
);
2602 s390_llong(code
, func
);
2603 s390_lg (code
, s390_r2
, 0, s390_r13
, 4);
2605 s390_lay (code
, s390_r3
, 0, STK_BASE
, parmOffset
);
2607 s390_la (code
, s390_r3
, 0, baseReg
, parmOffset
);
2608 s390_lgr (code
, s390_r4
, STK_BASE
);
2609 s390_aghi (code
, s390_r4
, cfg
->stack_usage
);
2610 s390_lg (code
, s390_r1
, 0, s390_r13
, 12);
2611 s390_basr (code
, s390_r14
, s390_r1
);
2613 s390_ldy (code
, s390_f6
, 0, STK_BASE
, fpOffset
+3*sizeof(gdouble
));
2614 s390_ldy (code
, s390_f4
, 0, STK_BASE
, fpOffset
+2*sizeof(gdouble
));
2615 s390_ldy (code
, s390_f2
, 0, STK_BASE
, fpOffset
+sizeof(gdouble
));
2616 s390_ldy (code
, s390_f0
, 0, STK_BASE
, fpOffset
);
2618 s390_ld (code
, s390_f6
, 0, baseReg
, fpOffset
+3*sizeof(gdouble
));
2619 s390_ld (code
, s390_f4
, 0, baseReg
, fpOffset
+2*sizeof(gdouble
));
2620 s390_ld (code
, s390_f2
, 0, baseReg
, fpOffset
+sizeof(gdouble
));
2621 s390_ld (code
, s390_f0
, 0, baseReg
, fpOffset
);
2623 s390_lmg (code
, s390_r2
, s390_r6
, STK_BASE
, parmOffset
);
2628 /*========================= End of Function ========================*/
2630 /*------------------------------------------------------------------*/
2632 /* Name - mono_arch_instrument_epilog */
2634 /* Function - Create an epilog that will handle the returned */
2635 /* values used in instrumentation. */
2637 /*------------------------------------------------------------------*/
2640 mono_arch_instrument_epilog (MonoCompile
*cfg
, void *func
, void *p
, gboolean enable_arguments
)
2643 int save_mode
= SAVE_NONE
,
2645 MonoMethod
*method
= cfg
->method
;
2646 int rtype
= mono_type_get_underlying_type (mono_method_signature (method
)->ret
)->type
;
2648 saveOffset
= cfg
->stack_usage
- S390_TRACE_STACK_SIZE
;
2649 if (method
->save_lmf
)
2650 saveOffset
-= sizeof(MonoLMF
);
2654 case MONO_TYPE_VOID
:
2655 /* special case string .ctor icall */
2656 if (strcmp (".ctor", method
->name
) && method
->klass
== mono_defaults
.string_class
)
2657 save_mode
= SAVE_ONE
;
2659 save_mode
= SAVE_NONE
;
2663 save_mode
= SAVE_ONE
;
2666 save_mode
= SAVE_R4
;
2669 save_mode
= SAVE_R8
;
2671 case MONO_TYPE_VALUETYPE
:
2672 if (mono_method_signature (method
)->ret
->data
.klass
->enumtype
) {
2673 rtype
= mono_method_signature (method
)->ret
->data
.klass
->enum_basetype
->type
;
2676 save_mode
= SAVE_STRUCT
;
2679 save_mode
= SAVE_ONE
;
2683 switch (save_mode
) {
2685 s390_stg (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2686 if (enable_arguments
) {
2687 s390_lgr (code
, s390_r3
, s390_r2
);
2691 s390_std (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2692 if (enable_arguments
) {
2693 s390_ldebr (code
, s390_f0
, s390_f0
);
2697 s390_std (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2700 s390_stg (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2701 if (enable_arguments
) {
2702 s390_lg (code
, s390_r3
, 0, cfg
->frame_reg
,
2703 S390_MINIMAL_STACK_SIZE
+cfg
->param_area
);
2711 s390_basr (code
, s390_r13
, 0);
2713 s390_llong(code
, cfg
->method
);
2714 s390_llong(code
, func
);
2715 s390_lg (code
, s390_r2
, 0, s390_r13
, 4);
2716 s390_lg (code
, s390_r1
, 0, s390_r13
, 12);
2717 s390_basr (code
, s390_r14
, s390_r1
);
2719 switch (save_mode
) {
2721 s390_lg (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2725 s390_ld (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2728 s390_lg (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2738 /*========================= End of Function ========================*/
2741 mono_arch_peephole_pass_1 (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2745 /*------------------------------------------------------------------*/
2747 /* Name - mono_arch_peephole_pass */
2749 /* Function - Form a peephole pass at the code looking for */
2750 /* simple optimizations. */
2752 /*------------------------------------------------------------------*/
2755 mono_arch_peephole_pass_2 (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2759 MONO_BB_FOR_EACH_INS_SAFE (bb
, n
, ins
) {
2760 mono_peephole_ins (bb
, ins
);
2764 /*========================= End of Function ========================*/
2767 mono_arch_lowering_pass (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2769 MonoInst
*ins
, *next
;
2771 if (bb
->max_vreg
> cfg
->rs
->next_vreg
)
2772 cfg
->rs
->next_vreg
= bb
->max_vreg
;
2774 MONO_BB_FOR_EACH_INS_SAFE (bb
, next
, ins
) {
2775 switch (ins
->opcode
) {
2780 case OP_IDIV_UN_IMM
:
2781 case OP_IREM_UN_IMM
:
2785 case OP_LOCALLOC_IMM
:
2786 mono_decompose_op_imm (cfg
, bb
, ins
);
2789 if (!s390_is_imm16 (ins
->inst_imm
))
2790 /* This is created by the memcpy code which ignores is_inst_imm */
2791 mono_decompose_op_imm (cfg
, bb
, ins
);
2798 bb
->max_vreg
= cfg
->rs
->next_vreg
;
2801 /*========================= End of Function ========================*/
2803 /*------------------------------------------------------------------*/
2805 /* Name - emit_float_to_int */
2807 /* Function - Create instructions which will convert a floating */
2808 /* point value to integer. */
2810 /*------------------------------------------------------------------*/
2813 emit_float_to_int (MonoCompile
*cfg
, guchar
*code
, int dreg
, int sreg
, int size
, gboolean is_signed
)
2815 /* sreg is a float, dreg is an integer reg. */
2817 s390_cfdbr (code
, dreg
, 5, sreg
);
2820 s390_lghi (code
, s390_r0
, 0);
2821 s390_lghi (code
, s390_r13
, 0xff);
2822 s390_ltgr (code
, dreg
, dreg
);
2824 s390_lghi (code
, s390_r0
, 0x80);
2825 s390_ngr (code
, dreg
, s390_r13
);
2826 s390_ogr (code
, dreg
, s390_r0
);
2831 s390_basr (code
, s390_r13
, 0);
2833 s390_llong (code
, 0x41e0000000000000);
2834 s390_llong (code
, 0x41f0000000000000);
2835 s390_ldr (code
, s390_f15
, sreg
);
2836 s390_cdb (code
, s390_f15
, 0, s390_r13
, 4);
2837 s390_jl (code
, 0); CODEPTR (code
, o
[0]);
2838 s390_sdb (code
, s390_f15
, 0, s390_r13
, 12);
2839 s390_cfdbr (code
, dreg
, 7, s390_f15
);
2841 PTRSLOT (code
, o
[0]);
2842 s390_cfdbr (code
, dreg
, 5, sreg
);
2845 s390_lghi (code
, s390_r0
, 0xff);
2846 s390_ngr (code
, dreg
, s390_r0
);
2849 s390_lghi (code
, s390_r0
, -1);
2850 s390_srlg (code
, s390_r0
, s390_r0
, 0, 16);
2851 s390_ngr (code
, dreg
, s390_r0
);
2858 /*========================= End of Function ========================*/
2860 static gboolean
is_unsigned (MonoInst
*next
)
2863 (((next
->opcode
>= OP_IBNE_UN
) &&
2864 (next
->opcode
<= OP_IBLT_UN
)) ||
2865 ((next
->opcode
>= OP_LBNE_UN
) &&
2866 (next
->opcode
<= OP_LBLT_UN
)) ||
2867 ((next
->opcode
>= OP_COND_EXC_NE_UN
) &&
2868 (next
->opcode
<= OP_COND_EXC_LT_UN
)) ||
2869 ((next
->opcode
>= OP_COND_EXC_INE_UN
) &&
2870 (next
->opcode
<= OP_COND_EXC_ILT_UN
)) ||
2871 ((next
->opcode
== OP_CLT_UN
) ||
2872 (next
->opcode
== OP_CGT_UN
)) ||
2873 ((next
->opcode
== OP_ICLT_UN
) ||
2874 (next
->opcode
== OP_ICGT_UN
) ||
2875 (next
->opcode
== OP_LCLT_UN
) ||
2876 (next
->opcode
== OP_LCGT_UN
))))
2882 /*------------------------------------------------------------------*/
2884 /* Name - mono_arch_output_basic_block */
2886 /* Function - Perform the "real" work of emitting instructions */
2887 /* that will do the work of in the basic block. */
2889 /*------------------------------------------------------------------*/
2892 mono_arch_output_basic_block (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2897 guint8
*code
= cfg
->native_code
+ cfg
->code_len
;
2898 guint last_offset
= 0;
2899 int max_len
, cpos
, src2
;
2901 /* we don't align basic blocks of loops on s390 */
2903 if (cfg
->verbose_level
> 2)
2904 g_print ("Basic block %d starting at offset 0x%x\n", bb
->block_num
, bb
->native_offset
);
2906 cpos
= bb
->max_offset
;
2908 if (cfg
->prof_options
& MONO_PROFILE_COVERAGE
) {
2909 //MonoCoverageInfo *cov = mono_get_coverage_info (cfg->method);
2910 //g_assert (!mono_compile_aot);
2913 // cov->data [bb->dfn].iloffset = bb->cil_code - cfg->cil_code;
2914 /* this is not thread save, but good enough */
2915 /* fixme: howto handle overflows? */
2916 //x86_inc_mem (code, &cov->data [bb->dfn].count);
2919 MONO_BB_FOR_EACH_INS (bb
, ins
) {
2920 offset
= code
- cfg
->native_code
;
2922 max_len
= ((guint8
*)ins_get_spec (ins
->opcode
))[MONO_INST_LEN
];
2924 if (offset
> (cfg
->code_size
- max_len
- 16)) {
2925 cfg
->code_size
*= 2;
2926 cfg
->native_code
= g_realloc (cfg
->native_code
, cfg
->code_size
);
2927 code
= cfg
->native_code
+ offset
;
2930 mono_debug_record_line_number (cfg
, ins
, offset
);
2932 switch (ins
->opcode
) {
2933 case OP_STOREI1_MEMBASE_IMM
: {
2934 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
2935 S390_LONG (code
, stcy
, stc
, s390_r0
, 0,
2936 ins
->inst_destbasereg
, ins
->inst_offset
);
2939 case OP_STOREI2_MEMBASE_IMM
: {
2940 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
2941 S390_LONG (code
, sthy
, sth
, s390_r0
, 0,
2942 ins
->inst_destbasereg
, ins
->inst_offset
);
2945 case OP_STOREI4_MEMBASE_IMM
: {
2946 if (s390_is_imm16(ins
->inst_imm
)) {
2947 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
2949 s390_basr (code
, s390_r13
, 0);
2951 s390_llong(code
, ins
->inst_imm
);
2952 s390_lg (code
, s390_r0
, 0, s390_r13
, 4);
2954 S390_LONG (code
, sty
, st
, s390_r0
, 0,
2955 ins
->inst_destbasereg
, ins
->inst_offset
);
2958 case OP_STORE_MEMBASE_IMM
:
2959 case OP_STOREI8_MEMBASE_IMM
: {
2960 if (s390_is_imm16(ins
->inst_imm
)) {
2961 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
2963 s390_basr (code
, s390_r13
, 0);
2965 s390_llong(code
, ins
->inst_imm
);
2966 s390_lg (code
, s390_r0
, 0, s390_r13
, 4);
2968 S390_LONG (code
, stg
, stg
, s390_r0
, 0,
2969 ins
->inst_destbasereg
, ins
->inst_offset
);
2972 case OP_STOREI1_MEMBASE_REG
: {
2973 S390_LONG (code
, stcy
, stc
, ins
->sreg1
, 0,
2974 ins
->inst_destbasereg
, ins
->inst_offset
);
2977 case OP_STOREI2_MEMBASE_REG
: {
2978 S390_LONG (code
, sthy
, sth
, ins
->sreg1
, 0,
2979 ins
->inst_destbasereg
, ins
->inst_offset
);
2982 case OP_STOREI4_MEMBASE_REG
: {
2983 S390_LONG (code
, sty
, st
, ins
->sreg1
, 0,
2984 ins
->inst_destbasereg
, ins
->inst_offset
);
2987 case OP_STORE_MEMBASE_REG
:
2988 case OP_STOREI8_MEMBASE_REG
: {
2989 S390_LONG (code
, stg
, stg
, ins
->sreg1
, 0,
2990 ins
->inst_destbasereg
, ins
->inst_offset
);
2994 g_assert_not_reached ();
2996 case OP_LOAD_MEMBASE
:
2997 case OP_LOADI8_MEMBASE
: {
2998 S390_LONG (code
, lg
, lg
, ins
->dreg
, 0,
2999 ins
->inst_basereg
, ins
->inst_offset
);
3002 case OP_LOADI4_MEMBASE
: {
3003 S390_LONG (code
, lgf
, lgf
, ins
->dreg
, 0,
3004 ins
->inst_basereg
, ins
->inst_offset
);
3007 case OP_LOADU4_MEMBASE
: {
3008 S390_LONG (code
, llgf
, llgf
, ins
->dreg
, 0,
3009 ins
->inst_basereg
, ins
->inst_offset
);
3012 case OP_LOADU1_MEMBASE
: {
3013 S390_LONG (code
, llgc
, llgc
, ins
->dreg
, 0,
3014 ins
->inst_basereg
, ins
->inst_offset
);
3017 case OP_LOADI1_MEMBASE
: {
3018 S390_LONG (code
, lgb
, lgb
, ins
->dreg
, 0,
3019 ins
->inst_basereg
, ins
->inst_offset
);
3022 case OP_LOADU2_MEMBASE
: {
3023 S390_LONG (code
, llgh
, llgh
, ins
->dreg
, 0,
3024 ins
->inst_basereg
, ins
->inst_offset
);
3027 case OP_LOADI2_MEMBASE
: {
3028 S390_LONG (code
, lgh
, lgh
, ins
->dreg
, 0,
3029 ins
->inst_basereg
, ins
->inst_offset
);
3032 case OP_LCONV_TO_I1
: {
3033 s390_lghi (code
, s390_r0
, 0x80);
3034 if (ins
->dreg
!= ins
->sreg1
) {
3035 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3037 s390_ngr (code
, s390_r0
, ins
->sreg1
);
3039 s390_lghi (code
, s390_r13
, -1);
3040 s390_sllg (code
, s390_r13
, s390_r13
, 0, 8);
3041 s390_ogr (code
, ins
->dreg
, s390_r13
);
3044 case OP_LCONV_TO_I2
: {
3045 s390_lghi (code
, s390_r0
, 0x80);
3046 s390_sllg (code
, s390_r0
, s390_r0
, 0, 8);
3047 if (ins
->dreg
!= ins
->sreg1
) {
3048 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3050 s390_ngr (code
, s390_r0
, ins
->sreg1
);
3052 s390_lghi (code
, s390_r13
, -1);
3053 s390_sllg (code
, s390_r13
, s390_r13
, 0, 16);
3054 s390_ogr (code
, ins
->dreg
, s390_r13
);
3057 case OP_LCONV_TO_U1
: {
3058 s390_lghi (code
, s390_r0
, 0xff);
3059 if (ins
->dreg
!= ins
->sreg1
) {
3060 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3062 s390_ngr (code
, ins
->dreg
, s390_r0
);
3065 case OP_LCONV_TO_U2
: {
3066 s390_lghi (code
, s390_r0
, -1);
3067 s390_sllg (code
, s390_r0
, s390_r0
, 0, 16);
3068 s390_srlg (code
, s390_r0
, s390_r0
, 0, 16);
3069 if (ins
->dreg
!= ins
->sreg1
) {
3070 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3072 s390_ngr (code
, ins
->dreg
, s390_r0
);
3075 case OP_ICONV_TO_I1
: {
3076 s390_lhi (code
, s390_r0
, 0x80);
3077 if (ins
->dreg
!= ins
->sreg1
) {
3078 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3080 s390_nr (code
, s390_r0
, ins
->sreg1
);
3082 s390_lhi (code
, s390_r13
, -1);
3083 s390_sll (code
, s390_r13
, 0, 8);
3084 s390_or (code
, ins
->dreg
, s390_r13
);
3087 case OP_ICONV_TO_I2
: {
3088 s390_lhi (code
, s390_r0
, 0x80);
3089 s390_sll (code
, s390_r0
, 0, 8);
3090 if (ins
->dreg
!= ins
->sreg1
) {
3091 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3093 s390_nr (code
, s390_r0
, ins
->sreg1
);
3095 s390_lhi (code
, s390_r13
, -1);
3096 s390_sll (code
, s390_r13
, 0, 16);
3097 s390_or (code
, ins
->dreg
, s390_r13
);
3100 case OP_ICONV_TO_U1
: {
3101 s390_lhi (code
, s390_r0
, 0xff);
3102 if (ins
->dreg
!= ins
->sreg1
) {
3103 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3105 s390_nr (code
, ins
->dreg
, s390_r0
);
3108 case OP_ICONV_TO_U2
: {
3109 s390_lhi (code
, s390_r0
, -1);
3110 s390_sll (code
, s390_r0
, 0, 16);
3111 s390_srl (code
, s390_r0
, 0, 16);
3112 if (ins
->dreg
!= ins
->sreg1
) {
3113 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3115 s390_nr (code
, ins
->dreg
, s390_r0
);
3120 if (is_unsigned (ins
->next
))
3121 s390_clgr (code
, ins
->sreg1
, ins
->sreg2
);
3123 s390_cgr (code
, ins
->sreg1
, ins
->sreg2
);
3127 if (is_unsigned (ins
->next
))
3128 s390_clr (code
, ins
->sreg1
, ins
->sreg2
);
3130 s390_cr (code
, ins
->sreg1
, ins
->sreg2
);
3133 case OP_COMPARE_IMM
:
3134 case OP_LCOMPARE_IMM
: {
3135 if (s390_is_imm16 (ins
->inst_imm
)) {
3136 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3137 if (is_unsigned (ins
->next
))
3138 s390_clgr (code
, ins
->sreg1
, s390_r0
);
3140 s390_cgr (code
, ins
->sreg1
, s390_r0
);
3142 s390_basr (code
, s390_r13
, 0);
3144 s390_llong(code
, ins
->inst_imm
);
3145 if (is_unsigned (ins
->next
))
3146 s390_clg (code
, ins
->sreg1
, 0, s390_r13
, 4);
3148 s390_cg (code
, ins
->sreg1
, 0, s390_r13
, 4);
3152 case OP_ICOMPARE_IMM
: {
3153 if (s390_is_imm16 (ins
->inst_imm
)) {
3154 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3155 if (is_unsigned (ins
->next
))
3156 s390_clr (code
, ins
->sreg1
, s390_r0
);
3158 s390_cr (code
, ins
->sreg1
, s390_r0
);
3161 s390_basr (code
, s390_r13
, 0);
3163 s390_word (code
, ins
->inst_imm
);
3164 if (is_unsigned (ins
->next
))
3165 s390_cl (code
, ins
->sreg1
, 0, s390_r13
, 4);
3167 s390_c (code
, ins
->sreg1
, 0, s390_r13
, 4);
3172 s390_basr (code
, s390_r13
, 0);
3174 mono_add_patch_info (cfg
, code
- cfg
->native_code
, MONO_PATCH_INFO_ABS
,
3176 s390_llong (code
, mono_break
);
3177 s390_lg (code
, s390_r14
, 0, s390_r13
, 4);
3178 s390_basr (code
, s390_r14
, s390_r14
);
3183 s390_agr (code
, ins
->dreg
, src2
);
3188 s390_agr (code
, ins
->dreg
, src2
);
3193 s390_alcgr (code
, ins
->dreg
, src2
);
3197 if (ins
->dreg
!= ins
->sreg1
) {
3198 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3200 if (s390_is_imm16 (ins
->inst_imm
)) {
3201 s390_aghi (code
, ins
->dreg
, ins
->inst_imm
);
3203 s390_basr (code
, s390_r13
, 0);
3205 s390_llong(code
, ins
->inst_imm
);
3206 s390_ag (code
, ins
->dreg
, 0, s390_r13
, 4);
3211 if (ins
->dreg
!= ins
->sreg1
) {
3212 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3214 g_assert (s390_is_imm16 (ins
->inst_imm
));
3215 s390_aghi (code
, ins
->dreg
, ins
->inst_imm
);
3219 if (ins
->dreg
!= ins
->sreg1
) {
3220 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3222 if (s390_is_imm16 (ins
->inst_imm
)) {
3223 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3224 s390_alcgr (code
, ins
->dreg
, s390_r0
);
3226 s390_basr (code
, s390_r13
, 0);
3228 s390_llong (code
, ins
->inst_imm
);
3229 s390_lg (code
, s390_r13
, 0, s390_r13
, 4);
3230 s390_alcgr (code
, ins
->dreg
, s390_r13
);
3235 case OP_S390_IADD_OVF
: {
3237 s390_ar (code
, ins
->dreg
, src2
);
3238 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3239 s390_lgfr (code
, ins
->dreg
, ins
->dreg
);
3242 case OP_IADD_OVF_UN
:
3243 case OP_S390_IADD_OVF_UN
: {
3245 s390_algr (code
, ins
->dreg
, src2
);
3246 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3247 s390_llgfr (code
, ins
->dreg
, ins
->dreg
);
3250 case OP_ADD_OVF_CARRY
: {
3252 s390_lghi (code
, s390_r0
, 0);
3253 s390_lgr (code
, s390_r1
, s390_r0
);
3254 s390_alcgr (code
, s390_r0
, s390_r1
);
3255 s390_agr (code
, ins
->dreg
, src2
);
3256 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3257 s390_agr (code
, ins
->dreg
, s390_r0
);
3258 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3261 case OP_ADD_OVF_UN_CARRY
: {
3263 s390_alcgr (code
, ins
->dreg
, src2
);
3264 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3269 s390_sgr (code
, ins
->dreg
, src2
);
3274 s390_sgr (code
, ins
->dreg
, src2
);
3279 s390_slbgr(code
, ins
->dreg
, src2
);
3283 if (ins
->dreg
!= ins
->sreg1
) {
3284 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3286 if (s390_is_imm16 (-ins
->inst_imm
)) {
3287 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3288 s390_slgr (code
, ins
->dreg
, s390_r0
);
3290 s390_basr (code
, s390_r13
, 0);
3292 s390_llong(code
, ins
->inst_imm
);
3293 s390_slg (code
, ins
->dreg
, 0, s390_r13
, 4);
3298 if (ins
->dreg
!= ins
->sreg1
) {
3299 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3301 if (s390_is_imm16 (-ins
->inst_imm
)) {
3302 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3303 s390_slgr (code
, ins
->dreg
, s390_r0
);
3305 s390_basr (code
, s390_r13
, 0);
3307 s390_llong(code
, ins
->inst_imm
);
3308 s390_slg (code
, ins
->dreg
, 0, s390_r13
, 4);
3313 if (ins
->dreg
!= ins
->sreg1
) {
3314 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3316 if (s390_is_imm16 (-ins
->inst_imm
)) {
3317 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3318 s390_slbgr (code
, ins
->dreg
, s390_r0
);
3320 s390_basr (code
, s390_r13
, 0);
3322 s390_llong(code
, ins
->inst_imm
);
3323 s390_slbg (code
, ins
->dreg
, 0, s390_r13
, 4);
3327 case OP_SUB_OVF_CARRY
: {
3329 s390_lghi (code
, s390_r0
, 0);
3330 s390_lgr (code
, s390_r1
, s390_r0
);
3331 s390_slbgr (code
, s390_r0
, s390_r1
);
3332 s390_sgr (code
, ins
->dreg
, src2
);
3333 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3334 s390_agr (code
, ins
->dreg
, s390_r0
);
3335 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3338 case OP_SUB_OVF_UN_CARRY
: {
3340 s390_slbgr (code
, ins
->dreg
, src2
);
3341 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, "OverflowException");
3345 if (ins
->sreg1
== ins
->dreg
) {
3346 s390_ngr (code
, ins
->dreg
, ins
->sreg2
);
3349 if (ins
->sreg2
== ins
->dreg
) {
3350 s390_ngr (code
, ins
->dreg
, ins
->sreg1
);
3353 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3354 s390_ngr (code
, ins
->dreg
, ins
->sreg2
);
3360 if (ins
->dreg
!= ins
->sreg1
) {
3361 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3363 if (s390_is_imm16 (ins
->inst_imm
)) {
3364 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3365 s390_ngr (code
, ins
->dreg
, s390_r0
);
3367 s390_basr (code
, s390_r13
, 0);
3369 s390_llong(code
, ins
->inst_imm
);
3370 s390_ng (code
, ins
->dreg
, 0, s390_r13
, 4);
3375 s390_lgr (code
, s390_r1
, ins
->sreg1
);
3376 s390_dsgr (code
, s390_r0
, ins
->sreg2
);
3377 s390_lgr (code
, ins
->dreg
, s390_r1
);
3381 s390_lgr (code
, s390_r1
, ins
->sreg1
);
3382 s390_lghi (code
, s390_r0
, 0);
3383 s390_dlgr (code
, s390_r0
, ins
->sreg2
);
3384 s390_lgr (code
, ins
->dreg
, s390_r1
);
3388 s390_lgr (code
, s390_r1
, ins
->sreg1
);
3389 s390_dsgr (code
, s390_r0
, ins
->sreg2
);
3390 s390_lgr (code
, ins
->dreg
, s390_r0
);
3394 s390_lgr (code
, s390_r1
, ins
->sreg1
);
3395 s390_lghi (code
, s390_r0
, 0);
3396 s390_dlgr (code
, s390_r0
, ins
->sreg2
);
3397 s390_lgr (code
, ins
->dreg
, s390_r0
);
3401 if (ins
->sreg1
== ins
->dreg
) {
3402 s390_ogr (code
, ins
->dreg
, ins
->sreg2
);
3405 if (ins
->sreg2
== ins
->dreg
) {
3406 s390_ogr (code
, ins
->dreg
, ins
->sreg1
);
3409 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3410 s390_ogr (code
, ins
->dreg
, ins
->sreg2
);
3416 if (ins
->dreg
!= ins
->sreg1
) {
3417 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3419 if (s390_is_imm16 (ins
->inst_imm
)) {
3420 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3421 s390_ogr (code
, ins
->dreg
, s390_r0
);
3423 s390_basr (code
, s390_r13
, 0);
3425 s390_llong(code
, ins
->inst_imm
);
3426 s390_og (code
, ins
->dreg
, 0, s390_r13
, 4);
3431 if (ins
->sreg1
== ins
->dreg
) {
3432 s390_xgr (code
, ins
->dreg
, ins
->sreg2
);
3435 if (ins
->sreg2
== ins
->dreg
) {
3436 s390_xgr (code
, ins
->dreg
, ins
->sreg1
);
3439 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3440 s390_xgr (code
, ins
->dreg
, ins
->sreg2
);
3446 if (ins
->dreg
!= ins
->sreg1
) {
3447 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3449 if (s390_is_imm16 (ins
->inst_imm
)) {
3450 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3451 s390_xgr (code
, ins
->dreg
, s390_r0
);
3453 s390_basr (code
, s390_r13
, 0);
3455 s390_llong(code
, ins
->inst_imm
);
3456 s390_xg (code
, ins
->dreg
, 0, s390_r13
, 4);
3462 s390_sllg (code
, ins
->dreg
, ins
->dreg
, src2
, 0);
3467 if (ins
->sreg1
!= ins
->dreg
) {
3468 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3470 s390_sllg (code
, ins
->dreg
, ins
->dreg
, 0, (ins
->inst_imm
& 0x3f));
3475 s390_srag (code
, ins
->dreg
, ins
->dreg
, src2
, 0);
3480 if (ins
->sreg1
!= ins
->dreg
) {
3481 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3483 s390_srag (code
, ins
->dreg
, ins
->dreg
, 0, (ins
->inst_imm
& 0x3f));
3487 case OP_LSHR_UN_IMM
: {
3488 if (ins
->sreg1
!= ins
->dreg
) {
3489 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3491 s390_srlg (code
, ins
->dreg
, ins
->dreg
, 0, (ins
->inst_imm
& 0x3f));
3496 s390_srlg (code
, ins
->dreg
, ins
->dreg
, src2
, 0);
3500 if (ins
->sreg1
!= ins
->dreg
) {
3501 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3503 s390_lghi (code
, s390_r0
, -1);
3504 s390_xgr (code
, ins
->dreg
, s390_r0
);
3508 s390_lcgr (code
, ins
->dreg
, ins
->sreg1
);
3513 s390_msgr (code
, ins
->dreg
, src2
);
3518 if (ins
->dreg
!= ins
->sreg1
) {
3519 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3521 if (s390_is_imm16 (ins
->inst_imm
)) {
3522 s390_lghi (code
, s390_r13
, ins
->inst_imm
);
3524 s390_basr (code
, s390_r13
, 0);
3526 s390_llong(code
, ins
->inst_imm
);
3527 s390_lg (code
, s390_r13
, 0, s390_r13
, 4);
3529 s390_msgr (code
, ins
->dreg
, s390_r13
);
3534 s390_ltgr (code
, s390_r1
, ins
->sreg1
);
3535 s390_jz (code
, 0); CODEPTR(code
, o
[0]);
3536 s390_ltgr (code
, s390_r0
, ins
->sreg2
);
3538 s390_lghi (code
, s390_r1
, 0);
3539 s390_j (code
, 0); CODEPTR(code
, o
[1]);
3540 s390_xgr (code
, s390_r0
, s390_r1
);
3541 s390_msgr (code
, s390_r1
, ins
->sreg2
);
3542 s390_xgr (code
, s390_r0
, s390_r1
);
3543 s390_srlg (code
, s390_r0
, s390_r0
, 0, 63);
3544 s390_ltgr (code
, s390_r0
, s390_r0
);
3545 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3546 PTRSLOT (code
, o
[0]);
3547 PTRSLOT (code
, o
[1]);
3548 s390_lgr (code
, ins
->dreg
, s390_r1
);
3551 case OP_LMUL_OVF_UN
: {
3552 s390_lghi (code
, s390_r0
, 0);
3553 s390_lgr (code
, s390_r1
, ins
->sreg1
);
3554 s390_mlgr (code
, s390_r0
, ins
->sreg2
);
3555 s390_ltgr (code
, s390_r0
, s390_r0
);
3556 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3557 s390_lgr (code
, ins
->dreg
, s390_r1
);
3561 g_assert_not_reached ();
3563 s390_algr (code
, ins
->dreg
, src2
);
3568 s390_agr (code
, ins
->dreg
, src2
);
3572 g_assert_not_reached ();
3574 s390_alcgr (code
, ins
->dreg
, src2
);
3578 if (ins
->dreg
!= ins
->sreg1
) {
3579 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3581 if (s390_is_imm16 (ins
->inst_imm
)) {
3582 s390_aghi(code
, ins
->dreg
, ins
->inst_imm
);
3584 s390_basr (code
, s390_r13
, 0);
3586 s390_word (code
, ins
->inst_imm
);
3587 s390_agf (code
, ins
->dreg
, 0, s390_r13
, 4);
3592 if (ins
->dreg
!= ins
->sreg1
) {
3593 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3595 if (s390_is_imm16 (ins
->inst_imm
)) {
3596 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3597 s390_alcgr (code
, ins
->dreg
, s390_r0
);
3599 s390_basr (code
, s390_r13
, 0);
3601 s390_word (code
, ins
->inst_imm
);
3602 s390_lgf (code
, s390_r13
, 0, s390_r13
, 4);
3603 s390_alcgr (code
, ins
->dreg
, s390_r13
);
3608 case OP_S390_LADD_OVF
: {
3610 s390_agr (code
, ins
->dreg
, src2
);
3611 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3614 case OP_LADD_OVF_UN
:
3615 case OP_S390_LADD_OVF_UN
: {
3617 s390_algr (code
, ins
->dreg
, src2
);
3618 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3622 CHECK_SRCDST_NCOM_I
;
3623 s390_slgr (code
, ins
->dreg
, src2
);
3627 CHECK_SRCDST_NCOM_I
;
3628 s390_sgr (code
, ins
->dreg
, src2
);
3632 CHECK_SRCDST_NCOM_I
;
3633 s390_slbgr (code
, ins
->dreg
, src2
);
3637 if (ins
->dreg
!= ins
->sreg1
) {
3638 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3640 if (s390_is_imm16 (-ins
->inst_imm
)) {
3641 s390_aghi (code
, ins
->dreg
, -ins
->inst_imm
);
3643 s390_basr (code
, s390_r13
, 0);
3645 s390_word (code
, ins
->inst_imm
);
3646 s390_sgf (code
, ins
->dreg
, 0, s390_r13
, 4);
3651 s390_basr (code
, s390_r13
, 0);
3653 s390_word (code
, ins
->inst_imm
);
3654 s390_slgf (code
, ins
->dreg
, 0, s390_r13
, 4);
3658 case OP_S390_ISUB_OVF
: {
3660 s390_sr (code
, ins
->dreg
, src2
);
3661 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3662 s390_lgfr (code
, ins
->dreg
, ins
->dreg
);
3665 case OP_ISUB_OVF_UN
:
3666 case OP_S390_ISUB_OVF_UN
: {
3668 s390_slr (code
, ins
->dreg
, src2
);
3669 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, "OverflowException");
3670 s390_llgfr(code
, ins
->dreg
, ins
->dreg
);
3674 case OP_S390_LSUB_OVF
: {
3676 s390_sgr (code
, ins
->dreg
, src2
);
3677 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3680 case OP_LSUB_OVF_UN
:
3681 case OP_S390_LSUB_OVF_UN
: {
3683 s390_slgr (code
, ins
->dreg
, src2
);
3684 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, "OverflowException");
3688 CHECK_SRCDST_NCOM_I
;
3689 s390_ngr (code
, ins
->dreg
, src2
);
3693 if (ins
->dreg
!= ins
->sreg1
) {
3694 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3696 if (s390_is_imm16 (ins
->inst_imm
)) {
3697 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3698 s390_ngr (code
, ins
->dreg
, s390_r0
);
3700 s390_basr (code
, s390_r13
, 0);
3702 s390_llong(code
, ins
->inst_imm
);
3703 s390_ng (code
, ins
->dreg
, 0, s390_r13
, 4);
3708 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3709 s390_srda (code
, s390_r0
, 0, 32);
3710 s390_dr (code
, s390_r0
, ins
->sreg2
);
3711 s390_lgfr (code
, ins
->dreg
, s390_r1
);
3715 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3716 s390_srdl (code
, s390_r0
, 0, 32);
3717 s390_dlr (code
, s390_r0
, ins
->sreg2
);
3718 s390_lgfr (code
, ins
->dreg
, s390_r1
);
3722 if (s390_is_imm16 (ins
->inst_imm
)) {
3723 s390_lghi (code
, s390_r13
, ins
->inst_imm
);
3724 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3726 s390_basr (code
, s390_r13
, 0);
3728 s390_word (code
, ins
->inst_imm
);
3729 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3730 s390_lgf (code
, s390_r13
, 0, s390_r13
, 4);
3732 s390_srda (code
, s390_r0
, 0, 32);
3733 s390_dr (code
, s390_r0
, ins
->sreg2
);
3734 s390_lgfr (code
, ins
->dreg
, s390_r1
);
3738 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3739 s390_srda (code
, s390_r0
, 0, 32);
3740 s390_dr (code
, s390_r0
, ins
->sreg2
);
3741 s390_lgfr (code
, ins
->dreg
, s390_r0
);
3744 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3745 s390_srdl (code
, s390_r0
, 0, 32);
3746 s390_dlr (code
, s390_r0
, ins
->sreg2
);
3747 s390_lgfr (code
, ins
->dreg
, s390_r0
);
3751 if (s390_is_imm16 (ins
->inst_imm
)) {
3752 s390_lghi (code
, s390_r13
, ins
->inst_imm
);
3753 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3755 s390_basr (code
, s390_r13
, 0);
3757 s390_word (code
, ins
->inst_imm
);
3758 s390_lgfr (code
, s390_r0
, ins
->sreg1
);
3759 s390_lgf (code
, s390_r13
, 0, s390_r13
, 4);
3761 s390_srda (code
, s390_r0
, 0, 32);
3762 s390_dr (code
, s390_r0
, ins
->sreg2
);
3763 s390_lgfr (code
, ins
->dreg
, s390_r0
);
3768 s390_ogr (code
, ins
->dreg
, src2
);
3772 if (ins
->dreg
!= ins
->sreg1
) {
3773 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3775 if (s390_is_imm16 (ins
->inst_imm
)) {
3776 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3777 s390_ogr (code
, ins
->dreg
, s390_r0
);
3779 s390_basr (code
, s390_r13
, 0);
3781 s390_llong(code
, ins
->inst_imm
);
3782 s390_og (code
, ins
->dreg
, 0, s390_r13
, 4);
3788 s390_xgr (code
, ins
->dreg
, src2
);
3792 if (ins
->dreg
!= ins
->sreg1
) {
3793 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3795 if (s390_is_imm16 (ins
->inst_imm
)) {
3796 s390_lghi (code
, s390_r0
, ins
->inst_imm
);
3797 s390_xgr (code
, ins
->dreg
, s390_r0
);
3799 s390_basr (code
, s390_r13
, 0);
3801 s390_llong(code
, ins
->inst_imm
);
3802 s390_xg (code
, ins
->dreg
, 0, s390_r13
, 4);
3808 s390_sll (code
, ins
->dreg
, src2
, 0);
3812 if (ins
->sreg1
!= ins
->dreg
) {
3813 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3815 s390_sll (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3820 s390_sra (code
, ins
->dreg
, src2
, 0);
3824 if (ins
->sreg1
!= ins
->dreg
) {
3825 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3827 s390_sra (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3830 case OP_ISHR_UN_IMM
: {
3831 if (ins
->sreg1
!= ins
->dreg
) {
3832 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3834 s390_srl (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3839 s390_srl (code
, ins
->dreg
, src2
, 0);
3843 if (ins
->sreg1
!= ins
->dreg
) {
3844 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3846 s390_lghi (code
, s390_r0
, -1);
3847 s390_xgr (code
, ins
->dreg
, s390_r0
);
3851 s390_lcgr (code
, ins
->dreg
, ins
->sreg1
);
3856 s390_msr (code
, ins
->dreg
, src2
);
3860 if (ins
->dreg
!= ins
->sreg1
) {
3861 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3863 if (s390_is_imm16 (ins
->inst_imm
)) {
3864 s390_lghi (code
, s390_r13
, ins
->inst_imm
);
3866 s390_basr (code
, s390_r13
, 0);
3868 s390_word (code
, ins
->inst_imm
);
3869 s390_lgf (code
, s390_r13
, 0, s390_r13
, 4);
3871 s390_msr (code
, ins
->dreg
, s390_r13
);
3876 s390_ltr (code
, s390_r1
, ins
->sreg1
);
3877 s390_jz (code
, 0); CODEPTR(code
, o
[0]);
3878 s390_ltr (code
, s390_r0
, ins
->sreg2
);
3880 s390_lhi (code
, s390_r1
, 0);
3881 s390_j (code
, 0); CODEPTR(code
, o
[1]);
3882 s390_xr (code
, s390_r0
, s390_r1
);
3883 s390_msr (code
, s390_r1
, ins
->sreg2
);
3884 s390_xr (code
, s390_r0
, s390_r1
);
3885 s390_srl (code
, s390_r0
, 0, 31);
3886 s390_ltr (code
, s390_r0
, s390_r0
);
3887 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3888 PTRSLOT (code
, o
[0]);
3889 PTRSLOT (code
, o
[1]);
3890 s390_lgfr (code
, ins
->dreg
, s390_r1
);
3893 case OP_IMUL_OVF_UN
: {
3894 s390_lhi (code
, s390_r0
, 0);
3895 s390_lr (code
, s390_r1
, ins
->sreg1
);
3896 s390_mlr (code
, s390_r0
, ins
->sreg2
);
3897 s390_ltr (code
, s390_r0
, s390_r0
);
3898 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3899 s390_lgfr (code
, ins
->dreg
, s390_r1
);
3904 if (s390_is_imm16(ins
->inst_c0
)) {
3905 s390_lghi (code
, ins
->dreg
, ins
->inst_c0
);
3907 s390_basr (code
, s390_r13
, 0);
3909 s390_llong(code
, ins
->inst_c0
);
3910 s390_lg (code
, ins
->dreg
, 0, s390_r13
, 4);
3915 s390_basr (code
, s390_r13
, 0);
3917 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3918 (MonoJumpInfoType
)ins
->inst_i1
, ins
->inst_p0
);
3919 s390_llong(code
, 0);
3920 s390_lg (code
,ins
->dreg
, 0, s390_r13
, 4);
3923 case OP_JUMP_TABLE
: {
3924 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3925 (MonoJumpInfoType
)ins
->inst_i1
, ins
->inst_p0
);
3926 s390_basr (code
, s390_r13
, 0);
3928 s390_llong (code
, 0);
3929 s390_lg (code
, ins
->dreg
, 0, s390_r13
, 4);
3933 if (ins
->dreg
!= ins
->sreg1
) {
3934 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
3938 case OP_LCONV_TO_I8
:
3940 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3942 case OP_LCONV_TO_I4
:
3943 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3946 case OP_LCONV_TO_U8
:
3947 case OP_LCONV_TO_U4
:
3949 s390_llgfr (code
, ins
->dreg
, ins
->sreg1
);
3951 case OP_LCONV_TO_OVF_U4
:
3952 s390_basr (code
, s390_r13
, 0);
3954 s390_llong(code
, 4294967295);
3955 s390_clg (code
, ins
->sreg1
, 0, s390_r13
, 4);
3956 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT
, "OverflowException");
3957 s390_ltgr (code
, ins
->sreg1
, ins
->sreg1
);
3958 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT
, "OverflowException");
3959 s390_llgfr(code
, ins
->dreg
, ins
->sreg1
);
3961 case OP_LCONV_TO_OVF_I4_UN
:
3962 s390_basr (code
, s390_r13
, 0);
3964 s390_llong(code
, 2147483647);
3965 s390_cg (code
, ins
->sreg1
, 0, s390_r13
, 4);
3966 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT
, "OverflowException");
3967 s390_ltgr (code
, ins
->sreg1
, ins
->sreg1
);
3968 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT
, "OverflowException");
3969 s390_lgfr (code
, ins
->dreg
, ins
->sreg1
);
3972 case OP_FCONV_TO_R4
: {
3973 if (ins
->dreg
!= ins
->sreg1
) {
3974 s390_ldr (code
, ins
->dreg
, ins
->sreg1
);
3978 case OP_S390_SETF4RET
: {
3979 s390_ledbr (code
, ins
->dreg
, ins
->sreg1
);
3983 if (cfg
->method
->save_lmf
)
3984 restoreLMF(code
, cfg
->frame_reg
, cfg
->stack_usage
);
3986 if (cfg
->flags
& MONO_CFG_HAS_TAIL
) {
3987 code
= emit_load_volatile_arguments (code
, cfg
);
3990 code
= backUpStackPtr(cfg
, code
);
3991 s390_lg (code
, s390_r14
, 0, STK_BASE
, S390_RET_ADDR_OFFSET
);
3992 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3993 MONO_PATCH_INFO_METHOD_JUMP
,
3995 s390_jcl (code
, S390_CC_UN
, 0);
3998 case OP_CHECK_THIS
: {
3999 /* ensure ins->sreg1 is not NULL */
4000 s390_lg (code
, s390_r0
, 0, ins
->sreg1
, 0);
4001 s390_ltgr (code
, s390_r0
, s390_r0
);
4005 int offset
= cfg
->sig_cookie
+ cfg
->stack_usage
;
4007 if (s390_is_imm16 (offset
))
4008 s390_lghi (code
, s390_r0
, offset
);
4010 s390_basr (code
, s390_r13
, 0);
4012 s390_llong(code
, offset
);
4013 s390_lg (code
, s390_r0
, 0, s390_r13
, 0);
4015 s390_agr (code
, s390_r0
, cfg
->frame_reg
);
4016 s390_stg (code
, s390_r0
, 0, ins
->sreg1
, 0);
4020 s390_basr (code
, s390_r13
, 0);
4022 call
= (MonoCallInst
*)ins
;
4023 if (ins
->flags
& MONO_INST_HAS_METHOD
)
4024 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4025 MONO_PATCH_INFO_METHOD
,
4028 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4029 MONO_PATCH_INFO_ABS
,
4031 s390_llong(code
, 0);
4032 s390_lg (code
, s390_r14
, 0, s390_r13
, 4);
4033 s390_basr (code
, s390_r14
, s390_r14
);
4034 if (call
->signature
->ret
->type
== MONO_TYPE_R4
)
4035 s390_ldebr (code
, s390_f0
, s390_f0
);
4043 s390_basr (code
, s390_r13
, 0);
4045 call
= (MonoCallInst
*)ins
;
4046 if (ins
->flags
& MONO_INST_HAS_METHOD
)
4047 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4048 MONO_PATCH_INFO_METHOD
,
4051 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4052 MONO_PATCH_INFO_ABS
,
4054 s390_llong(code
, 0);
4055 s390_lg (code
, s390_r14
, 0, s390_r13
, 4);
4056 s390_basr (code
, s390_r14
, s390_r14
);
4059 case OP_FCALL_REG
: {
4060 call
= (MonoCallInst
*)ins
;
4061 s390_lgr (code
, s390_r1
, ins
->sreg1
);
4062 s390_basr (code
, s390_r14
, s390_r1
);
4063 if (call
->signature
->ret
->type
== MONO_TYPE_R4
)
4064 s390_ldebr (code
, s390_f0
, s390_f0
);
4070 case OP_VOIDCALL_REG
:
4072 s390_lgr (code
, s390_r1
, ins
->sreg1
);
4073 s390_basr (code
, s390_r14
, s390_r1
);
4076 case OP_FCALL_MEMBASE
: {
4077 call
= (MonoCallInst
*)ins
;
4078 s390_lg (code
, s390_r1
, 0, ins
->sreg1
, ins
->inst_offset
);
4079 s390_basr (code
, s390_r14
, s390_r1
);
4080 if (call
->signature
->ret
->type
== MONO_TYPE_R4
)
4081 s390_ldebr (code
, s390_f0
, s390_f0
);
4084 case OP_LCALL_MEMBASE
:
4085 case OP_VCALL_MEMBASE
:
4086 case OP_VCALL2_MEMBASE
:
4087 case OP_VOIDCALL_MEMBASE
:
4088 case OP_CALL_MEMBASE
: {
4089 s390_lg (code
, s390_r1
, 0, ins
->sreg1
, ins
->inst_offset
);
4090 s390_basr (code
, s390_r14
, s390_r1
);
4094 g_assert_not_reached ();
4097 int alloca_skip
= S390_MINIMAL_STACK_SIZE
+ cfg
->param_area
;
4098 int area_offset
= S390_ALIGN(alloca_skip
, S390_STACK_ALIGNMENT
);
4099 s390_lgr (code
, s390_r1
, ins
->sreg1
);
4100 if (ins
->flags
& MONO_INST_INIT
)
4101 s390_lgr (code
, s390_r0
, ins
->sreg1
);
4102 s390_aghi (code
, s390_r1
, 14);
4103 s390_srlg (code
, s390_r1
, s390_r1
, 0, 3);
4104 s390_sllg (code
, s390_r1
, s390_r1
, 0, 3);
4105 if (cfg
->method
->save_lmf
) {
4106 /*----------------------------------*/
4107 /* we have to adjust lmf ebp value */
4108 /*----------------------------------*/
4109 int lmfOffset
= cfg
->stack_usage
- sizeof(MonoLMF
);
4111 s390_lgr (code
, s390_r13
, cfg
->frame_reg
);
4112 if (s390_is_imm16(lmfOffset
))
4113 s390_aghi (code
, s390_r13
, lmfOffset
);
4115 s390_basr (code
, s390_r14
, 0);
4117 s390_word (code
, lmfOffset
);
4118 s390_agf (code
, s390_r13
, 0, s390_r14
, 4);
4120 s390_lgr (code
, s390_r14
, STK_BASE
);
4121 s390_sgr (code
, s390_r14
, s390_r1
);
4122 s390_stg (code
, s390_r14
, 0, s390_r13
,
4123 G_STRUCT_OFFSET(MonoLMF
, ebp
));
4125 s390_lg (code
, s390_r13
, 0, STK_BASE
, 0);
4126 s390_sgr (code
, STK_BASE
, s390_r1
);
4127 s390_stg (code
, s390_r13
, 0, STK_BASE
, 0);
4128 s390_la (code
, ins
->dreg
, 0, STK_BASE
, area_offset
);
4129 s390_srlg (code
, ins
->dreg
, ins
->dreg
, 0, 3);
4130 s390_sllg (code
, ins
->dreg
, ins
->dreg
, 0, 3);
4131 if (ins
->flags
& MONO_INST_INIT
) {
4132 s390_lgr (code
, s390_r1
, s390_r0
);
4133 s390_lgr (code
, s390_r0
, ins
->dreg
);
4134 s390_lgr (code
, s390_r14
, s390_r12
);
4135 s390_lghi (code
, s390_r13
, 0);
4136 s390_mvcle(code
, s390_r0
, s390_r12
, 0, 0);
4138 s390_lgr (code
, s390_r12
, s390_r14
);
4143 s390_lgr (code
, s390_r2
, ins
->sreg1
);
4144 s390_basr (code
, s390_r13
, 0);
4146 mono_add_patch_info (cfg
, code
-cfg
->native_code
, MONO_PATCH_INFO_INTERNAL_METHOD
,
4147 (gpointer
) "mono_arch_throw_exception");
4148 s390_llong(code
, 0);
4149 s390_lg (code
, s390_r14
, 0, s390_r13
, 4);
4150 s390_basr (code
, s390_r14
, s390_r14
);
4154 s390_lgr (code
, s390_r2
, ins
->sreg1
);
4155 s390_basr (code
, s390_r13
, 0);
4157 mono_add_patch_info (cfg
, code
-cfg
->native_code
, MONO_PATCH_INFO_INTERNAL_METHOD
,
4158 (gpointer
) "mono_arch_rethrow_exception");
4159 s390_llong(code
, 0);
4160 s390_lg (code
, s390_r14
, 0, s390_r13
, 4);
4161 s390_basr (code
, s390_r14
, s390_r14
);
4164 case OP_START_HANDLER
: {
4165 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4167 S390_LONG (code
, stg
, stg
, s390_r14
, 0,
4168 spvar
->inst_basereg
,
4169 spvar
->inst_offset
);
4172 case OP_ENDFILTER
: {
4173 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4175 if (ins
->sreg1
!= s390_r2
)
4176 s390_lgr(code
, s390_r2
, ins
->sreg1
);
4177 S390_LONG (code
, lg
, lg
, s390_r14
, 0,
4178 spvar
->inst_basereg
,
4179 spvar
->inst_offset
);
4180 s390_br (code
, s390_r14
);
4183 case OP_ENDFINALLY
: {
4184 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4186 S390_LONG (code
, lg
, lg
, s390_r14
, 0,
4187 spvar
->inst_basereg
,
4188 spvar
->inst_offset
);
4189 s390_br (code
, s390_r14
);
4192 case OP_CALL_HANDLER
: {
4193 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4194 MONO_PATCH_INFO_BB
, ins
->inst_target_bb
);
4195 s390_brasl (code
, s390_r14
, 0);
4199 ins
->inst_c0
= code
- cfg
->native_code
;
4202 case OP_RELAXED_NOP
:
4205 case OP_DUMMY_STORE
:
4206 case OP_NOT_REACHED
:
4211 EMIT_UNCOND_BRANCH(ins
);
4214 s390_br (code
, ins
->sreg1
);
4220 s390_lghi(code
, ins
->dreg
, 1);
4222 s390_lghi(code
, ins
->dreg
, 0);
4228 s390_lghi(code
, ins
->dreg
, 1);
4230 s390_lghi(code
, ins
->dreg
, 0);
4236 s390_lghi(code
, ins
->dreg
, 1);
4238 s390_lghi(code
, ins
->dreg
, 0);
4244 s390_lghi(code
, ins
->dreg
, 1);
4246 s390_lghi(code
, ins
->dreg
, 0);
4252 s390_lghi(code
, ins
->dreg
, 1);
4254 s390_lghi(code
, ins
->dreg
, 0);
4257 case OP_COND_EXC_EQ
:
4258 case OP_COND_EXC_IEQ
:
4259 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_EQ
, ins
->inst_p1
);
4261 case OP_COND_EXC_NE_UN
:
4262 case OP_COND_EXC_INE_UN
:
4263 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NE
, ins
->inst_p1
);
4265 case OP_COND_EXC_LT
:
4266 case OP_COND_EXC_ILT
:
4267 case OP_COND_EXC_LT_UN
:
4268 case OP_COND_EXC_ILT_UN
:
4269 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT
, ins
->inst_p1
);
4271 case OP_COND_EXC_GT
:
4272 case OP_COND_EXC_IGT
:
4273 case OP_COND_EXC_GT_UN
:
4274 case OP_COND_EXC_IGT_UN
:
4275 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT
, ins
->inst_p1
);
4277 case OP_COND_EXC_GE
:
4278 case OP_COND_EXC_IGE
:
4279 case OP_COND_EXC_GE_UN
:
4280 case OP_COND_EXC_IGE_UN
:
4281 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GE
, ins
->inst_p1
);
4283 case OP_COND_EXC_LE
:
4284 case OP_COND_EXC_ILE
:
4285 case OP_COND_EXC_LE_UN
:
4286 case OP_COND_EXC_ILE_UN
:
4287 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LE
, ins
->inst_p1
);
4289 case OP_COND_EXC_OV
:
4290 case OP_COND_EXC_IOV
:
4291 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, ins
->inst_p1
);
4293 case OP_COND_EXC_NO
:
4294 case OP_COND_EXC_INO
:
4295 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NO
, ins
->inst_p1
);
4298 case OP_COND_EXC_IC
:
4299 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, ins
->inst_p1
);
4301 case OP_COND_EXC_NC
:
4302 case OP_COND_EXC_INC
:
4303 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, ins
->inst_p1
);
4307 EMIT_COND_BRANCH (ins
, S390_CC_EQ
);
4311 EMIT_COND_BRANCH (ins
, S390_CC_NE
);
4317 EMIT_COND_BRANCH (ins
, S390_CC_LT
);
4323 EMIT_COND_BRANCH (ins
, S390_CC_GT
);
4329 EMIT_COND_BRANCH (ins
, S390_CC_GE
);
4335 EMIT_COND_BRANCH (ins
, S390_CC_LE
);
4338 /* floating point opcodes */
4340 if (*((float *) ins
->inst_p0
) == 0) {
4341 s390_lzdr (code
, ins
->dreg
);
4343 s390_basr (code
, s390_r13
, 0);
4345 s390_llong (code
, ins
->inst_p0
);
4346 s390_lg (code
, s390_r13
, 0, s390_r13
, 4);
4347 s390_ld (code
, ins
->dreg
, 0, s390_r13
, 0);
4352 if (*((float *) ins
->inst_p0
) == 0) {
4353 s390_lzdr (code
, ins
->dreg
);
4355 s390_basr (code
, s390_r13
, 0);
4357 s390_llong(code
, ins
->inst_p0
);
4358 s390_lg (code
, s390_r13
, 0, s390_r13
, 4);
4359 s390_ldeb (code
, ins
->dreg
, 0, s390_r13
, 0);
4363 case OP_STORER8_MEMBASE_REG
: {
4364 S390_LONG (code
, stdy
, std
, ins
->sreg1
, 0,
4365 ins
->inst_destbasereg
, ins
->inst_offset
);
4368 case OP_LOADR8_MEMBASE
: {
4369 S390_LONG (code
, ldy
, ld
, ins
->dreg
, 0,
4370 ins
->inst_basereg
, ins
->inst_offset
);
4373 case OP_STORER4_MEMBASE_REG
: {
4374 s390_ledbr (code
, s390_f15
, ins
->sreg1
);
4375 S390_LONG (code
, stey
, ste
, s390_f15
, 0,
4376 ins
->inst_destbasereg
, ins
->inst_offset
);
4379 case OP_LOADR4_MEMBASE
: {
4380 S390_LONG (code
, ldy
, ld
, s390_f15
, 0,
4381 ins
->inst_basereg
, ins
->inst_offset
);
4382 s390_ldebr (code
, ins
->dreg
, s390_f15
);
4385 case OP_ICONV_TO_R_UN
: {
4386 s390_cdfbr (code
, ins
->dreg
, ins
->sreg1
);
4387 s390_ltr (code
, ins
->sreg1
, ins
->sreg1
);
4388 s390_jnl (code
, 12);
4389 s390_basr (code
, s390_r13
, 0);
4391 s390_word (code
, 0x41f00000);
4392 s390_word (code
, 0);
4393 s390_adb (code
, ins
->dreg
, 0, s390_r13
, 4);
4396 case OP_LCONV_TO_R_UN
: {
4397 s390_cdgbr (code
, ins
->dreg
, ins
->sreg1
);
4398 s390_ltgr (code
, ins
->sreg1
, ins
->sreg1
);
4399 s390_jnl (code
, 12);
4400 s390_basr (code
, s390_r13
, 0);
4402 s390_word (code
, 0x41f00000);
4403 s390_word (code
, 0);
4404 s390_adb (code
, ins
->dreg
, 0, s390_r13
, 4);
4407 case OP_LCONV_TO_R4
:
4408 case OP_ICONV_TO_R4
: {
4409 s390_cdgbr (code
, ins
->dreg
, ins
->sreg1
);
4412 case OP_LCONV_TO_R8
:
4413 case OP_ICONV_TO_R8
: {
4414 s390_cdgbr (code
, ins
->dreg
, ins
->sreg1
);
4417 case OP_FCONV_TO_I1
:
4418 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 1, TRUE
);
4420 case OP_FCONV_TO_U1
:
4421 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 1, FALSE
);
4423 case OP_FCONV_TO_I2
:
4424 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 2, TRUE
);
4426 case OP_FCONV_TO_U2
:
4427 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 2, FALSE
);
4429 case OP_FCONV_TO_I4
:
4431 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 4, TRUE
);
4433 case OP_FCONV_TO_U4
:
4435 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 4, FALSE
);
4437 case OP_FCONV_TO_I8
:
4438 s390_cgdbr (code
, ins
->dreg
, 5, ins
->sreg1
);
4440 case OP_LCONV_TO_OVF_I
: {
4441 /* Valid ints: 0xffffffff:8000000 to 00000000:0x7f000000 */
4443 s390_ltgr (code
, ins
->sreg2
, ins
->sreg2
);
4444 s390_jnl (code
, 0); CODEPTR(code
, o
[0]);
4445 s390_ltgr (code
, ins
->sreg1
, ins
->sreg1
);
4446 s390_jnl (code
, 0); CODEPTR(code
, o
[1]);
4447 s390_lhi (code
, s390_r13
, -1);
4448 s390_cgr (code
, ins
->sreg1
, s390_r13
);
4449 s390_jnz (code
, 0); CODEPTR(code
, o
[2]);
4450 if (ins
->dreg
!= ins
->sreg2
)
4451 s390_lgr (code
, ins
->dreg
, ins
->sreg2
);
4452 s390_j (code
, 0); CODEPTR(code
, o
[3]);
4453 PTRSLOT(code
, o
[0]);
4454 s390_jz (code
, 0); CODEPTR(code
, o
[4]);
4455 PTRSLOT(code
, o
[1]);
4456 PTRSLOT(code
, o
[2]);
4457 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
4458 MONO_PATCH_INFO_EXC
, "OverflowException");
4459 s390_brasl (code
, s390_r14
, 0);
4460 PTRSLOT(code
, o
[3]);
4461 PTRSLOT(code
, o
[4]);
4465 s390_lpdbr (code
, ins
->dreg
, ins
->sreg1
);
4469 s390_sqdbr (code
, ins
->dreg
, ins
->sreg1
);
4474 s390_adbr (code
, ins
->dreg
, src2
);
4478 CHECK_SRCDST_NCOM_F
;
4479 s390_sdbr (code
, ins
->dreg
, src2
);
4484 s390_mdbr (code
, ins
->dreg
, src2
);
4488 CHECK_SRCDST_NCOM_F
;
4489 s390_ddbr (code
, ins
->dreg
, src2
);
4493 s390_lcdbr (code
, ins
->dreg
, ins
->sreg1
);
4497 CHECK_SRCDST_NCOM_F
;
4498 s390_didbr (code
, ins
->dreg
, src2
, 5, s390_f15
);
4502 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4506 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4507 s390_lghi (code
, ins
->dreg
, 1);
4509 s390_lghi (code
, ins
->dreg
, 0);
4513 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4514 s390_lghi (code
, ins
->dreg
, 1);
4516 s390_lghi (code
, ins
->dreg
, 0);
4520 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4521 s390_lghi (code
, ins
->dreg
, 1);
4523 s390_lghi (code
, ins
->dreg
, 0);
4527 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4528 s390_lghi (code
, ins
->dreg
, 1);
4530 s390_lghi (code
, ins
->dreg
, 0);
4534 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4535 s390_lghi (code
, ins
->dreg
, 1);
4537 s390_lghi (code
, ins
->dreg
, 0);
4542 s390_jo (code
, 0); CODEPTR(code
, o
);
4543 EMIT_COND_BRANCH (ins
, S390_CC_EQ
);
4548 EMIT_COND_BRANCH (ins
, S390_CC_NE
|S390_CC_OV
);
4552 s390_jo (code
, 0); CODEPTR(code
, o
);
4553 EMIT_COND_BRANCH (ins
, S390_CC_LT
);
4558 EMIT_COND_BRANCH (ins
, S390_CC_LT
|S390_CC_OV
);
4562 s390_jo (code
, 0); CODEPTR(code
, o
);
4563 EMIT_COND_BRANCH (ins
, S390_CC_GT
);
4568 EMIT_COND_BRANCH (ins
, S390_CC_GT
|S390_CC_OV
);
4572 s390_jo (code
, 0); CODEPTR(code
, o
);
4573 EMIT_COND_BRANCH (ins
, S390_CC_GE
);
4578 EMIT_COND_BRANCH (ins
, S390_CC_GE
|S390_CC_OV
);
4582 s390_jo (code
, 0); CODEPTR(code
, o
);
4583 EMIT_COND_BRANCH (ins
, S390_CC_LE
);
4588 EMIT_COND_BRANCH (ins
, S390_CC_LE
|S390_CC_OV
);
4592 s390_lhi (code
, s390_r13
, 0x7f);
4593 s390_tcdb (code
, ins
->sreg1
, 0, s390_r13
, 0);
4594 s390_jz (code
, 0); CODEPTR(code
, o
);
4595 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
4596 MONO_PATCH_INFO_EXC
, "ArithmeticException");
4597 s390_brasl (code
, s390_r14
,0);
4601 case OP_S390_MOVE
: {
4602 if (ins
->backend
.size
> 0) {
4603 if (ins
->backend
.size
<= 256) {
4604 s390_mvc (code
, ins
->backend
.size
, ins
->dreg
,
4605 ins
->inst_offset
, ins
->sreg1
, ins
->inst_imm
);
4607 s390_lgr (code
, s390_r0
, ins
->dreg
);
4608 if (s390_is_imm16 (ins
->inst_offset
)) {
4609 s390_aghi (code
, s390_r0
, ins
->inst_offset
);
4611 s390_basr (code
, s390_r13
, 0);
4613 s390_llong(code
, ins
->inst_offset
);
4614 s390_a (code
, s390_r0
, 0, s390_r13
, 4);
4616 s390_lgr (code
, s390_r12
, ins
->sreg1
);
4617 if (s390_is_imm16 (ins
->inst_imm
)) {
4618 s390_aghi (code
, s390_r12
, ins
->inst_imm
);
4620 s390_basr (code
, s390_r13
, 0);
4622 s390_llong(code
, ins
->inst_imm
);
4623 s390_ag (code
, s390_r12
, 0, s390_r13
, 4);
4625 s390_lgr (code
, s390_r1
, ins
->sreg1
);
4626 s390_lgr (code
, s390_r13
, s390_r1
);
4627 s390_mvcle(code
, s390_r0
, s390_r12
, 0, 0);
4633 case OP_ATOMIC_ADD_I8
: {
4634 s390_lgr (code
, s390_r1
, ins
->sreg2
);
4635 s390_lg (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4636 s390_agr (code
, s390_r1
, s390_r0
);
4637 s390_csg (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4638 s390_jnz (code
, -10);
4639 s390_lgr (code
, ins
->dreg
, s390_r1
);
4642 case OP_ATOMIC_ADD_NEW_I8
: {
4643 s390_lgr (code
, s390_r1
, ins
->sreg2
);
4644 s390_lg (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4645 s390_agr (code
, s390_r1
, s390_r0
);
4646 s390_csg (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4647 s390_jnz (code
, -10);
4648 s390_lgr (code
, ins
->dreg
, s390_r1
);
4651 case OP_ATOMIC_EXCHANGE_I8
: {
4652 s390_lg (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4653 s390_csg (code
, s390_r0
, ins
->sreg2
, ins
->inst_basereg
, ins
->inst_offset
);
4654 s390_jnz (code
, -6);
4655 s390_lgr (code
, ins
->dreg
, s390_r0
);
4658 case OP_ATOMIC_ADD_I4
: {
4659 s390_lgfr(code
, s390_r1
, ins
->sreg2
);
4660 s390_lgf (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4661 s390_agr (code
, s390_r1
, s390_r0
);
4662 s390_cs (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4663 s390_jnz (code
, -9);
4664 s390_lgfr(code
, ins
->dreg
, s390_r1
);
4667 case OP_ATOMIC_ADD_NEW_I4
: {
4668 s390_lgfr(code
, s390_r1
, ins
->sreg2
);
4669 s390_lgf (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4670 s390_agr (code
, s390_r1
, s390_r0
);
4671 s390_cs (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4672 s390_jnz (code
, -9);
4673 s390_lgfr(code
, ins
->dreg
, s390_r1
);
4676 case OP_ATOMIC_EXCHANGE_I4
: {
4677 s390_lg (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4678 s390_cs (code
, s390_r0
, ins
->sreg2
, ins
->inst_basereg
, ins
->inst_offset
);
4679 s390_jnz (code
, -4);
4680 s390_lgfr(code
, ins
->dreg
, s390_r0
);
4683 case OP_S390_BKCHAIN
: {
4684 s390_lgr (code
, ins
->dreg
, ins
->sreg1
);
4685 if (s390_is_imm16 (cfg
->stack_offset
)) {
4686 s390_aghi (code
, ins
->dreg
, cfg
->stack_offset
);
4688 s390_basr (code
, s390_r13
, 0);
4690 s390_llong(code
, cfg
->stack_offset
);
4691 s390_ag (code
, ins
->dreg
, 0, s390_r13
, 4);
4695 case OP_MEMORY_BARRIER
: {
4699 g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins
->opcode
), __FUNCTION__
);
4700 g_assert_not_reached ();
4703 if ((cfg
->opt
& MONO_OPT_BRANCH
) && ((code
- cfg
->native_code
- offset
) > max_len
)) {
4704 g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %ld)",
4705 mono_inst_name (ins
->opcode
), max_len
, code
- cfg
->native_code
- offset
);
4706 g_assert_not_reached ();
4711 last_offset
= offset
;
4714 cfg
->code_len
= code
- cfg
->native_code
;
4717 /*========================= End of Function ========================*/
4719 /*------------------------------------------------------------------*/
4721 /* Name - mono_arch_register_lowlevel_calls */
4723 /* Function - Register routines to help with --trace operation. */
4725 /*------------------------------------------------------------------*/
4728 mono_arch_register_lowlevel_calls (void)
4730 mono_register_jit_icall (mono_arch_get_lmf_addr
, "mono_arch_get_lmf_addr", NULL
, TRUE
);
4733 /*========================= End of Function ========================*/
4735 /*------------------------------------------------------------------*/
4737 /* Name - mono_arch_patch_code */
4739 /* Function - Process the patch data created during the */
4740 /* instruction build process. This resolves jumps, */
4741 /* calls, variables etc. */
4743 /*------------------------------------------------------------------*/
4746 mono_arch_patch_code (MonoMethod
*method
, MonoDomain
*domain
,
4747 guint8
*code
, MonoJumpInfo
*ji
, gboolean run_cctors
)
4749 MonoJumpInfo
*patch_info
;
4751 for (patch_info
= ji
; patch_info
; patch_info
= patch_info
->next
) {
4752 unsigned char *ip
= patch_info
->ip
.i
+ code
;
4753 gconstpointer target
= NULL
;
4755 target
= mono_resolve_patch_target (method
, domain
, code
,
4756 patch_info
, run_cctors
);
4758 switch (patch_info
->type
) {
4759 case MONO_PATCH_INFO_IP
:
4760 case MONO_PATCH_INFO_EXC_NAME
:
4761 case MONO_PATCH_INFO_LDSTR
:
4762 case MONO_PATCH_INFO_TYPE_FROM_HANDLE
:
4763 case MONO_PATCH_INFO_LDTOKEN
:
4764 case MONO_PATCH_INFO_EXC
:
4765 case MONO_PATCH_INFO_ABS
:
4766 case MONO_PATCH_INFO_METHOD
:
4767 case MONO_PATCH_INFO_INTERNAL_METHOD
:
4768 case MONO_PATCH_INFO_CLASS_INIT
:
4769 s390_patch_addr (ip
, (guint64
) target
);
4771 case MONO_PATCH_INFO_SWITCH
:
4772 /*----------------------------------*/
4773 /* ip points at the basr r13,0/j +4 */
4774 /* instruction the vtable value */
4775 /* follows this (i.e. ip+6) */
4776 /*----------------------------------*/
4777 *((gconstpointer
*)(ip
+6)) = target
;
4779 case MONO_PATCH_INFO_METHODCONST
:
4780 case MONO_PATCH_INFO_CLASS
:
4781 case MONO_PATCH_INFO_IMAGE
:
4782 case MONO_PATCH_INFO_FIELD
:
4783 case MONO_PATCH_INFO_IID
:
4784 target
= S390_RELATIVE(target
, ip
);
4785 s390_patch_rel (ip
, (guint64
) target
);
4787 case MONO_PATCH_INFO_R4
:
4788 case MONO_PATCH_INFO_R8
:
4789 case MONO_PATCH_INFO_METHOD_REL
:
4790 g_assert_not_reached ();
4793 target
= S390_RELATIVE(target
, ip
);
4795 s390_patch_rel (ip
, (guint64
) target
);
4800 /*========================= End of Function ========================*/
4802 /*------------------------------------------------------------------*/
4804 /* Name - emit_load_volatile_arguments */
4806 /* Function - Emit the instructions to reload parameter regist- */
4807 /* registers for use with "tail" operations. */
4809 /* The register loading operations performed here */
4810 /* are the mirror of the store operations performed */
4811 /* in mono_arch_emit_prolog and need to be kept in */
4812 /* synchronization with it. */
4814 /*------------------------------------------------------------------*/
4817 emit_load_volatile_arguments (guint8
*code
, MonoCompile
*cfg
)
4820 MonoMethod
*method
= cfg
->method
;
4821 MonoMethodSignature
*sig
= mono_method_signature(method
);
4825 cinfo
= get_call_info (NULL
, NULL
, sig
, sig
->pinvoke
);
4827 if (cinfo
->struct_ret
) {
4828 ArgInfo
*ainfo
= &cinfo
->ret
;
4829 inst
= cfg
->vret_addr
;
4830 s390_lg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4833 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
4834 ArgInfo
*ainfo
= cinfo
->args
+ i
;
4835 inst
= cfg
->args
[pos
];
4837 if (inst
->opcode
== OP_REGVAR
) {
4838 if (ainfo
->regtype
== RegTypeGeneral
)
4839 s390_lgr (code
, ainfo
->reg
, inst
->dreg
);
4840 else if (ainfo
->regtype
== RegTypeFP
) {
4841 if (inst
->dreg
!= ainfo
->reg
) {
4842 if (ainfo
->size
== 4) {
4843 s390_ldebr (code
, ainfo
->reg
, inst
->dreg
);
4845 s390_ldr (code
, ainfo
->reg
, inst
->dreg
);
4849 else if (ainfo
->regtype
== RegTypeBase
) {
4851 g_assert_not_reached ();
4853 if (ainfo
->regtype
== RegTypeGeneral
) {
4854 if (!((ainfo
->reg
>= 2) && (ainfo
->reg
<= 6)))
4855 g_assert_not_reached();
4856 switch (ainfo
->size
) {
4858 s390_llgc (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4861 s390_lgh (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4864 s390_lgf (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4867 s390_lg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4870 } else if (ainfo
->regtype
== RegTypeBase
) {
4871 } else if (ainfo
->regtype
== RegTypeFP
) {
4872 if (ainfo
->size
== 8)
4873 s390_ld (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4874 else if (ainfo
->size
== 4)
4875 s390_le (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4877 g_assert_not_reached ();
4878 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
4879 if (ainfo
->reg
!= STK_BASE
) {
4880 switch (ainfo
->size
) {
4882 s390_llgc (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4885 s390_lgh (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4888 s390_lgf (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4891 s390_lg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4895 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
4896 if (ainfo
->reg
!= STK_BASE
) {
4897 s390_lg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4900 g_assert_not_reached ();
4908 /*========================= End of Function ========================*/
4910 /*------------------------------------------------------------------*/
4912 /* Name - mono_arch_emit_prolog */
4914 /* Function - Create the instruction sequence for a function */
4917 /*------------------------------------------------------------------*/
4920 mono_arch_emit_prolog (MonoCompile
*cfg
)
4922 MonoMethod
*method
= cfg
->method
;
4924 MonoMethodSignature
*sig
;
4926 int alloc_size
, pos
, max_offset
, i
;
4932 cfg
->code_size
= 512;
4934 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (method
)) {
4936 cfg
->code_size
+= 256;
4939 if (method
->save_lmf
)
4940 cfg
->code_size
+= 200;
4942 cfg
->native_code
= code
= g_malloc (cfg
->code_size
);
4944 s390_stmg (code
, s390_r6
, s390_r14
, STK_BASE
, S390_REG_SAVE_OFFSET
);
4946 if (cfg
->arch
.bkchain_reg
!= -1)
4947 s390_lgr (code
, cfg
->arch
.bkchain_reg
, STK_BASE
);
4949 if (cfg
->flags
& MONO_CFG_HAS_ALLOCA
) {
4950 cfg
->used_int_regs
|= 1 << 11;
4953 alloc_size
= cfg
->stack_offset
;
4955 cfg
->stack_usage
= alloc_size
;
4956 s390_lgr (code
, s390_r11
, STK_BASE
);
4957 if (s390_is_imm16 (alloc_size
)) {
4958 s390_aghi (code
, STK_BASE
, -alloc_size
);
4960 int stackSize
= alloc_size
;
4961 while (stackSize
> 32767) {
4962 s390_aghi (code
, STK_BASE
, -32767);
4965 s390_aghi (code
, STK_BASE
, -stackSize
);
4967 s390_stg (code
, s390_r11
, 0, STK_BASE
, 0);
4969 if (cfg
->frame_reg
!= STK_BASE
)
4970 s390_lgr (code
, s390_r11
, STK_BASE
);
4972 /* compute max_offset in order to use short forward jumps
4973 * we always do it on s390 because the immediate displacement
4974 * for jumps is too small
4977 for (bb
= cfg
->bb_entry
; bb
; bb
= bb
->next_bb
) {
4979 bb
->max_offset
= max_offset
;
4981 if (cfg
->prof_options
& MONO_PROFILE_COVERAGE
)
4984 MONO_BB_FOR_EACH_INS (bb
, ins
)
4985 max_offset
+= ((guint8
*)ins_get_spec (ins
->opcode
))[MONO_INST_LEN
];
4988 /* load arguments allocated to register from the stack */
4989 sig
= mono_method_signature (method
);
4992 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
4994 if (cinfo
->struct_ret
) {
4995 ArgInfo
*ainfo
= &cinfo
->ret
;
4996 inst
= cfg
->vret_addr
;
4997 inst
->backend
.size
= ainfo
->vtsize
;
4998 s390_stg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5001 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
5002 ArgInfo
*ainfo
= cinfo
->args
+ i
;
5003 inst
= cfg
->args
[pos
];
5005 if (inst
->opcode
== OP_VTARG_ADDR
)
5006 inst
= inst
->inst_left
;
5008 if (inst
->opcode
== OP_REGVAR
) {
5009 if (ainfo
->regtype
== RegTypeGeneral
)
5010 s390_lgr (code
, inst
->dreg
, ainfo
->reg
);
5011 else if (ainfo
->regtype
== RegTypeFP
) {
5012 if (inst
->dreg
!= ainfo
->reg
) {
5013 if (ainfo
->size
== 4) {
5014 s390_ledbr (code
, inst
->dreg
, ainfo
->reg
);
5016 s390_ldr (code
, inst
->dreg
, ainfo
->reg
);
5020 else if (ainfo
->regtype
== RegTypeBase
) {
5021 s390_lgr (code
, s390_r13
, STK_BASE
);
5022 s390_aghi (code
, s390_r13
, alloc_size
);
5023 s390_lg (code
, inst
->dreg
, 0, s390_r13
, ainfo
->offset
);
5025 g_assert_not_reached ();
5027 if (cfg
->verbose_level
> 2)
5028 g_print ("Argument %d assigned to register %s\n",
5029 pos
, mono_arch_regname (inst
->dreg
));
5031 if (ainfo
->regtype
== RegTypeGeneral
) {
5032 if (!((ainfo
->reg
>= 2) && (ainfo
->reg
<= 6)))
5033 g_assert_not_reached();
5034 switch (ainfo
->size
) {
5036 s390_stc (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5039 s390_sth (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5042 s390_st (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5045 s390_stg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5048 } else if (ainfo
->regtype
== RegTypeBase
) {
5049 } else if (ainfo
->regtype
== RegTypeFP
) {
5050 if (ainfo
->size
== 8)
5051 s390_std (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5052 else if (ainfo
->size
== 4)
5053 s390_ste (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5055 g_assert_not_reached ();
5056 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
5057 int doffset
= inst
->inst_offset
;
5059 if (ainfo
->reg
!= STK_BASE
)
5063 s390_lgr (code
, s390_r13
, STK_BASE
);
5064 s390_aghi (code
, s390_r13
, alloc_size
);
5066 switch (ainfo
->size
) {
5068 if (ainfo
->reg
== STK_BASE
)
5069 s390_ic (code
, reg
, 0, s390_r13
, ainfo
->offset
+7);
5070 s390_stc (code
, reg
, 0, inst
->inst_basereg
, doffset
);
5073 if (ainfo
->reg
== STK_BASE
)
5074 s390_lh (code
, reg
, 0, s390_r13
, ainfo
->offset
+6);
5075 s390_sth (code
, reg
, 0, inst
->inst_basereg
, doffset
);
5078 if (ainfo
->reg
== STK_BASE
)
5079 s390_l (code
, reg
, 0, s390_r13
, ainfo
->offset
+4);
5080 s390_st (code
, reg
, 0, inst
->inst_basereg
, doffset
);
5083 if (ainfo
->reg
== STK_BASE
)
5084 s390_lg (code
, reg
, 0, s390_r13
, ainfo
->offset
);
5085 s390_stg (code
, reg
, 0, inst
->inst_basereg
, doffset
);
5088 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
5089 s390_stg (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
5091 g_assert_not_reached ();
5096 if (method
->save_lmf
) {
5097 /*---------------------------------------------------------------*/
5098 /* we build the MonoLMF structure on the stack - see mini-s390.h */
5099 /*---------------------------------------------------------------*/
5100 lmfOffset
= alloc_size
- sizeof(MonoLMF
);
5102 s390_lgr (code
, s390_r13
, cfg
->frame_reg
);
5103 s390_aghi (code
, s390_r13
, lmfOffset
);
5105 /*---------------------------------------------------------------*/
5106 /* Preserve the parameter registers while we fix up the lmf */
5107 /*---------------------------------------------------------------*/
5108 s390_stmg (code
, s390_r2
, s390_r6
, s390_r13
,
5109 G_STRUCT_OFFSET(MonoLMF
, pregs
[0]));
5111 /*---------------------------------------------------------------*/
5112 /* On return from this call r2 have the address of the &lmf */
5113 /*---------------------------------------------------------------*/
5114 s390_basr(code
, s390_r10
, 0);
5116 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
5117 MONO_PATCH_INFO_INTERNAL_METHOD
,
5118 (gpointer
)"mono_get_lmf_addr");
5119 s390_llong(code
, 0);
5120 s390_lg (code
, s390_r1
, 0, s390_r10
, 4);
5121 s390_basr (code
, s390_r14
, s390_r1
);
5123 /*---------------------------------------------------------------*/
5124 /* Set lmf.lmf_addr = jit_tls->lmf */
5125 /*---------------------------------------------------------------*/
5126 s390_stg (code
, s390_r2
, 0, s390_r13
,
5127 G_STRUCT_OFFSET(MonoLMF
, lmf_addr
));
5129 /*---------------------------------------------------------------*/
5130 /* Get current lmf */
5131 /*---------------------------------------------------------------*/
5132 s390_lg (code
, s390_r0
, 0, s390_r2
, 0);
5134 /*---------------------------------------------------------------*/
5135 /* Set our lmf as the current lmf */
5136 /*---------------------------------------------------------------*/
5137 s390_stg (code
, s390_r13
, 0, s390_r2
, 0);
5139 /*---------------------------------------------------------------*/
5140 /* Have our lmf.previous_lmf point to the last lmf */
5141 /*---------------------------------------------------------------*/
5142 s390_stg (code
, s390_r0
, 0, s390_r13
,
5143 G_STRUCT_OFFSET(MonoLMF
, previous_lmf
));
5145 /*---------------------------------------------------------------*/
5146 /* save method info */
5147 /*---------------------------------------------------------------*/
5148 s390_basr (code
, s390_r1
, 0);
5150 s390_llong (code
, method
);
5151 s390_lg (code
, s390_r1
, 0, s390_r1
, 4);
5152 s390_stg (code
, s390_r1
, 0, s390_r13
,
5153 G_STRUCT_OFFSET(MonoLMF
, method
));
5155 /*---------------------------------------------------------------*/
5156 /* save the current IP */
5157 /*---------------------------------------------------------------*/
5158 s390_stg (code
, STK_BASE
, 0, s390_r13
, G_STRUCT_OFFSET(MonoLMF
, ebp
));
5159 s390_basr (code
, s390_r1
, 0);
5160 s390_stg (code
, s390_r1
, 0, s390_r13
, G_STRUCT_OFFSET(MonoLMF
, eip
));
5162 /*---------------------------------------------------------------*/
5163 /* Save general and floating point registers */
5164 /*---------------------------------------------------------------*/
5165 s390_stmg (code
, s390_r2
, s390_r12
, s390_r13
,
5166 G_STRUCT_OFFSET(MonoLMF
, gregs
[2]));
5167 for (i
= 0; i
< 16; i
++) {
5168 s390_std (code
, i
, 0, s390_r13
,
5169 G_STRUCT_OFFSET(MonoLMF
, fregs
[i
]));
5172 /*---------------------------------------------------------------*/
5173 /* Restore the parameter registers now that we've set up the lmf */
5174 /*---------------------------------------------------------------*/
5175 s390_lmg (code
, s390_r2
, s390_r6
, s390_r13
,
5176 G_STRUCT_OFFSET(MonoLMF
, pregs
[0]));
5180 code
= mono_arch_instrument_prolog(cfg
, enter_method
, code
, TRUE
);
5182 cfg
->code_len
= code
- cfg
->native_code
;
5183 g_assert (cfg
->code_len
< cfg
->code_size
);
5188 /*========================= End of Function ========================*/
5190 /*------------------------------------------------------------------*/
5192 /* Name - mono_arch_emit_epilog */
5194 /* Function - Emit the instructions for a function epilog. */
5196 /*------------------------------------------------------------------*/
5199 mono_arch_emit_epilog (MonoCompile
*cfg
)
5201 MonoMethod
*method
= cfg
->method
;
5204 int max_epilog_size
= 96;
5206 if (cfg
->method
->save_lmf
)
5207 max_epilog_size
+= 128;
5209 if (mono_jit_trace_calls
!= NULL
)
5210 max_epilog_size
+= 128;
5212 if (cfg
->prof_options
& MONO_PROFILE_ENTER_LEAVE
)
5213 max_epilog_size
+= 128;
5215 while ((cfg
->code_len
+ max_epilog_size
) > (cfg
->code_size
- 16)) {
5216 cfg
->code_size
*= 2;
5217 cfg
->native_code
= g_realloc (cfg
->native_code
, cfg
->code_size
);
5218 mono_jit_stats
.code_reallocs
++;
5221 code
= cfg
->native_code
+ cfg
->code_len
;
5223 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (method
)) {
5224 code
= mono_arch_instrument_epilog (cfg
, leave_method
, code
, TRUE
);
5228 if (method
->save_lmf
)
5229 restoreLMF(code
, cfg
->frame_reg
, cfg
->stack_usage
);
5231 if (cfg
->flags
& MONO_CFG_HAS_ALLOCA
)
5232 s390_lg (code
, STK_BASE
, 0, STK_BASE
, 0);
5234 code
= backUpStackPtr(cfg
, code
);
5236 s390_lmg (code
, s390_r6
, s390_r14
, STK_BASE
, S390_REG_SAVE_OFFSET
);
5237 s390_br (code
, s390_r14
);
5239 cfg
->code_len
= code
- cfg
->native_code
;
5241 g_assert (cfg
->code_len
< cfg
->code_size
);
5245 /*========================= End of Function ========================*/
5247 /*------------------------------------------------------------------*/
5249 /* Name - mono_arch_emit_exceptions */
5251 /* Function - Emit the blocks to handle exception conditions. */
5253 /*------------------------------------------------------------------*/
5256 mono_arch_emit_exceptions (MonoCompile
*cfg
)
5258 MonoJumpInfo
*patch_info
;
5264 MonoClass
*exc_classes
[MAX_EXC
];
5265 guint8
*exc_throw_start
[MAX_EXC
];
5267 for (patch_info
= cfg
->patch_info
;
5269 patch_info
= patch_info
->next
) {
5270 if (patch_info
->type
== MONO_PATCH_INFO_EXC
)
5274 code_size
= exc_count
* 48;
5276 while ((cfg
->code_len
+ code_size
) > (cfg
->code_size
- 16)) {
5277 cfg
->code_size
*= 2;
5278 cfg
->native_code
= g_realloc (cfg
->native_code
, cfg
->code_size
);
5279 mono_jit_stats
.code_reallocs
++;
5282 code
= cfg
->native_code
+ cfg
->code_len
;
5284 /*---------------------------------------------------------------------*/
5285 /* Add code to raise exceptions */
5286 /*---------------------------------------------------------------------*/
5287 for (patch_info
= cfg
->patch_info
; patch_info
; patch_info
= patch_info
->next
) {
5288 switch (patch_info
->type
) {
5289 case MONO_PATCH_INFO_EXC
: {
5290 guint8
*ip
= patch_info
->ip
.i
+ cfg
->native_code
;
5291 MonoClass
*exc_class
;
5294 /*-----------------------------------------------------*/
5295 /* Patch the branch in epilog to come here */
5296 /*-----------------------------------------------------*/
5297 s390_patch_rel (ip
+ 2, (guint64
) S390_RELATIVE(code
,ip
));
5299 exc_class
= mono_class_from_name (mono_defaults
.corlib
,
5301 patch_info
->data
.name
);
5302 g_assert (exc_class
);
5303 throw_ip
= patch_info
->ip
.i
;
5305 for (iExc
= 0; iExc
< nThrows
; ++iExc
)
5306 if (exc_classes
[iExc
] == exc_class
)
5309 if (iExc
< nThrows
) {
5310 s390_jcl (code
, S390_CC_UN
,
5311 (guint64
) exc_throw_start
[iExc
]);
5312 patch_info
->type
= MONO_PATCH_INFO_NONE
;
5315 if (nThrows
< MAX_EXC
) {
5316 exc_classes
[nThrows
] = exc_class
;
5317 exc_throw_start
[nThrows
] = code
;
5320 /*---------------------------------------------*/
5321 /* Patch the parameter passed to the handler */
5322 /*---------------------------------------------*/
5323 s390_basr (code
, s390_r13
, 0);
5325 s390_llong(code
, patch_info
->data
.target
);
5326 /*---------------------------------------------*/
5327 /* Load return address & parameter register */
5328 /*---------------------------------------------*/
5329 s390_larl (code
, s390_r14
, (guint64
)S390_RELATIVE((patch_info
->ip
.i
+
5330 cfg
->native_code
+ 8), code
));
5331 s390_lg (code
, s390_r2
, 0, s390_r13
, 4);
5332 /*---------------------------------------------*/
5333 /* Reuse the current patch to set the jump */
5334 /*---------------------------------------------*/
5335 s390_basr (code
, s390_r13
, 0);
5337 patch_info
->type
= MONO_PATCH_INFO_INTERNAL_METHOD
;
5338 patch_info
->data
.name
= "mono_arch_throw_exception_by_name";
5339 patch_info
->ip
.i
= code
- cfg
->native_code
;
5340 s390_llong(code
, 0);
5341 s390_lg (code
, s390_r1
, 0, s390_r13
, 4);
5342 s390_br (code
, s390_r1
);
5352 cfg
->code_len
= code
- cfg
->native_code
;
5354 g_assert (cfg
->code_len
< cfg
->code_size
);
5358 /*========================= End of Function ========================*/
5360 /*------------------------------------------------------------------*/
5362 /* Name - mono_arch_setup_jit_tls_data */
5364 /* Function - Setup the JIT's Thread Level Specific Data. */
5366 /*------------------------------------------------------------------*/
5369 mono_arch_setup_jit_tls_data (MonoJitTlsData
*tls
)
5371 if (!tls_offset_inited
) {
5372 tls_offset_inited
= TRUE
;
5376 __asm__ ("\tear\t%r1,0\n"
5383 : "=r" (appdomain_tls_offset
),
5384 "=r" (thread_tls_offset
),
5385 "=r" (lmf_tls_offset
)
5386 : "r" (&tls_appdomain
),
5387 "r" (&tls_current_object
),
5388 "r" (&mono_lmf_addr
)
5394 if (!lmf_addr_key_inited
) {
5395 lmf_addr_key_inited
= TRUE
;
5396 pthread_key_create (&lmf_addr_key
, NULL
);
5398 pthread_setspecific (lmf_addr_key
, &tls
->lmf
);
5402 /*========================= End of Function ========================*/
5404 /*------------------------------------------------------------------*/
5406 /* Name - mono_arch_free_jit_tls_data */
5408 /* Function - Free tls data. */
5410 /*------------------------------------------------------------------*/
5413 mono_arch_free_jit_tls_data (MonoJitTlsData
*tls
)
5418 /*========================= End of Function ========================*/
5420 /*------------------------------------------------------------------*/
5422 /* Name - mono_arch_emit_this_vret_args */
5426 /*------------------------------------------------------------------*/
5429 mono_arch_emit_this_vret_args (MonoCompile
*cfg
, MonoCallInst
*inst
, int this_reg
, int this_type
, int vt_reg
)
5431 int this_dreg
= s390_r2
;
5434 this_dreg
= s390_r3
;
5436 /* add the this argument */
5437 if (this_reg
!= -1) {
5439 MONO_INST_NEW (cfg
, this, OP_MOVE
);
5440 this->type
= this_type
;
5441 this->sreg1
= this_reg
;
5442 this->dreg
= mono_regstate_next_int (cfg
->rs
);
5443 mono_bblock_add_inst (cfg
->cbb
, this);
5444 mono_call_inst_add_outarg_reg (cfg
, inst
, this->dreg
, this_dreg
, FALSE
);
5449 MONO_INST_NEW (cfg
, vtarg
, OP_MOVE
);
5450 vtarg
->type
= STACK_MP
;
5451 vtarg
->sreg1
= vt_reg
;
5452 vtarg
->dreg
= mono_regstate_next_int (cfg
->rs
);
5453 mono_bblock_add_inst (cfg
->cbb
, vtarg
);
5454 mono_call_inst_add_outarg_reg (cfg
, inst
, vtarg
->dreg
, s390_r2
, FALSE
);
5458 /*========================= End of Function ========================*/
5460 /*------------------------------------------------------------------*/
5462 /* Name - mono_arch_get_inst_for_method */
5464 /* Function - Check for opcodes we can handle directly in */
5467 /*------------------------------------------------------------------*/
5470 mono_arch_get_inst_for_method (MonoCompile
*cfg
, MonoMethod
*cmethod
,
5471 MonoMethodSignature
*fsig
, MonoInst
**args
)
5473 MonoInst
*ins
= NULL
;
5475 if (cmethod
->klass
== mono_defaults
.math_class
) {
5476 if (strcmp (cmethod
->name
, "Sqrt") == 0) {
5477 MONO_INST_NEW (cfg
, ins
, OP_SQRT
);
5478 ins
->inst_i0
= args
[0];
5480 // if (strcmp (cmethod->name, "Abs") == 0) {
5481 // MONO_INST_NEW (cfg, ins, OP_ABS);
5482 // ins->inst_i0 = args [0];
5489 /*========================= End of Function ========================*/
5491 /*------------------------------------------------------------------*/
5493 /* Name - mono_arch_emit_inst_for_method */
5495 /*------------------------------------------------------------------*/
5498 mono_arch_emit_inst_for_method (MonoCompile
*cfg
, MonoMethod
*cmethod
, MonoMethodSignature
*fsig
, MonoInst
**args
)
5503 /*========================= End of Function ========================*/
5506 mono_arch_decompose_opts (MonoCompile
*cfg
, MonoInst
*ins
)
5509 * Have to rename these to avoid being decomposed normally, since the normal
5510 * decomposition does not work on S390.
5512 switch (ins
->opcode
) {
5514 ins
->opcode
= OP_S390_ISUB_OVF
;
5516 case OP_ISUB_OVF_UN
:
5517 ins
->opcode
= OP_S390_ISUB_OVF_UN
;
5520 ins
->opcode
= OP_S390_IADD_OVF
;
5522 case OP_IADD_OVF_UN
:
5523 ins
->opcode
= OP_S390_IADD_OVF_UN
;
5526 ins
->opcode
= OP_S390_LADD_OVF
;
5528 case OP_LADD_OVF_UN
:
5529 ins
->opcode
= OP_S390_LADD_OVF_UN
;
5532 ins
->opcode
= OP_S390_LSUB_OVF
;
5534 case OP_LSUB_OVF_UN
:
5535 ins
->opcode
= OP_S390_LSUB_OVF_UN
;
5542 /*========================= End of Function ========================*/
5544 /*------------------------------------------------------------------*/
5546 /* Name - mono_arch_print_tree */
5548 /* Function - Print platform-specific opcode details. */
5550 /* Returns - 1 - opcode details have been printed */
5551 /* 0 - opcode details have not been printed */
5553 /*------------------------------------------------------------------*/
5556 mono_arch_print_tree (MonoInst
*tree
, int arity
)
5560 switch (tree
->opcode
) {
5561 case OP_S390_LOADARG
:
5562 case OP_S390_ARGREG
:
5563 case OP_S390_ARGPTR
:
5564 printf ("[0x%lx(%s)]", tree
->inst_offset
,
5565 mono_arch_regname (tree
->inst_basereg
));
5568 case OP_S390_STKARG
:
5569 printf ("[0x%lx(previous_frame)]",
5574 printf ("[0x%lx(%d,%s),0x%lx(%s)]",
5575 tree
->inst_offset
, tree
->backend
.size
,
5576 mono_arch_regname(tree
->dreg
),
5578 mono_arch_regname(tree
->sreg1
));
5581 case OP_S390_SETF4RET
:
5582 printf ("[f%s,f%s]",
5583 mono_arch_regname (tree
->dreg
),
5584 mono_arch_regname (tree
->sreg1
));
5588 printf ("[0x%lx(0x%lx,%s)]", tree
->inst_offset
,
5590 mono_arch_regname (tree
->sreg1
));
5593 case OP_S390_BKCHAIN
:
5594 printf ("[previous_frame(%s)]",
5595 mono_arch_regname (tree
->sreg1
));
5603 /*========================= End of Function ========================*/
5605 /*------------------------------------------------------------------*/
5607 /* Name - mono_arch_regalloc_cost */
5609 /* Function - Determine the cost, in the number of memory */
5610 /* references, of the action of allocating the var- */
5611 /* iable VMV into a register during global register */
5614 /* Returns - Cost */
5616 /*------------------------------------------------------------------*/
5619 mono_arch_regalloc_cost (MonoCompile
*cfg
, MonoMethodVar
*vmv
)
5625 /*========================= End of Function ========================*/
5627 /*------------------------------------------------------------------*/
5629 /* Name - mono_arch_get_domain_intrinsic */
5635 /*------------------------------------------------------------------*/
5638 mono_arch_get_domain_intrinsic (MonoCompile
* cfg
)
5642 if (appdomain_tls_offset
== -1)
5645 MONO_INST_NEW (cfg
, ins
, OP_TLS_GET
);
5646 ins
->inst_offset
= appdomain_tls_offset
;
5650 /*========================= End of Function ========================*/
5652 /*------------------------------------------------------------------*/
5654 /* Name - mono_arch_get_thread_intrinsic */
5660 /*------------------------------------------------------------------*/
5663 mono_arch_get_thread_intrinsic (MonoCompile
* cfg
)
5667 if (thread_tls_offset
== -1)
5670 MONO_INST_NEW (cfg
, ins
, OP_TLS_GET
);
5671 ins
->inst_offset
= thread_tls_offset
;
5675 /*========================= End of Function ========================*/
5677 /*------------------------------------------------------------------*/
5679 /* Name - mono_arch_flush_register_windows */
5685 /*------------------------------------------------------------------*/
5688 mono_arch_flush_register_windows (void)
5692 /*========================= End of Function ========================*/
5694 /*------------------------------------------------------------------*/
5696 /* Name - mono_arch_get_lmf_addr */
5702 /*------------------------------------------------------------------*/
5705 mono_arch_get_lmf_addr (void)
5707 return pthread_getspecific (lmf_addr_key
);
5710 /*========================= End of Function ========================*/
5712 /*------------------------------------------------------------------*/
5714 /* Name - mono_arch_is_inst_imm */
5716 /* Function - Determine if operand qualifies as an immediate */
5717 /* value. For s390 this is a value -32768-32768 */
5719 /* Returns - True|False - is [not] immediate value. */
5721 /*------------------------------------------------------------------*/
5724 mono_arch_is_inst_imm (gint64 imm
)
5726 return s390_is_imm16 (imm
);
5729 /*========================= End of Function ========================*/
5731 /*------------------------------------------------------------------*/
5733 /* Name - mono_arch_get_patch_offset */
5735 /* Function - Dummy entry point until s390x supports aot. */
5737 /* Returns - Offset for patch. */
5739 /*------------------------------------------------------------------*/
5742 mono_arch_get_patch_offset (guint8
*code
)
5747 /*========================= End of Function ========================*/
5750 mono_arch_context_get_int_reg (MonoContext
*ctx
, int reg
)
5752 /* FIXME: implement */
5753 g_assert_not_reached ();