?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Rodrigo Kumpera <rkumpera@novell.com>
[mono.git] / mono / mini / decompose.c
blob8fa6bb3eb3c00b8d2165ed54cc2eef8dcee851d6
1 /*
2 * decompose.c: Functions to decompose complex IR instructions into simpler ones.
3 *
4 * Author:
5 * Zoltan Varga (vargaz@gmail.com)
6 *
7 * (C) 2002 Ximian, Inc.
8 */
9
10 #include "mini.h"
11 #include "ir-emit.h"
12 #include "jit-icalls.h"
13
14 #include <mono/metadata/gc-internal.h>
15
16 #ifndef DISABLE_JIT
17
18 /* FIXME: This conflicts with the definition in mini.c, so it cannot be moved to mini.h */
19 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
20 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
21 void mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass);
22
23 /*
24 * mono_decompose_opcode:
25 *
26 * Decompose complex opcodes into ones closer to opcodes supported by
27 * the given architecture.
28 * Returns a MonoInst which represents the result of the decomposition, and can
29 * be pushed on the IL stack. This is needed because the original instruction is
30 * nullified.
31 * Sets the cfg exception if an opcode is not supported.
32 */
33 MonoInst*
34 mono_decompose_opcode (MonoCompile *cfg, MonoInst *ins)
35 {
36 MonoInst *repl = NULL;
37 int type = ins->type;
38 int dreg = ins->dreg;
39
40 /* FIXME: Instead of = NOP, don't emit the original ins at all */
41
42 #ifdef MONO_ARCH_HAVE_DECOMPOSE_OPTS
43 mono_arch_decompose_opts (cfg, ins);
44 #endif
45
46 /*
47 * The code below assumes that we are called immediately after emitting
48 * ins. This means we can emit code using the normal code generation
49 * macros.
50 */
51 switch (ins->opcode) {
52 /* this doesn't make sense on ppc and other architectures */
53 #if !defined(MONO_ARCH_NO_IOV_CHECK)
54 case OP_IADD_OVF:
55 if (COMPILE_LLVM (cfg))
56 break;
57 ins->opcode = OP_IADDCC;
58 MONO_EMIT_NEW_COND_EXC (cfg, IOV, "OverflowException");
59 break;
60 case OP_IADD_OVF_UN:
61 if (COMPILE_LLVM (cfg))
62 break;
63 ins->opcode = OP_IADDCC;
64 MONO_EMIT_NEW_COND_EXC (cfg, IC, "OverflowException");
65 break;
66 case OP_ISUB_OVF:
67 if (COMPILE_LLVM (cfg))
68 break;
69 ins->opcode = OP_ISUBCC;
70 MONO_EMIT_NEW_COND_EXC (cfg, IOV, "OverflowException");
71 break;
72 case OP_ISUB_OVF_UN:
73 if (COMPILE_LLVM (cfg))
74 break;
75 ins->opcode = OP_ISUBCC;
76 MONO_EMIT_NEW_COND_EXC (cfg, IC, "OverflowException");
77 break;
78 #endif
79 case OP_ICONV_TO_OVF_I1:
80 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 127);
81 MONO_EMIT_NEW_COND_EXC (cfg, IGT, "OverflowException");
82 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, -128);
83 MONO_EMIT_NEW_COND_EXC (cfg, ILT, "OverflowException");
84 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I1, ins->dreg, ins->sreg1);
85 NULLIFY_INS (ins);
86 break;
87 case OP_ICONV_TO_OVF_I1_UN:
88 /* probe values between 0 to 127 */
89 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 127);
90 MONO_EMIT_NEW_COND_EXC (cfg, IGT_UN, "OverflowException");
91 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I1, ins->dreg, ins->sreg1);
92 NULLIFY_INS (ins);
93 break;
94 case OP_ICONV_TO_OVF_U1:
95 case OP_ICONV_TO_OVF_U1_UN:
96 /* probe value to be within 0 to 255 */
97 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 255);
98 MONO_EMIT_NEW_COND_EXC (cfg, IGT_UN, "OverflowException");
99 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, ins->dreg, ins->sreg1, 0xff);
100 NULLIFY_INS (ins);
101 break;
102 case OP_ICONV_TO_OVF_I2:
103 /* Probe value to be within -32768 and 32767 */
104 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 32767);
105 MONO_EMIT_NEW_COND_EXC (cfg, IGT, "OverflowException");
106 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, -32768);
107 MONO_EMIT_NEW_COND_EXC (cfg, ILT, "OverflowException");
108 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I2, ins->dreg, ins->sreg1);
109 NULLIFY_INS (ins);
110 break;
111 case OP_ICONV_TO_OVF_I2_UN:
112 /* Convert uint value into short, value within 0 and 32767 */
113 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 32767);
114 MONO_EMIT_NEW_COND_EXC (cfg, IGT_UN, "OverflowException");
115 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I2, ins->dreg, ins->sreg1);
116 NULLIFY_INS (ins);
117 break;
118 case OP_ICONV_TO_OVF_U2:
119 case OP_ICONV_TO_OVF_U2_UN:
120 /* Probe value to be within 0 and 65535 */
121 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 0xffff);
122 MONO_EMIT_NEW_COND_EXC (cfg, IGT_UN, "OverflowException");
123 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, ins->dreg, ins->sreg1, 0xffff);
124 NULLIFY_INS (ins);
125 break;
126 case OP_ICONV_TO_OVF_U4:
127 case OP_ICONV_TO_OVF_I4_UN:
128 #if SIZEOF_REGISTER == 4
129 case OP_ICONV_TO_OVF_U:
130 case OP_ICONV_TO_OVF_I_UN:
131 #endif
132 MONO_EMIT_NEW_ICOMPARE_IMM (cfg, ins->sreg1, 0);
133 MONO_EMIT_NEW_COND_EXC (cfg, ILT, "OverflowException");
134 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
135 NULLIFY_INS (ins);
136 break;
137 case OP_ICONV_TO_I4:
138 case OP_ICONV_TO_U4:
139 case OP_ICONV_TO_OVF_I4:
140 case OP_ICONV_TO_OVF_U4_UN:
141 #if SIZEOF_REGISTER == 4
142 case OP_ICONV_TO_OVF_I:
143 case OP_ICONV_TO_OVF_U_UN:
144 #endif
145 ins->opcode = OP_MOVE;
146 break;
147 case OP_ICONV_TO_I:
148 #if SIZEOF_REGISTER == 8
149 ins->opcode = OP_SEXT_I4;
150 #else
151 ins->opcode = OP_MOVE;
152 #endif
153 break;
154 case OP_ICONV_TO_U:
155 #if SIZEOF_REGISTER == 8
156 ins->opcode = OP_ZEXT_I4;
157 #else
158 ins->opcode = OP_MOVE;
159 #endif
160 break;
161
162 case OP_FCONV_TO_R8:
163 ins->opcode = OP_FMOVE;
164 break;
165
166 case OP_FCONV_TO_OVF_I1_UN:
167 case OP_FCONV_TO_OVF_I2_UN:
168 case OP_FCONV_TO_OVF_I4_UN:
169 case OP_FCONV_TO_OVF_I8_UN:
170 case OP_FCONV_TO_OVF_U1_UN:
171 case OP_FCONV_TO_OVF_U2_UN:
172 case OP_FCONV_TO_OVF_U4_UN:
173 case OP_FCONV_TO_OVF_U8_UN:
174 case OP_FCONV_TO_OVF_I_UN:
175 case OP_FCONV_TO_OVF_U_UN:
176 cfg->exception_type = MONO_EXCEPTION_INVALID_PROGRAM;
177 cfg->exception_message = g_strdup_printf ("float conv.ovf.un opcodes not supported.");
178 break;
179
180 /* Long opcodes on 64 bit machines */
181 #if SIZEOF_REGISTER == 8
182 case OP_LCONV_TO_I4:
183 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_LSHR_IMM, ins->dreg, ins->sreg1, 0);
184 NULLIFY_INS (ins);
185 break;
186 case OP_LCONV_TO_I8:
187 case OP_LCONV_TO_I:
188 case OP_LCONV_TO_U8:
189 case OP_LCONV_TO_U:
190 ins->opcode = OP_MOVE;
191 break;
192 case OP_ICONV_TO_I8:
193 ins->opcode = OP_SEXT_I4;
194 break;
195 case OP_ICONV_TO_U8:
196 ins->opcode = OP_ZEXT_I4;
197 break;
198 case OP_LCONV_TO_U4:
199 /* Clean out the upper word */
200 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_UN_IMM, ins->dreg, ins->sreg1, 0);
201 NULLIFY_INS (ins);
202 break;
203 case OP_LADD_OVF:
204 if (COMPILE_LLVM (cfg))
205 break;
206 EMIT_NEW_BIALU (cfg, repl, OP_ADDCC, ins->dreg, ins->sreg1, ins->sreg2);
207 MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
208 NULLIFY_INS (ins);
209 break;
210 case OP_LADD_OVF_UN:
211 if (COMPILE_LLVM (cfg))
212 break;
213 EMIT_NEW_BIALU (cfg, repl, OP_ADDCC, ins->dreg, ins->sreg1, ins->sreg2);
214 MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
215 NULLIFY_INS (ins);
216 break;
217 #ifndef __mono_ppc64__
218 case OP_LSUB_OVF:
219 if (COMPILE_LLVM (cfg))
220 break;
221 EMIT_NEW_BIALU (cfg, repl, OP_SUBCC, ins->dreg, ins->sreg1, ins->sreg2);
222 MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
223 NULLIFY_INS (ins);
224 break;
225 case OP_LSUB_OVF_UN:
226 if (COMPILE_LLVM (cfg))
227 break;
228 EMIT_NEW_BIALU (cfg, repl, OP_SUBCC, ins->dreg, ins->sreg1, ins->sreg2);
229 MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
230 NULLIFY_INS (ins);
231 break;
232 #endif
233
234 case OP_ICONV_TO_OVF_I8:
235 case OP_ICONV_TO_OVF_I:
236 ins->opcode = OP_SEXT_I4;
237 break;
238 case OP_ICONV_TO_OVF_U8:
239 case OP_ICONV_TO_OVF_U:
240 MONO_EMIT_NEW_COMPARE_IMM (cfg,ins->sreg1, 0);
241 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
242 MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, ins->dreg, ins->sreg1);
243 NULLIFY_INS (ins);
244 break;
245 case OP_ICONV_TO_OVF_I8_UN:
246 case OP_ICONV_TO_OVF_U8_UN:
247 case OP_ICONV_TO_OVF_I_UN:
248 case OP_ICONV_TO_OVF_U_UN:
249 /* an unsigned 32 bit num always fits in an (un)signed 64 bit one */
250 /* Clean out the upper word */
251 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_UN_IMM, ins->dreg, ins->sreg1, 0);
252 NULLIFY_INS (ins);
253 break;
254 case OP_LCONV_TO_OVF_I1:
255 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 127);
256 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
257 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, -128);
258 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
259 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I1, ins->dreg, ins->sreg1);
260 NULLIFY_INS (ins);
261 break;
262 case OP_LCONV_TO_OVF_I1_UN:
263 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 127);
264 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
265 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I1, ins->dreg, ins->sreg1);
266 NULLIFY_INS (ins);
267 break;
268 case OP_LCONV_TO_OVF_U1:
269 /* probe value to be within 0 to 255 */
270 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 255);
271 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
272 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, ins->dreg, ins->sreg1, 0xff);
273 NULLIFY_INS (ins);
274 break;
275 case OP_LCONV_TO_OVF_U1_UN:
276 /* probe value to be within 0 to 255 */
277 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 255);
278 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
279 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, ins->dreg, ins->sreg1, 0xff);
280 NULLIFY_INS (ins);
281 break;
282 case OP_LCONV_TO_OVF_I2:
283 /* Probe value to be within -32768 and 32767 */
284 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 32767);
285 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
286 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, -32768);
287 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
288 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I2, ins->dreg, ins->sreg1);
289 NULLIFY_INS (ins);
290 break;
291 case OP_LCONV_TO_OVF_I2_UN:
292 /* Probe value to be within 0 and 32767 */
293 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 32767);
294 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
295 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I2, ins->dreg, ins->sreg1);
296 NULLIFY_INS (ins);
297 break;
298 case OP_LCONV_TO_OVF_U2:
299 /* Probe value to be within 0 and 65535 */
300 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0xffff);
301 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
302 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, ins->dreg, ins->sreg1, 0xffff);
303 NULLIFY_INS (ins);
304 break;
305 case OP_LCONV_TO_OVF_U2_UN:
306 /* Probe value to be within 0 and 65535 */
307 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0xffff);
308 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
309 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, ins->dreg, ins->sreg1, 0xffff);
310 NULLIFY_INS (ins);
311 break;
312 case OP_LCONV_TO_OVF_I4:
313 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0x7fffffff);
314 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
315 /* The int cast is needed for the VS compiler. See Compiler Warning (level 2) C4146. */
316 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, ((int)-2147483648));
317 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
318 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
319 NULLIFY_INS (ins);
320 break;
321 case OP_LCONV_TO_OVF_I4_UN:
322 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0x7fffffff);
323 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
324 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
325 NULLIFY_INS (ins);
326 break;
327 case OP_LCONV_TO_OVF_U4:
328 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0xffffffffUL);
329 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
330 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, ins->sreg1, 0);
331 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
332 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
333 NULLIFY_INS (ins);
334 break;
335 case OP_LCONV_TO_OVF_U4_UN:
336 MONO_EMIT_NEW_COMPARE_IMM (cfg, ins->sreg1, 0xffffffff);
337 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
338 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
339 NULLIFY_INS (ins);
340 break;
341 case OP_LCONV_TO_OVF_I:
342 case OP_LCONV_TO_OVF_U_UN:
343 case OP_LCONV_TO_OVF_U8_UN:
344 case OP_LCONV_TO_OVF_I8:
345 ins->opcode = OP_MOVE;
346 break;
347 case OP_LCONV_TO_OVF_I_UN:
348 case OP_LCONV_TO_OVF_I8_UN:
349 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, ins->sreg1, 0);
350 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
351 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
352 NULLIFY_INS (ins);
353 break;
354 case OP_LCONV_TO_OVF_U8:
355 case OP_LCONV_TO_OVF_U:
356 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, ins->sreg1, 0);
357 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
358 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
359 NULLIFY_INS (ins);
360 break;
361 #endif
362
363 default: {
364 MonoJitICallInfo *info;
365
366 info = mono_find_jit_opcode_emulation (ins->opcode);
367 if (info) {
368 MonoInst **args;
369 MonoInst *call;
370
371 /* Create dummy MonoInst's for the arguments */
372 g_assert (!info->sig->hasthis);
373 g_assert (info->sig->param_count <= MONO_MAX_SRC_REGS);
374
375 args = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * info->sig->param_count);
376 if (info->sig->param_count > 0) {
377 int sregs [MONO_MAX_SRC_REGS];
378 int num_sregs, i;
379 num_sregs = mono_inst_get_src_registers (ins, sregs);
380 g_assert (num_sregs == info->sig->param_count);
381 for (i = 0; i < num_sregs; ++i) {
382 MONO_INST_NEW (cfg, args [i], OP_ARG);
383 args [i]->dreg = sregs [i];
384 }
385 }
386
387 call = mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, args);
388 call->dreg = ins->dreg;
389
390 NULLIFY_INS (ins);
391 }
392 break;
393 }
394 }
395
396 if (ins->opcode == OP_NOP) {
397 if (repl) {
398 repl->type = type;
399 return repl;
400 } else {
401 /* Use the last emitted instruction */
402 ins = cfg->cbb->last_ins;
403 g_assert (ins);
404 ins->type = type;
405 g_assert (ins->dreg == dreg);
406 return ins;
407 }
408 } else {
409 return ins;
410 }
411 }
412
413 #if SIZEOF_REGISTER == 4
414 static int lbr_decomp [][2] = {
415 {0, 0}, /* BEQ */
416 {OP_IBGT, OP_IBGE_UN}, /* BGE */
417 {OP_IBGT, OP_IBGT_UN}, /* BGT */
418 {OP_IBLT, OP_IBLE_UN}, /* BLE */
419 {OP_IBLT, OP_IBLT_UN}, /* BLT */
420 {0, 0}, /* BNE_UN */
421 {OP_IBGT_UN, OP_IBGE_UN}, /* BGE_UN */
422 {OP_IBGT_UN, OP_IBGT_UN}, /* BGT_UN */
423 {OP_IBLT_UN, OP_IBLE_UN}, /* BLE_UN */
424 {OP_IBLT_UN, OP_IBLT_UN}, /* BLT_UN */
425 };
426
427 static int lcset_decomp [][2] = {
428 {0, 0}, /* CEQ */
429 {OP_IBLT, OP_IBLE_UN}, /* CGT */
430 {OP_IBLT_UN, OP_IBLE_UN}, /* CGT_UN */
431 {OP_IBGT, OP_IBGE_UN}, /* CLT */
432 {OP_IBGT_UN, OP_IBGE_UN}, /* CLT_UN */
433 };
434 #endif
435
436 /**
437 * mono_decompose_long_opts:
438 *
439 * Decompose 64bit opcodes into 32bit opcodes on 32 bit platforms.
440 */
441 void
442 mono_decompose_long_opts (MonoCompile *cfg)
443 {
444 #if SIZEOF_REGISTER == 4
445 MonoBasicBlock *bb, *first_bb;
446
447 /*
448 * Some opcodes, like lcall can't be decomposed so the rest of the JIT
449 * needs to be able to handle long vregs.
450 */
451
452 /* reg + 1 contains the ls word, reg + 2 contains the ms word */
453
454 /**
455 * Create a dummy bblock and emit code into it so we can use the normal
456 * code generation macros.
457 */
458 cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
459 first_bb = cfg->cbb;
460
461 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
462 MonoInst *tree = bb->code;
463 MonoInst *prev = NULL;
464
465 /*
466 mono_print_bb (bb, "BEFORE LOWER_LONG_OPTS");
467 */
468
469 tree = bb->code;
470 cfg->cbb->code = cfg->cbb->last_ins = NULL;
471
472 while (tree) {
473
474 #ifdef MONO_ARCH_HAVE_DECOMPOSE_LONG_OPTS
475 mono_arch_decompose_long_opts (cfg, tree);
476 #endif
477
478 switch (tree->opcode) {
479 case OP_I8CONST:
480 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 1, tree->inst_ls_word);
481 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, tree->inst_ms_word);
482 break;
483 case OP_LMOVE:
484 case OP_LCONV_TO_U8:
485 case OP_LCONV_TO_I8:
486 case OP_LCONV_TO_OVF_U8_UN:
487 case OP_LCONV_TO_OVF_I8:
488 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1 + 1);
489 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 2, tree->sreg1 + 2);
490 break;
491 case OP_STOREI8_MEMBASE_REG:
492 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, tree->inst_destbasereg, tree->inst_offset + MINI_MS_WORD_OFFSET, tree->sreg1 + 2);
493 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, tree->inst_destbasereg, tree->inst_offset + MINI_LS_WORD_OFFSET, tree->sreg1 + 1);
494 break;
495 case OP_LOADI8_MEMBASE:
496 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, tree->dreg + 2, tree->inst_basereg, tree->inst_offset + MINI_MS_WORD_OFFSET);
497 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, tree->dreg + 1, tree->inst_basereg, tree->inst_offset + MINI_LS_WORD_OFFSET);
498 break;
499
500 case OP_ICONV_TO_I8: {
501 guint32 tmpreg = alloc_ireg (cfg);
502
503 /* branchless code:
504 * low = reg;
505 * tmp = low > -1 ? 1: 0;
506 * high = tmp - 1; if low is zero or pos high becomes 0, else -1
507 */
508 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1);
509 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, tree->dreg + 1, -1);
510 MONO_EMIT_NEW_BIALU (cfg, OP_ICGT, tmpreg, -1, -1);
511 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISUB_IMM, tree->dreg + 2, tmpreg, 1);
512 break;
513 }
514 case OP_ICONV_TO_U8:
515 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1);
516 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, 0);
517 break;
518 case OP_ICONV_TO_OVF_I8:
519 /* a signed 32 bit num always fits in a signed 64 bit one */
520 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_IMM, tree->dreg + 2, tree->sreg1, 31);
521 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1);
522 break;
523 case OP_ICONV_TO_OVF_U8:
524 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1, 0);
525 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
526 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, 0);
527 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1);
528 break;
529 case OP_ICONV_TO_OVF_I8_UN:
530 case OP_ICONV_TO_OVF_U8_UN:
531 /* an unsigned 32 bit num always fits in an (un)signed 64 bit one */
532 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, 0);
533 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1);
534 break;
535 case OP_LCONV_TO_I1:
536 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I1, tree->dreg, tree->sreg1 + 1);
537 break;
538 case OP_LCONV_TO_U1:
539 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_U1, tree->dreg, tree->sreg1 + 1);
540 break;
541 case OP_LCONV_TO_I2:
542 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I2, tree->dreg, tree->sreg1 + 1);
543 break;
544 case OP_LCONV_TO_U2:
545 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_U2, tree->dreg, tree->sreg1 + 1);
546 break;
547 case OP_LCONV_TO_I4:
548 case OP_LCONV_TO_U4:
549 case OP_LCONV_TO_I:
550 case OP_LCONV_TO_U:
551 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg, tree->sreg1 + 1);
552 break;
553 case OP_LCONV_TO_R8:
554 MONO_EMIT_NEW_BIALU (cfg, OP_LCONV_TO_R8_2, tree->dreg, tree->sreg1 + 1, tree->sreg1 + 2);
555 break;
556 case OP_LCONV_TO_R4:
557 MONO_EMIT_NEW_BIALU (cfg, OP_LCONV_TO_R4_2, tree->dreg, tree->sreg1 + 1, tree->sreg1 + 2);
558 break;
559 case OP_LCONV_TO_R_UN:
560 MONO_EMIT_NEW_BIALU (cfg, OP_LCONV_TO_R_UN_2, tree->dreg, tree->sreg1 + 1, tree->sreg1 + 2);
561 break;
562 case OP_LCONV_TO_OVF_I1: {
563 MonoBasicBlock *is_negative, *end_label;
564
565 NEW_BBLOCK (cfg, is_negative);
566 NEW_BBLOCK (cfg, end_label);
567
568 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
569 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
570 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, -1);
571 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
572
573 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
574 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBLT, is_negative);
575
576 /* Positive */
577 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 127);
578 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
579 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_label);
580
581 /* Negative */
582 MONO_START_BB (cfg, is_negative);
583 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, -128);
584 MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "OverflowException");
585
586 MONO_START_BB (cfg, end_label);
587
588 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I1, tree->dreg, tree->sreg1 + 1);
589 break;
590 }
591 case OP_LCONV_TO_OVF_I1_UN:
592 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
593 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
594
595 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 127);
596 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
597 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, -128);
598 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
599 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I1, tree->dreg, tree->sreg1 + 1);
600 break;
601 case OP_LCONV_TO_OVF_U1:
602 case OP_LCONV_TO_OVF_U1_UN:
603 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
604 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
605
606 /* probe value to be within 0 to 255 */
607 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 255);
608 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
609 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, tree->dreg, tree->sreg1 + 1, 0xff);
610 break;
611 case OP_LCONV_TO_OVF_I2: {
612 MonoBasicBlock *is_negative, *end_label;
613
614 NEW_BBLOCK (cfg, is_negative);
615 NEW_BBLOCK (cfg, end_label);
616
617 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
618 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
619 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, -1);
620 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
621
622 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
623 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBLT, is_negative);
624
625 /* Positive */
626 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 32767);
627 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
628 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_label);
629
630 /* Negative */
631 MONO_START_BB (cfg, is_negative);
632 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, -32768);
633 MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "OverflowException");
634 MONO_START_BB (cfg, end_label);
635
636 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I2, tree->dreg, tree->sreg1 + 1);
637 break;
638 }
639 case OP_LCONV_TO_OVF_I2_UN:
640 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
641 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
642
643 /* Probe value to be within -32768 and 32767 */
644 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 32767);
645 MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
646 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, -32768);
647 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
648 MONO_EMIT_NEW_UNALU (cfg, OP_ICONV_TO_I2, tree->dreg, tree->sreg1 + 1);
649 break;
650 case OP_LCONV_TO_OVF_U2:
651 case OP_LCONV_TO_OVF_U2_UN:
652 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
653 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
654
655 /* Probe value to be within 0 and 65535 */
656 MONO_EMIT_NEW_COMPARE_IMM (cfg, tree->sreg1 + 1, 0xffff);
657 MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
658 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, tree->dreg, tree->sreg1 + 1, 0xffff);
659 break;
660 case OP_LCONV_TO_OVF_I4:
661 case OP_LCONV_TO_OVF_I:
662 MONO_EMIT_NEW_BIALU (cfg, OP_LCONV_TO_OVF_I4_2, tree->dreg, tree->sreg1 + 1, tree->sreg1 + 2);
663 break;
664 case OP_LCONV_TO_OVF_U4:
665 case OP_LCONV_TO_OVF_U:
666 case OP_LCONV_TO_OVF_U4_UN:
667 case OP_LCONV_TO_OVF_U_UN:
668 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
669 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
670 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg, tree->sreg1 + 1);
671 break;
672 case OP_LCONV_TO_OVF_I_UN:
673 case OP_LCONV_TO_OVF_I4_UN:
674 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
675 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "OverflowException");
676 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 1, 0);
677 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
678 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg, tree->sreg1 + 1);
679 break;
680 case OP_LCONV_TO_OVF_U8:
681 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
682 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
683
684 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1 + 1);
685 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 2, tree->sreg1 + 2);
686 break;
687 case OP_LCONV_TO_OVF_I8_UN:
688 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tree->sreg1 + 2, 0);
689 MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
690
691 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1 + 1);
692 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 2, tree->sreg1 + 2);
693 break;
694
695 case OP_LADD:
696 MONO_EMIT_NEW_BIALU (cfg, OP_IADDCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
697 MONO_EMIT_NEW_BIALU (cfg, OP_IADC, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
698 break;
699 case OP_LSUB:
700 MONO_EMIT_NEW_BIALU (cfg, OP_ISUBCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
701 MONO_EMIT_NEW_BIALU (cfg, OP_ISBB, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
702 break;
703
704 case OP_LADD_OVF:
705 /* ADC sets the condition code */
706 MONO_EMIT_NEW_BIALU (cfg, OP_IADDCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
707 MONO_EMIT_NEW_BIALU (cfg, OP_IADC, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
708 MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
709 break;
710 case OP_LADD_OVF_UN:
711 /* ADC sets the condition code */
712 MONO_EMIT_NEW_BIALU (cfg, OP_IADDCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
713 MONO_EMIT_NEW_BIALU (cfg, OP_IADC, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
714 MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
715 break;
716 case OP_LSUB_OVF:
717 /* SBB sets the condition code */
718 MONO_EMIT_NEW_BIALU (cfg, OP_ISUBCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
719 MONO_EMIT_NEW_BIALU (cfg, OP_ISBB, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
720 MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
721 break;
722 case OP_LSUB_OVF_UN:
723 /* SBB sets the condition code */
724 MONO_EMIT_NEW_BIALU (cfg, OP_ISUBCC, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
725 MONO_EMIT_NEW_BIALU (cfg, OP_ISBB, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
726 MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
727 break;
728 case OP_LAND:
729 MONO_EMIT_NEW_BIALU (cfg, OP_IAND, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
730 MONO_EMIT_NEW_BIALU (cfg, OP_IAND, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
731 break;
732 case OP_LOR:
733 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
734 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
735 break;
736 case OP_LXOR:
737 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, tree->dreg + 1, tree->sreg1 + 1, tree->sreg2 + 1);
738 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, tree->dreg + 2, tree->sreg1 + 2, tree->sreg2 + 2);
739 break;
740 case OP_LNOT:
741 MONO_EMIT_NEW_UNALU (cfg, OP_INOT, tree->dreg + 1, tree->sreg1 + 1);
742 MONO_EMIT_NEW_UNALU (cfg, OP_INOT, tree->dreg + 2, tree->sreg1 + 2);
743 break;
744 case OP_LNEG:
745 /* Handled in mono_arch_decompose_long_opts () */
746 g_assert_not_reached ();
747 break;
748 case OP_LMUL:
749 /* Emulated */
750 /* FIXME: Add OP_BIGMUL optimization */
751 break;
752
753 case OP_LADD_IMM:
754 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADDCC_IMM, tree->dreg + 1, tree->sreg1 + 1, tree->inst_ls_word);
755 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADC_IMM, tree->dreg + 2, tree->sreg1 + 2, tree->inst_ms_word);
756 break;
757 case OP_LSUB_IMM:
758 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SUBCC_IMM, tree->dreg + 1, tree->sreg1 + 1, tree->inst_ls_word);
759 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SBB_IMM, tree->dreg + 2, tree->sreg1 + 2, tree->inst_ms_word);
760 break;
761 case OP_LAND_IMM:
762 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, tree->dreg + 1, tree->sreg1 + 1, tree->inst_ls_word);
763 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, tree->dreg + 2, tree->sreg1 + 2, tree->inst_ms_word);
764 break;
765 case OP_LOR_IMM:
766 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_OR_IMM, tree->dreg + 1, tree->sreg1 + 1, tree->inst_ls_word);
767 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_OR_IMM, tree->dreg + 2, tree->sreg1 + 2, tree->inst_ms_word);
768 break;
769 case OP_LXOR_IMM:
770 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_XOR_IMM, tree->dreg + 1, tree->sreg1 + 1, tree->inst_ls_word);
771 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_XOR_IMM, tree->dreg + 2, tree->sreg1 + 2, tree->inst_ms_word);
772 break;
773 case OP_LSHR_UN_IMM:
774 if (tree->inst_c1 == 32) {
775
776 /* The original code had this comment: */
777 /* special case that gives a nice speedup and happens to workaorund a ppc jit but (for the release)
778 * later apply the speedup to the left shift as well
779 * See BUG# 57957.
780 */
781 /* FIXME: Move this to the strength reduction pass */
782 /* just move the upper half to the lower and zero the high word */
783 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 1, tree->sreg1 + 2);
784 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, 0);
785 }
786 break;
787 case OP_LSHL_IMM:
788 if (tree->inst_c1 == 32) {
789 /* just move the lower half to the upper and zero the lower word */
790 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, tree->dreg + 2, tree->sreg1 + 1);
791 MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 1, 0);
792 }
793 break;
794
795 case OP_LCOMPARE: {
796 MonoInst *next = tree->next;
797
798 g_assert (next);
799
800 switch (next->opcode) {
801 case OP_LBEQ:
802 case OP_LBNE_UN: {
803 int d1, d2;
804
805 /* Branchless version based on gcc code */
806 d1 = alloc_ireg (cfg);
807 d2 = alloc_ireg (cfg);
808 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, d1, tree->sreg1 + 1, tree->sreg2 + 1);
809 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, d2, tree->sreg1 + 2, tree->sreg2 + 2);
810 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, d1, d1, d2);
811 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, d1, 0);
812 MONO_EMIT_NEW_BRANCH_BLOCK2 (cfg, next->opcode == OP_LBEQ ? OP_IBEQ : OP_IBNE_UN, next->inst_true_bb, next->inst_false_bb);
813 next->opcode = OP_NOP;
814 break;
815 }
816 case OP_LBGE:
817 case OP_LBGT:
818 case OP_LBLE:
819 case OP_LBLT:
820 case OP_LBGE_UN:
821 case OP_LBGT_UN:
822 case OP_LBLE_UN:
823 case OP_LBLT_UN:
824 /* Convert into three comparisons + branches */
825 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 2, tree->sreg2 + 2);
826 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lbr_decomp [next->opcode - OP_LBEQ][0], next->inst_true_bb);
827 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 2, tree->sreg2 + 2);
828 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, next->inst_false_bb);
829 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 1, tree->sreg2 + 1);
830 MONO_EMIT_NEW_BRANCH_BLOCK2 (cfg, lbr_decomp [next->opcode - OP_LBEQ][1], next->inst_true_bb, next->inst_false_bb);
831 next->opcode = OP_NOP;
832 break;
833 case OP_LCEQ: {
834 int d1, d2;
835
836 /* Branchless version based on gcc code */
837 d1 = alloc_ireg (cfg);
838 d2 = alloc_ireg (cfg);
839 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, d1, tree->sreg1 + 1, tree->sreg2 + 1);
840 MONO_EMIT_NEW_BIALU (cfg, OP_IXOR, d2, tree->sreg1 + 2, tree->sreg2 + 2);
841 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, d1, d1, d2);
842
843 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, d1, 0);
844 MONO_EMIT_NEW_UNALU (cfg, OP_ICEQ, next->dreg, -1);
845 next->opcode = OP_NOP;
846 break;
847 }
848 case OP_LCLT:
849 case OP_LCLT_UN:
850 case OP_LCGT:
851 case OP_LCGT_UN: {
852 MonoBasicBlock *set_to_0, *set_to_1;
853
854 NEW_BBLOCK (cfg, set_to_0);
855 NEW_BBLOCK (cfg, set_to_1);
856
857 MONO_EMIT_NEW_ICONST (cfg, next->dreg, 0);
858 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 2, tree->sreg2 + 2);
859 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lcset_decomp [next->opcode - OP_LCEQ][0], set_to_0);
860 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 2, tree->sreg2 + 2);
861 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, set_to_1);
862 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, tree->sreg1 + 1, tree->sreg2 + 1);
863 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lcset_decomp [next->opcode - OP_LCEQ][1], set_to_0);
864 MONO_START_BB (cfg, set_to_1);
865 MONO_EMIT_NEW_ICONST (cfg, next->dreg, 1);
866 MONO_START_BB (cfg, set_to_0);
867 next->opcode = OP_NOP;
868 break;
869 }
870 default:
871 g_assert_not_reached ();
872 }
873 break;
874 }
875
876 /* Not yet used, since lcompare is decomposed before local cprop */
877 case OP_LCOMPARE_IMM: {
878 MonoInst *next = tree->next;
879 guint32 low_imm = tree->inst_ls_word;
880 guint32 high_imm = tree->inst_ms_word;
881 int low_reg = tree->sreg1 + 1;
882 int high_reg = tree->sreg1 + 2;
883
884 g_assert (next);
885
886 switch (next->opcode) {
887 case OP_LBEQ:
888 case OP_LBNE_UN: {
889 int d1, d2;
890
891 /* Branchless version based on gcc code */
892 d1 = alloc_ireg (cfg);
893 d2 = alloc_ireg (cfg);
894 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IXOR_IMM, d1, low_reg, low_imm);
895 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IXOR_IMM, d2, high_reg, high_imm);
896 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, d1, d1, d2);
897 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, d1, 0);
898 MONO_EMIT_NEW_BRANCH_BLOCK2 (cfg, next->opcode == OP_LBEQ ? OP_IBEQ : OP_IBNE_UN, next->inst_true_bb, next->inst_false_bb);
899 next->opcode = OP_NOP;
900 break;
901 }
902
903 case OP_LBGE:
904 case OP_LBGT:
905 case OP_LBLE:
906 case OP_LBLT:
907 case OP_LBGE_UN:
908 case OP_LBGT_UN:
909 case OP_LBLE_UN:
910 case OP_LBLT_UN:
911 /* Convert into three comparisons + branches */
912 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, high_reg, high_imm);
913 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lbr_decomp [next->opcode - OP_LBEQ][0], next->inst_true_bb);
914 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, high_reg, high_imm);
915 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, next->inst_false_bb);
916 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, low_reg, low_imm);
917 MONO_EMIT_NEW_BRANCH_BLOCK2 (cfg, lbr_decomp [next->opcode - OP_LBEQ][1], next->inst_true_bb, next->inst_false_bb);
918 next->opcode = OP_NOP;
919 break;
920 case OP_LCEQ: {
921 int d1, d2;
922
923 /* Branchless version based on gcc code */
924 d1 = alloc_ireg (cfg);
925 d2 = alloc_ireg (cfg);
926 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IXOR_IMM, d1, low_reg, low_imm);
927 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IXOR_IMM, d2, high_reg, high_imm);
928 MONO_EMIT_NEW_BIALU (cfg, OP_IOR, d1, d1, d2);
929
930 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, d1, 0);
931 MONO_EMIT_NEW_UNALU (cfg, OP_ICEQ, next->dreg, -1);
932 next->opcode = OP_NOP;
933 break;
934 }
935 case OP_LCLT:
936 case OP_LCLT_UN:
937 case OP_LCGT:
938 case OP_LCGT_UN: {
939 MonoBasicBlock *set_to_0, *set_to_1;
940
941 NEW_BBLOCK (cfg, set_to_0);
942 NEW_BBLOCK (cfg, set_to_1);
943
944 MONO_EMIT_NEW_ICONST (cfg, next->dreg, 0);
945 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, high_reg, high_imm);
946 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lcset_decomp [next->opcode - OP_LCEQ][0], set_to_0);
947 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, high_reg, high_imm);
948 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, set_to_1);
949 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, low_reg, low_imm);
950 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, lcset_decomp [next->opcode - OP_LCEQ][1], set_to_0);
951 MONO_START_BB (cfg, set_to_1);
952 MONO_EMIT_NEW_ICONST (cfg, next->dreg, 1);
953 MONO_START_BB (cfg, set_to_0);
954 next->opcode = OP_NOP;
955 break;
956 }
957 default:
958 g_assert_not_reached ();
959 }
960 break;
961 }
962
963 default:
964 break;
965 }
966
967 if (cfg->cbb->code || (cfg->cbb != first_bb)) {
968 MonoInst *new_prev;
969
970 /* Replace the original instruction with the new code sequence */
971
972 /* Ignore the new value of prev */
973 new_prev = prev;
974 mono_replace_ins (cfg, bb, tree, &new_prev, first_bb, cfg->cbb);
975
976 /* Process the newly added ops again since they can be long ops too */
977 if (prev)
978 tree = prev->next;
979 else
980 tree = bb->code;
981
982 first_bb->code = first_bb->last_ins = NULL;
983 first_bb->in_count = first_bb->out_count = 0;
984 cfg->cbb = first_bb;
985 }
986 else {
987 prev = tree;
988 tree = tree->next;
989 }
990 }
991 }
992 #endif
993
994 /*
995 for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
996 mono_print_bb (bb, "AFTER LOWER-LONG-OPTS");
997 */
998 }
999
1000 /**
1001 * mono_decompose_vtype_opts:
1002 *
1003 * Decompose valuetype opcodes.
1004 */
1005 void
1006 mono_decompose_vtype_opts (MonoCompile *cfg)
1007 {
1008 MonoBasicBlock *bb, *first_bb;
1009
1010 /**
1011 * Using OP_V opcodes and decomposing them later have two main benefits:
1012 * - it simplifies method_to_ir () since there is no need to special-case vtypes
1013 * everywhere.
1014 * - it gets rid of the LDADDR opcodes generated when vtype operations are decomposed,
1015 * enabling optimizations to work on vtypes too.
1016 * Unlike decompose_long_opts, this pass does not alter the CFG of the method so it
1017 * can be executed anytime. It should be executed as late as possible so vtype
1018 * opcodes can be optimized by the other passes.
1019 * The pinvoke wrappers need to manipulate vtypes in their unmanaged representation.
1020 * This is indicated by setting the 'backend.is_pinvoke' field of the MonoInst for the
1021 * var to 1.
1022 * This is done on demand, ie. by the LDNATIVEOBJ opcode, and propagated by this pass
1023 * when OP_VMOVE opcodes are decomposed.
1024 */
1025
1026 /*
1027 * Vregs have no associated type information, so we store the type of the vregs
1028 * in ins->klass.
1029 */
1030
1031 /**
1032 * Create a dummy bblock and emit code into it so we can use the normal
1033 * code generation macros.
1034 */
1035 cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
1036 first_bb = cfg->cbb;
1037
1038 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1039 MonoInst *ins;
1040 MonoInst *prev = NULL;
1041 MonoInst *src_var, *dest_var, *src, *dest;
1042 gboolean restart;
1043 int dreg;
1044
1045 if (cfg->verbose_level > 2) mono_print_bb (bb, "BEFORE LOWER-VTYPE-OPTS ");
1046
1047 cfg->cbb->code = cfg->cbb->last_ins = NULL;
1048 restart = TRUE;
1049
1050 while (restart) {
1051 restart = FALSE;
1052
1053 for (ins = bb->code; ins; ins = ins->next) {
1054 switch (ins->opcode) {
1055 case OP_VMOVE: {
1056 src_var = get_vreg_to_inst (cfg, ins->sreg1);
1057 dest_var = get_vreg_to_inst (cfg, ins->dreg);
1058
1059 g_assert (ins->klass);
1060
1061 if (!src_var)
1062 src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg);
1063
1064 if (!dest_var)
1065 dest_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg);
1066
1067 // FIXME:
1068 if (src_var->backend.is_pinvoke)
1069 dest_var->backend.is_pinvoke = 1;
1070
1071 EMIT_NEW_VARLOADA ((cfg), (src), src_var, src_var->inst_vtype);
1072 EMIT_NEW_VARLOADA ((cfg), (dest), dest_var, dest_var->inst_vtype);
1073
1074 mini_emit_stobj (cfg, dest, src, src_var->klass, src_var->backend.is_pinvoke);
1075 break;
1076 }
1077 case OP_VZERO:
1078 g_assert (ins->klass);
1079
1080 EMIT_NEW_VARLOADA_VREG (cfg, dest, ins->dreg, &ins->klass->byval_arg);
1081 mini_emit_initobj (cfg, dest, NULL, ins->klass);
1082 break;
1083 case OP_STOREV_MEMBASE: {
1084 src_var = get_vreg_to_inst (cfg, ins->sreg1);
1085
1086 if (!src_var) {
1087 g_assert (ins->klass);
1088 src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1);
1089 }
1090
1091 EMIT_NEW_VARLOADA_VREG ((cfg), (src), ins->sreg1, &ins->klass->byval_arg);
1092
1093 dreg = alloc_preg (cfg);
1094 EMIT_NEW_BIALU_IMM (cfg, dest, OP_ADD_IMM, dreg, ins->inst_destbasereg, ins->inst_offset);
1095 mini_emit_stobj (cfg, dest, src, src_var->klass, src_var->backend.is_pinvoke);
1096 break;
1097 }
1098 case OP_LOADV_MEMBASE: {
1099 g_assert (ins->klass);
1100
1101 dest_var = get_vreg_to_inst (cfg, ins->dreg);
1102 // FIXME:
1103 if (!dest_var)
1104 dest_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg);
1105
1106 dreg = alloc_preg (cfg);
1107 EMIT_NEW_BIALU_IMM (cfg, src, OP_ADD_IMM, dreg, ins->inst_basereg, ins->inst_offset);
1108 EMIT_NEW_VARLOADA (cfg, dest, dest_var, dest_var->inst_vtype);
1109 mini_emit_stobj (cfg, dest, src, dest_var->klass, dest_var->backend.is_pinvoke);
1110 break;
1111 }
1112 case OP_OUTARG_VT: {
1113 g_assert (ins->klass);
1114
1115 src_var = get_vreg_to_inst (cfg, ins->sreg1);
1116 if (!src_var)
1117 src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1);
1118 EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
1119
1120 mono_arch_emit_outarg_vt (cfg, ins, src);
1121
1122 /* This might be decomposed into other vtype opcodes */
1123 restart = TRUE;
1124 break;
1125 }
1126 case OP_OUTARG_VTRETADDR: {
1127 MonoCallInst *call = (MonoCallInst*)ins->inst_p1;
1128
1129 src_var = get_vreg_to_inst (cfg, call->inst.dreg);
1130 if (!src_var)
1131 src_var = mono_compile_create_var_for_vreg (cfg, call->signature->ret, OP_LOCAL, call->inst.dreg);
1132 // FIXME: src_var->backend.is_pinvoke ?
1133
1134 EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
1135 src->dreg = ins->dreg;
1136 break;
1137 }
1138 case OP_VCALL:
1139 case OP_VCALL_REG:
1140 case OP_VCALL_MEMBASE: {
1141 MonoCallInst *call = (MonoCallInst*)ins;
1142 int size;
1143
1144 if (call->vret_in_reg) {
1145 MonoCallInst *call2;
1146
1147 /* Replace the vcall with an integer call */
1148 MONO_INST_NEW_CALL (cfg, call2, OP_NOP);
1149 memcpy (call2, call, sizeof (MonoCallInst));
1150 switch (ins->opcode) {
1151 case OP_VCALL:
1152 call2->inst.opcode = OP_CALL;
1153 break;
1154 case OP_VCALL_REG:
1155 call2->inst.opcode = OP_CALL_REG;
1156 break;
1157 case OP_VCALL_MEMBASE:
1158 call2->inst.opcode = OP_CALL_MEMBASE;
1159 break;
1160 }
1161 call2->inst.dreg = alloc_preg (cfg);
1162 MONO_ADD_INS (cfg->cbb, ((MonoInst*)call2));
1163
1164 /* Compute the vtype location */
1165 dest_var = get_vreg_to_inst (cfg, call->inst.dreg);
1166 if (!dest_var)
1167 dest_var = mono_compile_create_var_for_vreg (cfg, call->signature->ret, OP_LOCAL, call->inst.dreg);
1168 EMIT_NEW_VARLOADA (cfg, dest, dest_var, dest_var->inst_vtype);
1169
1170 /* Save the result */
1171 if (dest_var->backend.is_pinvoke)
1172 size = mono_class_native_size (mono_class_from_mono_type (dest_var->inst_vtype), NULL);
1173 else
1174 size = mono_type_size (dest_var->inst_vtype, NULL);
1175 switch (size) {
1176 case 1:
1177 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, dest->dreg, 0, call2->inst.dreg);
1178 break;
1179 case 2:
1180 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, dest->dreg, 0, call2->inst.dreg);
1181 break;
1182 case 4:
1183 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, dest->dreg, 0, call2->inst.dreg);
1184 break;
1185 case 8:
1186 #if SIZEOF_REGISTER == 4
1187 /*
1188 FIXME Other ABIs might return in different regs than the ones used for LCALL.
1189 FIXME It would be even nicer to be able to leverage the long decompose stuff.
1190 */
1191 switch (call2->inst.opcode) {
1192 case OP_CALL:
1193 call2->inst.opcode = OP_LCALL;
1194 break;
1195 case OP_CALL_REG:
1196 call2->inst.opcode = OP_LCALL_REG;
1197 break;
1198 case OP_CALL_MEMBASE:
1199 call2->inst.opcode = OP_LCALL_MEMBASE;
1200 break;
1201 }
1202 call2->inst.dreg = alloc_lreg (cfg);
1203 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, dest->dreg, MINI_MS_WORD_OFFSET, call2->inst.dreg + 2);
1204 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, dest->dreg, MINI_LS_WORD_OFFSET, call2->inst.dreg + 1);
1205 #else
1206 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, dest->dreg, 0, call2->inst.dreg);
1207 #endif
1208 break;
1209 default:
1210 /* This assumes the vtype is sizeof (gpointer) long */
1211 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, dest->dreg, 0, call2->inst.dreg);
1212 break;
1213 }
1214 } else {
1215 switch (ins->opcode) {
1216 case OP_VCALL:
1217 ins->opcode = OP_VCALL2;
1218 break;
1219 case OP_VCALL_REG:
1220 ins->opcode = OP_VCALL2_REG;
1221 break;
1222 case OP_VCALL_MEMBASE:
1223 ins->opcode = OP_VCALL2_MEMBASE;
1224 break;
1225 }
1226 ins->dreg = -1;
1227 }
1228 break;
1229 }
1230 default:
1231 break;
1232 }
1233
1234 g_assert (cfg->cbb == first_bb);
1235
1236 if (cfg->cbb->code || (cfg->cbb != first_bb)) {
1237 /* Replace the original instruction with the new code sequence */
1238
1239 mono_replace_ins (cfg, bb, ins, &prev, first_bb, cfg->cbb);
1240 first_bb->code = first_bb->last_ins = NULL;
1241 first_bb->in_count = first_bb->out_count = 0;
1242 cfg->cbb = first_bb;
1243 }
1244 else
1245 prev = ins;
1246 }
1247 }
1248
1249 if (cfg->verbose_level > 2) mono_print_bb (bb, "AFTER LOWER-VTYPE-OPTS ");
1250 }
1251 }
1252
1253 inline static MonoInst *
1254 mono_get_domainvar (MonoCompile *cfg)
1255 {
1256 if (!cfg->domainvar)
1257 cfg->domainvar = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1258 return cfg->domainvar;
1259 }
1260
1261 /**
1262 * mono_decompose_array_access_opts:
1263 *
1264 * Decompose array access opcodes.
1265 */
1266 void
1267 mono_decompose_array_access_opts (MonoCompile *cfg)
1268 {
1269 MonoBasicBlock *bb, *first_bb;
1270
1271 /*
1272 * Unlike decompose_long_opts, this pass does not alter the CFG of the method so it
1273 * can be executed anytime. It should be run before decompose_long
1274 */
1275
1276 /**
1277 * Create a dummy bblock and emit code into it so we can use the normal
1278 * code generation macros.
1279 */
1280 cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
1281 first_bb = cfg->cbb;
1282
1283 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1284 MonoInst *ins;
1285 MonoInst *prev = NULL;
1286 MonoInst *dest;
1287 MonoInst *iargs [3];
1288 gboolean restart;
1289
1290 if (!bb->has_array_access)
1291 continue;
1292
1293 if (cfg->verbose_level > 3) mono_print_bb (bb, "BEFORE DECOMPOSE-ARRAY-ACCESS-OPTS ");
1294
1295 cfg->cbb->code = cfg->cbb->last_ins = NULL;
1296 restart = TRUE;
1297
1298 while (restart) {
1299 restart = FALSE;
1300
1301 for (ins = bb->code; ins; ins = ins->next) {
1302 switch (ins->opcode) {
1303 case OP_LDLEN:
1304 NEW_LOAD_MEMBASE_FAULT (cfg, dest, OP_LOADI4_MEMBASE, ins->dreg, ins->sreg1,
1305 G_STRUCT_OFFSET (MonoArray, max_length));
1306 MONO_ADD_INS (cfg->cbb, dest);
1307 break;
1308 case OP_BOUNDS_CHECK:
1309 MONO_EMIT_NULL_CHECK (cfg, ins->sreg1);
1310 MONO_ARCH_EMIT_BOUNDS_CHECK (cfg, ins->sreg1, ins->inst_imm, ins->sreg2);
1311 break;
1312 case OP_NEWARR:
1313 if (cfg->opt & MONO_OPT_SHARED) {
1314 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
1315 EMIT_NEW_CLASSCONST (cfg, iargs [1], ins->inst_newa_class);
1316 MONO_INST_NEW (cfg, iargs [2], OP_MOVE);
1317 iargs [2]->dreg = ins->sreg1;
1318
1319 dest = mono_emit_jit_icall (cfg, mono_array_new, iargs);
1320 dest->dreg = ins->dreg;
1321 } else {
1322 MonoVTable *vtable = mono_class_vtable (cfg->domain, mono_array_class_get (ins->inst_newa_class, 1));
1323 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (vtable, 1);
1324
1325 g_assert (vtable); /*This shall not fail since we check for this condition on OP_NEWARR creation*/
1326 NEW_VTABLECONST (cfg, iargs [0], vtable);
1327 MONO_ADD_INS (cfg->cbb, iargs [0]);
1328 MONO_INST_NEW (cfg, iargs [1], OP_MOVE);
1329 iargs [1]->dreg = ins->sreg1;
1330
1331 if (managed_alloc)
1332 dest = mono_emit_method_call (cfg, managed_alloc, iargs, NULL);
1333 else
1334 dest = mono_emit_jit_icall (cfg, mono_array_new_specific, iargs);
1335 dest->dreg = ins->dreg;
1336 }
1337 break;
1338 case OP_STRLEN:
1339 MONO_EMIT_NEW_LOAD_MEMBASE_OP_FAULT (cfg, OP_LOADI4_MEMBASE, ins->dreg,
1340 ins->sreg1, G_STRUCT_OFFSET (MonoString, length));
1341 break;
1342 default:
1343 break;
1344 }
1345
1346 g_assert (cfg->cbb == first_bb);
1347
1348 if (cfg->cbb->code || (cfg->cbb != first_bb)) {
1349 /* Replace the original instruction with the new code sequence */
1350
1351 mono_replace_ins (cfg, bb, ins, &prev, first_bb, cfg->cbb);
1352 first_bb->code = first_bb->last_ins = NULL;
1353 first_bb->in_count = first_bb->out_count = 0;
1354 cfg->cbb = first_bb;
1355 }
1356 else
1357 prev = ins;
1358 }
1359 }
1360
1361 if (cfg->verbose_level > 3) mono_print_bb (bb, "AFTER DECOMPOSE-ARRAY-ACCESS-OPTS ");
1362 }
1363 }
1364
1365 typedef union {
1366 guint32 vali [2];
1367 gint64 vall;
1368 double vald;
1369 } DVal;
1370
1371 #ifdef MONO_ARCH_SOFT_FLOAT
1372
1373 /**
1374 * mono_decompose_soft_float:
1375 *
1376 * Soft float support on ARM. We store each double value in a pair of integer vregs,
1377 * similar to long support on 32 bit platforms. 32 bit float values require special
1378 * handling when used as locals, arguments, and in calls.
1379 * One big problem with soft-float is that there are few r4 test cases in our test suite.
1380 */
1381 void
1382 mono_decompose_soft_float (MonoCompile *cfg)
1383 {
1384 MonoBasicBlock *bb, *first_bb;
1385
1386 /*
1387 * This pass creates long opcodes, so it should be run before decompose_long_opts ().
1388 */
1389
1390 /**
1391 * Create a dummy bblock and emit code into it so we can use the normal
1392 * code generation macros.
1393 */
1394 cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
1395 first_bb = cfg->cbb;
1396
1397 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1398 MonoInst *ins;
1399 MonoInst *prev = NULL;
1400 gboolean restart;
1401
1402 if (cfg->verbose_level > 3) mono_print_bb (bb, "BEFORE HANDLE-SOFT-FLOAT ");
1403
1404 cfg->cbb->code = cfg->cbb->last_ins = NULL;
1405 restart = TRUE;
1406
1407 while (restart) {
1408 restart = FALSE;
1409
1410 for (ins = bb->code; ins; ins = ins->next) {
1411 const char *spec = INS_INFO (ins->opcode);
1412
1413 /* Most fp operations are handled automatically by opcode emulation */
1414
1415 switch (ins->opcode) {
1416 case OP_R8CONST: {
1417 DVal d;
1418 d.vald = *(double*)ins->inst_p0;
1419 MONO_EMIT_NEW_I8CONST (cfg, ins->dreg, d.vall);
1420 break;
1421 }
1422 case OP_R4CONST: {
1423 DVal d;
1424 /* We load the r8 value */
1425 d.vald = *(float*)ins->inst_p0;
1426 MONO_EMIT_NEW_I8CONST (cfg, ins->dreg, d.vall);
1427 break;
1428 }
1429 case OP_FMOVE:
1430 ins->opcode = OP_LMOVE;
1431 break;
1432 case OP_FGETLOW32:
1433 ins->opcode = OP_MOVE;
1434 ins->sreg1 = ins->sreg1 + 1;
1435 break;
1436 case OP_FGETHIGH32:
1437 ins->opcode = OP_MOVE;
1438 ins->sreg1 = ins->sreg1 + 2;
1439 break;
1440 case OP_SETFRET: {
1441 int reg = ins->sreg1;
1442
1443 ins->opcode = OP_SETLRET;
1444 ins->dreg = -1;
1445 ins->sreg1 = reg + 1;
1446 ins->sreg2 = reg + 2;
1447 break;
1448 }
1449 case OP_LOADR8_MEMBASE:
1450 ins->opcode = OP_LOADI8_MEMBASE;
1451 break;
1452 case OP_STORER8_MEMBASE_REG:
1453 ins->opcode = OP_STOREI8_MEMBASE_REG;
1454 break;
1455 case OP_STORER4_MEMBASE_REG: {
1456 MonoInst *iargs [2];
1457 int addr_reg;
1458
1459 /* Arg 1 is the double value */
1460 MONO_INST_NEW (cfg, iargs [0], OP_ARG);
1461 iargs [0]->dreg = ins->sreg1;
1462
1463 /* Arg 2 is the address to store to */
1464 addr_reg = mono_alloc_preg (cfg);
1465 EMIT_NEW_BIALU_IMM (cfg, iargs [1], OP_PADD_IMM, addr_reg, ins->inst_destbasereg, ins->inst_offset);
1466 mono_emit_jit_icall (cfg, mono_fstore_r4, iargs);
1467 restart = TRUE;
1468 break;
1469 }
1470 case OP_LOADR4_MEMBASE: {
1471 MonoInst *iargs [1];
1472 MonoInst *conv;
1473 int addr_reg;
1474
1475 addr_reg = mono_alloc_preg (cfg);
1476 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, addr_reg, ins->inst_basereg, ins->inst_offset);
1477 conv = mono_emit_jit_icall (cfg, mono_fload_r4, iargs);
1478 conv->dreg = ins->dreg;
1479 break;
1480 }
1481 case OP_FCALL:
1482 case OP_FCALL_REG:
1483 case OP_FCALL_MEMBASE: {
1484 MonoCallInst *call = (MonoCallInst*)ins;
1485 if (call->signature->ret->type == MONO_TYPE_R4) {
1486 MonoCallInst *call2;
1487 MonoInst *iargs [1];
1488 MonoInst *conv;
1489
1490 /* Convert the call into a call returning an int */
1491 MONO_INST_NEW_CALL (cfg, call2, OP_CALL);
1492 memcpy (call2, call, sizeof (MonoCallInst));
1493 switch (ins->opcode) {
1494 case OP_FCALL:
1495 call2->inst.opcode = OP_CALL;
1496 break;
1497 case OP_FCALL_REG:
1498 call2->inst.opcode = OP_CALL_REG;
1499 break;
1500 case OP_FCALL_MEMBASE:
1501 call2->inst.opcode = OP_CALL_MEMBASE;
1502 break;
1503 default:
1504 g_assert_not_reached ();
1505 }
1506 call2->inst.dreg = mono_alloc_ireg (cfg);
1507 MONO_ADD_INS (cfg->cbb, (MonoInst*)call2);
1508
1509 /* FIXME: Optimize this */
1510
1511 /* Emit an r4->r8 conversion */
1512 EMIT_NEW_VARLOADA_VREG (cfg, iargs [0], call2->inst.dreg, &mono_defaults.int32_class->byval_arg);
1513 conv = mono_emit_jit_icall (cfg, mono_fload_r4, iargs);
1514 conv->dreg = ins->dreg;
1515
1516 /* The call sequence might include fp ins */
1517 restart = TRUE;
1518 } else {
1519 switch (ins->opcode) {
1520 case OP_FCALL:
1521 ins->opcode = OP_LCALL;
1522 break;
1523 case OP_FCALL_REG:
1524 ins->opcode = OP_LCALL_REG;
1525 break;
1526 case OP_FCALL_MEMBASE:
1527 ins->opcode = OP_LCALL_MEMBASE;
1528 break;
1529 default:
1530 g_assert_not_reached ();
1531 }
1532 }
1533 break;
1534 }
1535 case OP_FCOMPARE: {
1536 MonoJitICallInfo *info;
1537 MonoInst *iargs [2];
1538 MonoInst *call, *cmp, *br;
1539
1540 /* Convert fcompare+fbcc to icall+icompare+beq */
1541
1542 info = mono_find_jit_opcode_emulation (ins->next->opcode);
1543 g_assert (info);
1544
1545 /* Create dummy MonoInst's for the arguments */
1546 MONO_INST_NEW (cfg, iargs [0], OP_ARG);
1547 iargs [0]->dreg = ins->sreg1;
1548 MONO_INST_NEW (cfg, iargs [1], OP_ARG);
1549 iargs [1]->dreg = ins->sreg2;
1550
1551 call = mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, iargs);
1552
1553 MONO_INST_NEW (cfg, cmp, OP_ICOMPARE_IMM);
1554 cmp->sreg1 = call->dreg;
1555 cmp->inst_imm = 0;
1556 MONO_ADD_INS (cfg->cbb, cmp);
1557
1558 MONO_INST_NEW (cfg, br, OP_IBNE_UN);
1559 br->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * 2);
1560 br->inst_true_bb = ins->next->inst_true_bb;
1561 br->inst_false_bb = ins->next->inst_false_bb;
1562 MONO_ADD_INS (cfg->cbb, br);
1563
1564 /* The call sequence might include fp ins */
1565 restart = TRUE;
1566
1567 /* Skip fbcc or fccc */
1568 NULLIFY_INS (ins->next);
1569 break;
1570 }
1571 case OP_FCEQ:
1572 case OP_FCGT:
1573 case OP_FCGT_UN:
1574 case OP_FCLT:
1575 case OP_FCLT_UN: {
1576 MonoJitICallInfo *info;
1577 MonoInst *iargs [2];
1578 MonoInst *call;
1579
1580 /* Convert fccc to icall+icompare+iceq */
1581
1582 info = mono_find_jit_opcode_emulation (ins->opcode);
1583 g_assert (info);
1584
1585 /* Create dummy MonoInst's for the arguments */
1586 MONO_INST_NEW (cfg, iargs [0], OP_ARG);
1587 iargs [0]->dreg = ins->sreg1;
1588 MONO_INST_NEW (cfg, iargs [1], OP_ARG);
1589 iargs [1]->dreg = ins->sreg2;
1590
1591 call = mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, iargs);
1592
1593 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, call->dreg, 1);
1594 MONO_EMIT_NEW_UNALU (cfg, OP_ICEQ, ins->dreg, -1);
1595
1596 /* The call sequence might include fp ins */
1597 restart = TRUE;
1598 break;
1599 }
1600 case OP_CKFINITE: {
1601 MonoInst *iargs [2];
1602 MonoInst *call, *cmp;
1603
1604 /* Convert to icall+icompare+cond_exc+move */
1605
1606 /* Create dummy MonoInst's for the arguments */
1607 MONO_INST_NEW (cfg, iargs [0], OP_ARG);
1608 iargs [0]->dreg = ins->sreg1;
1609
1610 call = mono_emit_jit_icall (cfg, mono_isfinite, iargs);
1611
1612 MONO_INST_NEW (cfg, cmp, OP_ICOMPARE_IMM);
1613 cmp->sreg1 = call->dreg;
1614 cmp->inst_imm = 1;
1615 MONO_ADD_INS (cfg->cbb, cmp);
1616
1617 MONO_EMIT_NEW_COND_EXC (cfg, INE_UN, "ArithmeticException");
1618
1619 /* Do the assignment if the value is finite */
1620 MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, ins->dreg, ins->sreg1);
1621
1622 restart = TRUE;
1623 break;
1624 }
1625 default:
1626 if (spec [MONO_INST_SRC1] == 'f' || spec [MONO_INST_SRC2] == 'f' || spec [MONO_INST_DEST] == 'f') {
1627 mono_print_ins (ins);
1628 g_assert_not_reached ();
1629 }
1630 break;
1631 }
1632
1633 g_assert (cfg->cbb == first_bb);
1634
1635 if (cfg->cbb->code || (cfg->cbb != first_bb)) {
1636 /* Replace the original instruction with the new code sequence */
1637
1638 mono_replace_ins (cfg, bb, ins, &prev, first_bb, cfg->cbb);
1639 first_bb->code = first_bb->last_ins = NULL;
1640 first_bb->in_count = first_bb->out_count = 0;
1641 cfg->cbb = first_bb;
1642 }
1643 else
1644 prev = ins;
1645 }
1646 }
1647
1648 if (cfg->verbose_level > 3) mono_print_bb (bb, "AFTER HANDLE-SOFT-FLOAT ");
1649 }
1650
1651 mono_decompose_long_opts (cfg);
1652 }
1653
1654 #endif
1655
1656 #endif /* DISABLE_JIT */
git-svn mirror of mono