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_lr (code, ins->dreg, ins->sreg1); \
106 #define CHECK_SRCDST_NCOM \
107 if (ins->dreg == ins->sreg2) { \
109 s390_lr (code, s390_r13, ins->sreg2); \
113 if (ins->dreg != ins->sreg1) { \
114 s390_lr (code, ins->dreg, ins->sreg1); \
117 #define CHECK_SRCDST_COM_F \
118 if (ins->dreg == ins->sreg2) { \
122 if (ins->dreg != ins->sreg1) { \
123 s390_ldr (code, ins->dreg, ins->sreg1); \
127 #define CHECK_SRCDST_NCOM_F \
128 if (ins->dreg == ins->sreg2) { \
130 s390_ldr (code, s390_r13, ins->sreg2); \
134 if (ins->dreg != ins->sreg1) { \
135 s390_ldr (code, ins->dreg, ins->sreg1); \
138 #define MONO_EMIT_NEW_MOVE2(cfg,dest,offset,src,imm,size) do { \
142 MONO_INST_NEW (cfg, inst, OP_NOP); \
144 tmpr = mono_alloc_preg (cfg); \
145 MONO_EMIT_NEW_ICONST(cfg,tmpr,size); \
147 inst->inst_offset = offset; \
149 inst->inst_imm = imm; \
150 inst->sreg2 = tmpr; \
152 if (s390_is_uimm12(offset)) { \
154 inst->inst_offset = offset; \
156 dReg = mono_alloc_preg (cfg); \
157 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM, \
158 dReg, dest, offset); \
160 inst->inst_offset = 0; \
162 if (s390_is_uimm12(imm)) { \
164 inst->inst_imm = imm; \
166 sReg = mono_alloc_preg (cfg); \
167 MONO_EMIT_NEW_BIALU_IMM(cfg, OP_ADD_IMM, \
169 inst->sreg1 = sReg; \
170 inst->inst_imm = 0; \
173 inst->opcode = OP_S390_MOVE; \
174 inst->backend.size = size; \
175 MONO_ADD_INS (cfg->cbb, inst); \
178 #define MONO_OUTPUT_VTR2(cfg, size, dr, sr, so) do { \
179 int reg = mono_alloc_preg (cfg); \
182 MONO_EMIT_NEW_ICONST(cfg, reg, 0); \
183 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
186 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE, \
188 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
191 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE, \
193 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
196 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOAD_MEMBASE, \
198 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
201 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOAD_MEMBASE, \
203 mono_call_inst_add_outarg_reg(cfg, call, reg, dr, FALSE); \
204 reg = mono_alloc_preg (cfg); \
205 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOAD_MEMBASE, \
206 reg, sr, so + sizeof (guint32)); \
207 mono_call_inst_add_outarg_reg(cfg, call, reg, dr + 1, FALSE); \
212 #define MONO_OUTPUT_VTS2(cfg, size, dr, dx, sr, so) do { \
216 tmpr = mono_alloc_preg (cfg); \
217 MONO_EMIT_NEW_ICONST(cfg, tmpr, 0); \
218 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
222 tmpr = mono_alloc_preg (cfg); \
223 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU1_MEMBASE, \
225 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
229 tmpr = mono_alloc_preg (cfg); \
230 MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg, OP_LOADU2_MEMBASE, \
232 MONO_EMIT_NEW_STORE_MEMBASE(cfg, OP_STORE_MEMBASE_REG, \
237 MONO_EMIT_NEW_MOVE2 (cfg, dr, dx, sr, so, size); \
243 #define DEBUG(a) if (cfg->verbose_level > 1) a
247 #define S390_TRACE_STACK_SIZE (5*sizeof(gint32)+3*sizeof(gdouble))
249 #define MAX (a, b) ((a) > (b) ? (a) : (b))
251 /*========================= End of Defines =========================*/
253 /*------------------------------------------------------------------*/
254 /* I n c l u d e s */
255 /*------------------------------------------------------------------*/
260 #include <mono/metadata/appdomain.h>
261 #include <mono/metadata/debug-helpers.h>
262 #include <mono/metadata/profiler-private.h>
263 #include <mono/utils/mono-math.h>
265 #include "mini-s390.h"
267 #include "cpu-s390.h"
268 #include "jit-icalls.h"
270 /*========================= End of Includes ========================*/
272 /*------------------------------------------------------------------*/
273 /* T y p e d e f s */
274 /*------------------------------------------------------------------*/
286 /*------------------------------------------------------------------*/
287 /* Used by the instrument_emit_epilog */
288 /*------------------------------------------------------------------*/
299 typedef struct InstList InstList
;
313 RegTypeStructByValInFP
,
318 gint32 offset
; /* offset from caller's stack */
319 gint32 offparm
; /* offset from callee's stack */
320 guint16 vtsize
; /* in param area */
322 ArgStorage regtype
; /* See RegType* */
323 guint32 size
; /* Size of structure used by RegTypeStructByVal */
338 gint32 gr
[5]; /* R2-R6 */
339 gdouble fp
[3]; /* F0-F2 */
340 } __attribute__ ((packed
)) RegParm
;
342 /*========================= End of Typedefs ========================*/
344 /*------------------------------------------------------------------*/
345 /* P r o t o t y p e s */
346 /*------------------------------------------------------------------*/
348 static void indent (int);
349 static guint8
* backUpStackPtr(MonoCompile
*, guint8
*, gint
);
350 static void decodeParm (MonoType
*, void *, int);
351 static void enter_method (MonoMethod
*, RegParm
*, char *);
352 static void leave_method (MonoMethod
*, ...);
353 static gboolean
is_regsize_var (MonoType
*);
354 static inline void add_general (guint
*, size_data
*, ArgInfo
*, gboolean
);
355 static inline void add_stackParm (guint
*, size_data
*, ArgInfo
*, gint
);
356 static inline void add_float (guint
*, size_data
*, ArgInfo
*);
357 static CallInfo
* get_call_info (MonoCompile
*, MonoMemPool
*, MonoMethodSignature
*, gboolean
);
358 static guchar
* emit_float_to_int (MonoCompile
*, guchar
*, int, int, int, gboolean
);
359 gpointer
mono_arch_get_lmf_addr (void);
360 static guint8
* emit_load_volatile_registers(guint8
*, MonoCompile
*);
361 static void emit_sig_cookie (MonoCompile
*, MonoCallInst
*, CallInfo
*, int);
363 /*========================= End of Prototypes ======================*/
365 /*------------------------------------------------------------------*/
366 /* G l o b a l V a r i a b l e s */
367 /*------------------------------------------------------------------*/
369 int mono_exc_esp_offset
= 0;
371 static int indent_level
= 0;
373 static gboolean tls_offset_inited
= FALSE
;
375 static int appdomain_tls_offset
= -1,
376 thread_tls_offset
= -1;
378 pthread_key_t lmf_addr_key
;
380 gboolean lmf_addr_key_inited
= FALSE
;
384 extern __thread MonoDomain
*tls_appdomain
;
385 extern __thread MonoThread
*tls_current_object
;
386 extern __thread gpointer mono_lmf_addr
;
390 /*====================== End of Global Variables ===================*/
392 /*------------------------------------------------------------------*/
394 /* Name - mono_arch_regname */
396 /* Function - Returns the name of the register specified by */
397 /* the input parameter. */
399 /*------------------------------------------------------------------*/
402 mono_arch_regname (int reg
) {
403 static const char * rnames
[] = {
404 "s390_r0", "s390_sp", "s390_r2", "s390_r3", "s390_r4",
405 "s390_r5", "s390_r6", "s390_r7", "s390_r8", "s390_r9",
406 "s390_r10", "s390_r11", "s390_r12", "s390_r13", "s390_r14",
410 if (reg
>= 0 && reg
< 16)
416 /*========================= End of Function ========================*/
418 /*------------------------------------------------------------------*/
420 /* Name - mono_arch_fregname */
422 /* Function - Returns the name of the register specified by */
423 /* the input parameter. */
425 /*------------------------------------------------------------------*/
428 mono_arch_fregname (int reg
) {
429 static const char * rnames
[] = {
430 "s390_f0", "s390_f1", "s390_f2", "s390_f3", "s390_f4",
431 "s390_f5", "s390_f6", "s390_f7", "s390_f8", "s390_f9",
432 "s390_f10", "s390_f11", "s390_f12", "s390_f13", "s390_f14",
436 if (reg
>= 0 && reg
< 16)
442 /*========================= End of Function ========================*/
444 /*------------------------------------------------------------------*/
446 /* Name - arch_get_argument_info */
448 /* Function - Gathers information on parameters such as size, */
449 /* alignment, and padding. arg_info should be large */
450 /* enough to hold param_count + 1 entries. */
452 /* Parameters - @csig - Method signature */
453 /* @param_count - No. of parameters to consider */
454 /* @arg_info - An array to store the result info */
456 /* Returns - Size of the activation frame */
458 /*------------------------------------------------------------------*/
461 mono_arch_get_argument_info (MonoMethodSignature
*csig
,
463 MonoJitArgumentInfo
*arg_info
)
465 int k
, frame_size
= 0;
466 int size
, align
, pad
;
469 if (MONO_TYPE_ISSTRUCT (csig
->ret
)) {
470 frame_size
+= sizeof (gpointer
);
474 arg_info
[0].offset
= offset
;
477 frame_size
+= sizeof (gpointer
);
481 arg_info
[0].size
= frame_size
;
483 for (k
= 0; k
< param_count
; k
++) {
486 size
= mono_type_native_stack_size (csig
->params
[k
], &align
);
488 size
= mini_type_stack_size (NULL
, csig
->params
[k
], &align
);
490 frame_size
+= pad
= (align
- (frame_size
& (align
- 1))) & (align
- 1);
491 arg_info
[k
].pad
= pad
;
493 arg_info
[k
+ 1].pad
= 0;
494 arg_info
[k
+ 1].size
= size
;
496 arg_info
[k
+ 1].offset
= offset
;
500 align
= MONO_ARCH_FRAME_ALIGNMENT
;
501 frame_size
+= pad
= (align
- (frame_size
& (align
- 1))) & (align
- 1);
502 arg_info
[k
].pad
= pad
;
507 /*========================= End of Function ========================*/
509 /*------------------------------------------------------------------*/
511 /* Name - retFitsInReg. */
513 /* Function - Determines if a value can be returned in one or */
516 /*------------------------------------------------------------------*/
518 static inline gboolean
519 retFitsInReg(guint32 size
)
534 /*========================= End of Function ========================*/
536 /*------------------------------------------------------------------*/
538 /* Name - backStackPtr. */
540 /* Function - Restore Stack Pointer to previous frame. */
542 /*------------------------------------------------------------------*/
544 static inline guint8
*
545 backUpStackPtr(MonoCompile
*cfg
, guint8
*code
, gint framePtr
)
547 int stackSize
= cfg
->stack_usage
;
549 if (s390_is_uimm16 (cfg
->stack_usage
)) {
550 s390_ahi (code
, framePtr
, cfg
->stack_usage
);
552 while (stackSize
> 32767) {
553 s390_ahi (code
, framePtr
, 32767);
556 s390_ahi (code
, framePtr
, stackSize
);
561 /*========================= End of Function ========================*/
563 /*------------------------------------------------------------------*/
567 /* Function - Perform nice indenting to current level */
569 /*------------------------------------------------------------------*/
575 indent_level
+= diff
;
582 indent_level
+= diff
;
585 /*========================= End of Function ========================*/
587 /*------------------------------------------------------------------*/
589 /* Name - decodeParm */
591 /* Function - Decode a parameter for the trace. */
593 /*------------------------------------------------------------------*/
596 decodeParm(MonoType
*type
, void *curParm
, int size
)
601 printf("[BYREF:%p], ", *((char **) curParm
));
603 simpleType
= mono_type_get_underlying_type(type
)->type
;
605 switch (simpleType
) {
607 printf ("[INTPTR:%p], ", *((int **) curParm
));
610 printf ("[UINTPTR:%p], ", *((int **) curParm
));
612 case MONO_TYPE_BOOLEAN
:
613 printf ("[BOOL:%d], ", *((int *) curParm
));
615 case MONO_TYPE_CHAR
:
616 printf ("[CHAR:%c], ", *((int *) curParm
));
619 printf ("[INT1:%d], ", *((int *) curParm
));
622 printf ("[INT2:%d], ", *((int *) curParm
));
625 printf ("[INT4:%d], ", *((int *) curParm
));
628 printf ("[UINT1:%u], ", *((unsigned int *) curParm
));
631 printf ("[UINT2:%u], ", *((guint16
*) curParm
));
634 printf ("[UINT4:%u], ", *((guint32
*) curParm
));
637 printf ("[UINT8:%llu], ", *((guint64
*) curParm
));
639 case MONO_TYPE_STRING
: {
640 MonoString
*s
= *((MonoString
**) curParm
);
642 g_assert (((MonoObject
*) s
)->vtable
->klass
== mono_defaults
.string_class
);
643 printf("[STRING:%p:%s], ", s
, mono_string_to_utf8(s
));
645 printf("[STRING:null], ");
649 case MONO_TYPE_CLASS
:
650 case MONO_TYPE_OBJECT
: {
651 MonoObject
*obj
= *((MonoObject
**) curParm
);
653 if ((obj
) && (obj
->vtable
)) {
654 printf("[CLASS/OBJ:");
655 class = obj
->vtable
->klass
;
656 printf("%p [%p] ",obj
,curParm
);
657 // if (class == mono_defaults.string_class) {
658 // printf("[STRING:%p:%s]",
659 // *obj, mono_string_to_utf8 (obj));
660 // } else if (class == mono_defaults.int32_class) {
661 // printf("[INT32:%p:%d]",
662 // obj, *(gint32 *)((char *)obj + sizeof (MonoObject)));
664 // printf("[%s.%s:%p]",
665 // class->name_space, class->name, obj);
668 printf("[OBJECT:null], ");
673 printf("[PTR:%p], ", *((gpointer
**) (curParm
)));
675 case MONO_TYPE_FNPTR
:
676 printf("[FNPTR:%p], ", *((gpointer
**) (curParm
)));
678 case MONO_TYPE_ARRAY
:
679 printf("[ARRAY:%p], ", *((gpointer
**) (curParm
)));
681 case MONO_TYPE_SZARRAY
:
682 printf("[SZARRAY:%p], ", *((gpointer
**) (curParm
)));
685 printf("[INT8:%lld], ", *((gint64
*) (curParm
)));
688 printf("[FLOAT4:%g], ", *((double *) (curParm
)));
691 printf("[FLOAT8:%g], ", *((double *) (curParm
)));
693 case MONO_TYPE_VALUETYPE
: {
695 MonoMarshalType
*info
;
697 if (type
->data
.klass
->enumtype
) {
698 simpleType
= type
->data
.klass
->enum_basetype
->type
;
699 printf("{VALUETYPE} - ");
703 info
= mono_marshal_load_type_info (type
->data
.klass
);
705 if ((info
->native_size
== sizeof(float)) &&
706 (info
->num_fields
== 1) &&
707 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
708 printf("[FLOAT4:%f], ", *((float *) (curParm
)));
712 if ((info
->native_size
== sizeof(double)) &&
713 (info
->num_fields
== 1) &&
714 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
715 printf("[FLOAT8:%g], ", *((double *) (curParm
)));
719 printf("[VALUETYPE:");
720 for (i
= 0; i
< size
; i
++)
721 printf("%02x,", *((guint8
*)curParm
+i
));
725 case MONO_TYPE_TYPEDBYREF
: {
727 printf("[TYPEDBYREF:");
728 for (i
= 0; i
< size
; i
++)
729 printf("%02x,", *((guint8
*)curParm
+i
));
734 printf("[?? - %d], ",simpleType
);
739 /*========================= End of Function ========================*/
743 /*------------------------------------------------------------------*/
745 /* Name - enter_method */
747 /* Function - Perform tracing of the entry to the current */
750 /*------------------------------------------------------------------*/
753 enter_method (MonoMethod
*method
, RegParm
*rParm
, char *sp
)
755 int i
, oParm
= 0, iParm
= 0;
757 MonoMethodSignature
*sig
;
764 fname
= mono_method_full_name (method
, TRUE
);
766 printf ("ENTER: %s(", fname
);
769 ip
= (*(guint32
*) (sp
+S390_RET_ADDR_OFFSET
)) & 0x7fffffff;
770 printf (") ip: %p sp: %p - ", (gpointer
) ip
, sp
);
775 sig
= mono_method_signature (method
);
777 cinfo
= get_call_info (NULL
, NULL
, sig
, sig
->pinvoke
);
779 if (cinfo
->struct_ret
) {
780 printf ("[STRUCTRET:%p], ", (gpointer
) rParm
->gr
[0]);
785 gpointer
*this = (gpointer
*) rParm
->gr
[iParm
];
786 obj
= (MonoObject
*) this;
787 if (method
->klass
->valuetype
) {
789 printf("this:[value:%p:%08x], ",
790 this, *((guint32
*)(this+sizeof(MonoObject
))));
792 printf ("this:[NULL], ");
795 // class = obj->vtable->klass;
796 // if (class == mono_defaults.string_class) {
797 // printf ("this:[STRING:%p:%s], ",
798 // obj, mono_string_to_utf8 ((MonoString *)obj));
800 // printf ("this:%p[%s.%s], ",
801 // obj, class->name_space, class->name);
803 printf("this:%p, ",obj
);
805 printf ("this:NULL, ");
810 for (i
= 0; i
< sig
->param_count
; ++i
) {
811 ainfo
= &cinfo
->args
[i
+ oParm
];
812 switch (ainfo
->regtype
) {
813 case RegTypeGeneral
:
814 decodeParm(sig
->params
[i
], &(rParm
->gr
[ainfo
->reg
-2]), ainfo
->size
);
817 decodeParm(sig
->params
[i
], &(rParm
->fp
[ainfo
->reg
]), ainfo
->size
);
820 decodeParm(sig
->params
[i
], sp
+ainfo
->offset
, ainfo
->size
);
822 case RegTypeStructByVal
:
823 if (ainfo
->reg
!= STK_BASE
)
824 curParm
= &(rParm
->gr
[ainfo
->reg
-2]);
826 curParm
= sp
+ainfo
->offset
;
828 if (retFitsInReg (ainfo
->vtsize
))
829 decodeParm(sig
->params
[i
],
833 decodeParm(sig
->params
[i
],
834 *((char **) curParm
),
837 case RegTypeStructByAddr
:
838 if (ainfo
->reg
!= STK_BASE
)
839 curParm
= &(rParm
->gr
[ainfo
->reg
-2]);
841 curParm
= sp
+ainfo
->offset
;
843 decodeParm(sig
->params
[i
],
844 *((char **) curParm
),
856 /*========================= End of Function ========================*/
858 /*------------------------------------------------------------------*/
860 /* Name - leave_method */
864 /*------------------------------------------------------------------*/
867 leave_method (MonoMethod
*method
, ...)
874 va_start(ap
, method
);
876 fname
= mono_method_full_name (method
, TRUE
);
878 printf ("LEAVE: %s", fname
);
881 type
= mono_method_signature (method
)->ret
;
884 switch (type
->type
) {
887 case MONO_TYPE_BOOLEAN
: {
888 int val
= va_arg (ap
, int);
890 printf ("[TRUE:%d]", val
);
896 case MONO_TYPE_CHAR
: {
897 int val
= va_arg (ap
, int);
898 printf ("[CHAR:%d]", val
);
902 int val
= va_arg (ap
, int);
903 printf ("[INT1:%d]", val
);
907 int val
= va_arg (ap
, int);
908 printf ("[UINT1:%d]", val
);
912 int val
= va_arg (ap
, int);
913 printf ("[INT2:%d]", val
);
917 int val
= va_arg (ap
, int);
918 printf ("[UINT2:%d]", val
);
922 int val
= va_arg (ap
, int);
923 printf ("[INT4:%d]", val
);
927 int val
= va_arg (ap
, int);
928 printf ("[UINT4:%d]", val
);
932 int val
= va_arg (ap
, int);
933 printf ("[INT:%d]", val
);
938 int val
= va_arg (ap
, int);
939 printf ("[UINT:%d]", val
);
943 case MONO_TYPE_STRING
: {
944 MonoString
*s
= va_arg (ap
, MonoString
*);
947 g_assert (((MonoObject
*)s
)->vtable
->klass
== mono_defaults
.string_class
);
948 printf ("[STRING:%p:%s]", s
, mono_string_to_utf8 (s
));
950 printf ("[STRING:null], ");
953 case MONO_TYPE_CLASS
:
954 case MONO_TYPE_OBJECT
: {
955 MonoObject
*o
= va_arg (ap
, MonoObject
*);
957 // if ((o) && (o->vtable)) {
958 // if (o->vtable->klass == mono_defaults.boolean_class) {
959 // printf ("[BOOLEAN:%p:%d]", o, *((guint8 *)o + sizeof (MonoObject)));
960 // } else if (o->vtable->klass == mono_defaults.int32_class) {
961 // printf ("[INT32:%p:%d]", o, *((gint32 *)((char *)o + sizeof (MonoObject))));
962 // } else if (o->vtable->klass == mono_defaults.int64_class) {
963 // printf ("[INT64:%p:%lld]", o, *((gint64 *)((char *)o + sizeof (MonoObject))));
965 // printf ("[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o);
967 printf ("[OBJECT:%p]", o
);
972 case MONO_TYPE_FNPTR
:
973 case MONO_TYPE_ARRAY
:
974 case MONO_TYPE_SZARRAY
: {
975 gpointer p
= va_arg (ap
, gpointer
);
976 printf ("[result=%p]", p
);
980 gint64 l
= va_arg (ap
, gint64
);
981 printf ("[LONG:%lld]", l
);
985 guint64 l
= va_arg (ap
, guint64
);
986 printf ("[ULONG:%llu]", l
);
991 f
= va_arg (ap
, double);
992 printf ("[FLOAT4:%g]\n", f
);
996 double f
= va_arg (ap
, double);
997 printf ("[FLOAT8:%g]\n", f
);
1000 case MONO_TYPE_VALUETYPE
: {
1001 MonoMarshalType
*info
;
1002 if (type
->data
.klass
->enumtype
) {
1003 type
= type
->data
.klass
->enum_basetype
;
1006 guint8
*p
= va_arg (ap
, gpointer
);
1009 info
= mono_marshal_load_type_info (type
->data
.klass
);
1011 if ((info
->native_size
== sizeof(float)) &&
1012 (info
->num_fields
== 1) &&
1013 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
1014 double f
= va_arg (ap
, double);
1015 printf("[FLOAT4:%g]\n", (double) f
);
1019 if ((info
->native_size
== sizeof(double)) &&
1020 (info
->num_fields
== 1) &&
1021 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
1022 double f
= va_arg (ap
, double);
1023 printf("[FLOAT8:%g]\n", f
);
1027 size
= mono_type_size (type
, &align
);
1034 for (j
= 0; p
&& j
< size
; j
++)
1035 printf ("%02x,", p
[j
]);
1039 printf ("[VALUERET]\n");
1044 case MONO_TYPE_TYPEDBYREF
: {
1045 guint8
*p
= va_arg (ap
, gpointer
);
1047 size
= mono_type_size (type
, &align
);
1054 for (j
= 0; p
&& j
< size
; j
++)
1055 printf ("%02x,", p
[j
]);
1059 printf ("[TYPEDBYREF]\n");
1064 printf ("(unknown return type %x)",
1065 mono_method_signature (method
)->ret
->type
);
1068 ip
= ((gint32
) __builtin_return_address (0)) & 0x7fffffff;
1069 printf (" ip: %p\n", (gpointer
) ip
);
1072 /*========================= End of Function ========================*/
1074 /*------------------------------------------------------------------*/
1076 /* Name - mono_arch_cpu_init */
1078 /* Function - Perform CPU specific initialization to execute */
1081 /*------------------------------------------------------------------*/
1084 mono_arch_cpu_init (void)
1088 /*--------------------------------------*/
1089 /* Set default rounding mode for FP */
1090 /*--------------------------------------*/
1091 __asm__ ("SRNM\t%0\n\t"
1095 /*========================= End of Function ========================*/
1099 * Initialize architecture specific code.
1102 mono_arch_init (void)
1107 * Cleanup architecture specific code.
1110 mono_arch_cleanup (void)
1114 /*------------------------------------------------------------------*/
1116 /* Name - mono_arch_cpu_optimizazions */
1118 /* Function - Returns the optimizations supported on this CPU */
1120 /*------------------------------------------------------------------*/
1123 mono_arch_cpu_optimizazions (guint32
*exclude_mask
)
1127 /*----------------------------------------------------------*/
1128 /* no s390-specific optimizations yet */
1129 /*----------------------------------------------------------*/
1130 *exclude_mask
= MONO_OPT_INLINE
|MONO_OPT_LINEARS
;
1131 // *exclude_mask = MONO_OPT_INLINE;
1135 /*========================= End of Function ========================*/
1137 /*------------------------------------------------------------------*/
1143 /*------------------------------------------------------------------*/
1146 is_regsize_var (MonoType
*t
) {
1149 switch (mono_type_get_underlying_type (t
)->type
) {
1155 case MONO_TYPE_FNPTR
:
1157 case MONO_TYPE_OBJECT
:
1158 case MONO_TYPE_STRING
:
1159 case MONO_TYPE_CLASS
:
1160 case MONO_TYPE_SZARRAY
:
1161 case MONO_TYPE_ARRAY
:
1163 case MONO_TYPE_VALUETYPE
:
1164 if (t
->data
.klass
->enumtype
)
1165 return is_regsize_var (t
->data
.klass
->enum_basetype
);
1171 /*========================= End of Function ========================*/
1173 /*------------------------------------------------------------------*/
1175 /* Name - mono_arch_get_allocatable_int_vars */
1179 /*------------------------------------------------------------------*/
1182 mono_arch_get_allocatable_int_vars (MonoCompile
*cfg
)
1187 for (i
= 0; i
< cfg
->num_varinfo
; i
++) {
1188 MonoInst
*ins
= cfg
->varinfo
[i
];
1189 MonoMethodVar
*vmv
= MONO_VARINFO (cfg
, i
);
1192 if (vmv
->range
.first_use
.abs_pos
>= vmv
->range
.last_use
.abs_pos
)
1195 if (ins
->flags
& (MONO_INST_VOLATILE
|MONO_INST_INDIRECT
) ||
1196 (ins
->opcode
!= OP_LOCAL
&& ins
->opcode
!= OP_ARG
))
1199 /* we can only allocate 32 bit values */
1200 if (is_regsize_var (ins
->inst_vtype
)) {
1201 g_assert (MONO_VARINFO (cfg
, i
)->reg
== -1);
1202 g_assert (i
== vmv
->idx
);
1203 vars
= mono_varlist_insert_sorted (cfg
, vars
, vmv
, FALSE
);
1210 /*========================= End of Function ========================*/
1212 /*------------------------------------------------------------------*/
1214 /* Name - mono_arch_global_int_regs */
1216 /* Function - Return a list of usable integer registers. */
1218 /*------------------------------------------------------------------*/
1221 mono_arch_get_global_int_regs (MonoCompile
*cfg
)
1224 MonoMethodHeader
*header
;
1227 header
= mono_method_get_header (cfg
->method
);
1228 if ((cfg
->flags
& MONO_CFG_HAS_ALLOCA
) || header
->num_clauses
)
1229 cfg
->frame_reg
= s390_r11
;
1231 /* FIXME: s390_r12 is reserved for bkchain_reg. Only reserve it if needed */
1233 for (i
= 8; i
< top
; ++i
) {
1234 if (cfg
->frame_reg
!= i
)
1235 regs
= g_list_prepend (regs
, GUINT_TO_POINTER (i
));
1241 /*========================= End of Function ========================*/
1243 /*------------------------------------------------------------------*/
1245 /* Name - mono_arch_flush_icache */
1247 /* Function - Flush the CPU icache. */
1249 /*------------------------------------------------------------------*/
1252 mono_arch_flush_icache (guint8
*code
, gint size
)
1256 /*========================= End of Function ========================*/
1258 /*------------------------------------------------------------------*/
1260 /* Name - mono_arch_is_inst_imm */
1262 /*------------------------------------------------------------------*/
1265 mono_arch_is_inst_imm (gint64 imm
)
1267 /* The lowering pass will take care of it */
1271 /*========================= End of Function ========================*/
1273 /*------------------------------------------------------------------*/
1275 /* Name - add_general */
1277 /* Function - Determine code and stack size incremements for a */
1280 /*------------------------------------------------------------------*/
1283 add_general (guint
*gr
, size_data
*sz
, ArgInfo
*ainfo
, gboolean simple
)
1288 if (*gr
> S390_LAST_ARG_REG
) {
1289 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1290 ainfo
->offset
= sz
->stack_size
;
1291 ainfo
->reg
= STK_BASE
;
1292 ainfo
->regtype
= RegTypeBase
;
1293 sz
->stack_size
+= sizeof(int);
1294 sz
->local_size
+= sizeof(int);
1295 sz
->offStruct
+= sizeof(int);
1296 sz
->code_size
+= 12;
1302 if (*gr
> S390_LAST_ARG_REG
- 1) {
1303 disp
= sz
->stack_size
;
1304 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, S390_STACK_ALIGNMENT
);
1305 disp
= sz
->stack_size
- disp
;
1306 ainfo
->offset
= sz
->stack_size
;
1307 ainfo
->reg
= STK_BASE
;
1308 ainfo
->regtype
= RegTypeBase
;
1309 sz
->stack_size
+= sizeof(long long);
1310 sz
->local_size
+= (sizeof(long long) + disp
);
1311 sz
->offStruct
+= (sizeof(long long) + disp
);
1312 sz
->code_size
+= 10;
1322 /*========================= End of Function ========================*/
1324 /*------------------------------------------------------------------*/
1326 /* Name - add_stackParm */
1328 /* Function - Determine code and stack size incremements for a */
1331 /*------------------------------------------------------------------*/
1334 add_stackParm (guint
*gr
, size_data
*sz
, ArgInfo
*ainfo
, gint size
)
1336 if (*gr
> S390_LAST_ARG_REG
) {
1337 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1338 ainfo
->reg
= STK_BASE
;
1339 ainfo
->offset
= sz
->stack_size
;
1340 sz
->stack_size
+= sizeof (gpointer
);
1341 sz
->parm_size
+= sizeof(gpointer
);
1342 sz
->offStruct
+= sizeof(gpointer
);
1345 ainfo
->offset
= sz
->stack_size
;
1348 ainfo
->offparm
= sz
->offset
;
1349 sz
->offset
= S390_ALIGN(sz
->offset
+size
, sizeof(long));
1351 ainfo
->regtype
= RegTypeStructByAddr
;
1352 ainfo
->vtsize
= size
;
1353 sz
->parm_size
+= size
;
1356 /*========================= End of Function ========================*/
1358 /*------------------------------------------------------------------*/
1360 /* Name - add_float */
1362 /* Function - Determine code and stack size incremements for a */
1363 /* float parameter. */
1365 /*------------------------------------------------------------------*/
1368 add_float (guint
*fr
, size_data
*sz
, ArgInfo
*ainfo
)
1370 if ((*fr
) <= S390_LAST_FPARG_REG
) {
1371 ainfo
->regtype
= RegTypeFP
;
1377 ainfo
->offset
= sz
->stack_size
;
1378 ainfo
->reg
= STK_BASE
;
1379 ainfo
->regtype
= RegTypeBase
;
1381 sz
->stack_size
+= ainfo
->size
;
1382 sz
->local_size
+= ainfo
->size
;
1383 sz
->offStruct
+= ainfo
->size
;
1387 /*========================= End of Function ========================*/
1389 /*------------------------------------------------------------------*/
1391 /* Name - get_call_info */
1393 /* Function - Determine the amount of space required for code */
1394 /* and stack. In addition determine starting points */
1395 /* for stack-based parameters, and area for struct- */
1396 /* ures being returned on the stack. */
1398 /*------------------------------------------------------------------*/
1401 get_call_info (MonoCompile
*cfg
, MonoMemPool
*mp
, MonoMethodSignature
*sig
, gboolean is_pinvoke
)
1403 guint i
, fr
, gr
, size
;
1404 int nParm
= sig
->hasthis
+ sig
->param_count
;
1406 guint32 simpletype
, align
;
1409 MonoGenericSharingContext
*gsctx
= cfg
? cfg
->generic_sharing_context
: NULL
;
1412 cinfo
= mono_mempool_alloc0 (mp
, sizeof (CallInfo
) + sizeof (ArgInfo
) * nParm
);
1414 cinfo
= g_malloc0 (sizeof (CallInfo
) + sizeof (ArgInfo
) * nParm
);
1419 cinfo
->struct_ret
= 0;
1422 sz
->offStruct
= S390_MINIMAL_STACK_SIZE
;
1424 sz
->stack_size
= S390_MINIMAL_STACK_SIZE
;
1429 /*----------------------------------------------------------*/
1430 /* We determine the size of the return code/stack in case we*/
1431 /* need to reserve a register to be used to address a stack */
1432 /* area that the callee will use. */
1433 /*----------------------------------------------------------*/
1435 ret_type
= mono_type_get_underlying_type (sig
->ret
);
1436 ret_type
= mini_get_basic_type_from_generic (gsctx
, ret_type
);
1437 simpletype
= ret_type
->type
;
1439 switch (simpletype
) {
1440 case MONO_TYPE_BOOLEAN
:
1445 case MONO_TYPE_CHAR
:
1450 case MONO_TYPE_CLASS
:
1451 case MONO_TYPE_OBJECT
:
1452 case MONO_TYPE_SZARRAY
:
1453 case MONO_TYPE_ARRAY
:
1455 case MONO_TYPE_FNPTR
:
1456 case MONO_TYPE_STRING
:
1457 cinfo
->ret
.reg
= s390_r2
;
1462 cinfo
->ret
.reg
= s390_f0
;
1467 cinfo
->ret
.reg
= s390_r2
;
1470 case MONO_TYPE_GENERICINST
:
1471 if (!mono_type_generic_inst_is_valuetype (sig
->ret
)) {
1472 cinfo
->ret
.reg
= s390_r2
;
1477 case MONO_TYPE_VALUETYPE
: {
1478 MonoClass
*klass
= mono_class_from_mono_type (sig
->ret
);
1479 if (klass
->enumtype
) {
1480 simpletype
= klass
->enum_basetype
->type
;
1484 size
= mono_class_native_size (klass
, &align
);
1486 size
= mono_class_value_size (klass
, &align
);
1488 cinfo
->ret
.reg
= s390_r2
;
1489 cinfo
->struct_ret
= 1;
1490 cinfo
->ret
.size
= size
;
1491 cinfo
->ret
.vtsize
= size
;
1495 case MONO_TYPE_TYPEDBYREF
:
1496 size
= sizeof (MonoTypedRef
);
1497 cinfo
->ret
.reg
= s390_r2
;
1498 cinfo
->struct_ret
= 1;
1499 cinfo
->ret
.size
= size
;
1500 cinfo
->ret
.vtsize
= size
;
1503 case MONO_TYPE_VOID
:
1506 g_error ("mini-s390: cannot handle as return value 0x%x (0x%x)", sig
->ret
->type
,simpletype
);
1510 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1511 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1515 /*----------------------------------------------------------*/
1516 /* We determine the size of the parameter code and stack */
1517 /* requirements by checking the types and sizes of the */
1519 /*----------------------------------------------------------*/
1521 for (i
= 0; i
< sig
->param_count
; ++i
) {
1524 /*--------------------------------------------------*/
1525 /* Handle vararg type calls. All args are put on */
1527 /*--------------------------------------------------*/
1528 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1529 (i
== sig
->sentinelpos
)) {
1530 gr
= S390_LAST_ARG_REG
+ 1;
1531 add_general (&gr
, sz
, &cinfo
->sigCookie
, TRUE
);
1534 if (sig
->params
[i
]->byref
) {
1535 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1536 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1541 ptype
= mono_type_get_underlying_type (sig
->params
[i
]);
1542 ptype
= mini_get_basic_type_from_generic (gsctx
, ptype
);
1543 simpletype
= ptype
->type
;
1544 switch (simpletype
) {
1545 case MONO_TYPE_BOOLEAN
:
1548 cinfo
->args
[nParm
].size
= sizeof(char);
1549 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1554 case MONO_TYPE_CHAR
:
1555 cinfo
->args
[nParm
].size
= sizeof(short);
1556 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1561 cinfo
->args
[nParm
].size
= sizeof(int);
1562 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1568 case MONO_TYPE_FNPTR
:
1569 case MONO_TYPE_CLASS
:
1570 case MONO_TYPE_OBJECT
:
1571 case MONO_TYPE_STRING
:
1572 case MONO_TYPE_SZARRAY
:
1573 case MONO_TYPE_ARRAY
:
1574 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1575 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1580 cinfo
->args
[nParm
].size
= sizeof(long long);
1581 add_general (&gr
, sz
, cinfo
->args
+nParm
, FALSE
);
1585 cinfo
->args
[nParm
].size
= sizeof(float);
1586 add_float (&fr
, sz
, cinfo
->args
+nParm
);
1590 cinfo
->args
[nParm
].size
= sizeof(double);
1591 add_float (&fr
, sz
, cinfo
->args
+nParm
);
1594 case MONO_TYPE_GENERICINST
:
1595 if (!mono_type_generic_inst_is_valuetype (sig
->params
[i
])) {
1596 cinfo
->args
[nParm
].size
= sizeof(gpointer
);
1597 add_general (&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1602 case MONO_TYPE_VALUETYPE
: {
1603 MonoMarshalType
*info
;
1604 MonoClass
*klass
= mono_class_from_mono_type (sig
->params
[i
]);
1606 size
= mono_class_native_size (klass
, &align
);
1608 size
= mono_class_value_size (klass
, &align
);
1610 info
= mono_marshal_load_type_info (klass
);
1612 if ((info
->native_size
== sizeof(float)) &&
1613 (info
->num_fields
== 1) &&
1614 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R4
)) {
1615 cinfo
->args
[nParm
].size
= sizeof(float);
1616 add_float(&fr
, sz
, cinfo
->args
+nParm
);
1621 if ((info
->native_size
== sizeof(double)) &&
1622 (info
->num_fields
== 1) &&
1623 (info
->fields
[0].field
->type
->type
== MONO_TYPE_R8
)) {
1624 cinfo
->args
[nParm
].size
= sizeof(double);
1625 add_float(&fr
, sz
, cinfo
->args
+nParm
);
1630 cinfo
->args
[nParm
].vtsize
= 0;
1631 cinfo
->args
[nParm
].size
= 0;
1634 /*----------------------------------*/
1635 /* On S/390, structures of size 1, */
1636 /* 2, 4, and 8 bytes are passed in */
1637 /* (a) register(s). */
1638 /*----------------------------------*/
1643 add_general(&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1644 cinfo
->args
[nParm
].size
= size
;
1645 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1647 sz
->local_size
+= sizeof(long);
1650 add_general(&gr
, sz
, cinfo
->args
+nParm
, FALSE
);
1651 cinfo
->args
[nParm
].size
= sizeof(long long);
1652 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1654 sz
->local_size
+= sizeof(long long);
1657 add_stackParm(&gr
, sz
, cinfo
->args
+nParm
, size
);
1662 case MONO_TYPE_TYPEDBYREF
: {
1663 int size
= sizeof (MonoTypedRef
);
1665 cinfo
->args
[nParm
].vtsize
= 0;
1666 cinfo
->args
[nParm
].size
= 0;
1669 /*----------------------------------*/
1670 /* On S/390, structures of size 1, */
1671 /* 2, 4, and 8 bytes are passed in */
1672 /* (a) register(s). */
1673 /*----------------------------------*/
1678 add_general(&gr
, sz
, cinfo
->args
+nParm
, TRUE
);
1679 cinfo
->args
[nParm
].size
= size
;
1680 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1682 sz
->local_size
+= sizeof(long);
1685 add_general(&gr
, sz
, cinfo
->args
+nParm
, FALSE
);
1686 cinfo
->args
[nParm
].size
= sizeof(long long);
1687 cinfo
->args
[nParm
].regtype
= RegTypeStructByVal
;
1689 sz
->local_size
+= sizeof(long long);
1692 add_stackParm(&gr
, sz
, cinfo
->args
+nParm
, size
);
1698 g_error ("Can't trampoline 0x%x", sig
->params
[i
]->type
);
1702 /*----------------------------------------------------------*/
1703 /* If we are passing a structure back then if it won't be */
1704 /* in a register(s) then we make room at the end of the */
1705 /* parameters that may have been placed on the stack */
1706 /*----------------------------------------------------------*/
1707 if (cinfo
->struct_ret
) {
1708 cinfo
->ret
.offset
= sz
->stack_size
;
1709 switch (cinfo
->ret
.size
) {
1717 sz
->stack_size
+= S390_ALIGN(cinfo
->ret
.size
, align
);
1721 /*----------------------------------------------------------*/
1722 /* Handle the case where there are no implicit arguments */
1723 /*----------------------------------------------------------*/
1724 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1725 (sig
->param_count
== sig
->sentinelpos
)) {
1726 gr
= S390_LAST_ARG_REG
+ 1;
1727 add_general (&gr
, sz
, &cinfo
->sigCookie
, TRUE
);
1731 sz
->stack_size
= sz
->stack_size
+ sz
->local_size
+ sz
->parm_size
+
1733 sz
->stack_size
= S390_ALIGN(sz
->stack_size
, sizeof(long));
1738 /*========================= End of Function ========================*/
1740 /*------------------------------------------------------------------*/
1742 /* Name - mono_arch_allocate_vars */
1744 /* Function - Set var information according to the calling */
1745 /* convention for S/390. The local var stuff should */
1746 /* most likely be split in another method. */
1748 /* Parameter - @m - Compile unit. */
1750 /*------------------------------------------------------------------*/
1753 mono_arch_allocate_vars (MonoCompile
*cfg
)
1755 MonoMethodSignature
*sig
;
1756 MonoMethodHeader
*header
;
1759 int iParm
, iVar
, offset
, size
, align
, curinst
;
1760 int frame_reg
= STK_BASE
;
1763 header
= mono_method_get_header (cfg
->method
);
1765 cfg
->flags
|= MONO_CFG_HAS_SPILLUP
;
1767 sig
= mono_method_signature (cfg
->method
);
1769 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
1771 /*---------------------------------------------------------*/
1772 /* We use the frame register also for any method that has */
1773 /* filter clauses. This way, when the handlers are called, */
1774 /* the code will reference local variables using the frame */
1775 /* reg instead of the stack pointer: if we had to restore */
1776 /* the stack pointer, we'd corrupt the method frames that */
1777 /* are already on the stack (since filters get called */
1778 /* before stack unwinding happens) when the filter code */
1779 /* would call any method. */
1780 /*---------------------------------------------------------*/
1781 if ((cfg
->flags
& MONO_CFG_HAS_ALLOCA
) || header
->num_clauses
)
1782 frame_reg
= s390_r11
;
1784 cfg
->frame_reg
= frame_reg
;
1786 cfg
->arch
.bkchain_reg
= -1;
1788 if (frame_reg
!= STK_BASE
)
1789 cfg
->used_int_regs
|= 1 << frame_reg
;
1791 sig
= mono_method_signature (cfg
->method
);
1793 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
1795 if (cinfo
->struct_ret
) {
1797 cfg
->vret_addr
->opcode
= OP_REGVAR
;
1798 cfg
->vret_addr
->inst_c0
= s390_r2
;
1801 switch (mono_type_get_underlying_type (sig
->ret
)->type
) {
1802 case MONO_TYPE_VOID
:
1805 cfg
->ret
->opcode
= OP_REGVAR
;
1806 cfg
->ret
->dreg
= s390_r2
;
1811 /*--------------------------------------------------------------*/
1812 /* local vars are at a positive offset from the stack pointer */
1813 /* also note that if the function uses alloca, we use s390_r11 */
1814 /* to point at the local variables. */
1815 /* add parameter area size for called functions */
1816 /*--------------------------------------------------------------*/
1817 offset
= (cfg
->param_area
+ S390_MINIMAL_STACK_SIZE
);
1818 cfg
->sig_cookie
= 0;
1820 if (cinfo
->struct_ret
) {
1821 inst
= cfg
->vret_addr
;
1822 offset
= S390_ALIGN(offset
, sizeof(gpointer
));
1823 inst
->inst_offset
= offset
;
1824 inst
->opcode
= OP_REGOFFSET
;
1825 inst
->inst_basereg
= frame_reg
;
1826 offset
+= sizeof(gpointer
);
1827 if (!cfg
->new_ir
&& (sig
->call_convention
== MONO_CALL_VARARG
) &&
1828 (!retFitsInReg (cinfo
->ret
.size
)))
1829 cfg
->sig_cookie
+= cinfo
->ret
.size
;
1830 if (G_UNLIKELY (cfg
->verbose_level
> 1)) {
1831 printf ("vret_addr =");
1832 mono_print_ins (cfg
->vret_addr
);
1837 inst
= cfg
->args
[0];
1838 if (inst
->opcode
!= OP_REGVAR
) {
1839 inst
->opcode
= OP_REGOFFSET
;
1840 inst
->inst_basereg
= frame_reg
;
1841 offset
= S390_ALIGN(offset
, sizeof(gpointer
));
1842 inst
->inst_offset
= offset
;
1843 offset
+= sizeof (gpointer
);
1850 eArg
= sig
->param_count
+ sArg
;
1852 if (sig
->call_convention
== MONO_CALL_VARARG
)
1853 cfg
->sig_cookie
+= S390_MINIMAL_STACK_SIZE
;
1855 for (iParm
= sArg
; iParm
< eArg
; ++iParm
) {
1856 inst
= cfg
->args
[curinst
];
1857 if (inst
->opcode
!= OP_REGVAR
) {
1858 switch (cinfo
->args
[iParm
].regtype
) {
1859 case RegTypeStructByAddr
:
1863 size
= sizeof (gpointer
);
1865 if (cinfo
->args
[iParm
].reg
== STK_BASE
) {
1866 cfg
->arch
.bkchain_reg
= s390_r12
;
1867 cfg
->used_int_regs
|= 1 << cfg
->arch
.bkchain_reg
;
1869 inst
->opcode
= OP_REGOFFSET
;
1870 inst
->inst_basereg
= cfg
->arch
.bkchain_reg
;
1871 inst
->inst_offset
= cinfo
->args
[iParm
].offset
;
1873 inst
->opcode
= OP_REGOFFSET
;
1874 inst
->inst_basereg
= frame_reg
;
1875 inst
->inst_offset
= S390_ALIGN(offset
, sizeof (gpointer
));
1878 /* Add a level of indirection */
1879 MONO_INST_NEW (cfg
, indir
, 0);
1881 inst
->opcode
= OP_VTARG_ADDR
;
1882 inst
->inst_left
= indir
;
1884 if (cinfo
->args
[iParm
].reg
== STK_BASE
) {
1885 inst
->opcode
= OP_S390_LOADARG
;
1886 inst
->inst_basereg
= frame_reg
;
1887 size
= abs(cinfo
->args
[iParm
].vtsize
);
1888 offset
= S390_ALIGN(offset
, sizeof(long));
1889 inst
->inst_offset
= offset
;
1890 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1892 inst
->opcode
= OP_S390_ARGREG
;
1893 inst
->inst_basereg
= frame_reg
;
1894 size
= sizeof(gpointer
);
1895 offset
= S390_ALIGN(offset
, size
);
1896 inst
->inst_offset
= offset
;
1897 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1901 case RegTypeStructByVal
:
1903 size
= cinfo
->args
[iParm
].size
;
1904 offset
= S390_ALIGN(offset
, size
);
1905 inst
->opcode
= OP_REGOFFSET
;
1906 inst
->inst_basereg
= frame_reg
;
1907 inst
->inst_offset
= S390_ALIGN (offset
, size
);
1909 inst
->opcode
= OP_S390_ARGPTR
;
1910 inst
->inst_basereg
= frame_reg
;
1911 size
= cinfo
->args
[iParm
].size
;
1912 offset
= S390_ALIGN(offset
, size
);
1913 inst
->inst_offset
= offset
;
1914 inst
->backend
.arg_info
= cinfo
->args
[iParm
].offset
;
1919 if (cinfo
->args
[iParm
].reg
== STK_BASE
) {
1921 * These arguments are in the previous frame, so we can't
1922 * compute their offset from the current frame pointer right
1923 * now, since cfg->stack_offset is not yet known, so dedicate a
1924 * register holding the previous frame pointer.
1926 cfg
->arch
.bkchain_reg
= s390_r12
;
1927 cfg
->used_int_regs
|= 1 << cfg
->arch
.bkchain_reg
;
1929 inst
->opcode
= OP_REGOFFSET
;
1930 inst
->inst_basereg
= cfg
->arch
.bkchain_reg
;
1931 size
= (cinfo
->args
[iParm
].size
< 4
1932 ? 4 - cinfo
->args
[iParm
].size
1934 inst
->inst_offset
= cinfo
->args
[iParm
].offset
+ size
;
1935 size
= sizeof (long);
1937 inst
->opcode
= OP_REGOFFSET
;
1938 inst
->inst_basereg
= frame_reg
;
1939 size
= (cinfo
->args
[iParm
].size
< 8
1941 : sizeof(long long));
1942 offset
= S390_ALIGN(offset
, size
);
1943 inst
->inst_offset
= offset
;
1946 if (cinfo
->args
[iParm
].reg
!= STK_BASE
) {
1947 inst
->opcode
= OP_REGOFFSET
;
1948 inst
->inst_basereg
= frame_reg
;
1949 size
= (cinfo
->args
[iParm
].size
< 8
1951 : sizeof(long long));
1952 offset
= S390_ALIGN(offset
, size
);
1953 inst
->inst_offset
= offset
;
1955 inst
->opcode
= OP_S390_STKARG
;
1956 inst
->inst_basereg
= frame_reg
;
1957 size
= (cinfo
->args
[iParm
].size
< 4
1958 ? 4 - cinfo
->args
[iParm
].size
1960 inst
->inst_offset
= cinfo
->args
[iParm
].offset
+
1962 inst
->backend
.arg_info
= 0;
1963 size
= sizeof(long);
1967 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
1968 (cinfo
->args
[iParm
].regtype
!= RegTypeGeneral
) &&
1969 (iParm
< sig
->sentinelpos
))
1970 cfg
->sig_cookie
+= size
;
1977 curinst
= cfg
->locals_start
;
1978 for (iVar
= curinst
; iVar
< cfg
->num_varinfo
; ++iVar
) {
1979 inst
= cfg
->varinfo
[iVar
];
1980 if ((inst
->flags
& MONO_INST_IS_DEAD
) ||
1981 (inst
->opcode
== OP_REGVAR
))
1984 /*--------------------------------------------------*/
1985 /* inst->backend.is_pinvoke indicates native sized value types, */
1986 /* this is used by the pinvoke wrappers when they */
1987 /* call functions returning structure */
1988 /*--------------------------------------------------*/
1989 if (inst
->backend
.is_pinvoke
&& MONO_TYPE_ISSTRUCT (inst
->inst_vtype
))
1990 size
= mono_class_native_size (mono_class_from_mono_type(inst
->inst_vtype
), &align
);
1992 size
= mono_type_size (inst
->inst_vtype
, &align
);
1994 offset
= S390_ALIGN(offset
, align
);
1995 inst
->inst_offset
= offset
;
1996 inst
->opcode
= OP_REGOFFSET
;
1997 inst
->inst_basereg
= frame_reg
;
1999 DEBUG (g_print("allocating local %d to %ld\n", iVar
, inst
->inst_offset
));
2002 /*------------------------------------------------------*/
2003 /* Allow space for the trace method stack area if needed*/
2004 /*------------------------------------------------------*/
2005 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (cfg
->method
)) {
2006 offset
+= S390_TRACE_STACK_SIZE
;
2009 /*------------------------------------------------------*/
2010 /* Reserve space to save LMF and caller saved registers */
2011 /*------------------------------------------------------*/
2012 if (cfg
->method
->save_lmf
)
2013 offset
+= sizeof (MonoLMF
);
2015 /*------------------------------------------------------*/
2016 /* align the offset */
2017 /*------------------------------------------------------*/
2018 cfg
->stack_offset
= S390_ALIGN(offset
, S390_STACK_ALIGNMENT
);
2020 /* Fix up offsets for arguments whose value is in the parent frame */
2022 for (iParm
= sArg
; iParm
< eArg
; ++iParm
) {
2023 inst
= cfg
->args
[iParm
];
2025 if (inst
->opcode
== OP_S390_STKARG
) {
2026 inst
->opcode
= OP_REGOFFSET
;
2027 inst
->inst_offset
+= cfg
->stack_offset
;
2033 /*========================= End of Function ========================*/
2035 /*------------------------------------------------------------------*/
2037 /* Name - mono_arch_create_vars */
2039 /*------------------------------------------------------------------*/
2042 mono_arch_create_vars (MonoCompile
*cfg
)
2044 MonoMethodSignature
*sig
;
2047 sig
= mono_method_signature (cfg
->method
);
2049 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2051 if (cinfo
->struct_ret
) {
2052 cfg
->vret_addr
= mono_compile_create_var (cfg
, &mono_defaults
.int_class
->byval_arg
, OP_ARG
);
2053 if (G_UNLIKELY (cfg
->verbose_level
> 1)) {
2054 printf ("vret_addr = ");
2055 mono_print_ins (cfg
->vret_addr
);
2060 /*========================= End of Function ========================*/
2062 /*------------------------------------------------------------------*/
2064 /* Name - mono_arch_call_opcode */
2066 /* Function - Take the arguments and generate the arch-specific */
2067 /* instructions to properly call the function. This */
2068 /* includes pushing, moving argments to the correct */
2071 /*------------------------------------------------------------------*/
2074 mono_arch_call_opcode (MonoCompile
*cfg
, MonoBasicBlock
* bb
,
2075 MonoCallInst
*call
, int is_virtual
)
2078 MonoCallArgParm
*arg
;
2079 MonoMethodSignature
*sig
;
2080 int i
, n
, lParamArea
;
2082 ArgInfo
*ainfo
= NULL
;
2085 sig
= call
->signature
;
2086 n
= sig
->param_count
+ sig
->hasthis
;
2087 DEBUG (g_print ("Call requires: %d parameters\n",n
));
2089 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2091 stackSize
= cinfo
->sz
.stack_size
+ cinfo
->sz
.local_size
+ cinfo
->sz
.parm_size
+ cinfo
->sz
.offset
;
2092 call
->stack_usage
= MAX(stackSize
, call
->stack_usage
);
2093 lParamArea
= MAX((call
->stack_usage
-S390_MINIMAL_STACK_SIZE
-cinfo
->sz
.parm_size
), 0);
2094 cfg
->param_area
= MAX(((signed) cfg
->param_area
), lParamArea
);
2095 cfg
->flags
|= MONO_CFG_HAS_CALLS
;
2097 if (cinfo
->struct_ret
)
2098 call
->used_iregs
|= 1 << cinfo
->ret
.reg
;
2100 for (i
= 0; i
< n
; ++i
) {
2101 ainfo
= cinfo
->args
+ i
;
2103 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2104 (i
== sig
->sentinelpos
)) {
2105 emit_sig_cookie (cfg
, call
, cinfo
, ainfo
->size
);
2108 if (is_virtual
&& i
== 0) {
2109 /* the argument will be attached to the call instrucion */
2110 in
= call
->args
[i
];
2111 call
->used_iregs
|= 1 << ainfo
->reg
;
2113 MONO_INST_NEW_CALL_ARG (cfg
, arg
, OP_OUTARG
);
2114 in
= call
->args
[i
];
2115 arg
->ins
.cil_code
= in
->cil_code
;
2116 arg
->ins
.inst_left
= in
;
2117 arg
->ins
.type
= in
->type
;
2118 /* prepend, we'll need to reverse them later */
2119 arg
->ins
.next
= call
->out_args
;
2120 call
->out_args
= (MonoInst
*) arg
;
2121 arg
->ins
.inst_right
= (MonoInst
*) call
;
2122 if (ainfo
->regtype
== RegTypeGeneral
) {
2123 arg
->ins
.backend
.reg3
= ainfo
->reg
;
2124 call
->used_iregs
|= 1 << ainfo
->reg
;
2125 if (arg
->ins
.type
== STACK_I8
)
2126 call
->used_iregs
|= 1 << (ainfo
->reg
+ 1);
2127 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
2128 call
->used_iregs
|= 1 << ainfo
->reg
;
2129 arg
->ins
.sreg1
= ainfo
->reg
;
2130 arg
->ins
.opcode
= OP_OUTARG_VT
;
2131 arg
->size
= -ainfo
->vtsize
;
2132 arg
->offset
= ainfo
->offset
;
2133 arg
->offPrm
= ainfo
->offparm
+ cinfo
->sz
.offStruct
;
2134 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
2135 if (ainfo
->reg
!= STK_BASE
) {
2136 switch (ainfo
->size
) {
2141 call
->used_iregs
|= 1 << ainfo
->reg
;
2144 call
->used_iregs
|= 1 << ainfo
->reg
;
2145 call
->used_iregs
|= 1 << (ainfo
->reg
+1);
2148 call
->used_iregs
|= 1 << ainfo
->reg
;
2151 arg
->ins
.sreg1
= ainfo
->reg
;
2152 arg
->ins
.opcode
= OP_OUTARG_VT
;
2153 arg
->size
= ainfo
->size
;
2154 arg
->offset
= ainfo
->offset
;
2155 arg
->offPrm
= ainfo
->offparm
+ cinfo
->sz
.offStruct
;
2156 } else if (ainfo
->regtype
== RegTypeBase
) {
2157 arg
->ins
.opcode
= OP_OUTARG_MEMBASE
;
2158 arg
->ins
.sreg1
= ainfo
->reg
;
2159 arg
->size
= ainfo
->size
;
2160 arg
->offset
= ainfo
->offset
;
2161 call
->used_iregs
|= 1 << ainfo
->reg
;
2162 } else if (ainfo
->regtype
== RegTypeFP
) {
2163 arg
->ins
.backend
.reg3
= ainfo
->reg
;
2164 call
->used_fregs
|= 1 << ainfo
->reg
;
2165 if (ainfo
->size
== 4)
2166 arg
->ins
.opcode
= OP_OUTARG_R4
;
2168 arg
->ins
.opcode
= OP_OUTARG_R8
;
2170 g_assert_not_reached ();
2176 * Handle the case where there are no implicit arguments
2178 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2179 (i
== sig
->sentinelpos
)) {
2180 emit_sig_cookie (cfg
, call
, cinfo
, ainfo
->size
);
2184 * Reverse the call->out_args list.
2187 MonoInst
*prev
= NULL
, *list
= call
->out_args
, *next
;
2194 call
->out_args
= prev
;
2200 /*========================= End of Function ========================*/
2203 add_outarg_reg2 (MonoCompile
*cfg
, MonoCallInst
*call
, ArgStorage storage
, int reg
, MonoInst
*tree
)
2208 case RegTypeGeneral
:
2209 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2210 ins
->dreg
= mono_alloc_ireg (cfg
);
2211 ins
->sreg1
= tree
->dreg
;
2212 MONO_ADD_INS (cfg
->cbb
, ins
);
2213 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, FALSE
);
2216 MONO_INST_NEW (cfg
, ins
, OP_FMOVE
);
2217 ins
->dreg
= mono_alloc_freg (cfg
);
2218 ins
->sreg1
= tree
->dreg
;
2219 MONO_ADD_INS (cfg
->cbb
, ins
);
2220 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, TRUE
);
2223 MONO_INST_NEW (cfg
, ins
, OP_S390_SETF4RET
);
2224 ins
->dreg
= mono_alloc_freg (cfg
);
2225 ins
->sreg1
= tree
->dreg
;
2226 MONO_ADD_INS (cfg
->cbb
, ins
);
2227 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, reg
, TRUE
);
2230 g_assert_not_reached ();
2235 emit_sig_cookie2 (MonoCompile
*cfg
, MonoCallInst
*call
, CallInfo
*cinfo
)
2237 MonoMethodSignature
*tmpSig
;
2240 cfg
->disable_aot
= TRUE
;
2242 /*----------------------------------------------------------*/
2243 /* mono_ArgIterator_Setup assumes the signature cookie is */
2244 /* passed first and all the arguments which were before it */
2245 /* passed on the stack after the signature. So compensate */
2246 /* by passing a different signature. */
2247 /*----------------------------------------------------------*/
2248 tmpSig
= mono_metadata_signature_dup (call
->signature
);
2249 tmpSig
->param_count
-= call
->signature
->sentinelpos
;
2250 tmpSig
->sentinelpos
= 0;
2251 if (tmpSig
->param_count
> 0)
2252 memcpy (tmpSig
->params
,
2253 call
->signature
->params
+ call
->signature
->sentinelpos
,
2254 tmpSig
->param_count
* sizeof(MonoType
*));
2256 MONO_INST_NEW (cfg
, sig_arg
, OP_ICONST
);
2257 sig_arg
->dreg
= mono_alloc_ireg (cfg
);
2258 sig_arg
->inst_p0
= tmpSig
;
2259 MONO_ADD_INS (cfg
->cbb
, sig_arg
);
2261 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORE_MEMBASE_REG
, STK_BASE
,
2262 cinfo
->sigCookie
.offset
, sig_arg
->dreg
);
2265 /*------------------------------------------------------------------*/
2267 /* Name - mono_arch_emit_call */
2269 /*------------------------------------------------------------------*/
2272 mono_arch_emit_call (MonoCompile
*cfg
, MonoCallInst
*call
)
2275 MonoMethodSignature
*sig
;
2277 int i
, n
, lParamArea
;
2279 ArgInfo
*ainfo
= NULL
;
2282 sig
= call
->signature
;
2283 n
= sig
->param_count
+ sig
->hasthis
;
2284 DEBUG (g_print ("Call requires: %d parameters\n",n
));
2286 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
2288 stackSize
= cinfo
->sz
.stack_size
+ cinfo
->sz
.local_size
+ cinfo
->sz
.parm_size
+ cinfo
->sz
.offset
;
2289 call
->stack_usage
= MAX(stackSize
, call
->stack_usage
);
2290 lParamArea
= MAX((call
->stack_usage
-S390_MINIMAL_STACK_SIZE
-cinfo
->sz
.parm_size
), 0);
2291 cfg
->param_area
= MAX(((signed) cfg
->param_area
), lParamArea
);
2292 cfg
->flags
|= MONO_CFG_HAS_CALLS
;
2294 if (cinfo
->struct_ret
) {
2295 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2296 ins
->sreg1
= call
->vret_var
->dreg
;
2297 ins
->dreg
= mono_alloc_preg (cfg
);
2298 MONO_ADD_INS (cfg
->cbb
, ins
);
2299 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, cinfo
->ret
.reg
, FALSE
);
2302 for (i
= 0; i
< n
; ++i
) {
2303 ainfo
= cinfo
->args
+ i
;
2306 if (i
>= sig
->hasthis
)
2307 t
= sig
->params
[i
- sig
->hasthis
];
2309 t
= &mono_defaults
.int_class
->byval_arg
;
2310 t
= mono_type_get_underlying_type (t
);
2312 in
= call
->args
[i
];
2314 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2315 (i
== sig
->sentinelpos
)) {
2316 emit_sig_cookie2 (cfg
, call
, cinfo
);
2319 switch (ainfo
->regtype
) {
2320 case RegTypeGeneral
:
2321 if (!t
->byref
&& (t
->type
== MONO_TYPE_I8
|| t
->type
== MONO_TYPE_U8
)) {
2322 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2323 ins
->dreg
= mono_alloc_ireg (cfg
);
2324 ins
->sreg1
= in
->dreg
+ 2;
2325 MONO_ADD_INS (cfg
->cbb
, ins
);
2326 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, ainfo
->reg
, FALSE
);
2327 MONO_INST_NEW (cfg
, ins
, OP_MOVE
);
2328 ins
->dreg
= mono_alloc_ireg (cfg
);
2329 ins
->sreg1
= in
->dreg
+ 1;
2330 MONO_ADD_INS (cfg
->cbb
, ins
);
2331 mono_call_inst_add_outarg_reg (cfg
, call
, ins
->dreg
, ainfo
->reg
+ 1, FALSE
);
2333 add_outarg_reg2 (cfg
, call
, ainfo
->regtype
, ainfo
->reg
, in
);
2337 if (MONO_TYPE_ISSTRUCT (t
)) {
2338 /* Valuetype passed in one fp register */
2339 ainfo
->regtype
= RegTypeStructByValInFP
;
2342 if (ainfo
->size
== 4)
2343 ainfo
->regtype
= RegTypeFPR4
;
2344 add_outarg_reg2 (cfg
, call
, ainfo
->regtype
, ainfo
->reg
, in
);
2347 case RegTypeStructByVal
:
2348 case RegTypeStructByAddr
: {
2352 if (sig
->params
[i
- sig
->hasthis
]->type
== MONO_TYPE_TYPEDBYREF
) {
2353 size
= sizeof (MonoTypedRef
);
2354 align
= sizeof (gpointer
);
2358 size
= mono_type_native_stack_size (&in
->klass
->byval_arg
, &align
);
2361 * Other backends use mono_type_stack_size (), but that
2362 * aligns the size to 8, which is larger than the size of
2363 * the source, leading to reads of invalid memory if the
2364 * source is at the end of address space.
2366 size
= mono_class_value_size (in
->klass
, &align
);
2369 g_assert (in
->klass
);
2371 ainfo
->offparm
+= cinfo
->sz
.offStruct
;
2373 MONO_INST_NEW (cfg
, ins
, OP_OUTARG_VT
);
2374 ins
->sreg1
= in
->dreg
;
2375 ins
->klass
= in
->klass
;
2376 ins
->backend
.size
= ainfo
->size
;
2377 ins
->inst_p0
= call
;
2378 ins
->inst_p1
= mono_mempool_alloc (cfg
->mempool
, sizeof (ArgInfo
));
2379 memcpy (ins
->inst_p1
, ainfo
, sizeof (ArgInfo
));
2381 MONO_ADD_INS (cfg
->cbb
, ins
);
2383 if (ainfo
->regtype
== RegTypeStructByAddr
) {
2385 * We use OP_OUTARG_VT to copy the valuetype to a stack location, then
2386 * use the normal OUTARG opcodes to pass the address of the location to
2389 int treg
= mono_alloc_preg (cfg
);
2390 MONO_EMIT_NEW_BIALU_IMM (cfg
, OP_ADD_IMM
, treg
,
2391 STK_BASE
, ainfo
->offparm
);
2392 if (ainfo
->reg
== STK_BASE
) {
2393 /* The address is passed on the stack */
2394 MONO_INST_NEW (cfg
, ins
, OP_STORE_MEMBASE_REG
);
2395 ins
->inst_destbasereg
= STK_BASE
;
2396 ins
->inst_offset
= ainfo
->offset
;
2398 MONO_ADD_INS (cfg
->cbb
, ins
);
2400 mono_call_inst_add_outarg_reg (cfg
, call
, treg
, ainfo
->reg
, FALSE
);
2406 if (!t
->byref
&& t
->type
== MONO_TYPE_R4
) {
2407 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORER4_MEMBASE_REG
,
2408 STK_BASE
, ainfo
->offset
,
2410 } else if (!t
->byref
&& (t
->type
== MONO_TYPE_R8
)) {
2411 MONO_EMIT_NEW_STORE_MEMBASE (cfg
, OP_STORER8_MEMBASE_REG
,
2412 STK_BASE
, ainfo
->offset
,
2414 } else if (!t
->byref
&& (t
->type
== MONO_TYPE_I8
|| t
->type
== MONO_TYPE_U8
)) {
2415 MONO_INST_NEW (cfg
, ins
, OP_STORE_MEMBASE_REG
);
2416 ins
->inst_destbasereg
= STK_BASE
;
2417 ins
->inst_offset
= ainfo
->offset
+ MINI_LS_WORD_OFFSET
;
2418 ins
->sreg1
= in
->dreg
+ 1;
2419 MONO_ADD_INS (cfg
->cbb
, ins
);
2421 MONO_INST_NEW (cfg
, ins
, OP_STORE_MEMBASE_REG
);
2422 ins
->inst_destbasereg
= STK_BASE
;
2423 ins
->inst_offset
= ainfo
->offset
+ MINI_MS_WORD_OFFSET
;
2424 ins
->sreg1
= in
->dreg
+ 2;
2425 MONO_ADD_INS (cfg
->cbb
, ins
);
2427 MONO_INST_NEW (cfg
, ins
, OP_STORE_MEMBASE_REG
);
2428 ins
->inst_destbasereg
= STK_BASE
;
2429 ins
->inst_offset
= ainfo
->offset
;
2430 ins
->sreg1
= in
->dreg
;
2431 MONO_ADD_INS (cfg
->cbb
, ins
);
2435 g_assert_not_reached ();
2441 * Handle the case where there are no implicit arguments
2443 if ((sig
->call_convention
== MONO_CALL_VARARG
) &&
2444 (i
== sig
->sentinelpos
)) {
2445 emit_sig_cookie2 (cfg
, call
, cinfo
);
2449 /*========================= End of Function ========================*/
2451 /*------------------------------------------------------------------*/
2453 /* Name - mono_arch_emit_outarg_vt */
2455 /*------------------------------------------------------------------*/
2458 mono_arch_emit_outarg_vt (MonoCompile
*cfg
, MonoInst
*ins
, MonoInst
*src
)
2460 MonoCallInst
*call
= (MonoCallInst
*)ins
->inst_p0
;
2461 ArgInfo
*ainfo
= (ArgInfo
*)ins
->inst_p1
;
2462 int size
= ins
->backend
.size
;
2464 if (ainfo
->regtype
== RegTypeStructByVal
) {
2466 arg->ins.sreg1 = ainfo->reg;
2467 arg->ins.opcode = OP_OUTARG_VT;
2468 arg->size = ainfo->size;
2469 arg->offset = ainfo->offset;
2470 arg->offPrm = ainfo->offparm + cinfo->sz.offStruct;
2472 if (ainfo
->reg
!= STK_BASE
) {
2473 MONO_OUTPUT_VTR2 (cfg
, size
, ainfo
->reg
, src
->dreg
, 0);
2475 MONO_OUTPUT_VTS2 (cfg
, size
, ainfo
->reg
, ainfo
->offset
,
2478 } else if (ainfo
->regtype
== RegTypeStructByValInFP
) {
2479 int dreg
= mono_alloc_freg (cfg
);
2481 if (ainfo
->size
== 4) {
2482 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg
, OP_LOADR4_MEMBASE
, dreg
, src
->dreg
, 0);
2483 MONO_EMIT_NEW_UNALU (cfg
, OP_S390_SETF4RET
, dreg
, dreg
);
2485 g_assert (ainfo
->size
== 8);
2487 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg
, OP_LOADR8_MEMBASE
, dreg
, src
->dreg
, 0);
2490 mono_call_inst_add_outarg_reg (cfg
, call
, dreg
, ainfo
->reg
, TRUE
);
2492 MONO_EMIT_NEW_MOVE2 (cfg
, STK_BASE
, ainfo
->offparm
,
2493 src
->dreg
, 0, size
);
2497 /*------------------------------------------------------------------*/
2499 /* Name - mono_arch_emit_setret */
2501 /*------------------------------------------------------------------*/
2504 mono_arch_emit_setret (MonoCompile
*cfg
, MonoMethod
*method
, MonoInst
*val
)
2506 MonoType
*ret
= mono_type_get_underlying_type (mono_method_signature (method
)->ret
);
2509 if (ret
->type
== MONO_TYPE_R4
) {
2510 MONO_EMIT_NEW_UNALU (cfg
, OP_S390_SETF4RET
, s390_f0
, val
->dreg
);
2512 } else if (ret
->type
== MONO_TYPE_R8
) {
2513 MONO_EMIT_NEW_UNALU (cfg
, OP_FMOVE
, s390_f0
, val
->dreg
);
2515 } else if (ret
->type
== MONO_TYPE_I8
|| ret
->type
== MONO_TYPE_U8
) {
2516 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, s390_r3
, val
->dreg
+ 1);
2517 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, s390_r2
, val
->dreg
+ 2);
2522 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, cfg
->ret
->dreg
, val
->dreg
);
2525 /*========================= End of Function ========================*/
2527 /*------------------------------------------------------------------*/
2529 /* Name - emit_sig_cookie. */
2531 /* Function - For variable length parameter lists construct a */
2532 /* signature cookie and emit it. */
2534 /*------------------------------------------------------------------*/
2537 emit_sig_cookie (MonoCompile
*cfg
, MonoCallInst
*call
,
2538 CallInfo
*cinfo
, int argSize
)
2540 MonoCallArgParm
*arg
;
2541 MonoMethodSignature
*tmpSig
;
2544 cfg
->disable_aot
= TRUE
;
2546 /*----------------------------------------------------------*/
2547 /* mono_ArgIterator_Setup assumes the signature cookie is */
2548 /* passed first and all the arguments which were before it */
2549 /* passed on the stack after the signature. So compensate */
2550 /* by passing a different signature. */
2551 /*----------------------------------------------------------*/
2552 tmpSig
= mono_metadata_signature_dup (call
->signature
);
2553 tmpSig
->param_count
-= call
->signature
->sentinelpos
;
2554 tmpSig
->sentinelpos
= 0;
2555 if (tmpSig
->param_count
> 0)
2556 memcpy (tmpSig
->params
,
2557 call
->signature
->params
+ call
->signature
->sentinelpos
,
2558 tmpSig
->param_count
* sizeof(MonoType
*));
2560 MONO_INST_NEW (cfg
, sigArg
, OP_ICONST
);
2561 sigArg
->inst_p0
= tmpSig
;
2563 MONO_INST_NEW_CALL_ARG (cfg
, arg
, OP_OUTARG_MEMBASE
);
2564 arg
->ins
.inst_left
= sigArg
;
2565 arg
->ins
.inst_right
= (MonoInst
*) call
;
2566 arg
->size
= argSize
;
2567 arg
->offset
= cinfo
->sigCookie
.offset
;
2568 arg
->ins
.next
= call
->out_args
;
2569 call
->out_args
= (MonoInst
*) arg
;
2572 /*========================= End of Function ========================*/
2574 /*------------------------------------------------------------------*/
2576 /* Name - mono_arch_instrument_mem_needs */
2578 /* Function - Allow tracing to work with this interface (with */
2579 /* an optional argument). */
2581 /*------------------------------------------------------------------*/
2584 mono_arch_instrument_mem_needs (MonoMethod
*method
, int *stack
, int *code
)
2586 /* no stack room needed now (may be needed for FASTCALL-trace support) */
2588 /* split prolog-epilog requirements? */
2589 *code
= 50; /* max bytes needed: check this number */
2592 /*========================= End of Function ========================*/
2594 /*------------------------------------------------------------------*/
2596 /* Name - mono_arch_instrument_prolog */
2598 /* Function - Create an "instrumented" prolog. */
2600 /*------------------------------------------------------------------*/
2603 mono_arch_instrument_prolog (MonoCompile
*cfg
, void *func
, void *p
,
2604 gboolean enable_arguments
)
2611 parmOffset
= cfg
->stack_usage
- S390_TRACE_STACK_SIZE
;
2612 if (cfg
->method
->save_lmf
)
2613 parmOffset
-= sizeof(MonoLMF
);
2614 fpOffset
= parmOffset
+ (5*sizeof(gint32
));
2615 if (fpOffset
> 4096) {
2616 s390_lr (code
, s390_r12
, STK_BASE
);
2618 while (fpOffset
> 4096) {
2619 s390_ahi (code
, baseReg
, 4096);
2627 s390_stm (code
, s390_r2
, s390_r6
, baseReg
, parmOffset
);
2628 s390_std (code
, s390_f0
, 0, baseReg
, fpOffset
);
2629 s390_std (code
, s390_f1
, 0, baseReg
, fpOffset
+sizeof(gdouble
));
2630 s390_std (code
, s390_f2
, 0, baseReg
, fpOffset
+2*sizeof(gdouble
));
2631 s390_basr (code
, s390_r13
, 0);
2633 s390_word (code
, cfg
->method
);
2634 s390_word (code
, func
);
2635 s390_l (code
, s390_r2
, 0, s390_r13
, 4);
2636 s390_la (code
, s390_r3
, 0, baseReg
, parmOffset
);
2637 s390_lr (code
, s390_r4
, STK_BASE
);
2638 s390_ahi (code
, s390_r4
, cfg
->stack_usage
);
2639 s390_l (code
, s390_r1
, 0, s390_r13
, 8);
2640 s390_basr (code
, s390_r14
, s390_r1
);
2641 s390_ld (code
, s390_f2
, 0, baseReg
, fpOffset
+2*sizeof(gdouble
));
2642 s390_ld (code
, s390_f1
, 0, baseReg
, fpOffset
+sizeof(gdouble
));
2643 s390_ld (code
, s390_f0
, 0, baseReg
, fpOffset
);
2644 s390_lm (code
, s390_r2
, s390_r6
, baseReg
, parmOffset
);
2649 /*========================= End of Function ========================*/
2651 /*------------------------------------------------------------------*/
2653 /* Name - mono_arch_instrument_epilog */
2655 /* Function - Create an epilog that will handle the returned */
2656 /* values used in instrumentation. */
2658 /*------------------------------------------------------------------*/
2661 mono_arch_instrument_epilog (MonoCompile
*cfg
, void *func
, void *p
, gboolean enable_arguments
)
2664 int save_mode
= SAVE_NONE
,
2666 MonoMethod
*method
= cfg
->method
;
2667 int rtype
= mono_type_get_underlying_type (mono_method_signature (method
)->ret
)->type
;
2669 saveOffset
= cfg
->stack_usage
- S390_TRACE_STACK_SIZE
;
2670 if (method
->save_lmf
)
2671 saveOffset
-= sizeof(MonoLMF
);
2675 case MONO_TYPE_VOID
:
2676 /* special case string .ctor icall */
2677 if (strcmp (".ctor", method
->name
) && method
->klass
== mono_defaults
.string_class
)
2678 save_mode
= SAVE_ONE
;
2680 save_mode
= SAVE_NONE
;
2684 save_mode
= SAVE_TWO
;
2687 save_mode
= SAVE_R4
;
2690 save_mode
= SAVE_R8
;
2692 case MONO_TYPE_VALUETYPE
:
2693 if (mono_method_signature (method
)->ret
->data
.klass
->enumtype
) {
2694 rtype
= mono_method_signature (method
)->ret
->data
.klass
->enum_basetype
->type
;
2697 save_mode
= SAVE_STRUCT
;
2700 save_mode
= SAVE_ONE
;
2704 switch (save_mode
) {
2706 s390_stm (code
, s390_r2
, s390_r3
, cfg
->frame_reg
, saveOffset
);
2707 if (enable_arguments
) {
2708 s390_lr (code
, s390_r4
, s390_r3
);
2709 s390_lr (code
, s390_r3
, s390_r2
);
2713 s390_st (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2714 if (enable_arguments
) {
2715 s390_lr (code
, s390_r3
, s390_r2
);
2719 s390_std (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2720 if (enable_arguments
) {
2721 s390_ldebr (code
, s390_f0
, s390_f0
);
2725 s390_std (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2728 s390_st (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2729 if (enable_arguments
) {
2730 s390_l (code
, s390_r3
, 0, cfg
->frame_reg
,
2731 S390_MINIMAL_STACK_SIZE
+cfg
->param_area
);
2739 s390_basr (code
, s390_r13
, 0);
2741 s390_word (code
, cfg
->method
);
2742 s390_word (code
, func
);
2743 s390_l (code
, s390_r2
, 0, s390_r13
, 4);
2744 s390_l (code
, s390_r1
, 0, s390_r13
, 8);
2745 s390_basr (code
, s390_r14
, s390_r1
);
2747 switch (save_mode
) {
2749 s390_lm (code
, s390_r2
, s390_r3
, cfg
->frame_reg
, saveOffset
);
2752 s390_l (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2756 s390_ld (code
, s390_f0
, 0, cfg
->frame_reg
, saveOffset
);
2759 s390_l (code
, s390_r2
, 0, cfg
->frame_reg
, saveOffset
);
2769 /*========================= End of Function ========================*/
2772 mono_arch_peephole_pass_1 (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2776 /*------------------------------------------------------------------*/
2778 /* Name - mono_arch_peephole_pass */
2780 /* Function - Form a peephole pass at the code looking for */
2781 /* simple optimizations. */
2783 /*------------------------------------------------------------------*/
2786 mono_arch_peephole_pass_2 (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2790 MONO_BB_FOR_EACH_INS_SAFE (bb
, n
, ins
) {
2791 mono_peephole_ins (bb
, ins
);
2795 /*========================= End of Function ========================*/
2798 mono_arch_lowering_pass (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2800 MonoInst
*ins
, *next
;
2802 if (bb
->max_vreg
> cfg
->rs
->next_vreg
)
2803 cfg
->rs
->next_vreg
= bb
->max_vreg
;
2805 MONO_BB_FOR_EACH_INS_SAFE (bb
, next
, ins
) {
2806 switch (ins
->opcode
) {
2811 case OP_IDIV_UN_IMM
:
2812 case OP_IREM_UN_IMM
:
2813 case OP_LOCALLOC_IMM
:
2814 mono_decompose_op_imm (cfg
, bb
, ins
);
2822 /*========================= End of Function ========================*/
2824 /*------------------------------------------------------------------*/
2826 /* Name - emit_float_to_int */
2828 /* Function - Create instructions which will convert a floating */
2829 /* point value to integer. */
2831 /*------------------------------------------------------------------*/
2834 emit_float_to_int (MonoCompile
*cfg
, guchar
*code
, int dreg
, int sreg
, int size
, gboolean is_signed
)
2836 /* sreg is a float, dreg is an integer reg. */
2838 s390_cfdbr (code
, dreg
, 5, sreg
);
2841 s390_lhi (code
, s390_r0
, 0);
2842 s390_lhi (code
, s390_r13
, 0xff);
2843 s390_ltr (code
, dreg
, dreg
);
2845 s390_lhi (code
, s390_r0
, 0x80);
2846 s390_nr (code
, dreg
, s390_r13
);
2847 s390_or (code
, dreg
, s390_r0
);
2852 s390_basr (code
, s390_r13
, 0);
2854 s390_llong (code
, 0x41e0000000000000LL
);
2855 s390_llong (code
, 0x41f0000000000000LL
);
2856 s390_ldr (code
, s390_f15
, sreg
);
2857 s390_cdb (code
, s390_f15
, 0, s390_r13
, 4);
2858 s390_jl (code
, 0); CODEPTR(code
, o
[0]);
2859 s390_sdb (code
, s390_f15
, 0, s390_r13
, 12);
2860 s390_cfdbr (code
, dreg
, 7, s390_f15
);
2862 PTRSLOT(code
, o
[0]);
2863 s390_cfdbr (code
, dreg
, 5, sreg
);
2866 s390_lhi (code
, s390_r0
, 0xff);
2867 s390_nr (code
, dreg
, s390_r0
);
2870 s390_lhi (code
, s390_r0
, -1);
2871 s390_srl (code
, s390_r0
, 0, 16);
2872 s390_nr (code
, dreg
, s390_r0
);
2879 /*========================= End of Function ========================*/
2881 /*------------------------------------------------------------------*/
2883 /* Name - mono_arch_output_basic_block */
2885 /* Function - Perform the "real" work of emitting instructions */
2886 /* that will do the work of in the basic block. */
2888 /*------------------------------------------------------------------*/
2891 mono_arch_output_basic_block (MonoCompile
*cfg
, MonoBasicBlock
*bb
)
2896 guint8
*code
= cfg
->native_code
+ cfg
->code_len
;
2897 MonoInst
*last_ins
= NULL
;
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_lhi (code
, s390_r0
, ins
->inst_imm
);
2935 if (s390_is_uimm12(ins
->inst_offset
))
2936 s390_stc (code
, s390_r0
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
2938 s390_basr (code
, s390_r13
, 0);
2940 s390_word (code
, ins
->inst_offset
);
2941 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
2942 s390_stc (code
, s390_r0
, s390_r13
, ins
->inst_destbasereg
, 0);
2946 case OP_STOREI2_MEMBASE_IMM
: {
2947 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
2948 if (s390_is_uimm12(ins
->inst_offset
)) {
2949 s390_sth (code
, s390_r0
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
2951 s390_basr (code
, s390_r13
, 0);
2953 s390_word (code
, ins
->inst_offset
);
2954 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
2955 s390_sth (code
, s390_r0
, s390_r13
, ins
->inst_destbasereg
, 0);
2959 case OP_STORE_MEMBASE_IMM
:
2960 case OP_STOREI4_MEMBASE_IMM
: {
2961 if (s390_is_imm16(ins
->inst_imm
)) {
2962 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
2964 s390_basr (code
, s390_r13
, 0);
2966 s390_word (code
, ins
->inst_imm
);
2967 s390_l (code
, s390_r0
, 0, s390_r13
, 4);
2969 if (s390_is_uimm12(ins
->inst_offset
)) {
2970 s390_st (code
, s390_r0
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
2972 s390_basr (code
, s390_r13
, 0);
2974 s390_word (code
, ins
->inst_offset
);
2975 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
2976 s390_st (code
, s390_r0
, s390_r13
, ins
->inst_destbasereg
, 0);
2980 case OP_STOREI1_MEMBASE_REG
: {
2981 if (s390_is_uimm12(ins
->inst_offset
)) {
2982 s390_stc (code
, ins
->sreg1
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
2984 s390_basr (code
, s390_r13
, 0);
2986 s390_word (code
, ins
->inst_offset
);
2987 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
2988 s390_stc (code
, ins
->sreg1
, s390_r13
, ins
->inst_destbasereg
, 0);
2992 case OP_STOREI2_MEMBASE_REG
: {
2993 if (s390_is_uimm12(ins
->inst_offset
)) {
2994 s390_sth (code
, ins
->sreg1
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
2996 s390_basr (code
, s390_r13
, 0);
2998 s390_word (code
, ins
->inst_offset
);
2999 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3000 s390_sth (code
, ins
->sreg1
, s390_r13
, ins
->inst_destbasereg
, 0);
3004 case OP_STORE_MEMBASE_REG
:
3005 case OP_STOREI4_MEMBASE_REG
: {
3006 if (s390_is_uimm12(ins
->inst_offset
)) {
3007 s390_st (code
, ins
->sreg1
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
3009 s390_basr (code
, s390_r13
, 0);
3011 s390_word (code
, ins
->inst_offset
);
3012 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3013 s390_st (code
, ins
->sreg1
, s390_r13
, ins
->inst_destbasereg
, 0);
3018 g_assert_not_reached ();
3020 case OP_LOAD_MEMBASE
:
3021 case OP_LOADI4_MEMBASE
:
3022 case OP_LOADU4_MEMBASE
: {
3023 if (s390_is_uimm12(ins
->inst_offset
))
3024 s390_l (code
, ins
->dreg
, 0, ins
->inst_basereg
, ins
->inst_offset
);
3026 if (s390_is_imm16(ins
->inst_offset
)) {
3027 s390_lhi (code
, s390_r13
, ins
->inst_offset
);
3028 s390_l (code
, ins
->dreg
, s390_r13
, ins
->inst_basereg
, 0);
3030 s390_basr (code
, s390_r13
, 0);
3032 s390_word (code
, ins
->inst_offset
);
3033 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3034 s390_l (code
, ins
->dreg
, s390_r13
, ins
->inst_basereg
, 0);
3039 case OP_LOADU1_MEMBASE
: {
3040 s390_lhi (code
, s390_r0
, 0);
3041 if (s390_is_uimm12(ins
->inst_offset
))
3042 s390_ic (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
3044 s390_basr (code
, s390_r13
, 0);
3046 s390_word (code
, ins
->inst_offset
);
3047 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3048 s390_ic (code
, s390_r0
, s390_r13
, ins
->inst_basereg
, 0);
3050 s390_lr (code
, ins
->dreg
, s390_r0
);
3053 case OP_LOADI1_MEMBASE
: {
3054 s390_lhi (code
, s390_r0
, 0);
3055 if (s390_is_uimm12(ins
->inst_offset
))
3056 s390_ic (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
3058 s390_basr (code
, s390_r13
, 0);
3060 s390_word (code
, ins
->inst_offset
);
3061 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3062 s390_ic (code
, s390_r0
, s390_r13
, ins
->inst_basereg
, 0);
3064 s390_lhi (code
, s390_r13
, 0x80);
3065 s390_nr (code
, s390_r13
, s390_r0
);
3067 s390_lhi (code
, s390_r13
, 0xff00);
3068 s390_or (code
, s390_r0
, s390_r13
);
3069 s390_lr (code
, ins
->dreg
, s390_r0
);
3072 case OP_LOADU2_MEMBASE
: {
3073 s390_lhi (code
, s390_r0
, 0);
3074 if (s390_is_uimm12(ins
->inst_offset
))
3075 s390_icm (code
, s390_r0
, 3, ins
->inst_basereg
, ins
->inst_offset
);
3077 s390_basr (code
, s390_r13
, 0);
3079 s390_word (code
, ins
->inst_offset
);
3080 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3081 s390_ar (code
, s390_r13
, ins
->inst_basereg
);
3082 s390_icm (code
, s390_r0
, 3, s390_r13
, 0);
3084 s390_lr (code
, ins
->dreg
, s390_r0
);
3087 case OP_LOADI2_MEMBASE
: {
3088 s390_lhi (code
, s390_r0
, 0);
3089 if (s390_is_uimm12(ins
->inst_offset
))
3090 s390_lh (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
3092 s390_basr (code
, s390_r13
, 0);
3094 s390_word (code
, ins
->inst_offset
);
3095 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3096 s390_lh (code
, s390_r0
, s390_r13
, ins
->inst_basereg
, 0);
3098 s390_lr (code
, ins
->dreg
, s390_r0
);
3102 case OP_ICONV_TO_I1
: {
3103 if (ins
->dreg
!= ins
->sreg1
)
3104 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3105 s390_sll (code
, ins
->dreg
, 0, 24);
3106 s390_sra (code
, ins
->dreg
, 0, 24);
3109 case OP_ICONV_TO_I2
: {
3110 if (ins
->dreg
!= ins
->sreg1
)
3111 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3112 s390_sll (code
, ins
->dreg
, 0, 16);
3113 s390_sra (code
, ins
->dreg
, 0, 16);
3116 case OP_ICONV_TO_U1
: {
3117 s390_lhi (code
, s390_r0
, 0xff);
3118 if (ins
->dreg
!= ins
->sreg1
) {
3119 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3121 s390_nr (code
, ins
->dreg
, s390_r0
);
3124 case OP_ICONV_TO_U2
: {
3125 s390_lhi (code
, s390_r0
, -1);
3126 s390_sll (code
, s390_r0
, 0, 16);
3127 s390_srl (code
, s390_r0
, 0, 16);
3128 if (ins
->dreg
!= ins
->sreg1
) {
3129 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3131 s390_nr (code
, ins
->dreg
, s390_r0
);
3136 gboolean un
= FALSE
;
3137 MonoInst
*next
= ins
->next
;
3140 (((next
->opcode
>= OP_IBNE_UN
) &&
3141 (next
->opcode
<= OP_IBLT_UN
)) ||
3142 ((next
->opcode
>= OP_COND_EXC_NE_UN
) &&
3143 (next
->opcode
<= OP_COND_EXC_LT_UN
)) ||
3144 ((next
->opcode
>= OP_COND_EXC_INE_UN
) &&
3145 (next
->opcode
<= OP_COND_EXC_ILT_UN
)) ||
3146 ((next
->opcode
== OP_CLT_UN
) ||
3147 (next
->opcode
== OP_CGT_UN
)) ||
3148 ((next
->opcode
== OP_ICLT_UN
) ||
3149 (next
->opcode
== OP_ICGT_UN
))))
3153 s390_clr (code
, ins
->sreg1
, ins
->sreg2
);
3155 s390_cr (code
, ins
->sreg1
, ins
->sreg2
);
3158 case OP_COMPARE_IMM
:
3159 case OP_ICOMPARE_IMM
: {
3160 gboolean un
= FALSE
;
3161 MonoInst
*next
= ins
->next
;
3164 (((next
->opcode
>= OP_IBNE_UN
) &&
3165 (next
->opcode
<= OP_IBLT_UN
)) ||
3166 ((next
->opcode
>= OP_COND_EXC_NE_UN
) &&
3167 (next
->opcode
<= OP_COND_EXC_LT_UN
)) ||
3168 ((next
->opcode
>= OP_COND_EXC_INE_UN
) &&
3169 (next
->opcode
<= OP_COND_EXC_ILT_UN
)) ||
3170 ((next
->opcode
== OP_CLT_UN
) ||
3171 (next
->opcode
== OP_CGT_UN
)) ||
3172 ((next
->opcode
== OP_ICLT_UN
) ||
3173 (next
->opcode
== OP_ICGT_UN
))))
3176 if (s390_is_imm16 (ins
->inst_imm
)) {
3177 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3179 s390_clr (code
, ins
->sreg1
, s390_r0
);
3181 s390_cr (code
, ins
->sreg1
, s390_r0
);
3184 s390_basr (code
, s390_r13
, 0);
3186 s390_word (code
, ins
->inst_imm
);
3188 s390_cl (code
, ins
->sreg1
, 0, s390_r13
, 4);
3190 s390_c (code
, ins
->sreg1
, 0, s390_r13
, 4);
3195 mono_add_patch_info (cfg
, offset
, MONO_PATCH_INFO_ABS
, mono_break
);
3196 s390_brasl (code
, s390_r14
, 0);
3202 s390_alr (code
, ins
->dreg
, src2
);
3207 s390_ar (code
, ins
->dreg
, src2
);
3213 s390_alcr (code
, ins
->dreg
, src2
);
3218 if (ins
->dreg
!= ins
->sreg1
) {
3219 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3222 (ins
->next
->opcode
== OP_ADC_IMM
)) {
3223 s390_basr (code
, s390_r13
, 0);
3225 s390_word (code
, ins
->inst_imm
);
3226 s390_a (code
, ins
->dreg
, 0, s390_r13
, 4);
3228 if (s390_is_imm16 (ins
->inst_imm
)) {
3229 s390_ahi (code
, ins
->dreg
, ins
->inst_imm
);
3231 s390_basr (code
, s390_r13
, 0);
3233 s390_word (code
, ins
->inst_imm
);
3234 s390_a (code
, ins
->dreg
, 0, s390_r13
, 4);
3239 case OP_ADDCC_IMM
: {
3241 (ins
->next
->opcode
== OP_ADC_IMM
)) {
3242 s390_basr (code
, s390_r13
, 0);
3244 s390_word (code
, ins
->inst_imm
);
3245 if (ins
->dreg
!= ins
->sreg1
) {
3246 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3248 s390_al (code
, ins
->dreg
, 0, s390_r13
, 4);
3250 if (s390_is_imm16 (ins
->inst_imm
)) {
3251 if (ins
->dreg
!= ins
->sreg1
) {
3252 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3254 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3255 s390_alcr (code
, ins
->dreg
, s390_r0
);
3257 s390_basr (code
, s390_r13
, 0);
3259 s390_word (code
, ins
->inst_imm
);
3260 if (ins
->dreg
!= ins
->sreg1
) {
3261 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3263 s390_al (code
, ins
->dreg
, 0, s390_r13
, 4);
3269 if (s390_is_imm16 (ins
->inst_imm
)) {
3270 if (ins
->dreg
!= ins
->sreg1
) {
3271 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3273 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3274 s390_alcr (code
, ins
->dreg
, s390_r0
);
3276 s390_basr (code
, s390_r13
, 0);
3278 s390_word (code
, ins
->inst_imm
);
3279 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3280 s390_alcr (code
, ins
->dreg
, s390_r13
);
3285 case OP_S390_IADD_OVF
: {
3287 s390_ar (code
, ins
->dreg
, src2
);
3288 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3291 case OP_IADD_OVF_UN
:
3292 case OP_S390_IADD_OVF_UN
: {
3294 s390_alr (code
, ins
->dreg
, src2
);
3295 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3299 case OP_S390_LADD
: {
3300 s390_alr (code
, s390_r0
, ins
->sreg1
);
3302 s390_ahi (code
, s390_r1
, 1);
3303 s390_ar (code
, s390_r1
, ins
->sreg2
);
3304 s390_lr (code
, ins
->dreg
, s390_r0
);
3305 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3309 case OP_S390_LADD_OVF
: {
3311 s390_alr (code
, s390_r0
, ins
->sreg1
);
3312 s390_jnc (code
, 0); CODEPTR(code
, o
[0]);
3313 s390_ahi (code
, s390_r1
, 1);
3314 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3315 PTRSLOT (code
, o
[0]);
3316 s390_ar (code
, s390_r1
, ins
->sreg2
);
3317 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3318 s390_lr (code
, ins
->dreg
, s390_r0
);
3319 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3322 case OP_LADD_OVF_UN
:
3323 case OP_S390_LADD_OVF_UN
: {
3324 s390_alr (code
, s390_r0
, ins
->sreg1
);
3325 s390_alcr (code
, s390_r1
, ins
->sreg2
);
3326 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3327 s390_lr (code
, ins
->dreg
, s390_r0
);
3328 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3331 case OP_ADD_OVF_CARRY
: {
3333 s390_lhi (code
, s390_r0
, 0);
3334 s390_lr (code
, s390_r1
, s390_r0
);
3335 s390_alcr (code
, s390_r0
, s390_r1
);
3336 s390_ar (code
, ins
->dreg
, src2
);
3337 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3338 s390_ar (code
, ins
->dreg
, s390_r0
);
3339 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3342 case OP_ADD_OVF_UN_CARRY
: {
3344 s390_alcr (code
, ins
->dreg
, src2
);
3345 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, "OverflowException");
3351 s390_slr (code
, ins
->dreg
, src2
);
3356 s390_sr (code
, ins
->dreg
, src2
);
3362 s390_slbr (code
, ins
->dreg
, src2
);
3365 case OP_SUBCC_IMM
: {
3366 if (s390_is_imm16 (-ins
->inst_imm
)) {
3367 if (ins
->dreg
!= ins
->sreg1
) {
3368 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3370 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3371 s390_slr (code
, ins
->dreg
, s390_r0
);
3373 s390_basr (code
, s390_r13
, 0);
3375 s390_word (code
, ins
->inst_imm
);
3376 if (ins
->dreg
!= ins
->sreg1
) {
3377 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3379 s390_sl (code
, ins
->dreg
, 0, s390_r13
, 4);
3385 if (s390_is_imm16 (-ins
->inst_imm
)) {
3386 if (ins
->dreg
!= ins
->sreg1
) {
3387 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3389 s390_ahi (code
, ins
->dreg
, -ins
->inst_imm
);
3391 s390_basr (code
, s390_r13
, 0);
3393 s390_word (code
, ins
->inst_imm
);
3394 if (ins
->dreg
!= ins
->sreg1
) {
3395 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3397 s390_s (code
, ins
->dreg
, 0, s390_r13
, 4);
3402 if (ins
->dreg
!= ins
->sreg1
) {
3403 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3405 if (s390_is_imm16 (-ins
->inst_imm
)) {
3406 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3407 s390_slbr (code
, ins
->dreg
, s390_r0
);
3409 s390_basr (code
, s390_r13
, 0);
3411 s390_word (code
, ins
->inst_imm
);
3412 s390_slb (code
, ins
->dreg
, 0, s390_r13
, 4);
3417 case OP_S390_ISUB_OVF
: {
3419 s390_sr (code
, ins
->dreg
, src2
);
3420 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3423 case OP_ISUB_OVF_UN
:
3424 case OP_S390_ISUB_OVF_UN
: {
3426 s390_slr (code
, ins
->dreg
, src2
);
3427 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, "OverflowException");
3431 case OP_S390_LSUB
: {
3432 s390_lr (code
, s390_r14
, ins
->sreg2
);
3433 s390_slr (code
, s390_r0
, ins
->sreg1
);
3435 s390_ahi (code
, s390_r14
, 1);
3436 s390_sr (code
, s390_r1
, s390_r14
);
3437 s390_lr (code
, ins
->dreg
, s390_r0
);
3438 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3442 case OP_S390_LSUB_OVF
: {
3444 s390_lr (code
, s390_r14
, ins
->sreg2
);
3445 s390_slr (code
, s390_r0
, ins
->sreg1
);
3446 s390_jnl (code
, 0); CODEPTR(code
, o
[0]);
3447 s390_ahi (code
, s390_r14
, 1);
3448 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3449 PTRSLOT (code
, o
[0]);
3450 s390_sr (code
, s390_r1
, s390_r14
);
3451 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3452 s390_lr (code
, ins
->dreg
, s390_r0
);
3453 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3456 case OP_LSUB_OVF_UN
:
3457 case OP_S390_LSUB_OVF_UN
: {
3458 s390_slr (code
, s390_r0
, ins
->sreg1
);
3459 s390_slbr (code
, s390_r1
, ins
->sreg2
);
3460 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT
, "OverflowException");
3461 s390_lr (code
, ins
->dreg
, s390_r0
);
3462 s390_lr (code
, ins
->dreg
+1, s390_r1
);
3465 case OP_SUB_OVF_CARRY
: {
3467 s390_lhi (code
, s390_r0
, 0);
3468 s390_lr (code
, s390_r1
, s390_r0
);
3469 s390_slbr (code
, s390_r0
, s390_r1
);
3470 s390_sr (code
, ins
->dreg
, src2
);
3471 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3472 s390_ar (code
, ins
->dreg
, s390_r0
);
3473 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, "OverflowException");
3476 case OP_SUB_OVF_UN_CARRY
: {
3478 s390_slbr (code
, ins
->dreg
, src2
);
3479 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, "OverflowException");
3483 if (ins
->sreg1
== ins
->dreg
) {
3484 s390_nr (code
, ins
->dreg
, ins
->sreg2
);
3487 if (ins
->sreg2
== ins
->dreg
) {
3488 s390_nr (code
, ins
->dreg
, ins
->sreg1
);
3491 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3492 s390_nr (code
, ins
->dreg
, ins
->sreg2
);
3499 if (s390_is_imm16 (ins
->inst_imm
)) {
3500 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3501 if (ins
->dreg
!= ins
->sreg1
) {
3502 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3504 s390_nr (code
, ins
->dreg
, s390_r0
);
3506 s390_basr (code
, s390_r13
, 0);
3508 s390_word (code
, ins
->inst_imm
);
3509 if (ins
->dreg
!= ins
->sreg1
) {
3510 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3512 s390_n (code
, ins
->dreg
, 0, s390_r13
, 4);
3517 s390_lr (code
, s390_r0
, ins
->sreg1
);
3518 s390_srda (code
, s390_r0
, 0, 32);
3519 s390_dr (code
, s390_r0
, ins
->sreg2
);
3520 s390_lr (code
, ins
->dreg
, s390_r1
);
3524 s390_lr (code
, s390_r0
, ins
->sreg1
);
3525 s390_srdl (code
, s390_r0
, 0, 32);
3526 s390_dlr (code
, s390_r0
, ins
->sreg2
);
3527 s390_lr (code
, ins
->dreg
, s390_r1
);
3531 s390_lr (code
, s390_r0
, ins
->sreg1
);
3532 s390_srda (code
, s390_r0
, 0, 32);
3533 s390_dr (code
, s390_r0
, ins
->sreg2
);
3534 s390_lr (code
, ins
->dreg
, s390_r0
);
3537 s390_lr (code
, s390_r0
, ins
->sreg1
);
3538 s390_srdl (code
, s390_r0
, 0, 32);
3539 s390_dlr (code
, s390_r0
, ins
->sreg2
);
3540 s390_lr (code
, ins
->dreg
, s390_r0
);
3544 if (ins
->sreg1
== ins
->dreg
) {
3545 s390_or (code
, ins
->dreg
, ins
->sreg2
);
3548 if (ins
->sreg2
== ins
->dreg
) {
3549 s390_or (code
, ins
->dreg
, ins
->sreg1
);
3552 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3553 s390_or (code
, ins
->dreg
, ins
->sreg2
);
3560 if (s390_is_imm16 (ins
->inst_imm
)) {
3561 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3562 if (ins
->dreg
!= ins
->sreg1
) {
3563 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3565 s390_or (code
, ins
->dreg
, s390_r0
);
3567 s390_basr (code
, s390_r13
, 0);
3569 s390_word (code
, ins
->inst_imm
);
3570 if (ins
->dreg
!= ins
->sreg1
) {
3571 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3573 s390_o (code
, ins
->dreg
, 0, s390_r13
, 4);
3578 if (ins
->sreg1
== ins
->dreg
) {
3579 s390_xr (code
, ins
->dreg
, ins
->sreg2
);
3582 if (ins
->sreg2
== ins
->dreg
) {
3583 s390_xr (code
, ins
->dreg
, ins
->sreg1
);
3586 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3587 s390_xr (code
, ins
->dreg
, ins
->sreg2
);
3594 if (s390_is_imm16 (ins
->inst_imm
)) {
3595 s390_lhi (code
, s390_r0
, ins
->inst_imm
);
3596 if (ins
->dreg
!= ins
->sreg1
) {
3597 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3599 s390_xr (code
, ins
->dreg
, s390_r0
);
3601 s390_basr (code
, s390_r13
, 0);
3603 s390_word (code
, ins
->inst_imm
);
3604 if (ins
->dreg
!= ins
->sreg1
) {
3605 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3607 s390_x (code
, ins
->dreg
, 0, s390_r13
, 4);
3613 s390_sll (code
, ins
->dreg
, src2
, 0);
3618 if (ins
->sreg1
!= ins
->dreg
) {
3619 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3621 s390_sll (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3626 s390_sra (code
, ins
->dreg
, src2
, 0);
3631 if (ins
->sreg1
!= ins
->dreg
) {
3632 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3634 s390_sra (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3638 case OP_ISHR_UN_IMM
: {
3639 if (ins
->sreg1
!= ins
->dreg
) {
3640 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3642 s390_srl (code
, ins
->dreg
, 0, (ins
->inst_imm
& 0x1f));
3647 s390_srl (code
, ins
->dreg
, src2
, 0);
3651 if (ins
->sreg1
!= ins
->dreg
) {
3652 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3654 s390_lhi (code
, s390_r0
, -1);
3655 s390_xr (code
, ins
->dreg
, s390_r0
);
3659 s390_lcr (code
, ins
->dreg
, ins
->sreg1
);
3662 case OP_S390_LNEG
: {
3664 g_assert (ins
->dreg
+ 1 != ins
->sreg1
);
3665 s390_lcr (code
, ins
->dreg
+ 1, ins
->sreg2
);
3666 s390_lcr (code
, ins
->dreg
, ins
->sreg1
);
3668 s390_bctr (code
, ins
->dreg
+ 1, 0);
3672 if (ins
->sreg1
== ins
->dreg
) {
3673 s390_msr (code
, ins
->dreg
, ins
->sreg2
);
3676 if (ins
->sreg2
== ins
->dreg
) {
3677 s390_msr (code
, ins
->dreg
, ins
->sreg1
);
3680 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3681 s390_msr (code
, ins
->dreg
, ins
->sreg2
);
3688 if (s390_is_imm16 (ins
->inst_imm
)) {
3689 s390_lhi (code
, s390_r13
, ins
->inst_imm
);
3691 s390_basr (code
, s390_r13
, 0);
3693 s390_word (code
, ins
->inst_imm
);
3694 // if (ins->dreg != ins->sreg1) {
3695 // s390_lr (code, ins->dreg, ins->sreg1);
3697 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3699 if (ins
->dreg
!= ins
->sreg1
) {
3700 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3702 s390_msr (code
, ins
->dreg
, s390_r13
);
3707 s390_ltr (code
, s390_r1
, ins
->sreg1
);
3708 s390_jz (code
, 0); CODEPTR(code
, o
[0]);
3709 s390_ltr (code
, s390_r0
, ins
->sreg2
);
3711 s390_lhi (code
, s390_r1
, 0);
3712 s390_j (code
, 0); CODEPTR(code
, o
[1]);
3713 s390_xr (code
, s390_r0
, s390_r1
);
3714 s390_msr (code
, s390_r1
, ins
->sreg2
);
3715 s390_xr (code
, s390_r0
, s390_r1
);
3716 s390_srl (code
, s390_r0
, 0, 31);
3717 s390_ltr (code
, s390_r0
, s390_r0
);
3718 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3719 PTRSLOT (code
, o
[0]);
3720 PTRSLOT (code
, o
[1]);
3721 s390_lr (code
, ins
->dreg
, s390_r1
);
3724 case OP_IMUL_OVF_UN
: {
3725 s390_lhi (code
, s390_r0
, 0);
3726 s390_lr (code
, s390_r1
, ins
->sreg1
);
3727 s390_mlr (code
, s390_r0
, ins
->sreg2
);
3728 s390_ltr (code
, s390_r0
, s390_r0
);
3729 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NZ
, "OverflowException");
3730 s390_lr (code
, ins
->dreg
, s390_r1
);
3734 s390_l (code
, s390_r0
, 0, ins
->sreg1
, 4);
3735 s390_srda (code
, s390_r0
, 0, 32);
3736 s390_m (code
, s390_r0
, 0, ins
->sreg2
, 4);
3737 s390_l (code
, s390_r0
, 0, ins
->sreg1
, 4);
3738 s390_srl (code
, s390_r0
, 0, 31);
3739 s390_a (code
, s390_r0
, 0, ins
->sreg1
, 0);
3740 s390_l (code
, s390_r13
, 0, ins
->sreg2
, 0);
3741 s390_srl (code
, s390_r13
, 0, 31);
3742 s390_ms (code
, s390_r13
, 0, ins
->sreg1
, 4);
3743 s390_ar (code
, s390_r0
, s390_r13
);
3744 s390_st (code
, s390_r0
, 0, ins
->dreg
, 0);
3745 s390_st (code
, s390_r1
, 0, ins
->dreg
, 4);
3749 if (s390_is_imm16(ins
->inst_c0
)) {
3750 s390_lhi (code
, ins
->dreg
, ins
->inst_c0
);
3752 s390_basr (code
, s390_r13
, 0);
3754 s390_word (code
, ins
->inst_c0
);
3755 s390_l (code
, ins
->dreg
, 0, s390_r13
, 4);
3760 s390_basr (code
, s390_r13
, 0);
3762 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3763 (MonoJumpInfoType
)ins
->inst_i1
, ins
->inst_p0
);
3764 s390_word (code
, 0);
3765 s390_l (code
,ins
->dreg
, 0, s390_r13
, 4);
3768 case OP_JUMP_TABLE
: {
3769 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3770 (MonoJumpInfoType
)ins
->inst_i1
, ins
->inst_p0
);
3771 s390_basr (code
, s390_r13
, 0);
3773 s390_word (code
, 0);
3774 s390_l (code
, ins
->dreg
, 0, s390_r13
, 4);
3777 case OP_ICONV_TO_I4
:
3778 case OP_ICONV_TO_U4
:
3780 if (ins
->dreg
!= ins
->sreg1
) {
3781 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
3786 int saved
= ins
->sreg1
;
3787 if (ins
->sreg1
== s390_r2
) {
3788 s390_lr (code
, s390_r0
, ins
->sreg1
);
3791 if (ins
->sreg2
!= s390_r2
)
3792 s390_lr (code
, s390_r2
, ins
->sreg2
);
3793 if (saved
!= s390_r3
)
3794 s390_lr (code
, s390_r3
, saved
);
3798 if (ins
->dreg
!= ins
->sreg1
) {
3799 s390_ldr (code
, ins
->dreg
, ins
->sreg1
);
3803 case OP_S390_SETF4RET
: {
3804 s390_ledbr (code
, ins
->dreg
, ins
->sreg1
);
3808 if (s390_is_imm16 (ins
->inst_offset
)) {
3809 s390_lhi (code
, s390_r13
, ins
->inst_offset
);
3811 s390_bras (code
, s390_r13
, 0);
3813 s390_word (code
, ins
->inst_offset
);
3814 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3816 s390_ear (code
, s390_r1
, 0);
3817 s390_l (code
, ins
->dreg
, s390_r13
, s390_r1
, 0);
3820 case OP_FCONV_TO_R4
: {
3822 if (ins
->dreg
!= ins
->sreg1
) {
3823 s390_ldr (code
, ins
->dreg
, ins
->sreg1
);
3828 (ins->next->opcode != OP_FMOVE) &&
3829 (ins->next->opcode != OP_STORER4_MEMBASE_REG))
3830 s390_ledbr (code, ins->dreg, ins->sreg1);
3835 if (cfg
->method
->save_lmf
)
3836 restoreLMF(code
, cfg
->frame_reg
, cfg
->stack_usage
);
3838 if (cfg
->flags
& MONO_CFG_HAS_TAIL
) {
3839 code
= emit_load_volatile_registers(code
, cfg
);
3842 code
= backUpStackPtr(cfg
, code
, STK_BASE
);
3843 s390_l (code
, s390_r14
, 0, STK_BASE
, S390_RET_ADDR_OFFSET
);
3844 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
3845 MONO_PATCH_INFO_METHOD_JUMP
,
3847 s390_jcl (code
, S390_CC_UN
, 0);
3850 case OP_CHECK_THIS
: {
3851 /* ensure ins->sreg1 is not NULL */
3852 s390_icm (code
, s390_r0
, 15, ins
->sreg1
, 0);
3856 int offset
= cfg
->sig_cookie
+ cfg
->stack_usage
;
3858 if (s390_is_imm16 (offset
))
3859 s390_lhi (code
, s390_r0
, offset
);
3861 s390_basr (code
, s390_r13
, 0);
3863 s390_word (code
, offset
);
3864 s390_l (code
, s390_r0
, 0, s390_r13
, 0);
3866 s390_ar (code
, s390_r0
, cfg
->frame_reg
);
3867 s390_st (code
, s390_r0
, 0, ins
->sreg1
, 0);
3871 call
= (MonoCallInst
*)ins
;
3872 if (ins
->flags
& MONO_INST_HAS_METHOD
)
3873 mono_add_patch_info (cfg
, offset
, MONO_PATCH_INFO_METHOD
,
3876 mono_add_patch_info (cfg
, offset
, MONO_PATCH_INFO_ABS
,
3878 s390_brasl (code
, s390_r14
, 0);
3879 if (call
->signature
->ret
->type
== MONO_TYPE_R4
)
3880 s390_ldebr (code
, s390_f0
, s390_f0
);
3888 call
= (MonoCallInst
*)ins
;
3889 if (ins
->flags
& MONO_INST_HAS_METHOD
)
3890 mono_add_patch_info (cfg
, offset
, MONO_PATCH_INFO_METHOD
, call
->method
);
3892 mono_add_patch_info (cfg
, offset
, MONO_PATCH_INFO_ABS
, call
->fptr
);
3893 s390_brasl (code
, s390_r14
, 0);
3896 case OP_FCALL_REG
: {
3897 call
= (MonoCallInst
*)ins
;
3898 s390_lr (code
, s390_r1
, ins
->sreg1
);
3899 s390_basr (code
, s390_r14
, s390_r1
);
3900 if (call
->signature
->ret
->type
== MONO_TYPE_R4
)
3901 s390_ldebr (code
, s390_f0
, s390_f0
);
3907 case OP_VOIDCALL_REG
:
3909 s390_lr (code
, s390_r1
, ins
->sreg1
);
3910 s390_basr (code
, s390_r14
, s390_r1
);
3913 case OP_LCALL_MEMBASE
:
3914 case OP_VCALL_MEMBASE
:
3915 case OP_VCALL2_MEMBASE
:
3916 case OP_VOIDCALL_MEMBASE
:
3917 case OP_FCALL_MEMBASE
:
3918 case OP_CALL_MEMBASE
: {
3919 call
= (MonoCallInst
*)ins
;
3920 if (s390_is_uimm12(ins
->inst_offset
))
3921 s390_l (code
, s390_r1
, 0, ins
->inst_basereg
, ins
->inst_offset
);
3923 if (s390_is_imm16(ins
->inst_offset
)) {
3924 s390_lhi (code
, s390_r13
, ins
->inst_offset
);
3925 s390_l (code
, s390_r1
, s390_r13
, ins
->inst_basereg
, 0);
3927 s390_basr (code
, s390_r13
, 0);
3929 s390_word (code
, ins
->inst_offset
);
3930 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
3931 s390_l (code
, s390_r1
, s390_r13
, ins
->inst_basereg
, 0);
3934 s390_basr (code
, s390_r14
, s390_r1
);
3935 if (ins
->opcode
== OP_FCALL_MEMBASE
&& call
->signature
->ret
->type
== MONO_TYPE_R4
)
3936 s390_ldebr (code
, s390_f0
, s390_f0
);
3940 g_assert_not_reached ();
3943 /*------------------------------------------*/
3944 /* To allocate space on the stack we have */
3945 /* to allow room for parameters passed in */
3946 /* calls, the backchain pointer and round */
3947 /* it to our stack alignment requirements */
3948 /*------------------------------------------*/
3949 int alloca_skip
= S390_MINIMAL_STACK_SIZE
+ cfg
->param_area
;
3950 int area_offset
= S390_ALIGN(alloca_skip
, S390_STACK_ALIGNMENT
);
3951 s390_lr (code
, s390_r1
, ins
->sreg1
);
3952 if (ins
->flags
& MONO_INST_INIT
)
3953 s390_lr (code
, s390_r0
, ins
->sreg1
);
3954 s390_ahi (code
, s390_r1
, 14);
3955 s390_srl (code
, s390_r1
, 0, 3);
3956 s390_sll (code
, s390_r1
, 0, 3);
3957 if (cfg
->method
->save_lmf
) {
3958 /*----------------------------------*/
3959 /* we have to adjust lmf ebp value */
3960 /*----------------------------------*/
3961 int lmfOffset
= cfg
->stack_usage
- sizeof(MonoLMF
);
3963 s390_lr (code
, s390_r13
, cfg
->frame_reg
);
3964 if (s390_is_uimm16(lmfOffset
))
3965 s390_ahi (code
, s390_r13
, lmfOffset
);
3967 s390_basr (code
, s390_r14
, 0);
3969 s390_word (code
, lmfOffset
);
3970 s390_a (code
, s390_r13
, 0, s390_r14
, 4);
3972 s390_lr (code
, s390_r14
, STK_BASE
);
3973 s390_sr (code
, s390_r14
, s390_r1
);
3974 s390_st (code
, s390_r14
, 0, s390_r13
,
3975 G_STRUCT_OFFSET(MonoLMF
, ebp
));
3977 s390_l (code
, s390_r13
, 0, STK_BASE
, 0);
3978 s390_sr (code
, STK_BASE
, s390_r1
);
3979 s390_st (code
, s390_r13
, 0, STK_BASE
, 0);
3980 s390_la (code
, ins
->dreg
, 0, STK_BASE
, area_offset
);
3981 s390_srl (code
, ins
->dreg
, 0, 3);
3982 s390_sll (code
, ins
->dreg
, 0, 3);
3983 if (ins
->flags
& MONO_INST_INIT
) {
3984 s390_lr (code
, s390_r1
, s390_r0
);
3985 s390_lr (code
, s390_r0
, ins
->dreg
);
3986 s390_lr (code
, s390_r14
, s390_r12
);
3987 s390_lhi (code
, s390_r13
, 0);
3988 s390_mvcle(code
, s390_r0
, s390_r12
, 0, 0);
3990 s390_lr (code
, s390_r12
, s390_r14
);
3995 s390_lr (code
, s390_r2
, ins
->sreg1
);
3996 mono_add_patch_info (cfg
, code
-cfg
->native_code
, MONO_PATCH_INFO_INTERNAL_METHOD
,
3997 (gpointer
)"mono_arch_throw_exception");
3998 s390_brasl (code
, s390_r14
, 0);
4002 s390_lr (code
, s390_r2
, ins
->sreg1
);
4003 mono_add_patch_info (cfg
, code
-cfg
->native_code
, MONO_PATCH_INFO_INTERNAL_METHOD
,
4004 (gpointer
)"mono_arch_rethrow_exception");
4005 s390_brasl (code
, s390_r14
, 0);
4008 case OP_START_HANDLER
: {
4009 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4010 if (s390_is_uimm12 (spvar
->inst_offset
)) {
4011 s390_st (code
, s390_r14
, 0,
4012 spvar
->inst_basereg
,
4013 spvar
->inst_offset
);
4015 s390_basr (code
, s390_r13
, 0);
4017 s390_word (code
, spvar
->inst_offset
);
4018 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4019 s390_st (code
, s390_r14
, s390_r13
,
4020 spvar
->inst_basereg
, 0);
4024 case OP_ENDFILTER
: {
4025 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4026 if (ins
->sreg1
!= s390_r2
)
4027 s390_lr (code
, s390_r2
, ins
->sreg1
);
4028 if (s390_is_uimm12 (spvar
->inst_offset
)) {
4029 s390_l (code
, s390_r14
, 0, spvar
->inst_basereg
,
4030 spvar
->inst_offset
);
4032 s390_basr (code
, s390_r13
, 0);
4034 s390_word (code
, spvar
->inst_offset
);
4035 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4036 s390_l (code
, s390_r14
, s390_r13
,
4037 spvar
->inst_basereg
, 0);
4039 s390_br (code
, s390_r14
);
4042 case OP_ENDFINALLY
: {
4043 MonoInst
*spvar
= mono_find_spvar_for_region (cfg
, bb
->region
);
4044 if (s390_is_uimm12 (spvar
->inst_offset
)) {
4045 s390_l (code
, s390_r14
, 0, spvar
->inst_basereg
,
4046 spvar
->inst_offset
);
4048 s390_basr (code
, s390_r13
, 0);
4050 s390_word (code
, spvar
->inst_offset
);
4051 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4052 s390_l (code
, s390_r14
, s390_r13
,
4053 spvar
->inst_basereg
, 0);
4055 s390_br (code
, s390_r14
);
4058 case OP_CALL_HANDLER
: {
4059 mono_add_patch_info (cfg
, code
-cfg
->native_code
,
4060 MONO_PATCH_INFO_BB
, ins
->inst_target_bb
);
4061 s390_brasl (code
, s390_r14
, 0);
4065 ins
->inst_c0
= code
- cfg
->native_code
;
4068 case OP_RELAXED_NOP
:
4071 case OP_DUMMY_STORE
:
4072 case OP_NOT_REACHED
:
4077 EMIT_UNCOND_BRANCH(ins
);
4080 s390_br (code
, ins
->sreg1
);
4085 s390_lhi (code
, ins
->dreg
, 1);
4087 s390_lhi (code
, ins
->dreg
, 0);
4092 s390_lhi (code
, ins
->dreg
, 1);
4094 s390_lhi (code
, ins
->dreg
, 0);
4099 s390_lhi (code
, ins
->dreg
, 1);
4101 s390_lhi (code
, ins
->dreg
, 0);
4106 s390_lhi (code
, ins
->dreg
, 1);
4108 s390_lhi (code
, ins
->dreg
, 0);
4113 s390_lhi (code
, ins
->dreg
, 1);
4115 s390_lhi (code
, ins
->dreg
, 0);
4118 case OP_COND_EXC_EQ
:
4119 case OP_COND_EXC_IEQ
:
4120 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_EQ
, ins
->inst_p1
);
4122 case OP_COND_EXC_NE_UN
:
4123 case OP_COND_EXC_INE_UN
:
4124 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NE
, ins
->inst_p1
);
4126 case OP_COND_EXC_LT
:
4127 case OP_COND_EXC_ILT
:
4128 case OP_COND_EXC_LT_UN
:
4129 case OP_COND_EXC_ILT_UN
:
4130 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LT
, ins
->inst_p1
);
4132 case OP_COND_EXC_GT
:
4133 case OP_COND_EXC_IGT
:
4134 case OP_COND_EXC_GT_UN
:
4135 case OP_COND_EXC_IGT_UN
:
4136 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GT
, ins
->inst_p1
);
4138 case OP_COND_EXC_GE
:
4139 case OP_COND_EXC_IGE
:
4140 case OP_COND_EXC_GE_UN
:
4141 case OP_COND_EXC_IGE_UN
:
4142 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_GE
, ins
->inst_p1
);
4144 case OP_COND_EXC_LE
:
4145 case OP_COND_EXC_ILE
:
4146 case OP_COND_EXC_LE_UN
:
4147 case OP_COND_EXC_ILE_UN
:
4148 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_LE
, ins
->inst_p1
);
4150 case OP_COND_EXC_OV
:
4151 case OP_COND_EXC_IOV
:
4152 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV
, ins
->inst_p1
);
4154 case OP_COND_EXC_NO
:
4155 case OP_COND_EXC_INO
:
4156 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NO
, ins
->inst_p1
);
4159 case OP_COND_EXC_IC
:
4160 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_CY
, ins
->inst_p1
);
4162 case OP_COND_EXC_NC
:
4163 case OP_COND_EXC_INC
:
4164 EMIT_COND_SYSTEM_EXCEPTION (S390_CC_NC
, ins
->inst_p1
);
4167 EMIT_COND_BRANCH (ins
, S390_CC_EQ
);
4170 EMIT_COND_BRANCH (ins
, S390_CC_NE
);
4174 EMIT_COND_BRANCH (ins
, S390_CC_LT
);
4178 EMIT_COND_BRANCH (ins
, S390_CC_GT
);
4182 EMIT_COND_BRANCH (ins
, S390_CC_GE
);
4186 EMIT_COND_BRANCH (ins
, S390_CC_LE
);
4189 /* floating point opcodes */
4191 if (*((float *) ins
->inst_p0
) == 0) {
4192 s390_lzdr (code
, ins
->dreg
);
4194 s390_basr (code
, s390_r13
, 0);
4196 s390_word (code
, ins
->inst_p0
);
4197 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4198 s390_ld (code
, ins
->dreg
, 0, s390_r13
, 0);
4203 if (*((float *) ins
->inst_p0
) == 0) {
4204 s390_lzdr (code
, ins
->dreg
);
4206 s390_basr (code
, s390_r13
, 0);
4208 s390_word (code
, ins
->inst_p0
);
4209 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4210 s390_ldeb (code
, ins
->dreg
, 0, s390_r13
, 0);
4214 case OP_STORER8_MEMBASE_REG
: {
4215 if (s390_is_uimm12(ins
->inst_offset
)) {
4216 s390_std (code
, ins
->sreg1
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
4218 s390_basr (code
, s390_r13
, 0);
4220 s390_word (code
, ins
->inst_offset
);
4221 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4222 s390_std (code
, ins
->sreg1
, s390_r13
, ins
->inst_destbasereg
, 0);
4226 case OP_LOADR8_MEMBASE
: {
4227 if (s390_is_uimm12(ins
->inst_offset
)) {
4228 s390_ld (code
, ins
->dreg
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4230 s390_basr (code
, s390_r13
, 0);
4232 s390_word (code
, ins
->inst_offset
);
4233 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4234 s390_ld (code
, ins
->dreg
, s390_r13
, ins
->inst_basereg
, 0);
4238 case OP_STORER4_MEMBASE_REG
: {
4239 if (s390_is_uimm12(ins
->inst_offset
)) {
4240 s390_ledbr(code
, s390_f15
, ins
->sreg1
);
4241 s390_ste (code
, s390_f15
, 0, ins
->inst_destbasereg
, ins
->inst_offset
);
4243 s390_basr (code
, s390_r13
, 0);
4245 s390_word (code
, ins
->inst_offset
);
4246 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4247 s390_ledbr(code
, s390_f15
, ins
->sreg1
);
4248 s390_ste (code
, s390_f15
, s390_r13
, ins
->inst_destbasereg
, 0);
4252 case OP_LOADR4_MEMBASE
: {
4253 if (s390_is_uimm12(ins
->inst_offset
)) {
4254 s390_ldeb (code
, ins
->dreg
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4256 s390_basr (code
, s390_r13
, 0);
4258 s390_word (code
, ins
->inst_offset
);
4259 s390_l (code
, s390_r13
, 0, s390_r13
, 4);
4260 s390_ldeb (code
, ins
->dreg
, s390_r13
, ins
->inst_basereg
, 0);
4264 case OP_ICONV_TO_R_UN
: {
4265 s390_cdfbr (code
, ins
->dreg
, ins
->sreg1
);
4266 s390_ltr (code
, ins
->sreg1
, ins
->sreg1
);
4267 s390_jnl (code
, 12);
4268 s390_basr (code
, s390_r13
, 0);
4270 s390_word (code
, 0x41f00000);
4271 s390_word (code
, 0);
4272 s390_adb (code
, ins
->dreg
, 0, s390_r13
, 4);
4275 case OP_ICONV_TO_R4
: {
4276 s390_cdfbr (code
, ins
->dreg
, ins
->sreg1
);
4279 case OP_ICONV_TO_R8
: {
4280 s390_cdfbr (code
, ins
->dreg
, ins
->sreg1
);
4283 case OP_FCONV_TO_I1
:
4284 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 1, TRUE
);
4286 case OP_FCONV_TO_U1
:
4287 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 1, FALSE
);
4289 case OP_FCONV_TO_I2
:
4290 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 2, TRUE
);
4292 case OP_FCONV_TO_U2
:
4293 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 2, FALSE
);
4295 case OP_FCONV_TO_I4
:
4297 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 4, TRUE
);
4299 case OP_FCONV_TO_U4
:
4301 code
= emit_float_to_int (cfg
, code
, ins
->dreg
, ins
->sreg1
, 4, FALSE
);
4303 case OP_FCONV_TO_I8
:
4304 case OP_FCONV_TO_U8
:
4305 g_assert_not_reached ();
4306 /* Implemented as helper calls */
4308 case OP_LCONV_TO_R_UN
:
4309 g_assert_not_reached ();
4310 /* Implemented as helper calls */
4312 case OP_LCONV_TO_OVF_I
:
4313 case OP_LCONV_TO_OVF_I4_2
: {
4314 /* Valid ints: 0xffffffff:8000000 to 00000000:0x7f000000 */
4316 s390_ltr (code
, ins
->sreg1
, ins
->sreg1
);
4317 s390_jnl (code
, 0); CODEPTR(code
, o
[0]);
4318 s390_ltr (code
, ins
->sreg2
, ins
->sreg2
);
4319 s390_jnl (code
, 0); CODEPTR(code
, o
[1]);
4320 s390_lhi (code
, s390_r13
, -1);
4321 s390_cr (code
, ins
->sreg2
, s390_r13
);
4322 s390_jnz (code
, 0); CODEPTR(code
, o
[2]);
4323 s390_j (code
, 0); CODEPTR(code
, o
[3]);
4324 PTRSLOT(code
, o
[0]);
4325 s390_ltr (code
, ins
->sreg2
, ins
->sreg2
);
4326 s390_jz (code
, 0); CODEPTR(code
, o
[4]);
4327 PTRSLOT(code
, o
[1]);
4328 PTRSLOT(code
, o
[2]);
4329 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
4330 MONO_PATCH_INFO_EXC
, "OverflowException");
4331 s390_brasl (code
, s390_r14
, 0);
4332 PTRSLOT(code
, o
[3]);
4333 PTRSLOT(code
, o
[4]);
4334 if (ins
->dreg
!= ins
->sreg1
)
4335 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
4339 s390_sqdbr (code
, ins
->dreg
, ins
->sreg1
);
4344 s390_adbr (code
, ins
->dreg
, src2
);
4348 CHECK_SRCDST_NCOM_F
;
4349 s390_sdbr (code
, ins
->dreg
, src2
);
4354 s390_mdbr (code
, ins
->dreg
, src2
);
4358 CHECK_SRCDST_NCOM_F
;
4359 s390_ddbr (code
, ins
->dreg
, src2
);
4363 s390_lcdbr (code
, ins
->dreg
, ins
->sreg1
);
4367 CHECK_SRCDST_NCOM_F
;
4368 s390_didbr (code
, ins
->dreg
, src2
, 5, s390_f15
);
4372 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4376 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4377 s390_lhi (code
, ins
->dreg
, 1);
4379 s390_lhi (code
, ins
->dreg
, 0);
4383 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4384 s390_lhi (code
, ins
->dreg
, 1);
4386 s390_lhi (code
, ins
->dreg
, 0);
4390 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4391 s390_lhi (code
, ins
->dreg
, 1);
4393 s390_lhi (code
, ins
->dreg
, 0);
4397 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4398 s390_lhi (code
, ins
->dreg
, 1);
4400 s390_lhi (code
, ins
->dreg
, 0);
4404 s390_cdbr (code
, ins
->sreg1
, ins
->sreg2
);
4405 s390_lhi (code
, ins
->dreg
, 1);
4407 s390_lhi (code
, ins
->dreg
, 0);
4412 s390_jo (code
, 0); CODEPTR(code
, o
);
4413 EMIT_COND_BRANCH (ins
, S390_CC_EQ
);
4418 EMIT_COND_BRANCH (ins
, S390_CC_NE
|S390_CC_OV
);
4422 s390_jo (code
, 0); CODEPTR(code
, o
);
4423 EMIT_COND_BRANCH (ins
, S390_CC_LT
);
4428 EMIT_COND_BRANCH (ins
, S390_CC_LT
|S390_CC_OV
);
4432 s390_jo (code
, 0); CODEPTR(code
, o
);
4433 EMIT_COND_BRANCH (ins
, S390_CC_GT
);
4438 EMIT_COND_BRANCH (ins
, S390_CC_GT
|S390_CC_OV
);
4442 s390_jo (code
, 0); CODEPTR(code
, o
);
4443 EMIT_COND_BRANCH (ins
, S390_CC_GE
);
4448 EMIT_COND_BRANCH (ins
, S390_CC_GE
|S390_CC_OV
);
4452 s390_jo (code
, 0); CODEPTR(code
, o
);
4453 EMIT_COND_BRANCH (ins
, S390_CC_LE
);
4458 EMIT_COND_BRANCH (ins
, S390_CC_LE
|S390_CC_OV
);
4462 s390_lhi (code
, s390_r13
, 0x7f);
4463 s390_tcdb (code
, ins
->sreg1
, 0, s390_r13
, 0);
4464 s390_jz (code
, 0); CODEPTR(code
, o
);
4465 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
4466 MONO_PATCH_INFO_EXC
, "ArithmeticException");
4467 s390_brasl (code
, s390_r14
,0);
4471 case OP_S390_MOVE
: {
4472 if (ins
->backend
.size
> 0) {
4473 if (ins
->backend
.size
<= 256) {
4474 s390_mvc (code
, ins
->backend
.size
, ins
->dreg
,
4475 ins
->inst_offset
, ins
->sreg1
, ins
->inst_imm
);
4477 s390_lr (code
, s390_r0
, ins
->dreg
);
4478 if (s390_is_imm16 (ins
->inst_offset
)) {
4479 s390_ahi (code
, s390_r0
, ins
->inst_offset
);
4481 s390_basr (code
, s390_r13
, 0);
4483 s390_word (code
, ins
->inst_offset
);
4484 s390_a (code
, s390_r0
, 0, s390_r13
, 4);
4486 s390_lr (code
, s390_r14
, s390_r12
);
4487 s390_lr (code
, s390_r12
, ins
->sreg1
);
4488 if (s390_is_imm16 (ins
->inst_imm
)) {
4489 s390_ahi (code
, s390_r12
, ins
->inst_imm
);
4491 s390_basr (code
, s390_r13
, 0);
4493 s390_word (code
, ins
->inst_imm
);
4494 s390_a (code
, s390_r12
, 0, s390_r13
, 4);
4496 s390_lr (code
, s390_r1
, ins
->sreg1
);
4497 s390_lr (code
, s390_r13
, s390_r1
);
4498 s390_mvcle(code
, s390_r0
, s390_r12
, 0, 0);
4500 s390_lr (code
, s390_r12
, s390_r14
);
4505 case OP_ATOMIC_ADD_I4
: {
4506 s390_lr (code
, s390_r1
, ins
->sreg2
);
4507 s390_l (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4508 s390_a (code
, s390_r1
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4509 s390_cs (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4510 s390_jnz (code
, -7);
4511 s390_lr (code
, ins
->dreg
, s390_r1
);
4514 case OP_ATOMIC_ADD_NEW_I4
: {
4515 s390_lr (code
, s390_r1
, ins
->sreg2
);
4516 s390_l (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4517 s390_a (code
, s390_r1
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4518 s390_cs (code
, s390_r0
, s390_r1
, ins
->inst_basereg
, ins
->inst_offset
);
4519 s390_jnz (code
, -7);
4520 s390_lr (code
, ins
->dreg
, s390_r1
);
4523 case OP_ATOMIC_EXCHANGE_I4
: {
4524 s390_l (code
, s390_r0
, 0, ins
->inst_basereg
, ins
->inst_offset
);
4525 s390_cs (code
, s390_r0
, ins
->sreg2
, ins
->inst_basereg
, ins
->inst_offset
);
4526 s390_jnz (code
, -4);
4527 s390_lr (code
, ins
->dreg
, s390_r0
);
4530 case OP_S390_BKCHAIN
: {
4531 s390_lr (code
, ins
->dreg
, ins
->sreg1
);
4532 if (s390_is_imm16 (cfg
->stack_offset
)) {
4533 s390_ahi (code
, ins
->dreg
, cfg
->stack_offset
);
4535 s390_basr (code
, s390_r13
, 0);
4537 s390_word (code
, cfg
->stack_offset
);
4538 s390_a (code
, ins
->dreg
, 0, s390_r13
, 4);
4541 case OP_MEMORY_BARRIER
: {
4545 g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins
->opcode
), __FUNCTION__
);
4546 g_assert_not_reached ();
4549 if ((cfg
->opt
& MONO_OPT_BRANCH
) && ((code
- cfg
->native_code
- offset
) > max_len
)) {
4550 g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %d)",
4551 mono_inst_name (ins
->opcode
), max_len
, code
- cfg
->native_code
- offset
);
4552 g_assert_not_reached ();
4558 last_offset
= offset
;
4561 cfg
->code_len
= code
- cfg
->native_code
;
4564 /*========================= End of Function ========================*/
4566 /*------------------------------------------------------------------*/
4568 /* Name - mono_arch_register_lowlevel_calls */
4570 /* Function - Register routines to help with --trace operation. */
4572 /*------------------------------------------------------------------*/
4575 mono_arch_register_lowlevel_calls (void)
4577 mono_register_jit_icall (mono_arch_get_lmf_addr
, "mono_arch_get_lmf_addr", NULL
, TRUE
);
4580 /*========================= End of Function ========================*/
4582 /*------------------------------------------------------------------*/
4584 /* Name - mono_arch_patch_code */
4586 /* Function - Process the patch data created during the */
4587 /* instruction build process. This resolves jumps, */
4588 /* calls, variables etc. */
4590 /*------------------------------------------------------------------*/
4593 mono_arch_patch_code (MonoMethod
*method
, MonoDomain
*domain
,
4594 guint8
*code
, MonoJumpInfo
*ji
, gboolean run_cctors
)
4596 MonoJumpInfo
*patch_info
;
4598 for (patch_info
= ji
; patch_info
; patch_info
= patch_info
->next
) {
4599 unsigned char *ip
= patch_info
->ip
.i
+ code
;
4600 gconstpointer target
= NULL
;
4602 target
= mono_resolve_patch_target (method
, domain
, code
,
4603 patch_info
, run_cctors
);
4605 switch (patch_info
->type
) {
4606 case MONO_PATCH_INFO_IP
:
4607 case MONO_PATCH_INFO_EXC_NAME
:
4608 case MONO_PATCH_INFO_LDSTR
:
4609 case MONO_PATCH_INFO_TYPE_FROM_HANDLE
:
4610 case MONO_PATCH_INFO_LDTOKEN
:
4611 case MONO_PATCH_INFO_EXC
:
4613 case MONO_PATCH_INFO_SWITCH
:
4614 /*----------------------------------*/
4615 /* ip points at the basr r13,0/j +4 */
4616 /* instruction the vtable value */
4617 /* follows this (i.e. ip+6) */
4618 /*----------------------------------*/
4619 *((gconstpointer
*)(ip
+6)) = target
;
4622 case MONO_PATCH_INFO_METHODCONST
:
4623 case MONO_PATCH_INFO_CLASS
:
4624 case MONO_PATCH_INFO_IMAGE
:
4625 case MONO_PATCH_INFO_FIELD
:
4626 case MONO_PATCH_INFO_IID
:
4627 target
= S390_RELATIVE(target
, ip
);
4629 case MONO_PATCH_INFO_R4
:
4630 case MONO_PATCH_INFO_R8
:
4631 case MONO_PATCH_INFO_METHOD_REL
:
4632 g_assert_not_reached ();
4635 target
= S390_RELATIVE(target
, ip
);
4638 s390_patch (ip
, (guint32
) target
);
4642 /*========================= End of Function ========================*/
4644 /*------------------------------------------------------------------*/
4646 /* Name - emit_load_volatile_registers */
4648 /* Function - Create the instruction sequence for loading the */
4649 /* parameter registers for use with the 'tail' op. */
4651 /* The register loading operations performed here */
4652 /* are the mirror of the store operations performed */
4653 /* in mono_arch_emit_prolog and need to be kept in */
4654 /* synchronization with it. */
4656 /*------------------------------------------------------------------*/
4659 emit_load_volatile_registers (guint8
* code
, MonoCompile
*cfg
)
4661 MonoMethod
*method
= cfg
->method
;
4662 MonoMethodSignature
*sig
;
4667 sig
= mono_method_signature (method
);
4670 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
4672 if (cinfo
->struct_ret
) {
4673 ArgInfo
*ainfo
= &cinfo
->ret
;
4674 inst
= cfg
->vret_addr
;
4675 s390_l (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4678 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
4679 ArgInfo
*ainfo
= cinfo
->args
+ i
;
4680 inst
= cfg
->args
[pos
];
4682 if (inst
->opcode
== OP_REGVAR
) {
4683 if (ainfo
->regtype
== RegTypeGeneral
)
4684 s390_lr (code
, ainfo
->reg
, inst
->dreg
);
4685 else if (ainfo
->regtype
== RegTypeFP
) {
4686 if (inst
->dreg
!= ainfo
->reg
) {
4687 if (ainfo
->size
== 4) {
4688 s390_ldebr (code
, ainfo
->reg
, inst
->dreg
);
4690 s390_ldr (code
, ainfo
->reg
, inst
->dreg
);
4694 else if (ainfo
->regtype
== RegTypeBase
) {
4696 g_assert_not_reached ();
4698 if (ainfo
->regtype
== RegTypeGeneral
) {
4699 if (!((ainfo
->reg
>= 2) && (ainfo
->reg
<= 6)))
4700 g_assert_not_reached();
4701 switch (ainfo
->size
) {
4703 s390_ic (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4706 s390_lh (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4709 s390_lm (code
, ainfo
->reg
, ainfo
->reg
+ 1,
4710 inst
->inst_basereg
, inst
->inst_offset
);
4713 s390_l (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4715 } else if (ainfo
->regtype
== RegTypeBase
) {
4716 } else if (ainfo
->regtype
== RegTypeFP
) {
4717 if (ainfo
->size
== 8)
4718 s390_ld (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4719 else if (ainfo
->size
== 4)
4720 s390_le (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4722 g_assert_not_reached ();
4723 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
4724 if (ainfo
->reg
!= STK_BASE
) {
4725 switch (ainfo
->size
) {
4727 s390_ic (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4730 s390_lh (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4733 s390_l (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4736 s390_lm (code
, ainfo
->reg
, ainfo
->reg
+1, inst
->inst_basereg
, inst
->inst_offset
);
4740 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
4741 if (ainfo
->reg
!= STK_BASE
) {
4742 s390_l (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4745 g_assert_not_reached ();
4753 /*========================= End of Function ========================*/
4755 /*------------------------------------------------------------------*/
4757 /* Name - mono_arch_emit_prolog */
4759 /* Function - Create the instruction sequence for a function */
4762 /*------------------------------------------------------------------*/
4765 mono_arch_emit_prolog (MonoCompile
*cfg
)
4767 MonoMethod
*method
= cfg
->method
;
4769 MonoMethodSignature
*sig
;
4771 int alloc_size
, pos
, max_offset
, i
;
4777 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (method
))
4780 cfg
->code_size
= 1024;
4781 cfg
->native_code
= code
= g_malloc (cfg
->code_size
);
4783 s390_stm (code
, s390_r6
, s390_r14
, STK_BASE
, S390_REG_SAVE_OFFSET
);
4785 if (cfg
->arch
.bkchain_reg
!= -1)
4786 s390_lr (code
, cfg
->arch
.bkchain_reg
, STK_BASE
);
4788 if (cfg
->flags
& MONO_CFG_HAS_ALLOCA
) {
4789 cfg
->used_int_regs
|= 1 << 11;
4792 alloc_size
= cfg
->stack_offset
;
4794 cfg
->stack_usage
= alloc_size
;
4795 s390_lr (code
, s390_r11
, STK_BASE
);
4796 if (s390_is_uimm16 (alloc_size
)) {
4797 s390_ahi (code
, STK_BASE
, -alloc_size
);
4799 int stackSize
= alloc_size
;
4800 while (stackSize
> 32767) {
4801 s390_ahi (code
, STK_BASE
, -32767);
4804 s390_ahi (code
, STK_BASE
, -stackSize
);
4806 s390_st (code
, s390_r11
, 0, STK_BASE
, 0);
4808 if (cfg
->frame_reg
!= STK_BASE
)
4809 s390_lr (code
, s390_r11
, STK_BASE
);
4811 /* compute max_offset in order to use short forward jumps
4812 * we always do it on s390 because the immediate displacement
4813 * for jumps is too small
4816 for (bb
= cfg
->bb_entry
; bb
; bb
= bb
->next_bb
) {
4817 MonoInst
*ins
= bb
->code
;
4818 bb
->max_offset
= max_offset
;
4820 if (cfg
->prof_options
& MONO_PROFILE_COVERAGE
)
4823 MONO_BB_FOR_EACH_INS (bb
, ins
)
4824 max_offset
+= ((guint8
*)ins_get_spec (ins
->opcode
))[MONO_INST_LEN
];
4827 /* load arguments allocated to register from the stack */
4828 sig
= mono_method_signature (method
);
4831 cinfo
= get_call_info (cfg
, cfg
->mempool
, sig
, sig
->pinvoke
);
4833 if (cinfo
->struct_ret
) {
4834 ArgInfo
*ainfo
= &cinfo
->ret
;
4835 inst
= cfg
->vret_addr
;
4836 inst
->backend
.size
= ainfo
->vtsize
;
4837 s390_st (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4840 for (i
= 0; i
< sig
->param_count
+ sig
->hasthis
; ++i
) {
4841 ArgInfo
*ainfo
= cinfo
->args
+ i
;
4842 inst
= cfg
->args
[pos
];
4844 if (inst
->opcode
== OP_VTARG_ADDR
)
4845 inst
= inst
->inst_left
;
4847 if (inst
->opcode
== OP_REGVAR
) {
4848 if (ainfo
->regtype
== RegTypeGeneral
)
4849 s390_lr (code
, inst
->dreg
, ainfo
->reg
);
4850 else if (ainfo
->regtype
== RegTypeFP
) {
4851 if (inst
->dreg
!= ainfo
->reg
) {
4852 if (ainfo
->size
== 4) {
4853 s390_ledbr (code
, inst
->dreg
, ainfo
->reg
);
4855 s390_ldr (code
, inst
->dreg
, ainfo
->reg
);
4859 else if (ainfo
->regtype
== RegTypeBase
) {
4860 s390_lr (code
, s390_r13
, STK_BASE
);
4861 s390_ahi (code
, s390_r13
, alloc_size
);
4862 s390_l (code
, inst
->dreg
, 0, s390_r13
, ainfo
->offset
);
4864 g_assert_not_reached ();
4866 if (cfg
->verbose_level
> 2)
4867 g_print ("Argument %d assigned to register %s\n",
4868 pos
, mono_arch_regname (inst
->dreg
));
4870 if (ainfo
->regtype
== RegTypeGeneral
) {
4871 if (!((ainfo
->reg
>= 2) && (ainfo
->reg
<= 6)))
4872 g_assert_not_reached();
4873 switch (ainfo
->size
) {
4875 s390_stc (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4878 s390_sth (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4881 s390_stm (code
, ainfo
->reg
, ainfo
->reg
+ 1,
4882 inst
->inst_basereg
, inst
->inst_offset
);
4885 s390_st (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4887 } else if (ainfo
->regtype
== RegTypeBase
) {
4888 } else if (ainfo
->regtype
== RegTypeFP
) {
4889 if (ainfo
->size
== 8)
4890 s390_std (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4891 else if (ainfo
->size
== 4)
4892 s390_ste (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4894 g_assert_not_reached ();
4895 } else if (ainfo
->regtype
== RegTypeStructByVal
) {
4896 int doffset
= inst
->inst_offset
;
4898 if (ainfo
->reg
!= STK_BASE
)
4902 s390_lr (code
, s390_r13
, STK_BASE
);
4903 s390_ahi (code
, s390_r13
, alloc_size
);
4905 switch (ainfo
->size
) {
4907 if (ainfo
->reg
== STK_BASE
)
4908 s390_ic (code
, reg
, 0, s390_r13
, ainfo
->offset
+3);
4909 s390_stc (code
, reg
, 0, inst
->inst_basereg
, doffset
);
4912 if (ainfo
->reg
== STK_BASE
)
4913 s390_lh (code
, reg
, 0, s390_r13
, ainfo
->offset
+2);
4914 s390_sth (code
, reg
, 0, inst
->inst_basereg
, doffset
);
4917 if (ainfo
->reg
== STK_BASE
)
4918 s390_l (code
, reg
, 0, s390_r13
, ainfo
->offset
);
4919 s390_st (code
, reg
, 0, inst
->inst_basereg
, doffset
);
4922 if (ainfo
->reg
== STK_BASE
)
4923 s390_lm (code
, s390_r0
, s390_r1
, s390_r13
, ainfo
->offset
);
4924 s390_stm (code
, reg
, reg
+1, inst
->inst_basereg
, doffset
);
4927 } else if (ainfo
->regtype
== RegTypeStructByAddr
) {
4928 if (ainfo
->reg
!= STK_BASE
)
4929 s390_st (code
, ainfo
->reg
, 0, inst
->inst_basereg
, inst
->inst_offset
);
4931 g_assert_not_reached ();
4936 if (method
->save_lmf
) {
4937 /*---------------------------------------------------------------*/
4938 /* we build the MonoLMF structure on the stack - see mini-s390.h */
4939 /*---------------------------------------------------------------*/
4940 lmfOffset
= alloc_size
- sizeof(MonoLMF
);
4942 s390_lr (code
, s390_r13
, cfg
->frame_reg
);
4943 if (s390_is_uimm16(lmfOffset
))
4944 s390_ahi (code
, s390_r13
, lmfOffset
);
4946 s390_basr (code
, s390_r14
, 0);
4948 s390_word (code
, lmfOffset
);
4949 s390_a (code
, s390_r13
, 0, s390_r14
, 4);
4952 /*---------------------------------------------------------------*/
4953 /* Preserve the parameter registers while we fix up the lmf */
4954 /*---------------------------------------------------------------*/
4955 s390_stm (code
, s390_r2
, s390_r6
, s390_r13
,
4956 G_STRUCT_OFFSET(MonoLMF
, pregs
[0]));
4958 /*---------------------------------------------------------------*/
4959 /* On return from this call r2 have the address of the &lmf */
4960 /*---------------------------------------------------------------*/
4961 mono_add_patch_info (cfg
, code
- cfg
->native_code
,
4962 MONO_PATCH_INFO_INTERNAL_METHOD
,
4963 (gpointer
)"mono_get_lmf_addr");
4964 s390_brasl (code
, s390_r14
, 0);
4966 /*---------------------------------------------------------------*/
4967 /* Set lmf.lmf_addr = jit_tls->lmf */
4968 /*---------------------------------------------------------------*/
4969 s390_st (code
, s390_r2
, 0, s390_r13
,
4970 G_STRUCT_OFFSET(MonoLMF
, lmf_addr
));
4972 /*---------------------------------------------------------------*/
4973 /* Get current lmf */
4974 /*---------------------------------------------------------------*/
4975 s390_l (code
, s390_r0
, 0, s390_r2
, 0);
4977 /*---------------------------------------------------------------*/
4978 /* Set our lmf as the current lmf */
4979 /*---------------------------------------------------------------*/
4980 s390_st (code
, s390_r13
, 0, s390_r2
, 0);
4982 /*---------------------------------------------------------------*/
4983 /* Have our lmf.previous_lmf point to the last lmf */
4984 /*---------------------------------------------------------------*/
4985 s390_st (code
, s390_r0
, 0, s390_r13
,
4986 G_STRUCT_OFFSET(MonoLMF
, previous_lmf
));
4988 /*---------------------------------------------------------------*/
4989 /* save method info */
4990 /*---------------------------------------------------------------*/
4991 s390_basr (code
, s390_r1
, 0);
4993 s390_word (code
, method
);
4994 s390_l (code
, s390_r1
, 0, s390_r1
, 4);
4995 s390_st (code
, s390_r1
, 0, s390_r13
,
4996 G_STRUCT_OFFSET(MonoLMF
, method
));
4998 /*---------------------------------------------------------------*/
4999 /* save the current IP */
5000 /*---------------------------------------------------------------*/
5001 s390_st (code
, STK_BASE
, 0, s390_r13
, G_STRUCT_OFFSET(MonoLMF
, ebp
));
5002 s390_basr (code
, s390_r1
, 0);
5003 s390_la (code
, s390_r1
, 0, s390_r1
, 0);
5004 s390_st (code
, s390_r1
, 0, s390_r13
, G_STRUCT_OFFSET(MonoLMF
, eip
));
5006 /*---------------------------------------------------------------*/
5007 /* Save general and floating point registers */
5008 /*---------------------------------------------------------------*/
5009 s390_stm (code
, s390_r2
, s390_r12
, s390_r13
,
5010 G_STRUCT_OFFSET(MonoLMF
, gregs
[2]));
5011 for (i
= 0; i
< 16; i
++) {
5012 s390_std (code
, i
, 0, s390_r13
,
5013 G_STRUCT_OFFSET(MonoLMF
, fregs
[i
]));
5016 /*---------------------------------------------------------------*/
5017 /* Restore the parameter registers now that we've set up the lmf */
5018 /*---------------------------------------------------------------*/
5019 s390_lm (code
, s390_r2
, s390_r6
, s390_r13
,
5020 G_STRUCT_OFFSET(MonoLMF
, pregs
[0]));
5024 code
= mono_arch_instrument_prolog(cfg
, enter_method
, code
, TRUE
);
5026 cfg
->code_len
= code
- cfg
->native_code
;
5028 g_assert (cfg
->code_len
< cfg
->code_size
);
5033 /*========================= End of Function ========================*/
5035 /*------------------------------------------------------------------*/
5037 /* Name - mono_arch_emit_epilog */
5039 /* Function - Emit the instructions for a function epilog. */
5041 /*------------------------------------------------------------------*/
5044 mono_arch_emit_epilog (MonoCompile
*cfg
)
5046 MonoMethod
*method
= cfg
->method
;
5049 int max_epilog_size
= 96;
5051 if (cfg
->method
->save_lmf
)
5052 max_epilog_size
+= 128;
5054 if (mono_jit_trace_calls
!= NULL
)
5055 max_epilog_size
+= 128;
5057 if (cfg
->prof_options
& MONO_PROFILE_ENTER_LEAVE
)
5058 max_epilog_size
+= 128;
5060 while ((cfg
->code_len
+ max_epilog_size
) > (cfg
->code_size
- 16)) {
5061 cfg
->code_size
*= 2;
5062 cfg
->native_code
= g_realloc (cfg
->native_code
, cfg
->code_size
);
5063 mono_jit_stats
.code_reallocs
++;
5066 code
= cfg
->native_code
+ cfg
->code_len
;
5068 if (mono_jit_trace_calls
!= NULL
&& mono_trace_eval (method
)) {
5069 code
= mono_arch_instrument_epilog (cfg
, leave_method
, code
, TRUE
);
5073 if (method
->save_lmf
)
5074 restoreLMF(code
, cfg
->frame_reg
, cfg
->stack_usage
);
5076 if (cfg
->flags
& MONO_CFG_HAS_ALLOCA
)
5077 s390_l (code
, STK_BASE
, 0, STK_BASE
, 0);
5079 code
= backUpStackPtr(cfg
, code
, STK_BASE
);
5081 s390_lm (code
, s390_r6
, s390_r14
, STK_BASE
, S390_REG_SAVE_OFFSET
);
5082 s390_br (code
, s390_r14
);
5084 cfg
->code_len
= code
- cfg
->native_code
;
5086 g_assert (cfg
->code_len
< cfg
->code_size
);
5090 /*========================= End of Function ========================*/
5092 /*------------------------------------------------------------------*/
5094 /* Name - mono_arch_emit_exceptions */
5096 /* Function - Emit the blocks to handle exception conditions. */
5098 /*------------------------------------------------------------------*/
5101 mono_arch_emit_exceptions (MonoCompile
*cfg
)
5103 MonoJumpInfo
*patch_info
;
5109 MonoClass
*exc_classes
[MAX_EXC
];
5110 guint8
*exc_throw_start
[MAX_EXC
];
5112 for (patch_info
= cfg
->patch_info
;
5114 patch_info
= patch_info
->next
) {
5115 if (patch_info
->type
== MONO_PATCH_INFO_EXC
)
5119 code_size
= exc_count
* 26;
5121 while ((cfg
->code_len
+ code_size
) > (cfg
->code_size
- 16)) {
5122 cfg
->code_size
*= 2;
5123 cfg
->native_code
= g_realloc (cfg
->native_code
, cfg
->code_size
);
5124 mono_jit_stats
.code_reallocs
++;
5127 code
= cfg
->native_code
+ cfg
->code_len
;
5129 /*---------------------------------------------------------------------*/
5130 /* Add code to raise exceptions */
5131 /*---------------------------------------------------------------------*/
5132 for (patch_info
= cfg
->patch_info
; patch_info
; patch_info
= patch_info
->next
) {
5133 switch (patch_info
->type
) {
5134 case MONO_PATCH_INFO_EXC
: {
5135 guint8
*ip
= patch_info
->ip
.i
+ cfg
->native_code
;
5136 MonoClass
*exc_class
;
5139 /*-----------------------------------------------------*/
5140 /* Patch the branch in epilog to come here */
5141 /*-----------------------------------------------------*/
5142 s390_patch (ip
+ 2, (guint32
) (S390_RELATIVE(code
,ip
)));
5144 exc_class
= mono_class_from_name (mono_defaults
.corlib
,
5146 patch_info
->data
.name
);
5147 g_assert (exc_class
);
5148 throw_ip
= patch_info
->ip
.i
;
5150 for (iExc
= 0; iExc
< nThrows
; ++iExc
)
5151 if (exc_classes
[iExc
] == exc_class
)
5154 if (iExc
< nThrows
) {
5155 s390_jcl (code
, S390_CC_UN
, (guint32
) exc_throw_start
[iExc
]);
5156 patch_info
->type
= MONO_PATCH_INFO_NONE
;
5159 if (nThrows
< MAX_EXC
) {
5160 exc_classes
[nThrows
] = exc_class
;
5161 exc_throw_start
[nThrows
] = code
;
5164 /*---------------------------------------------*/
5165 /* Patch the parameter passed to the handler */
5166 /*---------------------------------------------*/
5167 s390_basr (code
, s390_r13
, 0);
5169 s390_word (code
, patch_info
->data
.target
);
5170 /*---------------------------------------------*/
5171 /* Load return address & parameter register */
5172 /*---------------------------------------------*/
5173 s390_larl (code
, s390_r14
, (gsize
)S390_RELATIVE((patch_info
->ip
.i
+
5174 cfg
->native_code
+ 8), code
));
5175 s390_l (code
, s390_r2
, 0, s390_r13
, 4);
5176 /*---------------------------------------------*/
5177 /* Reuse the current patch to set the jump */
5178 /*---------------------------------------------*/
5179 patch_info
->type
= MONO_PATCH_INFO_INTERNAL_METHOD
;
5180 patch_info
->data
.name
= "mono_arch_throw_exception_by_name";
5181 patch_info
->ip
.i
= code
- cfg
->native_code
;
5182 s390_jcl (code
, S390_CC_UN
, 0);
5192 cfg
->code_len
= code
- cfg
->native_code
;
5194 g_assert (cfg
->code_len
< cfg
->code_size
);
5198 /*========================= End of Function ========================*/
5200 /*------------------------------------------------------------------*/
5202 /* Name - mono_arch_setup_jit_tls_data */
5204 /* Function - Setup the JIT's Thread Level Specific Data. */
5206 /*------------------------------------------------------------------*/
5209 mono_arch_setup_jit_tls_data (MonoJitTlsData
*tls
)
5212 if (!tls_offset_inited
) {
5213 tls_offset_inited
= TRUE
;
5217 __asm__ ("\tear\t%r1,0\n"
5224 : "=r" (appdomain_tls_offset
),
5225 "=r" (thread_tls_offset
),
5226 "=r" (lmf_tls_offset
)
5227 : "r" (&tls_appdomain
),
5228 "r" (&tls_current_object
),
5229 "r" (&mono_lmf_addr
)
5235 if (!lmf_addr_key_inited
) {
5236 lmf_addr_key_inited
= TRUE
;
5237 pthread_key_create (&lmf_addr_key
, NULL
);
5239 pthread_setspecific (lmf_addr_key
, &tls
->lmf
);
5243 /*========================= End of Function ========================*/
5245 /*------------------------------------------------------------------*/
5247 /* Name - mono_arch_free_jit_tls_data */
5249 /* Function - Free tls data. */
5251 /*------------------------------------------------------------------*/
5254 mono_arch_free_jit_tls_data (MonoJitTlsData
*tls
)
5259 /*========================= End of Function ========================*/
5261 /*------------------------------------------------------------------*/
5263 /* Name - mono_arch_emit_this_vret_args */
5267 /*------------------------------------------------------------------*/
5270 mono_arch_emit_this_vret_args (MonoCompile
*cfg
, MonoCallInst
*inst
, int this_reg
, int this_type
, int vt_reg
)
5272 int this_dreg
= s390_r2
;
5275 this_dreg
= s390_r3
;
5277 /* add the this argument */
5278 if (this_reg
!= -1) {
5280 MONO_INST_NEW (cfg
, this, OP_MOVE
);
5281 this->type
= this_type
;
5282 this->sreg1
= this_reg
;
5283 this->dreg
= mono_regstate_next_int (cfg
->rs
);
5284 mono_bblock_add_inst (cfg
->cbb
, this);
5285 mono_call_inst_add_outarg_reg (cfg
, inst
, this->dreg
, this_dreg
, FALSE
);
5290 MONO_INST_NEW (cfg
, vtarg
, OP_MOVE
);
5291 vtarg
->type
= STACK_MP
;
5292 vtarg
->sreg1
= vt_reg
;
5293 vtarg
->dreg
= mono_regstate_next_int (cfg
->rs
);
5294 mono_bblock_add_inst (cfg
->cbb
, vtarg
);
5295 mono_call_inst_add_outarg_reg (cfg
, inst
, vtarg
->dreg
, s390_r2
, FALSE
);
5299 /*========================= End of Function ========================*/
5301 /*------------------------------------------------------------------*/
5303 /* Name - mono_arch_get_inst_for_method */
5305 /* Function - Check for opcodes we can handle directly in */
5308 /*------------------------------------------------------------------*/
5311 mono_arch_get_inst_for_method (MonoCompile
*cfg
, MonoMethod
*cmethod
,
5312 MonoMethodSignature
*fsig
, MonoInst
**args
)
5314 MonoInst
*ins
= NULL
;
5316 if (cmethod
->klass
== mono_defaults
.math_class
) {
5317 if (strcmp (cmethod
->name
, "Sqrt") == 0) {
5318 MONO_INST_NEW (cfg
, ins
, OP_SQRT
);
5319 ins
->inst_i0
= args
[0];
5326 /*========================= End of Function ========================*/
5328 /*------------------------------------------------------------------*/
5330 /* Name - mono_arch_emit_inst_for_method */
5332 /*------------------------------------------------------------------*/
5335 mono_arch_emit_inst_for_method (MonoCompile
*cfg
, MonoMethod
*cmethod
, MonoMethodSignature
*fsig
, MonoInst
**args
)
5340 /*========================= End of Function ========================*/
5343 mono_arch_decompose_opts (MonoCompile
*cfg
, MonoInst
*ins
)
5345 switch (ins
->opcode
) {
5347 ins
->opcode
= OP_S390_ISUB_OVF
;
5349 case OP_ISUB_OVF_UN
:
5350 ins
->opcode
= OP_S390_ISUB_OVF_UN
;
5353 ins
->opcode
= OP_S390_IADD_OVF
;
5355 case OP_IADD_OVF_UN
:
5356 ins
->opcode
= OP_S390_IADD_OVF_UN
;
5363 /*========================= End of Function ========================*/
5365 /*------------------------------------------------------------------*/
5367 /* Name - mono_arch_decompose_long_opts */
5369 /*------------------------------------------------------------------*/
5372 mono_arch_decompose_long_opts (MonoCompile
*cfg
, MonoInst
*ins
)
5374 // The generic code seems to work for OP_LSUB fine on s390, why is a different
5375 // implementation needed ? gcc also seems to use the different implementation.
5376 // FIXME: What about the other OP_L opcodes below ?
5378 switch (ins
->opcode
) {
5380 case OP_LADD_OVF_UN
:
5382 case OP_LSUB_OVF_UN
: {
5385 switch (ins
->opcode
) {
5387 opcode
= OP_S390_LADD
;
5390 opcode
= OP_S390_LADD_OVF
;
5392 case OP_LADD_OVF_UN
:
5393 opcode
= OP_S390_LADD_OVF_UN
;
5396 opcode
= OP_S390_LSUB
;
5399 opcode
= OP_S390_LSUB_OVF
;
5401 case OP_LSUB_OVF_UN
:
5402 opcode
= OP_S390_LSUB_OVF_UN
;
5405 g_assert_not_reached ();
5408 /* These hard regs make ssa crazy */
5409 cfg
->disable_ssa
= TRUE
;
5410 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, s390_r0
, ins
->sreg1
+ 1);
5411 MONO_EMIT_NEW_UNALU (cfg
, OP_MOVE
, s390_r1
, ins
->sreg1
+ 2);
5412 MONO_EMIT_NEW_BIALU (cfg
, opcode
, ins
->dreg
, ins
->sreg2
+ 1, ins
->sreg2
+ 2);
5417 int dreg
= mono_alloc_dreg (cfg
, STACK_I8
);
5418 MONO_EMIT_NEW_I8CONST (cfg
, dreg
, ins
->inst_l
);
5419 MONO_EMIT_NEW_BIALU (cfg
, OP_LADD
, ins
->dreg
, ins
->sreg1
, dreg
);
5424 int dreg
= mono_alloc_dreg (cfg
, STACK_I8
);
5425 MONO_EMIT_NEW_I8CONST (cfg
, dreg
, ins
->inst_l
);
5426 MONO_EMIT_NEW_BIALU (cfg
, OP_LSUB
, ins
->dreg
, ins
->sreg1
, dreg
);
5431 MONO_EMIT_NEW_BIALU (cfg
, OP_S390_LNEG
, ins
->dreg
, ins
->sreg1
+ 1, ins
->sreg1
+ 2);
5436 ins
->opcode
= OP_S390_ISUB_OVF
;
5438 case OP_ISUB_OVF_UN
:
5439 ins
->opcode
= OP_S390_ISUB_OVF_UN
;
5446 /*========================= End of Function ========================*/
5448 /*------------------------------------------------------------------*/
5450 /* Name - mono_arch_print_tree */
5452 /* Function - Print platform-specific opcode details. */
5454 /* Returns - 1 - opcode details have been printed */
5455 /* 0 - opcode details have not been printed */
5457 /*------------------------------------------------------------------*/
5460 mono_arch_print_tree (MonoInst
*tree
, int arity
)
5464 switch (tree
->opcode
) {
5465 case OP_S390_LOADARG
:
5466 case OP_S390_ARGREG
:
5467 case OP_S390_ARGPTR
:
5468 printf ("[0x%lx(%s)]", tree
->inst_offset
,
5469 mono_arch_regname (tree
->inst_basereg
));
5472 case OP_S390_STKARG
:
5473 printf ("[0x%lx(previous_frame)]",
5478 printf ("[0x%lx(%d,%s),0x%lx(%s)]",
5479 tree
->inst_offset
, tree
->backend
.size
,
5480 mono_arch_regname(tree
->dreg
), tree
->inst_imm
,
5481 mono_arch_regname(tree
->sreg1
));
5484 case OP_S390_SETF4RET
:
5486 mono_arch_fregname (tree
->dreg
),
5487 mono_arch_fregname (tree
->sreg1
));
5491 printf ("[0x%lx(0x%lx,%s)]", tree
->inst_offset
,
5493 mono_arch_regname (tree
->sreg1
));
5496 case OP_S390_BKCHAIN
:
5497 printf ("[previous_frame(%s)]",
5498 mono_arch_regname (tree
->sreg1
));
5507 /*========================= End of Function ========================*/
5509 /*------------------------------------------------------------------*/
5511 /* Name - mono_arch_regalloc_cost */
5513 /* Function - Determine the cost, in the number of memory */
5514 /* references, of the action of allocating the var- */
5515 /* iable VMV into a register during global register */
5518 /* Returns - Cost */
5520 /*------------------------------------------------------------------*/
5523 mono_arch_regalloc_cost (MonoCompile
*cfg
, MonoMethodVar
*vmv
)
5529 /*========================= End of Function ========================*/
5531 /*------------------------------------------------------------------*/
5533 /* Name - mono_arch_get_domain_intrinsic */
5539 /*------------------------------------------------------------------*/
5542 mono_arch_get_domain_intrinsic (MonoCompile
* cfg
)
5546 if (appdomain_tls_offset
== -1)
5549 MONO_INST_NEW (cfg
, ins
, OP_TLS_GET
);
5550 ins
->inst_offset
= appdomain_tls_offset
;
5554 /*========================= End of Function ========================*/
5556 /*------------------------------------------------------------------*/
5558 /* Name - mono_arch_get_thread_intrinsic */
5564 /*------------------------------------------------------------------*/
5567 mono_arch_get_thread_intrinsic (MonoCompile
* cfg
)
5571 if (thread_tls_offset
== -1)
5574 MONO_INST_NEW (cfg
, ins
, OP_TLS_GET
);
5575 ins
->inst_offset
= thread_tls_offset
;
5579 /*========================= End of Function ========================*/
5581 /*------------------------------------------------------------------*/
5583 /* Name - mono_arch_flush_register_windows */
5589 /*------------------------------------------------------------------*/
5592 mono_arch_flush_register_windows (void)
5596 /*========================= End of Function ========================*/
5598 /*------------------------------------------------------------------*/
5600 /* Name - mono_arch_get_lmf_addr */
5606 /*------------------------------------------------------------------*/
5609 mono_arch_get_lmf_addr (void)
5611 return pthread_getspecific (lmf_addr_key
);
5615 /*========================= End of Function ========================*/
5617 /*------------------------------------------------------------------*/
5619 /* Name - mono_arch_get_patch_offset */
5621 /* Function - Dummy entry point until s390x supports aot. */
5623 /* Returns - Offset for patch. */
5625 /*------------------------------------------------------------------*/
5628 mono_arch_get_patch_offset (guint8
*code
)
5633 /*========================= End of Function ========================*/
5636 mono_arch_context_get_int_reg (MonoContext
*ctx
, int reg
)
5638 /* FIXME: implement */
5639 g_assert_not_reached ();