4 # inssel-arm.brg: burg file for special ARM instructions
7 # Dietmar Maurer (dietmar@ximian.com)
8 # Paolo Molaro (lupus@ximian.com)
10 # (C) 2002 Ximian, Inc.
13 stmt: OP_START_HANDLER {
14 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
15 /*MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, spvar->inst_basereg, spvar->inst_offset, ppc_sp);
17 tree->inst_left = spvar;
18 mono_bblock_add_inst (s->cbb, tree);
22 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
23 tree->inst_left = spvar;
24 mono_bblock_add_inst (s->cbb, tree);
27 stmt: OP_ENDFILTER (reg) {
28 MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
29 tree->inst_left = spvar;
30 tree->sreg1 = state->left->reg1;
31 mono_bblock_add_inst (s->cbb, tree);
34 lreg: OP_LADD_OVF (lreg, lreg) "0" {
35 /* ADC sets the condition code */
36 MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
37 MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
40 lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
41 /* ADC sets the condition code */
42 MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
43 MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
46 lreg: OP_LSUB_OVF (lreg, lreg) "0" {
47 /* SBB sets the condition code */
48 MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
49 MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
52 lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
53 /* SBB sets the condition code */
54 MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
55 MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
58 stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
59 /* this should only happen for methods returning a long */
60 MONO_EMIT_NEW_UNALU (s, OP_MOVE, ARMREG_R0, state->right->reg1);
61 MONO_EMIT_NEW_UNALU (s, OP_MOVE, ARMREG_R1, state->right->reg2);
64 lreg: OP_LNEG (lreg) "2" {
65 MONO_EMIT_NEW_BIALU_IMM (s, OP_ARM_RSBS_IMM, state->reg1, state->left->reg1, 0);
66 MONO_EMIT_BIALU_IMM (s, tree, OP_ARM_RSC_IMM, state->reg2, state->left->reg2, 0);
69 freg: OP_LCONV_TO_R8 (lreg) {
70 tree->dreg = state->reg1;
71 tree->sreg1 = state->left->reg1;
72 tree->sreg2 = state->left->reg2;
73 mono_bblock_add_inst (s->cbb, tree);
76 freg: OP_LCONV_TO_R4 (lreg) {
77 tree->dreg = state->reg1;
78 tree->sreg1 = state->left->reg1;
79 tree->sreg2 = state->left->reg2;
80 mono_bblock_add_inst (s->cbb, tree);
83 freg: CEE_CONV_R_UN (reg) {
84 tree->dreg = state->reg1;
85 tree->sreg1 = state->left->reg1;
86 mono_bblock_add_inst (s->cbb, tree);
89 reg: OP_LOCALLOC (OP_ICONST) {
90 /* microcoded in mini-arm.c */
91 tree->sreg1 = mono_regstate_next_int (s->rs);
92 tree->dreg = state->reg1;
93 MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
94 mono_bblock_add_inst (s->cbb, tree);
97 reg: OP_LOCALLOC (reg) {
98 tree->dreg = state->reg1;
99 tree->sreg1 = state->left->reg1;
100 mono_bblock_add_inst (s->cbb, tree);
103 stmt: OP_SETRET (reg) {
104 tree->opcode = OP_MOVE;
105 tree->sreg1 = state->left->reg1;
106 tree->dreg = ARMREG_R0;
107 mono_bblock_add_inst (s->cbb, tree);
110 stmt: OP_SETRET (lreg) {
111 tree->opcode = OP_SETLRET;
112 tree->sreg1 = state->left->reg1;
113 tree->sreg2 = state->left->reg2;
114 tree->dreg = ARMREG_R0;
115 mono_bblock_add_inst (s->cbb, tree);
118 stmt: OP_SETRET (freg) {
119 if (SOFT_FLOAT_IMPL) {
120 tree->opcode = OP_SETLRET;
121 tree->sreg1 = state->left->reg1;
122 tree->sreg2 = state->left->reg2;
123 tree->dreg = ARMREG_R0;
124 mono_bblock_add_inst (s->cbb, tree);
126 tree->opcode = OP_FMOVE;
127 tree->sreg1 = state->left->reg1;
129 mono_bblock_add_inst (s->cbb, tree);
133 stmt: OP_SETRET (OP_ICONST) {
134 tree->opcode = OP_ICONST;
135 tree->inst_c0 = state->left->tree->inst_c0;
136 tree->dreg = ARMREG_R0;
137 mono_bblock_add_inst (s->cbb, tree);
140 stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
141 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
142 stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
143 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
144 int con = state->right->right->tree->inst_c0;
145 int dreg = state->left->tree->dreg;
146 int sreg = state->right->left->left->tree->dreg;
148 if (state->right->op == CEE_ADD)
149 tree->opcode = OP_ADD_IMM;
150 else if (state->right->op == CEE_SUB)
151 tree->opcode = OP_SUB_IMM;
153 g_assert_not_reached ();
154 tree->inst_imm = con;
157 mono_bblock_add_inst (s->cbb, tree);
160 stmt: OP_OUTARG (reg) {
161 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
163 tree->opcode = OP_SETREG;
164 tree->dreg = mono_regstate_next_int (s->rs);
165 tree->sreg1 = state->left->reg1;
166 mono_bblock_add_inst (s->cbb, tree);
168 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
171 stmt: OP_OUTARG (OP_REGVAR) {
172 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
173 tree->opcode = OP_SETREG;
174 tree->dreg = mono_regstate_next_int (s->rs);
175 tree->sreg1 = state->left->tree->dreg;
176 mono_bblock_add_inst (s->cbb, tree);
178 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
181 stmt: OP_OUTARG (lreg) {
182 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
184 tdreg = mono_regstate_next_int (s->rs);
185 MONO_EMIT_NEW_UNALU (s, OP_SETREG, tdreg, state->left->reg2);
187 /* An #if would be better here, but monoburg
188 strips them out as comments */
189 if (G_BYTE_ORDER == G_BIG_ENDIAN)
190 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
192 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3 + 1, FALSE);
194 tree->opcode = OP_SETREG;
195 tree->dreg = mono_regstate_next_int (s->rs);
196 tree->sreg1 = state->left->reg1;
197 mono_bblock_add_inst (s->cbb, tree);
199 if (G_BYTE_ORDER == G_BIG_ENDIAN)
200 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
202 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
205 stmt: OP_OUTARG (OP_ICONST) {
206 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
207 tree->opcode = OP_ICONST;
208 tree->dreg = mono_regstate_next_int (s->rs);
209 tree->inst_c0 = state->left->tree->inst_c0;
210 mono_bblock_add_inst (s->cbb, tree);
212 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
215 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
216 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
217 tree->opcode = OP_SETREG;
218 tree->sreg1 = state->left->left->tree->dreg;
219 tree->dreg = mono_regstate_next_int (s->rs);
220 mono_bblock_add_inst (s->cbb, tree);
222 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
225 stmt: OP_OUTARG_R8 (freg),
226 stmt: OP_OUTARG (freg) {
227 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
229 if (SOFT_FLOAT_IMPL) {
230 /* same as the OUTARG (lreg) case */
232 tdreg = mono_regstate_next_int (s->rs);
233 MONO_EMIT_NEW_UNALU (s, OP_SETREG, tdreg, state->left->reg2);
235 /* An #if would be better here, but monoburg
236 strips them out as comments */
237 if (G_BYTE_ORDER == G_BIG_ENDIAN)
238 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
240 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3 + 1, FALSE);
242 tree->opcode = OP_SETREG;
243 tree->dreg = mono_regstate_next_int (s->rs);
244 tree->sreg1 = state->left->reg1;
245 mono_bblock_add_inst (s->cbb, tree);
247 if (G_BYTE_ORDER == G_BIG_ENDIAN)
248 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
250 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
252 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
253 creg = mono_regstate_next_int (s->rs);
254 mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3, FALSE);
255 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
256 creg = mono_regstate_next_int (s->rs);
257 mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3 + 1, FALSE);
258 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8 + 4));
262 stmt: OP_OUTARG_R4 (freg) {
263 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
265 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
266 creg = mono_regstate_next_int (s->rs);
267 mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3, FALSE);
268 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
271 stmt: OP_OUTARG_MEMBASE (reg) {
272 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, tree->backend.arg_info >> 8, state->left->reg1);
275 stmt: OP_OUTARG_MEMBASE (lreg) {
276 int offset = tree->backend.arg_info >> 8;
277 int partial = (tree->backend.arg_info & 0xff) == 0xff;
279 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
280 if (G_BYTE_ORDER == G_BIG_ENDIAN) {
281 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
283 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
285 tree->opcode = OP_SETREG;
286 tree->dreg = mono_regstate_next_int (s->rs);
287 tree->sreg1 = G_BYTE_ORDER == G_BIG_ENDIAN? state->left->reg2: state->left->reg1;
288 mono_bblock_add_inst (s->cbb, tree);
289 mono_call_inst_add_outarg_reg (s, call, tree->dreg, ARMREG_R3, FALSE);
292 if (G_BYTE_ORDER == G_BIG_ENDIAN) {
293 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
294 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg1);
296 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
297 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg2);
301 stmt: OP_OUTARG_MEMBASE (freg) {
302 int offset = tree->backend.arg_info >> 8;
303 if (SOFT_FLOAT_IMPL) {
304 int partial = (tree->backend.arg_info & 0xff) == 0xff;
305 /* same as OP_OUTARG_MEMBASE (lreg) */
306 if (G_BYTE_ORDER == G_BIG_ENDIAN) {
307 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
308 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg1);
310 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
311 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg2);
314 if ((tree->backend.arg_info & 0xff) == 8)
315 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
316 else if ((tree->backend.arg_info & 0xff) == 4)
317 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
318 else if ((tree->backend.arg_info & 0xff) == 0xff) {
319 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
321 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
322 creg = mono_regstate_next_int (s->rs);
323 mono_call_inst_add_outarg_reg (s, call, creg, ARMREG_R3, FALSE);
324 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
325 creg = mono_regstate_next_int (s->rs);
326 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 4));
327 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, creg);
329 g_assert_not_reached ();
333 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
334 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
335 MonoInst *vt = state->left->left->tree;
336 int start_reg = tree->backend.arg_info & 0xf;
337 int nregs = (tree->backend.arg_info >> 4) & 0xf;
338 int ovf_size = (tree->backend.arg_info >> 8) & 0xfff;
339 int doffset = ((tree->backend.arg_info >> 20) & 0xfff) * 4;
340 int i, tmpr, soffset, dreg;
342 soffset = vt->inst_offset;
344 for (i = 0; i < nregs; ++i) {
345 tmpr = mono_regstate_next_int (s->rs);
346 dreg = mono_regstate_next_int (s->rs);
347 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
348 MONO_EMIT_NEW_UNALU (s, OP_SETREG, dreg, tmpr);
349 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
350 soffset += sizeof (gpointer);
352 //g_print ("vt size: %d at R%d + %d\n", doffset, vt->inst_basereg, vt->inst_offset);
354 mini_emit_memcpy (s, ARMREG_SP, doffset, vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
358 stmt: OP_OUTARG_VT (OP_ICONST) {
359 int nregs = (tree->backend.arg_info >> 4) & 0xf;
361 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
362 tree->opcode = OP_ICONST;
363 tree->dreg = mono_regstate_next_int (s->rs);
364 tree->inst_c0 = state->left->tree->inst_c0;
365 mono_bblock_add_inst (s->cbb, tree);
367 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.arg_info & 0xf, FALSE);
369 g_assert_not_reached ();
373 stmt: OP_OUTARG_VT (reg) {
374 int start_reg = tree->backend.arg_info & 0xff;
375 int nregs = (tree->backend.arg_info >> 8) & 0xff;
377 tree->opcode = OP_SETREG;
378 tree->dreg = start_reg;
379 tree->sreg1 = state->left->reg1;
380 mono_bblock_add_inst (s->cbb, tree);
382 g_assert_not_reached ();
386 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
387 /* nothing to do: the value is already on the FP stack */
390 stmt: CEE_BNE_UN (OP_COMPARE (freg, freg)) {
391 MONO_EMIT_BIALU (s, tree, OP_FBNE_UN, -1, state->left->left->reg1, state->left->right->reg1);
394 stmt: CEE_BEQ (OP_COMPARE (freg, freg)) {
395 MONO_EMIT_BIALU (s, tree, OP_FBEQ, -1, state->left->left->reg1, state->left->right->reg1);
398 stmt: CEE_BLT (OP_COMPARE (freg, freg)) {
399 MONO_EMIT_BIALU (s, tree, OP_FBLT, -1, state->left->left->reg1, state->left->right->reg1);
402 stmt: CEE_BLT_UN (OP_COMPARE (freg, freg)) {
403 MONO_EMIT_BIALU (s, tree, OP_FBLT_UN, -1, state->left->left->reg1, state->left->right->reg1);
406 stmt: CEE_BGT (OP_COMPARE (freg, freg)) {
407 MONO_EMIT_BIALU (s, tree, OP_FBGT, -1, state->left->left->reg1, state->left->right->reg1);
410 stmt: CEE_BGT_UN (OP_COMPARE (freg, freg)) {
411 MONO_EMIT_BIALU (s, tree, OP_FBGT_UN, -1, state->left->left->reg1, state->left->right->reg1);
414 stmt: CEE_BGE (OP_COMPARE (freg, freg)) {
415 MONO_EMIT_BIALU (s, tree, OP_FBGE, -1, state->left->left->reg1, state->left->right->reg1);
418 stmt: CEE_BGE_UN (OP_COMPARE (freg, freg)) {
419 MONO_EMIT_BIALU (s, tree, OP_FBGE_UN, -1, state->left->left->reg1, state->left->right->reg1);
422 stmt: CEE_BLE (OP_COMPARE (freg, freg)) {
423 MONO_EMIT_BIALU (s, tree, OP_FBLE, -1, state->left->left->reg1, state->left->right->reg1);
426 stmt: CEE_BLE_UN (OP_COMPARE (freg, freg)) {
427 MONO_EMIT_BIALU (s, tree, OP_FBLE_UN, -1, state->left->left->reg1, state->left->right->reg1);
430 stmt: CEE_POP (freg) "0" {
434 freg: OP_LCONV_TO_R8 (lreg) {
435 /* nothing to do - emulated */
438 freg: OP_LCONV_TO_R4 (lreg) {
439 /* nothing to do - emulated */
442 freg: OP_LCONV_TO_R_UN (lreg) {
443 /* nothing to do - emulated */
446 freg: OP_FREM (freg, freg) {
447 /* nothing to do - emulated */
450 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
451 MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
452 state->left->right->reg1);
455 reg: OP_CLT (OP_COMPARE (freg, freg)) {
456 MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
457 state->left->right->reg1);
460 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
461 MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
462 state->left->right->reg1);
465 reg: OP_CGT (OP_COMPARE (freg, freg)) {
466 MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
467 state->left->right->reg1);
470 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
471 MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
472 state->left->right->reg1);
475 reg: CEE_ADD_OVF (reg, reg) "0" {
476 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
479 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
480 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
483 reg: CEE_SUB_OVF (reg, reg) "0" {
484 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
487 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
488 MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
491 stmt: OP_SWITCH (reg) {
493 int n = GPOINTER_TO_INT (tree->klass);
495 MONO_NEW_LABEL (s, label);
497 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
498 MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
500 if (s->compile_aot) {
501 /* FIXME: Optimize this */
502 int offset_reg = mono_regstate_next_int (s->rs);
503 int target_reg = mono_regstate_next_int (s->rs);
504 int table_reg = mono_regstate_next_int (s->rs);
505 int sum_reg = mono_regstate_next_int (s->rs);
506 MonoJumpInfoBBTable *table;
508 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 2);
510 table = mono_mempool_alloc (s->mempool, sizeof (MonoJumpInfoBBTable));
511 table->table = tree->inst_many_bb;
512 table->table_size = n;
514 MONO_EMIT_NEW_AOTCONST (s, table_reg, table, MONO_PATCH_INFO_SWITCH);
516 MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg, offset_reg);
517 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
518 MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
520 mono_bblock_add_inst (s->cbb, label);
521 mono_create_jump_table (s, label, tree->inst_many_bb, n);
522 /* the backend code will deal with aot vs normal case */
523 tree->sreg1 = state->left->reg1;
524 mono_bblock_add_inst (s->cbb, tree);