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