1 #define MONO_EMIT_NEW_LOAD_R8(cfg,dr,addr) do { \
3 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
4 inst->opcode = OP_R8CONST; \
6 inst->inst_p0 = addr; \
7 mono_bblock_add_inst (cfg->cbb, inst); \
13 # inssel-ppc.brg: burg file for special ppc instructions
16 # Dietmar Maurer (dietmar@ximian.com)
17 # Paolo Molaro (lupus@ximian.com)
19 # (C) 2002 Ximian, Inc.
22 stmt: OP_START_HANDLER {
23 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
24 /*MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, spvar->inst_basereg, spvar->inst_offset, ppc_sp);
26 tree->inst_left = spvar;
27 mono_bblock_add_inst (s->cbb, tree);
31 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
32 tree->inst_left = spvar;
33 mono_bblock_add_inst (s->cbb, tree);
36 stmt: OP_ENDFILTER (reg) {
37 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
38 tree->inst_left = spvar;
39 tree->sreg1 = state->left->reg1;
40 mono_bblock_add_inst (s->cbb, tree);
43 reg: CEE_REM_UN (reg, reg),
44 reg: CEE_REM (reg, reg) "0" {
45 int div_result = mono_regstate_next_int (s->rs);
46 int mul_result = mono_regstate_next_int (s->rs);
47 MONO_EMIT_NEW_BIALU (s, (tree->opcode == CEE_REM_UN?CEE_DIV_UN:CEE_DIV), div_result, state->left->reg1, state->right->reg1);
48 MONO_EMIT_NEW_BIALU (s, CEE_MUL, mul_result, div_result, state->right->reg1);
49 MONO_EMIT_NEW_BIALU (s, CEE_SUB, state->reg1, state->left->reg1, mul_result);
52 freg: OP_CKFINITE (freg) "0" {
53 int msw_reg = mono_regstate_next_int (s->rs);
54 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_sp, -8, state->left->reg1);
55 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, msw_reg, ppc_sp, -8);
56 MONO_EMIT_NEW_UNALU (s, OP_CHECK_FINITE, -1, msw_reg);
57 MONO_EMIT_NEW_UNALU (s, OP_FMOVE, state->reg1, state->left->reg1);
60 lreg: OP_LADD_OVF (lreg, lreg) "0" {
61 /* ADC sets the condition code */
62 MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
63 MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
66 lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
67 /* ADC sets the condition code */
68 MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
69 MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
72 lreg: OP_LSUB_OVF (lreg, lreg) "0" {
73 /* SBB sets the condition code */
74 MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
75 MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
78 lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
79 /* SBB sets the condition code */
80 MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
81 MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
84 stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
85 /* this should only happen for methods returning a long */
86 MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r3, state->right->reg1);
87 MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r4, state->right->reg2);
90 lreg: OP_LNEG (lreg) "2" {
91 MONO_EMIT_NEW_BIALU_IMM (s, OP_PPC_SUBFIC, state->reg1, state->left->reg1, 0);
92 MONO_EMIT_UNALU (s, tree, OP_PPC_SUBFZE, state->reg2, state->left->reg2);
95 freg: OP_LCONV_TO_R8 (lreg) {
96 tree->dreg = state->reg1;
97 tree->sreg1 = state->left->reg1;
98 tree->sreg2 = state->left->reg2;
99 mono_bblock_add_inst (s->cbb, tree);
102 freg: OP_LCONV_TO_R4 (lreg) {
103 tree->dreg = state->reg1;
104 tree->sreg1 = state->left->reg1;
105 tree->sreg2 = state->left->reg2;
106 mono_bblock_add_inst (s->cbb, tree);
109 freg: CEE_CONV_R_UN (reg) "1" {
110 static const guint64 adjust_val = 0x4330000000000000ULL;
111 int msw_reg = mono_regstate_next_int (s->rs);
112 int adj_reg = mono_regstate_next_float (s->rs);
113 int tmp_reg = mono_regstate_next_float (s->rs);
114 MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
115 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
116 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, state->left->reg1);
117 MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
118 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
119 MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
122 freg: CEE_CONV_R8 (reg),
123 freg: CEE_CONV_R4 (reg) "1" {
124 /* FIXME: change precision for CEE_CONV_R4 */
125 static const guint64 adjust_val = 0x4330000080000000ULL;
126 int msw_reg = mono_regstate_next_int (s->rs);
127 int xored = mono_regstate_next_int (s->rs);
128 int adj_reg = mono_regstate_next_float (s->rs);
129 int tmp_reg = mono_regstate_next_float (s->rs);
130 MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
131 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
132 MONO_EMIT_NEW_BIALU_IMM (s, OP_XOR_IMM, xored, state->left->reg1, 0x80000000);
133 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, xored);
134 MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
135 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
136 MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
139 reg: OP_LOCALLOC (OP_ICONST) {
140 /* microcoded in mini-ppc.c */
141 tree->sreg1 = mono_regstate_next_int (s->rs);
142 tree->dreg = state->reg1;
143 MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
144 mono_bblock_add_inst (s->cbb, tree);
147 reg: OP_LOCALLOC (reg) {
148 tree->dreg = state->reg1;
149 tree->sreg1 = state->left->reg1;
150 mono_bblock_add_inst (s->cbb, tree);
153 stmt: OP_SETRET (reg) {
154 tree->opcode = OP_MOVE;
155 tree->sreg1 = state->left->reg1;
157 mono_bblock_add_inst (s->cbb, tree);
160 stmt: OP_SETRET (lreg) {
161 tree->opcode = OP_SETLRET;
162 tree->sreg1 = state->left->reg1;
163 tree->sreg2 = state->left->reg2;
165 mono_bblock_add_inst (s->cbb, tree);
168 stmt: OP_SETRET (freg) {
169 tree->opcode = OP_FMOVE;
170 tree->sreg1 = state->left->reg1;
172 mono_bblock_add_inst (s->cbb, tree);
175 stmt: OP_SETRET (OP_ICONST) {
176 tree->opcode = OP_ICONST;
177 tree->inst_c0 = state->left->tree->inst_c0;
179 mono_bblock_add_inst (s->cbb, tree);
182 stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
183 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
184 stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
185 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
186 int con = state->right->right->tree->inst_c0;
187 int dreg = state->left->tree->dreg;
188 int sreg = state->right->left->left->tree->dreg;
190 if (state->right->op == CEE_ADD)
191 tree->opcode = OP_ADD_IMM;
192 else if (state->right->op == CEE_SUB)
193 tree->opcode = OP_SUB_IMM;
195 g_assert_not_reached ();
196 tree->inst_imm = con;
199 mono_bblock_add_inst (s->cbb, tree);
202 stmt: OP_OUTARG_MEMBASE (reg) {
203 MonoPPCArgInfo *ai = tree->backend.data;
204 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg1);
207 stmt: OP_OUTARG_MEMBASE (OP_REGVAR) {
208 MonoPPCArgInfo *ai = tree->backend.data;
209 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->tree->dreg);
212 stmt: OP_OUTARG_MEMBASE (lreg) {
213 MonoPPCArgInfo *ai = tree->backend.data;
214 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg2);
215 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset + 4, state->left->reg1);
218 stmt: OP_OUTARG_MEMBASE (OP_ICONST) {
219 MonoPPCArgInfo *ai = tree->backend.data;
220 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, ai->offset, state->left->tree->inst_c0);
223 stmt: OP_OUTARG_MEMBASE (CEE_LDIND_REF (OP_REGVAR)) {
224 MonoPPCArgInfo *ai = tree->backend.data;
225 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->left->tree->dreg);
228 stmt: OP_OUTARG_MEMBASE (freg) {
229 MonoPPCArgInfo *ai = tree->backend.data;
230 int opcode = ai->size == 4? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
231 MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, ai->offset, state->left->reg1);
234 stmt: OP_OUTARG (reg) {
235 MonoCallInst *call = tree->inst_call;
237 tree->opcode = OP_MOVE;
238 tree->dreg = mono_regstate_next_int (s->rs);
239 tree->sreg1 = state->left->reg1;
240 mono_bblock_add_inst (s->cbb, tree);
241 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
244 stmt: OP_OUTARG (OP_REGVAR) {
245 MonoCallInst *call = tree->inst_call;
247 tree->opcode = OP_MOVE;
248 tree->dreg = mono_regstate_next_int (s->rs);
249 tree->sreg1 = state->left->tree->dreg;
250 mono_bblock_add_inst (s->cbb, tree);
251 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
254 stmt: OP_OUTARG (lreg) {
255 MonoCallInst *call = tree->inst_call;
256 int tdreg = mono_regstate_next_int (s->rs);
258 MONO_EMIT_NEW_UNALU (s, OP_MOVE, tdreg, state->left->reg2);
259 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
260 tree->opcode = OP_MOVE;
261 tree->dreg = mono_regstate_next_int (s->rs);
262 tree->sreg1 = state->left->reg1;
263 mono_bblock_add_inst (s->cbb, tree);
264 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
267 stmt: OP_OUTARG (OP_ICONST) {
268 MonoCallInst *call = tree->inst_call;
270 tree->opcode = OP_ICONST;
271 tree->dreg = mono_regstate_next_int (s->rs);
272 tree->inst_c0 = state->left->tree->inst_c0;
273 mono_bblock_add_inst (s->cbb, tree);
274 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
277 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
278 MonoCallInst *call = tree->inst_call;
280 tree->opcode = OP_MOVE;
281 tree->dreg = mono_regstate_next_int (s->rs);
282 tree->sreg1 = state->left->left->tree->dreg;
283 mono_bblock_add_inst (s->cbb, tree);
284 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
287 #stmt: OP_OUTARG (CEE_LDOBJ (reg)) {
288 # tree->opcode = OP_X86_PUSH;
289 # tree->sreg1 = state->left->reg1;
290 # mono_bblock_add_inst (s->cbb, tree);
293 stmt: OP_OUTARG_R8 (freg),
294 stmt: OP_OUTARG (freg) {
295 MonoCallInst *call = tree->inst_call;
297 tree->opcode = OP_FMOVE;
298 tree->dreg = mono_regstate_next_float (s->rs);
299 tree->sreg1 = state->left->reg1;
300 mono_bblock_add_inst (s->cbb, tree);
301 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
304 stmt: OP_OUTARG_R8 (CEE_LDOBJ (base)) {
305 /* small struct with fp value goes in a fp register */
306 MonoInst *vt = state->left->left->tree;
307 int tmpr, soffset, dreg;
308 MonoCallInst *call = tree->inst_call;
310 soffset = vt->inst_offset;
311 tmpr = mono_regstate_next_float (s->rs);
312 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR4_MEMBASE, tmpr, vt->inst_basereg, soffset);
313 dreg = mono_regstate_next_float (s->rs);
314 MONO_EMIT_NEW_UNALU (s, OP_FMOVE, dreg, tmpr);
315 mono_call_inst_add_outarg_reg (s, call, dreg, tree->backend.reg3, TRUE);
318 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
319 MonoCallInst *call = tree->inst_call;
320 MonoPPCArgInfo *ai = tree->backend.data;
321 MonoInst *vt = state->left->left->tree;
322 int start_reg = ai->reg;
323 int nregs = ai->size;
324 int ovf_size = ai->vtsize;
325 int i, tmpr, soffset, dreg;
327 soffset = vt->inst_offset;
329 Darwin needs some special handling for 1 and 2 byte arguments
332 if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
333 size = mono_class_native_size (mono_class_from_mono_type (vt->inst_vtype), NULL);
334 if (size == 2 || size == 1) {
335 tmpr = mono_regstate_next_int (s->rs);
337 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
339 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
340 dreg = mono_regstate_next_int (s->rs);
341 MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
342 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg, FALSE);
345 for (i = 0; i < nregs; ++i) {
346 tmpr = mono_regstate_next_int (s->rs);
347 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
348 dreg = mono_regstate_next_int (s->rs);
349 MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
350 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
351 soffset += sizeof (gpointer);
353 //g_print ("vt size: %d at R%d + %d\n", ai->offset, vt->inst_basereg, vt->inst_offset);
355 mini_emit_memcpy (s, ppc_r1, ai->offset + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
359 stmt: OP_OUTARG_VT (OP_ICONST) {
360 MonoCallInst *call = tree->inst_call;
361 MonoPPCArgInfo *ai = tree->backend.data;
362 int start_reg = ai->reg;
363 int nregs = ai->size;
365 tree->opcode = OP_ICONST;
366 tree->dreg = mono_regstate_next_int (s->rs);
367 tree->inst_c0 = state->left->tree->inst_c0;
368 mono_bblock_add_inst (s->cbb, tree);
369 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
371 g_assert_not_reached ();
375 stmt: OP_OUTARG_VT (reg) {
376 MonoCallInst *call = tree->inst_call;
377 MonoPPCArgInfo *ai = tree->backend.data;
378 int start_reg = ai->reg;
379 int nregs = ai->size;
381 tree->opcode = OP_MOVE;
382 tree->dreg = mono_regstate_next_int (s->rs);
383 tree->sreg1 = state->left->reg1;
384 mono_bblock_add_inst (s->cbb, tree);
385 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
387 g_assert_not_reached ();
391 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
392 /* nothing to do: the value is already on the FP stack */
395 stmt: CEE_BNE_UN (fpcflags) {
396 tree->opcode = OP_FBNE_UN;
397 mono_bblock_add_inst (s->cbb, tree);
400 stmt: CEE_BEQ (fpcflags) {
401 tree->opcode = OP_FBEQ;
402 mono_bblock_add_inst (s->cbb, tree);
405 stmt: CEE_BLT (fpcflags) {
406 tree->opcode = OP_FBLT;
407 mono_bblock_add_inst (s->cbb, tree);
410 stmt: CEE_BLT_UN (fpcflags) {
411 tree->opcode = OP_FBLT_UN;
412 mono_bblock_add_inst (s->cbb, tree);
415 stmt: CEE_BGT (fpcflags) {
416 tree->opcode = OP_FBGT;
417 mono_bblock_add_inst (s->cbb, tree);
420 stmt: CEE_BGT_UN (fpcflags) {
421 tree->opcode = OP_FBGT_UN;
422 mono_bblock_add_inst (s->cbb, tree);
425 stmt: CEE_BGE (fpcflags) {
426 tree->opcode = OP_FBGE;
427 mono_bblock_add_inst (s->cbb, tree);
430 stmt: CEE_BGE_UN (fpcflags) {
431 tree->opcode = OP_FBGE_UN;
432 mono_bblock_add_inst (s->cbb, tree);
435 stmt: CEE_BLE (fpcflags) {
436 tree->opcode = OP_FBLE;
437 mono_bblock_add_inst (s->cbb, tree);
440 stmt: CEE_BLE_UN (fpcflags) {
441 tree->opcode = OP_FBLE_UN;
442 mono_bblock_add_inst (s->cbb, tree);
445 stmt: CEE_POP (freg) "0" {
449 freg: OP_LCONV_TO_R8 (lreg) {
450 /* nothing to do - emulated */
453 freg: OP_LCONV_TO_R4 (lreg) {
454 /* nothing to do - emulated */
457 freg: OP_LCONV_TO_R_UN (lreg) {
458 /* nothing to do - emulated */
461 freg: OP_FREM (freg, freg) {
462 /* nothing to do - emulated */
465 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
466 MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
467 state->left->right->reg1);
470 reg: OP_CLT (OP_COMPARE (freg, freg)) {
471 MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
472 state->left->right->reg1);
475 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
476 MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
477 state->left->right->reg1);
480 reg: OP_CGT (OP_COMPARE (freg, freg)) {
481 MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
482 state->left->right->reg1);
485 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
486 MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
487 state->left->right->reg1);
490 reg: CEE_ADD_OVF (reg, reg) "0" {
491 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
494 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
495 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
498 reg: CEE_SUB_OVF (reg, reg) "0" {
499 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
502 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
503 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);