5 # inssel-alpha.brg: burg file for special Alpha instructions
8 # Sergey Tikhonov (tsv@solvo.ru)
10 # Derived work from other arches
15 stmt: OP_OUTARG_REG (reg) {
16 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
18 tree->opcode = OP_MOVE;
19 tree->sreg1 = state->left->reg1;
20 tree->dreg = mono_regstate_next_int (s->rs);
21 mono_bblock_add_inst (s->cbb, tree);
23 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
26 stmt: OP_OUTARG_FREG (freg) {
27 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
29 tree->opcode = OP_FMOVE;
30 tree->sreg1 = state->left->reg1;
31 tree->dreg = mono_regstate_next_float (s->rs);
32 mono_bblock_add_inst (s->cbb, tree);
34 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
37 stmt: OP_SETRET (reg) {
38 tree->opcode = OP_MOVE;
39 tree->sreg1 = state->left->reg1;
40 tree->dreg = alpha_r0;
41 mono_bblock_add_inst (s->cbb, tree);
44 stmt: OP_SETRET (freg) {
45 tree->opcode = OP_FMOVE;
46 tree->sreg1 = state->left->reg1;
47 tree->dreg = alpha_f0;
48 mono_bblock_add_inst (s->cbb, tree);
52 reg: OP_LOCALLOC (OP_ICONST) {
53 /* microcoded in mini-arm.c */
54 tree->sreg1 = mono_regstate_next_int (s->rs);
55 tree->dreg = state->reg1;
57 if (tree->flags & MONO_INST_INIT)
58 tree->sreg2 = mono_regstate_next_int (s->rs);
60 MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
61 mono_bblock_add_inst (s->cbb, tree);
64 reg: OP_LOCALLOC (reg) {
65 tree->dreg = state->reg1;
66 tree->sreg1 = state->left->reg1;
68 if (tree->flags & MONO_INST_INIT)
69 tree->sreg2 = mono_regstate_next_int (s->rs);
71 mono_bblock_add_inst (s->cbb, tree);
75 # This handles trees like outarg_vt (refanytype)
76 #stmt: OP_OUTARG_VT (reg, base) {
77 # MonoInst *stack_addr = state->right->tree;
79 # MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG,
80 # stack_addr->inst_basereg, stack_addr->inst_offset, state->left->reg1);
84 stmt: OP_OUTARG_REG (CEE_LDIND_I (base)),
85 stmt: OP_OUTARG_REG (CEE_LDIND_REF (base)),
86 stmt: OP_OUTARG_REG (CEE_LDIND_I1 (base)),
87 stmt: OP_OUTARG_REG (CEE_LDIND_U1 (base)),
88 stmt: OP_OUTARG_REG (CEE_LDIND_I2 (base)),
89 stmt: OP_OUTARG_REG (CEE_LDIND_U2 (base)),
90 stmt: OP_OUTARG_REG (CEE_LDIND_I4 (base)),
91 stmt: OP_OUTARG_REG (CEE_LDIND_U4 (base)),
92 stmt: OP_OUTARG_REG (CEE_LDIND_I8 (base)) {
93 /* FIXME: Move this to inssel.brg or inssel-long.brg */
94 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
96 MonoInst *base = state->left->left->tree;
98 dreg = mono_regstate_next_int (s->rs);
99 MONO_EMIT_LOAD_MEMBASE_OP (s, tree, ldind_to_load_membase (state->left->tree->opcode),
100 dreg, base->inst_basereg, base->inst_offset);
102 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
105 stmt: OP_OUTARG_REG (OP_I8CONST) {
106 /* FIXME: Move this to inssel.brg or inssel-long.brg */
107 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
109 tree->opcode = OP_I8CONST;
110 tree->inst_c0 = state->left->tree->inst_c0;
111 tree->dreg = mono_regstate_next_int (s->rs);
112 mono_bblock_add_inst (s->cbb, tree);
114 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
117 stmt: OP_OUTARG_REG (OP_ICONST) {
118 /* FIXME: Move this to inssel.brg or inssel-long.brg */
119 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
121 tree->opcode = OP_ICONST;
122 tree->inst_c0 = state->left->tree->inst_c0;
123 tree->dreg = mono_regstate_next_int (s->rs);
124 mono_bblock_add_inst (s->cbb, tree);
126 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
129 stmt: OP_OUTARG_REG (CEE_LDIND_I (OP_REGVAR)),
130 stmt: OP_OUTARG_REG (CEE_LDIND_I8 (OP_REGVAR)),
131 stmt: OP_OUTARG_REG (CEE_LDIND_I4 (OP_REGVAR)),
132 stmt: OP_OUTARG_REG (CEE_LDIND_U4 (OP_REGVAR)),
133 stmt: OP_OUTARG_REG (CEE_LDIND_REF (OP_REGVAR)) {
134 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
136 tree->opcode = OP_MOVE;
137 tree->sreg1 = state->left->left->tree->dreg;
138 tree->dreg = mono_regstate_next_int (s->rs);
139 mono_bblock_add_inst (s->cbb, tree);
141 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
144 stmt: OP_OUTARG_REG (OP_LDADDR (OP_REGOFFSET)),
145 stmt: OP_OUTARG_REG (CEE_LDOBJ (OP_REGOFFSET)) {
146 /* FIXME: Move this to inssel.brg */
147 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
149 tree->opcode = OP_ADD_IMM;
150 tree->sreg1 = state->left->left->tree->inst_basereg;
151 tree->inst_imm = state->left->left->tree->inst_offset;
152 tree->dreg = mono_regstate_next_int (s->rs);
153 mono_bblock_add_inst (s->cbb, tree);
155 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
158 stmt: OP_OUTARG (reg) {
159 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, alpha_sp,
160 tree->dreg, state->left->reg1);
163 stmt: OP_OUTARG (freg) {
164 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, alpha_sp,
165 tree->dreg, state->left->reg1);
168 stmt: OP_OUTARG_R4 (freg) {
169 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, alpha_sp,
170 tree->dreg, state->left->reg1);
173 stmt: OP_OUTARG_R8 (freg) {
174 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, alpha_sp,
175 tree->dreg, state->left->reg1);
178 stmt: OP_OUTARG_VT (CEE_LDOBJ (base), base) {
179 MonoInst *vt = state->left->left->tree;
180 MonoInst *stack_addr = state->right->tree;
181 int sz = stack_addr->inst_imm;
186 mini_emit_memcpy (s, stack_addr->inst_basereg, stack_addr->inst_offset,
187 vt->inst_basereg, vt->inst_offset, sz, 0);
190 # This handles trees like outarg_vt (refanytype)
191 stmt: OP_OUTARG_VT (reg, base) {
192 MonoInst *stack_addr = state->right->tree;
194 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, stack_addr->inst_basereg, stack_addr->inst_offset, state->left->reg1);
197 stmt: OP_START_HANDLER {
198 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
199 tree->inst_left = spvar;
200 mono_bblock_add_inst (s->cbb, tree);
203 stmt: CEE_ENDFINALLY {
204 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
205 tree->inst_left = spvar;
206 mono_bblock_add_inst (s->cbb, tree);
209 stmt: OP_ENDFILTER (reg) {
210 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
211 tree->inst_left = spvar;
212 tree->sreg1 = state->left->reg1;
213 mono_bblock_add_inst (s->cbb, tree);
216 stmt: CEE_SWITCH (reg) {
218 int offset_reg = mono_regstate_next_int (s->rs);
219 int target_reg = mono_regstate_next_int (s->rs);
220 int n = GPOINTER_TO_INT (tree->klass);
222 MONO_NEW_LABEL (s, label);
224 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
225 MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
226 if (sizeof (gpointer) == 8)
227 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg,
228 state->left->reg1, 3);
230 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg,
231 state->left->reg1, 2);
232 mono_bblock_add_inst (s->cbb, label);
233 if (s->compile_aot) {
234 int table_reg = mono_regstate_next_int (s->rs);
235 int sum_reg = mono_regstate_next_int (s->rs);
236 MonoJumpInfoBBTable *table;
238 table = mono_mempool_alloc (s->mempool,
239 sizeof (MonoJumpInfoBBTable));
240 table->table = tree->inst_many_bb;
241 table->table_size = n;
243 MONO_EMIT_NEW_AOTCONST (s, table_reg, table,
244 MONO_PATCH_INFO_SWITCH);
246 MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg,
248 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
250 mono_create_jump_table (s, label, tree->inst_many_bb, n);
252 /* On Alpha GP points to the beginning of procedure.
256 br ... skip two longs
257 2 longs = jump table address
258 addq at, offset_reg, dest_reg
261 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
262 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
263 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
264 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
265 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
266 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
268 MONO_EMIT_NEW_BIALU (s, CEE_ADD, target_reg, alpha_at,
270 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
273 /* the backend must patch the address.
274 we use 0xf0f0f0f0 to avoid the usage
275 * of special (short) opcodes on x86
276 if (sizeof (gpointer) == 8)
277 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
278 offset_reg, (long)0xf0f0f0f0f0f0f0f1LL);
280 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
281 offset_reg, 0xf0f0f0f0);
284 MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
287 stmt: CEE_STIND_I8 (OP_REGVAR, reg) {
288 MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->left->tree->dreg,
292 reg: CEE_LDIND_I1 (OP_REGVAR) {
293 MONO_EMIT_UNALU (s, tree, OP_SEXT_I1, state->reg1,
294 state->left->tree->dreg);
297 reg: CEE_LDIND_I2 (OP_REGVAR) {
298 MONO_EMIT_UNALU (s, tree, OP_SEXT_I2, state->reg1,
299 state->left->tree->dreg);
304 #stmt: CEE_BEQ (OP_LCOMPARE(reg, OP_I8CONST)) {
305 # printf("Found match for CEE_BEQ (OP_LCOMPARE(reg, OP_I8CONST))\n");
308 # Compare floats sequences (comments from Zoltan Varga)
310 # non-un comparisions should return false if the arguments are not
311 # comparable, ie. 1.0 < nan is false. The un comparisions are needed
312 # to implement the opposite of normal comparisions, i.e.
313 # (a < b) is bl, while !(a < b) is translated into bge.un. This is
314 # because fp comparirions can return 4 values, not just three: lesser,
315 # greater, equal or unordered
318 stmt: CEE_BLT_UN (OP_COMPARE (freg, freg)) {
319 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
320 state->left->left->reg1, state->left->right->reg1);
321 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
322 state->left->left->reg1, state->left->right->reg1);
323 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
325 MONO_EMIT_UNALU (s, tree, OP_FBLT_UN, -1, -1);
328 stmt: CEE_BLT (OP_COMPARE (freg, freg)) {
329 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
330 state->left->left->reg1, state->left->right->reg1);
331 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
332 state->left->left->reg1, state->left->right->reg1);
333 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
335 MONO_EMIT_UNALU (s, tree, OP_FBLT, -1, -1);
339 stmt: CEE_BLE_UN (OP_COMPARE (freg, freg)) {
340 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
341 state->left->left->reg1, state->left->right->reg1);
342 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
343 state->left->left->reg1, state->left->right->reg1);
344 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
346 MONO_EMIT_UNALU (s, tree, OP_FBLE_UN, -1, -1);
349 stmt: CEE_BLE (OP_COMPARE (freg, freg)) {
350 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
351 state->left->left->reg1, state->left->right->reg1);
352 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
353 state->left->left->reg1, state->left->right->reg1);
354 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
356 MONO_EMIT_UNALU (s, tree, OP_FBLE, -1, -1);
359 stmt: CEE_BGT_UN (OP_COMPARE (freg, freg)) {
360 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
361 state->left->left->reg1, state->left->right->reg1);
362 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
363 state->left->left->reg1, state->left->right->reg1);
364 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
366 MONO_EMIT_UNALU (s, tree, OP_FBGT_UN, -1, -1);
369 stmt: CEE_BGT (OP_COMPARE (freg, freg)) {
370 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
371 state->left->left->reg1, state->left->right->reg1);
372 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
373 state->left->left->reg1, state->left->right->reg1);
374 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
376 MONO_EMIT_UNALU (s, tree, OP_FBGT, -1, -1);
379 stmt: CEE_BGE_UN (OP_COMPARE (freg, freg)) {
380 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
381 state->left->left->reg1, state->left->right->reg1);
382 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
383 state->left->left->reg1, state->left->right->reg1);
384 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
386 MONO_EMIT_UNALU (s, tree, OP_FBGE_UN, -1, -1);
389 stmt: CEE_BGE (OP_COMPARE (freg, freg)) {
390 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
391 state->left->left->reg1, state->left->right->reg1);
392 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
393 state->left->left->reg1, state->left->right->reg1);
394 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
396 MONO_EMIT_UNALU (s, tree, OP_FBGE, -1, -1);
399 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
400 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
401 state->left->left->reg1, state->left->right->reg1);
402 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
404 tree->dreg = state->reg1;
405 tree->opcode = OP_FCEQ;
406 mono_bblock_add_inst (s->cbb, tree);
409 reg: OP_CLT (OP_COMPARE (freg, freg)) {
410 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
411 state->left->left->reg1, state->left->right->reg1);
412 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
414 tree->dreg = state->reg1;
415 tree->opcode = OP_FCLT;
416 mono_bblock_add_inst (s->cbb, tree);
419 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
420 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
421 state->left->right->reg1, state->left->left->reg1);
422 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
423 state->left->left->reg1, state->left->right->reg1);
424 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
426 tree->dreg = state->reg1;
427 tree->opcode = OP_FCLT_UN;
428 mono_bblock_add_inst (s->cbb, tree);
432 reg: OP_CGT (OP_COMPARE (freg, freg)) {
433 // Same as CLT_n (OP_COMPARE) - just exchange parameters
434 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
435 // state->left->left->reg1, state->left->right->reg1);
436 state->left->right->reg1, state->left->left->reg1);
437 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
439 // tree->opcode = OP_FCGT;
440 tree->dreg = state->reg1;
441 tree->opcode = OP_FCLT;
442 mono_bblock_add_inst (s->cbb, tree);
445 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
447 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
448 state->left->right->reg1, state->left->left->reg1);
449 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
450 state->left->right->reg1, state->left->left->reg1);
451 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
453 tree->dreg = state->reg1;
454 tree->opcode = OP_FCLT_UN;
455 mono_bblock_add_inst (s->cbb, tree);
459 stmt: CEE_BEQ (OP_COMPARE (freg, freg)) {
460 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
461 state->left->left->reg1, state->left->right->reg1);
462 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
464 MONO_EMIT_UNALU (s, tree, OP_FBEQ, -1, -1);
467 stmt: CEE_BNE_UN (OP_COMPARE (freg, freg)) {
468 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
469 state->left->left->reg1, state->left->right->reg1);
470 MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
471 state->left->left->reg1, state->left->right->reg1);
472 MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
474 MONO_EMIT_UNALU (s, tree, OP_FBNE_UN, -1, -1);
478 fpcflags: OP_COMPARE (freg, freg) {
479 tree->opcode = OP_FCOMPARE;
480 mono_bblock_add_inst (s->cbb, tree);
482 reg: OP_CEQ (fpcflags) {
483 tree->dreg = state->reg1;
484 tree->opcode = OP_FCEQ;
485 mono_bblock_add_inst (s->cbb, tree);
488 reg: OP_CLT (fpcflags) {
489 tree->dreg = state->reg1;
490 tree->opcode = OP_FCLT;
491 mono_bblock_add_inst (s->cbb, tree);
494 reg: OP_CLT_UN (fpcflags) {
495 tree->dreg = state->reg1;
496 tree->opcode = OP_FCLT_UN;
497 mono_bblock_add_inst (s->cbb, tree);
500 reg: OP_CGT (fpcflags) {
501 tree->dreg = state->reg1;
502 tree->opcode = OP_FCGT;
503 mono_bblock_add_inst (s->cbb, tree);
506 reg: OP_CGT_UN (fpcflags) {
507 tree->dreg = state->reg1;
508 tree->opcode = OP_FCGT_UN;
509 mono_bblock_add_inst (s->cbb, tree);
512 reg: OP_LCONV_TO_I4 (reg) "0" {
513 /* Sign extend the value in the lower word into the upper word */
514 MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_I4, state->reg1,
515 state->left->reg1, 0);
518 reg: OP_LCONV_TO_U4 (reg) "0" {
519 /* Clean out the upper word */
520 MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_U4, state->reg1,
521 state->left->reg1, 0);
524 freg: OP_LCONV_TO_R8 (reg) {
525 /* FIXME: Move this inssel-long.brg */
526 tree->sreg1 = state->left->reg1;
527 tree->dreg = state->reg1;
528 mono_bblock_add_inst (s->cbb, tree);
531 freg: OP_LCONV_TO_R4 (reg) {
532 /* FIXME: Move this inssel-long.brg */
533 tree->sreg1 = state->left->reg1;
534 tree->dreg = state->reg1;
535 mono_bblock_add_inst (s->cbb, tree);
538 reg: CEE_LDIND_REF (OP_REGVAR),
539 reg: CEE_LDIND_I (OP_REGVAR),
540 reg: CEE_LDIND_I8 (OP_REGVAR),
541 reg: CEE_LDIND_I4 (OP_REGVAR),
542 reg: CEE_LDIND_U4 (OP_REGVAR) "0" {
543 state->reg1 = state->left->tree->dreg;
544 tree->dreg = state->reg1;