mono/mini/mini-mips.h

   1 #ifndef __MONO_MINI_MIPS_H__
   2 #define __MONO_MINI_MIPS_H__
   3
   4 #include <mono/arch/mips/mips-codegen.h>
   5 #include <glib.h>
   6
   7 #define MONO_ARCH_CPU_SPEC mips_desc
   8
   9 #define MONO_MAX_IREGS 32
  10 #define MONO_MAX_FREGS 32
  11
  12 #define MONO_SAVED_GREGS 32
  13 #define MONO_SAVED_FREGS 32
  14
  15 /*
  16  * at and t0 used internally
  17  * v0, v1 aren't here for clarity reasons
  18  * a0, a1, a2, a3 are for arguments
  19  * Use t9 for indirect calls to match the ABI
  20  */
  21
  22 #define MIPS_V_REGS     ((1 << mips_v0) | \
  23                          (1 << mips_v1))
  24 #define MIPS_T_REGS     ((1 << mips_t0) | \
  25                          (1 << mips_t1) | \
  26                          (1 << mips_t2) | \
  27                          (1 << mips_t3) | \
  28                          (1 << mips_t4) | \
  29                          (1 << mips_t5) | \
  30                          (1 << mips_t6) | \
  31                          (1 << mips_t7))
  32 #define MIPS_S_REGS     ((1 << mips_s0) | \
  33                          (1 << mips_s1) | \
  34                          (1 << mips_s2) | \
  35                          (1 << mips_s3) | \
  36                          (1 << mips_s4) | \
  37                          (1 << mips_s5) | \
  38                          (1 << mips_s6) | \
  39                          (1 << mips_s7) | \
  40                          (1 << mips_fp))
  41 #define MIPS_A_REGS     ((1 << mips_a0) | \
  42                          (1 << mips_a1) | \
  43                          (1 << mips_a2) | \
  44                          (1 << mips_a3))
  45
  46 #define mips_temp mips_t8
  47
  48 #define MONO_ARCH_CALLEE_REGS           (MIPS_T_REGS | MIPS_V_REGS)
  49 #define MONO_ARCH_CALLEE_SAVED_REGS     MIPS_S_REGS
  50 #define MIPS_ARG_REGS                   MIPS_A_REGS
  51
  52 #if 0
  53 #define MIPS_FP_PAIR(reg)       ((1 << (reg)) | (1 << ((reg)+1)))
  54 #else
  55 /* Only put the even regs in */
  56 #define MIPS_FP_PAIR(reg)       (1 << (reg))
  57 #endif
  58
  59 #define MONO_ARCH_CALLEE_FREGS          (MIPS_FP_PAIR(mips_f0) |        \
  60                                          MIPS_FP_PAIR(mips_f2) |        \
  61                                          MIPS_FP_PAIR(mips_f4) |        \
  62                                          MIPS_FP_PAIR(mips_f6) |        \
  63                                          MIPS_FP_PAIR(mips_f8) |        \
  64                                          MIPS_FP_PAIR(mips_f10) |       \
  65                                          MIPS_FP_PAIR(mips_f12) |       \
  66                                          MIPS_FP_PAIR(mips_f14) |       \
  67                                          MIPS_FP_PAIR(mips_f16) |       \
  68                                          MIPS_FP_PAIR(mips_f18))
  69
  70 #define MONO_ARCH_CALLEE_SAVED_FREGS    (MIPS_FP_PAIR(mips_f20) |       \
  71                                          MIPS_FP_PAIR(mips_f22) |       \
  72                                          MIPS_FP_PAIR(mips_f24) |       \
  73                                          MIPS_FP_PAIR(mips_f26) |       \
  74                                          MIPS_FP_PAIR(mips_f28) |       \
  75                                          MIPS_FP_PAIR(mips_f30))
  76
  77 #define mips_ftemp mips_f18
  78
  79 #define MONO_ARCH_USE_FPSTACK FALSE
  80 #define MONO_ARCH_FPSTACK_SIZE 0
  81
  82 /* Parameters used by the register allocator */
  83
  84 /* On Mips, for regpairs, the lower-numbered reg is most significant
  85  * This is true in both big and little endian
  86  */
  87
  88 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
  89 #define RET_REG1 mips_v0
  90 #define RET_REG2 mips_v1
  91 #else
  92 #define RET_REG1 mips_v1
  93 #define RET_REG2 mips_v0
  94 #endif
  95
  96 #define MONO_ARCH_INST_SREG2_MASK(ins)          (0)
  97 #define MONO_ARCH_INST_IS_REGPAIR(desc)         ((desc) == 'V' || (desc) == 'l')
  98 #define MONO_ARCH_INST_REGPAIR_REG2(desc,hreg1) (((desc) == 'l') ? ((hreg1) + 1) : (((desc) == 'V') ? RET_REG2 : -1))
  99 #define MONO_ARCH_INST_IS_FLOAT(desc)           ((desc == 'f') || (desc == 'g'))
 100
 101 // This define is called to get specific dest register as defined
 102 // by md file (letter after "dest"). Overwise return -1
 103
 104 #define MONO_ARCH_INST_FIXED_REG(desc)          (((desc) == '0') ? mips_zero : (((desc) == 'a') ? mips_at : ((((desc) == 'v')) ? mips_v0 : (((desc) == 'V') ? RET_REG1 : (((desc) == 'g') ? mips_f0 : -1)))))
 105
 106 #define MONO_ARCH_FRAME_ALIGNMENT 8
 107
 108 /* fixme: align to 16byte instead of 32byte (we align to 32byte to get
 109  * reproduceable results for benchmarks */
 110 #define MONO_ARCH_CODE_ALIGNMENT 32
 111
 112 void mips_patch (guint32 *code, guint32 target);
 113
 114 #define MIPS_LMF_MAGIC1 0xa5a5a5a5
 115 #define MIPS_LMF_MAGIC2 0xc3c3c3c3
 116
 117 struct MonoLMF {
 118         gpointer    previous_lmf;
 119         gpointer    lmf_addr;
 120         MonoMethod *method;
 121         gulong     ebp;
 122         gulong     eip;
 123         gulong     iregs [MONO_SAVED_GREGS];
 124         gfloat     fregs [MONO_SAVED_FREGS];
 125         gulong     magic;
 126 };
 127
 128 /* we define our own structure and we'll copy the data
 129  * from sigcontext/ucontext/mach when we need it.
 130  * This also makes us save stack space and time when copying
 131  * We might also want to add an additional field to propagate
 132  * the original context from the signal handler.
 133  */
 134 typedef struct {
 135         gulong sc_pc;
 136         gulong sc_regs [MONO_SAVED_GREGS];
 137         gfloat sc_fpregs [MONO_SAVED_FREGS];
 138 } MonoContext;
 139
 140 typedef struct MonoCompileArch {
 141         guint           iregs_offset;
 142         guint           lmf_offset;
 143         guint           spillvar_offset;
 144         guint           spillvar_offset_float;
 145 } MonoCompileArch;
 146
 147 #define MONO_ARCH_EMULATE_FCONV_TO_I8 1
 148 #define MONO_ARCH_EMULATE_LCONV_TO_R8 1
 149 #define MONO_ARCH_EMULATE_LCONV_TO_R4 1
 150 #define MONO_ARCH_EMULATE_LCONV_TO_R8_UN 1
 151 #define MONO_ARCH_EMULATE_FREM 1
 152 #define MONO_ARCH_BIGMUL_INTRINS 1
 153
 154 #define MIPS_RET_ADDR_OFFSET    (-4)
 155 #define MIPS_FP_ADDR_OFFSET     (-8)
 156 #define MIPS_STACK_ALIGNMENT    16
 157 #define MIPS_STACK_PARAM_OFFSET 16              /* from sp to first parameter */
 158 #define MIPS_MINIMAL_STACK_SIZE (4*4 + 4*4)
 159 #define MIPS_EXTRA_STACK_SIZE   16              /* from last parameter to top of frame */
 160 #define MIPS_FIRST_ARG_REG      mips_a0
 161 #define MIPS_LAST_ARG_REG       mips_a3
 162 #define MIPS_FIRST_FPARG_REG    mips_f12
 163 #define MIPS_LAST_FPARG_REG     mips_f14
 164
 165
 166
 167 /* XXX - a mystery, but it works */
 168 #define MONO_GET_CONTEXT \
 169         void *ctx = (void *)(((int)context)+24);
 170
 171 /* set the next to 0 once inssel-mips.brg is updated */
 172 #define MIPS_PASS_STRUCTS_BY_VALUE 1
 173 #define MIPS_SMALL_RET_STRUCT_IN_REG 0
 174
 175 #define MONO_ARCH_USE_SIGACTION
 176 #define MONO_ARCH_NEED_DIV_CHECK 1
 177 #define MONO_ARCH_ENABLE_NORMALIZE_OPCODES 1
 178
 179 #define MIPS_NUM_REG_ARGS (MIPS_LAST_ARG_REG-MIPS_FIRST_ARG_REG+1)
 180 #define MIPS_NUM_REG_FPARGS (MIPS_LAST_FPARG_REG-MIPS_FIRST_FPARG_REG+1)
 181
 182 /* we have the stack pointer, not the base pointer in sigcontext */
 183 #define MONO_CONTEXT_SET_IP(ctx,ip) do { (ctx)->sc_pc = (int)(ip); } while (0);
 184 #define MONO_CONTEXT_SET_BP(ctx,bp) do { (ctx)->sc_regs[mips_fp] = (int)(bp); } while (0);
 185 #define MONO_CONTEXT_SET_SP(ctx,sp) do { (ctx)->sc_regs[mips_sp] = (int)(sp); } while (0);
 186
 187 #define MONO_CONTEXT_GET_IP(ctx) ((gpointer)((ctx)->sc_pc))
 188 #define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->sc_regs[mips_fp]))
 189 #define MONO_CONTEXT_GET_SP(ctx) ((gpointer)((ctx)->sc_regs[mips_sp]))
 190
 191 typedef struct {
 192         unsigned long zero;
 193         unsigned long at; /* assembler temp */
 194         unsigned long v0; /* return values */
 195         unsigned long v1;
 196         unsigned long a0; /* 4 - func arguments */
 197         unsigned long a1;
 198         unsigned long a2;
 199         unsigned long a3;
 200         unsigned long t0; /* 8 temporaries */
 201         unsigned long t1;
 202         unsigned long t2;
 203         unsigned long t3;
 204         unsigned long t4;
 205         unsigned long t5;
 206         unsigned long t6;
 207         unsigned long t7;
 208         unsigned long s0; /* 16 calle saved */
 209         unsigned long s1;
 210         unsigned long s2;
 211         unsigned long s3;
 212         unsigned long s4;
 213         unsigned long s5;
 214         unsigned long s6;
 215         unsigned long s7;
 216         unsigned long t8; /* 24 temps */
 217         unsigned long t9; /* 25 temp / pic call-through register */
 218         unsigned long k0; /* 26 kernel-reserved */
 219         unsigned long k1;
 220         unsigned long gp; /* 28 */
 221         unsigned long sp; /* stack pointer */
 222         unsigned long fp; /* frame pointer */
 223         unsigned long ra; /* return address */
 224 } MonoMipsStackFrame;
 225
 226 #define MONO_INIT_CONTEXT_FROM_FUNC(ctx,func) do {      \
 227                 guint32 sp, ra;                                 \
 228                 guint32 *code = (guint32 *)(void *)func;        \
 229                 short imm;                                      \
 230                 memset ((ctx), 0, sizeof (*(ctx)));             \
 231                 __asm__ volatile("addu %0,$0,$29" : "=r" (sp)); \
 232                 /* Look for adjustment of sp */                 \
 233                 while ((*code & 0xffff0000) != 0x27bd0000)      \
 234                         ++code;                                 \
 235                 imm = (short) (*code & 0xffff);                 \
 236                 MONO_CONTEXT_SET_BP ((ctx), sp + (-imm));       \
 237                 ra = *(guint32 *)(sp + (-imm) + MIPS_RET_ADDR_OFFSET);  \
 238                 MONO_CONTEXT_SET_IP ((ctx),ra); \
 239                 MONO_CONTEXT_SET_SP ((ctx), MONO_CONTEXT_GET_BP (ctx)); \
 240         } while (0)
 241
 242 /* re-attaches with gdb - sometimes causes executable to hang */
 243 #undef HAVE_BACKTRACE_SYMBOLS
 244
 245 #undef DEBUG_EXCEPTIONS
 246
 247 #define MONO_ZERO_REG           mips_zero
 248
 249 #define MONO_EMIT_NEW_BRANCH_UNREG_LABEL(cfg,op,sr1,label) do { \
 250                 MonoInst *inst; \
 251                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 252                 inst->opcode = op;      \
 253                 inst->sreg1 = sr1;      \
 254                 inst->inst_i0 = label;  \
 255                 inst->flags = MONO_INST_BRLABEL;        \
 256                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 257         } while (0)
 258
 259 #define MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg,op,sr1,sr2,label) do {     \
 260                 MonoInst *inst; \
 261                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 262                 inst->opcode = op;      \
 263                 inst->sreg1 = sr1;      \
 264                 inst->sreg2 = sr2;      \
 265                 inst->inst_i0 = label;  \
 266                 inst->flags = MONO_INST_BRLABEL;        \
 267                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 268         } while (0)
 269
 270 #define MONO_EMIT_NEW_BRANCH_NONZERO_LABEL(cfg,op,sr1,targetbb) do {    \
 271                 MonoInst *inst; \
 272                 MonoInst *target_label; \
 273                 target_label = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 274                 target_label->opcode = OP_LABEL;        \
 275                 target_label->next = (targetbb)->code; \
 276                 target_label->inst_c0 = (targetbb)->native_offset; \
 277                 (targetbb)->code = target_label; \
 278                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 279                 inst->opcode = op;      \
 280                 (inst)->sreg1 = sr1; \
 281                 (inst)->sreg2 = sr2; \
 282                 inst->inst_i0 = target_label;   \
 283                 inst->flags = MONO_INST_BRLABEL;        \
 284                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 285         } while (0)
 286
 287 #define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK(cfg,op,sr1,sr2,targetbb) do {        \
 288                 MonoInst *inst; \
 289                 MonoInst *target_label; \
 290                 target_label = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 291                 target_label->opcode = OP_LABEL;        \
 292                 target_label->next = (targetbb)->code; \
 293                 target_label->inst_c0 = (targetbb)->native_offset; \
 294                 (targetbb)->code = target_label; \
 295                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 296                 inst->opcode = op;      \
 297                 (inst)->sreg1 = sr1; \
 298                 (inst)->sreg2 = sr2; \
 299                 inst->inst_i0 = target_label;   \
 300                 inst->flags = MONO_INST_BRLABEL;        \
 301                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 302         } while (0)
 303
 304 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL
 305 #define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL(cfg, cmp_op, sreg1, sreg2, label) \
 306         do { \
 307                 switch (cmp_op) { \
 308                 case CEE_BEQ: \
 309                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BEQ, sreg1, sreg2, label); \
 310                         break; \
 311                 case CEE_BNE_UN: \
 312                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, sreg1, sreg2, label); \
 313                         break; \
 314                 case CEE_BGE: \
 315                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg1, sreg2); \
 316                         MONO_EMIT_NEW_BIALU_IMM (s, OP_MIPS_XORI, mips_at, mips_at, 1); \
 317                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 318                         break; \
 319                 case CEE_BGE_UN: \
 320                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg1, sreg2); \
 321                         MONO_EMIT_NEW_BIALU_IMM (s, OP_MIPS_XORI, mips_at, mips_at, 1); \
 322                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 323                         break; \
 324                 case CEE_BGT: \
 325                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg2, sreg1); \
 326                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 327                         break; \
 328                 case CEE_BGT_UN: \
 329                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg2, sreg1); \
 330                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 331                         break; \
 332                 case CEE_BLT: \
 333                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg1, sreg2); \
 334                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 335                         break; \
 336                 case CEE_BLT_UN: \
 337                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg1, sreg2); \
 338                         MONO_EMIT_NEW_BRANCH_BIREG_LABEL(cfg, OP_MIPS_BNE, mips_at, mips_zero, label); \
 339                         break; \
 340                 default: \
 341                         g_assert_not_reached(); \
 342                 } \
 343         } while (0)
 344 #endif
 345
 346 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL
 347 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL(cfg, cmp_op, sreg1, imm, label) \
 348         do { \
 349                 guint32 cmp_reg; \
 350                 if (!(imm)) { \
 351                         cmp_reg = mips_zero; \
 352                 } \
 353                 else { \
 354                         cmp_reg = mips_at; \
 355                         MONO_EMIT_NEW_ICONST (cfg, cmp_reg, (imm)); \
 356                 } \
 357                 MONO_EMIT_NEW_COMPARE_BRANCH_LABEL(cfg, cmp_op, sreg1, cmp_reg, label); \
 358         } while (0)
 359 #endif
 360
 361 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK
 362 #define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK(cfg, cmp_op, sreg1, sreg2, block) \
 363         do { \
 364                 switch (cmp_op) { \
 365                 case CEE_BEQ: \
 366                         MONO_EMIT_NEW_BRANCH_BIREG_BLOCK (cfg, OP_MIPS_BEQ, sreg1, sreg2, block); \
 367                         break; \
 368                 case CEE_BNE_UN: \
 369                         MONO_EMIT_NEW_BRANCH_BIREG_BLOCK (cfg, OP_MIPS_BNE, sreg1, sreg2, block); \
 370                         break; \
 371                 case CEE_BLT_UN: \
 372                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg1, sreg2); \
 373                         MONO_EMIT_NEW_BRANCH_BIREG_BLOCK (cfg, OP_MIPS_BNE, mips_at, mips_zero, block); \
 374                         break; \
 375                 default: \
 376                         g_assert_not_reached (); \
 377                 } \
 378         } while (0)
 379 #endif
 380
 381 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK
 382 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK(cfg, cmp_op, sreg1, imm, block) \
 383         do { \
 384                 guint32 cmp_reg; \
 385                 if (!(imm)) { \
 386                         cmp_reg = mips_zero; \
 387                 } \
 388                 else { \
 389                         cmp_reg = mips_at; \
 390                         MONO_EMIT_NEW_ICONST (cfg, cmp_reg, (imm)); \
 391                 } \
 392                 MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK(cfg, cmp_op, sreg1, cmp_reg, block); \
 393         } while (0)
 394 #endif
 395
 396 #define MONO_EMIT_NEW_MIPS_COND_EXC(cfg,cond,sr1,sr2,name) do { \
 397                 MonoInst *inst; \
 398                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 399                 inst->opcode = cond;  \
 400                 inst->inst_p1 = (char*)name; \
 401                 inst->sreg1 = sr1; \
 402                 inst->sreg2 = sr2; \
 403                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 404         } while (0)
 405
 406 #ifndef MONO_EMIT_NEW_COMPARE_EXC
 407 #define MONO_EMIT_NEW_COMPARE_EXC(cfg, cmp_op, sreg1, sreg2, exc) do { \
 408                 switch (OP_MIPS_COND_EXC_##cmp_op) { \
 409                 case OP_MIPS_COND_EXC_EQ: \
 410                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_EQ, sreg1, sreg2, exc); \
 411                         break; \
 412                 case OP_MIPS_COND_EXC_NE_UN: \
 413                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_NE_UN, sreg1, sreg2, exc); \
 414                         break; \
 415                 case OP_MIPS_COND_EXC_GT: \
 416                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg2, sreg1); \
 417                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_NE_UN, mips_at, mips_zero, exc); \
 418                         break; \
 419                 case OP_MIPS_COND_EXC_GT_UN: \
 420                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg2, sreg1); \
 421                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_NE_UN, mips_at, mips_zero, exc); \
 422                         break; \
 423                 case OP_MIPS_COND_EXC_LE: \
 424                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg2, sreg1); \
 425                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_EQ, mips_at, mips_zero, exc); \
 426                         break; \
 427                 case OP_MIPS_COND_EXC_LE_UN: \
 428                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg2, sreg1); \
 429                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_EQ, mips_at, mips_zero, exc); \
 430                         break; \
 431                 case OP_MIPS_COND_EXC_LT: \
 432                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLT, mips_at, sreg1, sreg2); \
 433                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_NE_UN, mips_at, mips_zero, exc); \
 434                         break; \
 435                 case OP_MIPS_COND_EXC_LT_UN: \
 436                         MONO_EMIT_NEW_BIALU (cfg, OP_MIPS_SLTU, mips_at, sreg1, sreg2); \
 437                         MONO_EMIT_NEW_MIPS_COND_EXC (cfg, OP_MIPS_COND_EXC_NE_UN, mips_at, mips_zero, exc); \
 438                         break; \
 439                 default: \
 440                         g_warning ("unknown comparison %s\n", #cmp_op); \
 441                         g_assert_not_reached (); \
 442                 } \
 443         } while (0)
 444 #endif
 445
 446 #ifndef MONO_EMIT_NEW_COMPARE_IMM_EXC
 447 #define MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
 448                 guint32 cmp_reg; \
 449                 if (!(imm)) { \
 450                         cmp_reg = mips_zero; \
 451                 } \
 452                 else { \
 453                         cmp_reg = mips_at; \
 454                         MONO_EMIT_NEW_ICONST (cfg, cmp_reg, (imm)); \
 455                 } \
 456                 MONO_EMIT_NEW_COMPARE_EXC (cfg, cmp_op, sreg1, cmp_reg, exc); \
 457         } while (0)
 458 #endif
 459
 460 #ifndef MONO_EMIT_NEW_ICOMPARE_IMM_EXC
 461 #define MONO_EMIT_NEW_ICOMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
 462                 MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc); \
 463         } while (0)
 464 #endif
 465
 466 typedef struct {
 467         gint8 reg;
 468         gint8 size;
 469         int vtsize;
 470         int offset;
 471 } MonoMIPSArgInfo;
 472
 473 #endif /* __MONO_MINI_MIPS_H__ */