mono/mini/mini-hppa.c

   1 /*
   2  * mini-hppa.c: HPPA backend for the Mono code generator
   3  *
   4  * Copyright (c) 2007 Randolph Chung
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  */
  25 #include "mini.h"
  26 #include <string.h>
  27 #include <pthread.h>
  28 #include <unistd.h>
  29
  30 #include <unistd.h>
  31 #include <sys/mman.h>
  32
  33 #include <mono/metadata/appdomain.h>
  34 #include <mono/metadata/debug-helpers.h>
  35 #include <mono/metadata/tokentype.h>
  36 #include <mono/utils/mono-math.h>
  37
  38 #include "mini-hppa.h"
  39 #include "trace.h"
  40 #include "cpu-hppa.h"
  41
  42 #define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
  43 #define SIGNAL_STACK_SIZE (64 * 1024)
  44
  45 #define DEBUG(a) // a
  46 #define DEBUG_FUNC_ENTER() // printf("Entering %s\n", __FUNCTION__)
  47 #define DEBUG_FUNC_EXIT() // printf("Exiting %s\n", __FUNCTION__)
  48
  49 static const guchar
  50 branch_b0_table [] = {
  51         TRUE, /* OP_HPPA_BEQ */
  52         FALSE, /* OP_HPPA_BGE */
  53         FALSE, /* OP_HPPA_BGT */
  54         TRUE, /* OP_HPPA_BLE */
  55         TRUE, /* OP_HPPA_BLT */
  56         FALSE, /* OP_HPPA_BNE */
  57         FALSE, /* OP_HPPA_BGE_UN */
  58         FALSE, /* OP_HPPA_BGT_UN */
  59         TRUE, /* OP_HPPA_BLE_UN */
  60         TRUE, /* OP_HPPA_BLT_UN */
  61 };
  62
  63 static const guchar
  64 branch_b1_table [] = {
  65         HPPA_CMP_COND_EQ, /* OP_HPPA_BEQ */
  66         HPPA_CMP_COND_SLT, /* OP_HPPA_BGE */
  67         HPPA_CMP_COND_SLE, /* OP_HPPA_BGT */
  68         HPPA_CMP_COND_SLE, /* OP_HPPA_BLE */
  69         HPPA_CMP_COND_SLT, /* OP_HPPA_BLT */
  70         HPPA_CMP_COND_EQ, /* OP_HPPA_BNE_UN */
  71         HPPA_CMP_COND_ULT, /* OP_HPPA_BGE_UN */
  72         HPPA_CMP_COND_ULE, /* OP_HPPA_BGT_UN */
  73         HPPA_CMP_COND_ULE, /* OP_HPPA_BLE_UN */
  74         HPPA_CMP_COND_ULT, /* OP_HPPA_BLT_UN */
  75 };
  76
  77 /* Note that these are inverted from the OP_xxx, because we nullify
  78  * the branch if the condition is met
  79  */
  80 static const guchar
  81 float_branch_table [] = {
  82         26, /* OP_FBEQ */
  83         11, /* OP_FBGE */
  84         15, /* OP_FBGT */
  85         19, /* OP_FBLE */
  86         23, /* OP_FBLT */
  87         4, /* OP_FBNE_UN */
  88         8, /* OP_FBGE_UN */
  89         13, /* OP_FBGT_UN */
  90         17, /* OP_FBLE_UN */
  91         20, /* OP_FBLT_UN */
  92 };
  93
  94 static const guchar
  95 float_ceq_table [] = {
  96         26, /* OP_FCEQ */
  97         15, /* OP_FCGT */
  98         13, /* OP_FCGT_UN */
  99         23, /* OP_FCLT */
 100         21, /* OP_FCLT_UN */
 101 };
 102
 103 /*
 104  * Branches have short (14 or 17 bit) targets on HPPA. To make longer jumps,
 105  * we will need to rely on stubs - basically we create stub structures in
 106  * the epilogue that uses a long branch to the destination, and any short
 107  * jumps inside a method that cannot reach the destination directly will
 108  * branch first to the stub.
 109  */
 110 typedef struct MonoOvfJump {
 111         union {
 112                 MonoBasicBlock *bb;
 113                 const char *exception;
 114         } data;
 115         guint32 ip_offset;
 116 } MonoOvfJump;
 117
 118 /* Create a literal 0.0 double for FNEG */
 119 double hppa_zero = 0;
 120
 121 const char*
 122 mono_arch_regname (int reg)
 123 {
 124         static const char * rnames[] = {
 125                 "hppa_r0", "hppa_r1", "hppa_rp", "hppa_r3", "hppa_r4",
 126                 "hppa_r5", "hppa_r6", "hppa_r7", "hppa_r8", "hppa_r9",
 127                 "hppa_r10", "hppa_r11", "hppa_r12", "hppa_r13", "hppa_r14",
 128                 "hppa_r15", "hppa_r16", "hppa_r17", "hppa_r18", "hppa_r19",
 129                 "hppa_r20", "hppa_r21", "hppa_r22", "hppa_r23", "hppa_r24",
 130                 "hppa_r25", "hppa_r26", "hppa_r27", "hppa_r28", "hppa_r29",
 131                 "hppa_sp", "hppa_r31"
 132         };
 133         if (reg >= 0 && reg < MONO_MAX_IREGS)
 134                 return rnames [reg];
 135         return "unknown";
 136 }
 137
 138 const char*
 139 mono_arch_fregname (int reg)
 140 {
 141         static const char *rnames [] = {
 142                 "hppa_fr0", "hppa_fr1", "hppa_fr2", "hppa_fr3", "hppa_fr4",
 143                 "hppa_fr5", "hppa_fr6", "hppa_fr7", "hppa_fr8", "hppa_fr9",
 144                 "hppa_fr10", "hppa_fr11", "hppa_fr12", "hppa_fr13", "hppa_fr14",
 145                 "hppa_fr15", "hppa_fr16", "hppa_fr17", "hppa_fr18", "hppa_fr19",
 146                 "hppa_fr20", "hppa_fr21", "hppa_fr22", "hppa_fr23", "hppa_fr24",
 147                 "hppa_fr25", "hppa_fr26", "hppa_fr27", "hppa_fr28", "hppa_fr29",
 148                 "hppa_fr30", "hppa_fr31",
 149         };
 150
 151         if (reg >= 0 && reg < MONO_MAX_FREGS)
 152                 return rnames [reg];
 153         else
 154                 return "unknown";
 155 }
 156
 157 /*
 158  * Initialize the cpu to execute managed code.
 159  */
 160 void
 161 mono_arch_cpu_init (void)
 162 {
 163         guint32 dummy;
 164         mono_arch_cpu_optimizazions(&dummy);
 165 }
 166
 167 /*
 168  * Initialize architecture specific code.
 169  */
 170 void
 171 mono_arch_init (void)
 172 {
 173 }
 174
 175 /*
 176  * Cleanup architecture specific code.
 177  */
 178 void
 179 mono_arch_cleanup (void)
 180 {
 181 }
 182
 183 /*
 184  * This function returns the optimizations supported on this cpu.
 185  */
 186 guint32
 187 mono_arch_cpu_optimizazions (guint32 *exclude_mask)
 188 {
 189         guint32 opts = 0;
 190         *exclude_mask = 0;
 191         return opts;
 192 }
 193
 194 void
 195 mono_arch_flush_icache (guint8 *code, gint size)
 196 {
 197         guint8* p = (guint8*)((guint32)code & ~(0x3f));
 198         guint8* end = (guint8*)((guint32)code + size);
 199         while (p < end) {
 200                 __asm__ __volatile__ ("fdc %%r0(%%sr3, %0)\n"
 201                         "sync\n"
 202                         "fic %%r0(%%sr3, %0)\n"
 203                         "sync\n"
 204                         : : "r"(p));
 205                 p += 32; /* can be 64 on pa20 cpus */
 206         }
 207 }
 208
 209 void
 210 mono_arch_flush_register_windows (void)
 211 {
 212         /* No register windows on hppa */
 213 }
 214
 215 typedef enum {
 216         ArgInIReg,
 217         ArgInIRegPair,
 218         ArgInFReg,
 219         ArgInDReg,
 220         ArgOnStack,
 221 } ArgStorage;
 222
 223 typedef struct {
 224         gint16 offset;
 225         gint16 size;
 226         guint8 type;
 227         gint8  reg;
 228         ArgStorage storage;
 229 } ArgInfo;
 230
 231 typedef struct {
 232         int nargs;
 233         guint32 stack_usage;
 234         int struct_return;
 235         ArgInfo ret;
 236         ArgInfo sig_cookie;
 237         ArgInfo args [1];
 238 } CallInfo;
 239
 240 #define PARAM_REGS 4
 241 #define ARGS_OFFSET 36
 242
 243 static void
 244 add_parameter (CallInfo *cinfo, ArgInfo *ainfo, MonoType *type)
 245 {
 246         int is_fp = (type->type == MONO_TYPE_R4 || type->type == MONO_TYPE_R8);
 247         int ofs, align;
 248
 249         DEBUG_FUNC_ENTER ();
 250         ainfo->reg = -1;
 251         ainfo->size = mono_type_size (type, &align);
 252         ainfo->type = type->type;
 253
 254         if (ainfo->size <= 4) {
 255                 cinfo->stack_usage += 4;
 256                 ainfo->offset = cinfo->stack_usage - (4 - ainfo->size);
 257         }
 258         else if (ainfo->size <= 8)
 259         {
 260                 cinfo->stack_usage += 8;
 261                 cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, 8);
 262                 ainfo->offset = cinfo->stack_usage - (8 - ainfo->size);
 263         }
 264         else
 265         {
 266                 cinfo->stack_usage += ainfo->size;
 267                 cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, align);
 268                 ainfo->offset = cinfo->stack_usage;
 269         }
 270
 271         ofs = (ALIGN_TO (ainfo->offset, 4) - ARGS_OFFSET) / 4;
 272         if (ofs < PARAM_REGS) {
 273                 if (!is_fp) {
 274                         if (ainfo->size <= 4)
 275                                 ainfo->storage = ArgInIReg;
 276                         else
 277                                 ainfo->storage = ArgInIRegPair;
 278                         ainfo->reg = hppa_r26 - ofs;
 279                 } else if (type->type == MONO_TYPE_R4) {
 280                         ainfo->storage = ArgInFReg;
 281                         ainfo->reg = hppa_fr4 + ofs;
 282                 } else { /* type->type == MONO_TYPE_R8 */
 283                         ainfo->storage = ArgInDReg;
 284                         ainfo->reg = hppa_fr4 + ofs;
 285                 }
 286         }
 287         else {
 288                 /* frame pointer based offset */
 289                 ainfo->reg = hppa_r3;
 290                 ainfo->storage = ArgOnStack;
 291         }
 292
 293         /* All offsets are negative relative to the frame pointer */
 294         ainfo->offset = -ainfo->offset;
 295
 296         DEBUG_FUNC_EXIT ();
 297 }
 298
 299 static void
 300 analyze_return (CallInfo *cinfo, MonoMethodSignature *sig)
 301 {
 302         MonoType *type;
 303         int align;
 304         int size;
 305
 306         type = sig->ret;
 307         size = mono_type_size (type, &align);
 308
 309         /* ref: mono_type_to_stind */
 310         cinfo->ret.type = type->type;
 311         if (type->byref) {
 312                 cinfo->ret.storage = ArgInIReg;
 313                 cinfo->ret.reg = hppa_r28;
 314         } else {
 315 handle_enum:
 316                 switch (type->type) {
 317                 case MONO_TYPE_VOID:
 318                         break;
 319                 case MONO_TYPE_BOOLEAN:
 320                 case MONO_TYPE_I1:
 321                 case MONO_TYPE_U1:
 322                 case MONO_TYPE_I2:
 323                 case MONO_TYPE_U2:
 324                 case MONO_TYPE_CHAR:
 325                 case MONO_TYPE_I4:
 326                 case MONO_TYPE_U4:
 327                 case MONO_TYPE_I:
 328                 case MONO_TYPE_U:
 329                 case MONO_TYPE_PTR:
 330                 case MONO_TYPE_FNPTR:
 331                 case MONO_TYPE_CLASS:
 332                 case MONO_TYPE_STRING:
 333                 case MONO_TYPE_OBJECT:
 334                 case MONO_TYPE_SZARRAY:
 335                 case MONO_TYPE_ARRAY:
 336                         cinfo->ret.storage = ArgInIReg;
 337                         cinfo->ret.reg = hppa_r28;
 338                         break;
 339                 case MONO_TYPE_U8:
 340                 case MONO_TYPE_I8:
 341                         cinfo->ret.storage = ArgInIRegPair;
 342                         cinfo->ret.reg = hppa_r28;
 343                         break;
 344                 case MONO_TYPE_R4:
 345                         cinfo->ret.storage = ArgInFReg;
 346                         cinfo->ret.reg = hppa_fr4;
 347                         break;
 348                 case MONO_TYPE_R8:
 349                         cinfo->ret.storage = ArgInDReg;
 350                         cinfo->ret.reg = hppa_fr4;
 351                         break;
 352                 case MONO_TYPE_GENERICINST:
 353                         type = &type->data.generic_class->container_class->byval_arg;
 354                         goto handle_enum;
 355
 356                 case MONO_TYPE_VALUETYPE:
 357                         if (type->data.klass->enumtype) {
 358                                 type = type->data.klass->enum_basetype;
 359                                 goto handle_enum;
 360                         }
 361                         /* Fall through */
 362                 case MONO_TYPE_TYPEDBYREF:
 363                         cinfo->struct_return = 1;
 364                         /* cinfo->ret.storage tells us how the ABI expects
 365                          * the parameter to be returned
 366                          */
 367                         if (size <= 4) {
 368                                 cinfo->ret.storage = ArgInIReg;
 369                                 cinfo->ret.reg = hppa_r28;
 370                         } else if (size <= 8) {
 371                                 cinfo->ret.storage = ArgInIRegPair;
 372                                 cinfo->ret.reg = hppa_r28;
 373                         } else {
 374                                 cinfo->ret.storage = ArgOnStack;
 375                                 cinfo->ret.reg = hppa_sp;
 376                         }
 377
 378                         /* We always allocate stack space for this because the
 379                          * arch-indep code expects us to
 380                          */
 381                         cinfo->stack_usage += size;
 382                         cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, align);
 383                         cinfo->ret.offset = -cinfo->stack_usage;
 384                         break;
 385
 386                 default:
 387                         g_error ("Can't handle as return value 0x%x", sig->ret->type);
 388                 }
 389         }
 390 }
 391
 392 /*
 393  * get_call_info:
 394  *
 395  *  Obtain information about a call according to the calling convention.
 396  */
 397 static CallInfo*
 398 get_call_info (MonoMethodSignature *sig, gboolean is_pinvoke)
 399 {
 400         guint32 i;
 401         int n = sig->hasthis + sig->param_count;
 402         CallInfo *cinfo;
 403         MonoType *type;
 404         MonoType ptrtype;
 405         int dummy;
 406
 407         ptrtype.type = MONO_TYPE_PTR;
 408
 409         DEBUG_FUNC_ENTER();
 410         cinfo = g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
 411
 412         /* The area below ARGS_OFFSET is the linkage area... */
 413         cinfo->stack_usage = ARGS_OFFSET - 4;
 414         /* -4, because the first argument will allocate the area it needs */
 415
 416         /* this */
 417         if (sig->hasthis) {
 418                 add_parameter (cinfo, cinfo->args + 0, &ptrtype);
 419                 DEBUG (printf ("param <this>: assigned to reg %s offset %d\n", mono_arch_regname (cinfo->args[0].reg), cinfo->args[0].offset));
 420         }
 421
 422         /* TODO: What to do with varargs? */
 423
 424         for (i = 0; i < sig->param_count; ++i) {
 425                 ArgInfo *ainfo = &cinfo->args [sig->hasthis + i];
 426                 if (sig->params [i]->byref)
 427                         type = &ptrtype;
 428                 else
 429                         type = mono_type_get_underlying_type (sig->params [i]);
 430                 add_parameter (cinfo, ainfo, type);
 431
 432                 DEBUG (printf ("param %d: type %d size %d assigned to reg %s offset %d\n", i, type->type, mono_type_size (type, &dummy), mono_arch_regname (ainfo->reg), ainfo->offset));
 433         }
 434
 435         analyze_return (cinfo, sig);
 436
 437         DEBUG_FUNC_EXIT();
 438         return cinfo;
 439 }
 440
 441 GList *
 442 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
 443 {
 444         GList *vars = NULL;
 445         int i;
 446
 447         DEBUG_FUNC_ENTER();
 448         for (i = 0; i < cfg->num_varinfo; i++) {
 449                 MonoInst *ins = cfg->varinfo [i];
 450                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
 451
 452                 /* unused vars */
 453                 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
 454                         continue;
 455
 456                 if ((ins->flags & (MONO_INST_IS_DEAD|MONO_INST_VOLATILE|MONO_INST_INDIRECT)) ||
 457                     (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
 458                         continue;
 459
 460                 if (mono_is_regsize_var (ins->inst_vtype)) {
 461                         g_assert (MONO_VARINFO (cfg, i)->reg == -1);
 462                         g_assert (i == vmv->idx);
 463                         vars = mono_varlist_insert_sorted (cfg, vars, vmv, FALSE);
 464                 }
 465         }
 466         DEBUG_FUNC_EXIT();
 467
 468         return vars;
 469 }
 470
 471 GList *
 472 mono_arch_get_global_int_regs (MonoCompile *cfg)
 473 {
 474         GList *regs = NULL;
 475         int i;
 476
 477         /* r3 is sometimes used as our frame pointer, so don't allocate it
 478          * r19 is the GOT pointer, don't allocate it either
 479          */
 480
 481         DEBUG_FUNC_ENTER();
 482         for (i = 4; i <= 18; i++)
 483                 regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
 484         DEBUG_FUNC_EXIT();
 485
 486         return regs;
 487 }
 488
 489 /*
 490  * mono_arch_regalloc_cost:
 491  *
 492  *  Return the cost, in number of memory references, of the action of
 493  * allocating the variable VMV into a register during global register
 494  * allocation.
 495  */
 496 guint32
 497 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
 498 {
 499         /* FIXME */
 500         return 0;
 501 }
 502
 503 /*
 504  * Set var information according to the calling convention.
 505  * The locals var stuff should most likely be split in another method.
 506  *
 507  * updates m->stack_offset based on the amount of stack space needed for
 508  * local vars
 509  */
 510 void
 511 mono_arch_allocate_vars (MonoCompile *m)
 512 {
 513         MonoMethodSignature *sig;
 514         MonoMethodHeader *header;
 515         MonoInst *inst;
 516         int i, offset, size, align, curinst;
 517         guint32 stack_ptr;
 518         guint rettype;
 519         CallInfo *cinfo;
 520
 521         DEBUG_FUNC_ENTER();
 522         m->flags |= MONO_CFG_HAS_SPILLUP;
 523
 524         header = mono_method_get_header (m->method);
 525
 526         sig = mono_method_signature (m->method);
 527         DEBUG (printf ("Allocating locals - incoming params:\n"));
 528         cinfo = get_call_info (sig, FALSE);
 529
 530         /*
 531          * We use the ABI calling conventions for managed code as well.
 532          */
 533         if (m->flags & MONO_CFG_HAS_ALLOCA) {
 534                 stack_ptr = hppa_r4;
 535                 m->used_int_regs |= 1 << hppa_r4;
 536         } else {
 537                 stack_ptr = hppa_sp;
 538         }
 539
 540         /* Before this function is called, we would have looked at all
 541          * calls from this method and figured out how much space is needed
 542          * for the param area.
 543          *
 544          * Locals are allocated backwards, right before the param area
 545          */
 546         /* TODO: in some cases we don't need the frame pointer... */
 547         m->frame_reg = hppa_r3;
 548         offset = m->param_area;
 549
 550         /* Return values can be passed back either in four ways:
 551          * r28 is used for data <= 4 bytes (32-bit ABI)
 552          * r28/r29 are used for data >4 && <= 8 bytes
 553          * fr4 is used for floating point data
 554          * data larger than 8 bytes is returned on the stack pointed to
 555          *      by r28
 556          *
 557          * This code needs to be in sync with how CEE_RET is handled
 558          * in mono_method_to_ir (). In some cases when we return small
 559          * structs, the ABI specifies that they should be returned in
 560          * registers, but the code in mono_method_to_ir () always emits
 561          * a memcpy for valuetype returns, so we need to make sure we
 562          * allocate space on the stack for this copy.
 563          */
 564         if (cinfo->struct_return) {
 565                 /* this is used to stash the incoming r28 pointer */
 566                 offset += sizeof (gpointer);
 567                 m->ret->opcode = OP_REGOFFSET;
 568                 m->ret->inst_basereg = stack_ptr;
 569                 m->ret->inst_offset = -offset;
 570         } else if (sig->ret->type != MONO_TYPE_VOID) {
 571                 m->ret->opcode = OP_REGVAR;
 572                 m->ret->inst_c0 = cinfo->ret.reg;
 573         }
 574
 575         curinst = m->locals_start;
 576         for (i = curinst; i < m->num_varinfo; ++i) {
 577                 inst = m->varinfo [i];
 578
 579                 if (inst->opcode == OP_REGVAR) {
 580                         DEBUG (printf ("allocating local %d to %s\n", i, mono_arch_regname (inst->dreg)));
 581                         continue;
 582                 }
 583
 584                 if (inst->flags & MONO_INST_IS_DEAD)
 585                         continue;
 586
 587                 /* inst->backend.is_pinvoke indicates native sized value types, this is used by the
 588                 * pinvoke wrappers when they call functions returning structure */
 589                 if (inst->backend.is_pinvoke && MONO_TYPE_ISSTRUCT (inst->inst_vtype) && inst->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
 590                         size = mono_class_native_size (inst->inst_vtype->data.klass, &align);
 591                 else
 592                         size = mini_type_stack_size (cfg->generic_sharing_context, inst->inst_vtype, &align);
 593
 594                 /*
 595                  * This is needed since structures containing doubles must be doubleword
 596          * aligned.
 597                  * FIXME: Do this only if needed.
 598                  */
 599                 if (MONO_TYPE_ISSTRUCT (inst->inst_vtype))
 600                         align = 8;
 601
 602                 /*
 603                  * variables are accessed as negative offsets from hppa_sp
 604                  */
 605                 inst->opcode = OP_REGOFFSET;
 606                 inst->inst_basereg = stack_ptr;
 607                 offset += size;
 608                 offset = ALIGN_TO (offset, align);
 609                 inst->inst_offset = -offset;
 610
 611                 DEBUG (printf ("allocating local %d (size = %d) to [%s - %d]\n", i, size, mono_arch_regname (inst->inst_basereg), -inst->inst_offset));
 612         }
 613
 614         if (sig->call_convention == MONO_CALL_VARARG) {
 615                 /* TODO */
 616         }
 617
 618         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
 619                 ArgInfo *ainfo = &cinfo->args [i];
 620                 inst = m->args [i];
 621                 if (inst->opcode != OP_REGVAR) {
 622                         switch (ainfo->storage) {
 623                         case ArgInIReg:
 624                         case ArgInIRegPair:
 625                         case ArgInFReg:
 626                         case ArgInDReg:
 627                                 /* Currently mono requests all incoming registers
 628                                  * be assigned to a stack location :-(
 629                                  */
 630 #if 0
 631                                 if (!(inst->flags & (MONO_INST_VOLATILE | MONO_INST_INDIRECT))) {
 632                                         inst->opcode = OP_REGVAR;
 633                                         inst->dreg = ainfo->reg;
 634                                         DEBUG (printf ("param %d in register %s\n", i, mono_arch_regname (inst->dreg)));
 635                                         break;
 636                                 }
 637 #endif
 638                                 /* fallthrough */
 639                         case ArgOnStack:
 640                                 inst->opcode = OP_REGOFFSET;
 641                                 inst->inst_basereg = hppa_r3;
 642                                 inst->inst_offset = ainfo->offset;
 643                                 DEBUG (printf ("param %d stored on stack [%s - %d]\n", i, mono_arch_regname (hppa_r3), -inst->inst_offset));
 644                                 break;
 645                         }
 646                 }
 647         }
 648
 649         m->stack_offset = offset; /* Includes cfg->param_area */
 650
 651         g_free (cinfo);
 652         DEBUG_FUNC_EXIT();
 653 }
 654
 655 /*
 656  * take the arguments and generate the arch-specific
 657  * instructions to properly call the function in call.
 658  * This includes pushing, moving arguments to the right register
 659  * etc.
 660  *
 661  * sets call->stack_usage and cfg->param_area
 662  */
 663 MonoCallInst*
 664 mono_arch_call_opcode (MonoCompile *cfg, MonoBasicBlock* bb, MonoCallInst *call, int is_virtual)
 665 {
 666         MonoInst *arg, *in;
 667         MonoMethodSignature *sig;
 668         int i, n;
 669         CallInfo *cinfo;
 670         ArgInfo *ainfo;
 671
 672         DEBUG_FUNC_ENTER();
 673         DEBUG (printf ("is_virtual = %d\n", is_virtual));
 674
 675         sig = call->signature;
 676         n = sig->param_count + sig->hasthis;
 677
 678         DEBUG (printf ("Calling method with %d parameters\n", n));
 679
 680         cinfo = get_call_info (sig, sig->pinvoke);
 681
 682         // DEBUG
 683         g_assert (sig->call_convention != MONO_CALL_VARARG);
 684
 685         for (i = 0; i < n; ++i) {
 686                 ainfo = &cinfo->args [i];
 687
 688                 if ((sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
 689                         /* TODO */
 690                 }
 691
 692                 if (is_virtual && i == 0) {
 693                         /* the argument will be attached to the call instruction */
 694                         in = call->args [i];
 695                         call->used_iregs |= 1 << ainfo->reg;
 696                 } else {
 697                         MONO_INST_NEW (cfg, arg, OP_OUTARG);
 698                         in = call->args [i];
 699                         arg->cil_code = in->cil_code;
 700                         arg->inst_left = in;
 701                         arg->inst_call = call;
 702                         arg->type = in->type;
 703
 704                         /* prepend, we'll need to reverse them later */
 705                         arg->next = call->out_args;
 706                         call->out_args = arg;
 707
 708                         switch (ainfo->storage) {
 709                         case ArgInIReg:
 710                         case ArgInIRegPair: {
 711                                 MonoHPPAArgInfo *ai = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoHPPAArgInfo));
 712                                 ai->reg = ainfo->reg;
 713                                 ai->size = ainfo->size;
 714                                 ai->offset = ainfo->offset;
 715                                 ai->pass_in_reg = 1;
 716                                 arg->backend.data = ai;
 717
 718                                 call->used_iregs |= 1 << ainfo->reg;
 719                                 if (ainfo->storage == ArgInIRegPair)
 720                                         call->used_iregs |= 1 << (ainfo->reg + 1);
 721                                 if (ainfo->type == MONO_TYPE_VALUETYPE)
 722                                         arg->opcode = OP_OUTARG_VT;
 723                                 break;
 724                         }
 725                         case ArgOnStack: {
 726                                 MonoHPPAArgInfo *ai = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoHPPAArgInfo));
 727                                 ai->reg = hppa_sp;
 728                                 ai->size = ainfo->size;
 729                                 ai->offset = ainfo->offset;
 730                                 ai->pass_in_reg = 0;
 731                                 arg->backend.data = ai;
 732                                 if (ainfo->type == MONO_TYPE_VALUETYPE)
 733                                         arg->opcode = OP_OUTARG_VT;
 734                                 else
 735                                         arg->opcode = OP_OUTARG_MEMBASE;
 736                                 call->used_iregs |= 1 << ainfo->reg;
 737                                 break;
 738                         }
 739                         case ArgInFReg:
 740                                 arg->backend.reg3 = ainfo->reg;
 741                                 arg->opcode = OP_OUTARG_R4;
 742                                 call->used_fregs |= 1 << ainfo->reg;
 743                                 break;
 744                         case ArgInDReg:
 745                                 arg->backend.reg3 = ainfo->reg;
 746                                 arg->opcode = OP_OUTARG_R8;
 747                                 call->used_fregs |= 1 << ainfo->reg;
 748                                 break;
 749                         default:
 750                                 NOT_IMPLEMENTED;
 751                         }
 752                 }
 753         }
 754
 755         /*
 756          * Reverse the call->out_args list.
 757          */
 758         {
 759                 MonoInst *prev = NULL, *list = call->out_args, *next;
 760                 while (list) {
 761                         next = list->next;
 762                         list->next = prev;
 763                         prev = list;
 764                         list = next;
 765                 }
 766                 call->out_args = prev;
 767         }
 768         call->stack_usage = cinfo->stack_usage;
 769         cfg->param_area = MAX (cfg->param_area, call->stack_usage);
 770         cfg->param_area = ALIGN_TO (cfg->param_area, MONO_ARCH_FRAME_ALIGNMENT);
 771
 772         cfg->flags |= MONO_CFG_HAS_CALLS;
 773
 774         g_free (cinfo);
 775
 776         DEBUG_FUNC_EXIT();
 777         return call;
 778 }
 779
 780 void
 781 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
 782 {
 783 }
 784
 785 void
 786 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
 787 {
 788         DEBUG_FUNC_ENTER();
 789         DEBUG_FUNC_EXIT();
 790 }
 791
 792 static void
 793 insert_after_ins (MonoBasicBlock *bb, MonoInst *ins, MonoInst *to_insert)
 794 {
 795         if (ins == NULL) {
 796                 ins = bb->code;
 797                 bb->code = to_insert;
 798                 to_insert->next = ins;
 799         } else {
 800                 to_insert->next = ins->next;
 801                 ins->next = to_insert;
 802         }
 803 }
 804
 805 #define NEW_INS(cfg,dest,op) do {       \
 806                 (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));       \
 807                 (dest)->opcode = (op);  \
 808                 insert_after_ins (bb, last_ins, (dest)); \
 809         } while (0)
 810
 811 static int
 812 map_to_reg_reg_op (int op)
 813 {
 814         switch (op) {
 815         case OP_ADD_IMM:
 816                 return CEE_ADD;
 817         case OP_SUB_IMM:
 818                 return CEE_SUB;
 819         case OP_AND_IMM:
 820                 return CEE_AND;
 821         case OP_COMPARE_IMM:
 822                 return OP_COMPARE;
 823         case OP_ADDCC_IMM:
 824                 return OP_ADDCC;
 825         case OP_ADC_IMM:
 826                 return OP_ADC;
 827         case OP_SUBCC_IMM:
 828                 return OP_SUBCC;
 829         case OP_SBB_IMM:
 830                 return OP_SBB;
 831         case OP_OR_IMM:
 832                 return CEE_OR;
 833         case OP_XOR_IMM:
 834                 return CEE_XOR;
 835         case OP_MUL_IMM:
 836                 return CEE_MUL;
 837         case OP_LOAD_MEMBASE:
 838                 return OP_LOAD_MEMINDEX;
 839         case OP_LOADI4_MEMBASE:
 840                 return OP_LOADI4_MEMINDEX;
 841         case OP_LOADU4_MEMBASE:
 842                 return OP_LOADU4_MEMINDEX;
 843         case OP_LOADU1_MEMBASE:
 844                 return OP_LOADU1_MEMINDEX;
 845         case OP_LOADI2_MEMBASE:
 846                 return OP_LOADI2_MEMINDEX;
 847         case OP_LOADU2_MEMBASE:
 848                 return OP_LOADU2_MEMINDEX;
 849         case OP_LOADI1_MEMBASE:
 850                 return OP_LOADI1_MEMINDEX;
 851         case OP_LOADR4_MEMBASE:
 852                 return OP_LOADR4_MEMINDEX;
 853         case OP_LOADR8_MEMBASE:
 854                 return OP_LOADR8_MEMINDEX;
 855         case OP_STOREI1_MEMBASE_REG:
 856                 return OP_STOREI1_MEMINDEX;
 857         case OP_STOREI2_MEMBASE_REG:
 858                 return OP_STOREI2_MEMINDEX;
 859         case OP_STOREI4_MEMBASE_REG:
 860                 return OP_STOREI4_MEMINDEX;
 861         case OP_STORE_MEMBASE_REG:
 862                 return OP_STORE_MEMINDEX;
 863         case OP_STORER4_MEMBASE_REG:
 864                 return OP_STORER4_MEMINDEX;
 865         case OP_STORER8_MEMBASE_REG:
 866                 return OP_STORER8_MEMINDEX;
 867         case OP_STORE_MEMBASE_IMM:
 868                 return OP_STORE_MEMBASE_REG;
 869         case OP_STOREI1_MEMBASE_IMM:
 870                 return OP_STOREI1_MEMBASE_REG;
 871         case OP_STOREI2_MEMBASE_IMM:
 872                 return OP_STOREI2_MEMBASE_REG;
 873         case OP_STOREI4_MEMBASE_IMM:
 874                 return OP_STOREI4_MEMBASE_REG;
 875         }
 876         g_assert_not_reached ();
 877 }
 878
 879 /*
 880  * Remove from the instruction list the instructions that can't be
 881  * represented with very simple instructions with no register
 882  * requirements.
 883  */
 884 void
 885 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
 886 {
 887         MonoInst *ins, *next, *temp, *last_ins = NULL;
 888         int imm;
 889
 890         MONO_BB_FOR_EACH_INS (bb, ins) {
 891 loop_start:
 892                 switch (ins->opcode) {
 893                 case OP_ADD_IMM:
 894                 case OP_ADDCC_IMM:
 895                         if (!hppa_check_bits (ins->inst_imm, 11)) {
 896                                 NEW_INS (cfg, temp, OP_ICONST);
 897                                 temp->inst_c0 = ins->inst_imm;
 898                                 temp->dreg = mono_alloc_ireg (cfg);
 899                                 ins->sreg2 = temp->dreg;
 900                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
 901                         }
 902                         break;
 903                 case OP_SUB_IMM:
 904                 case OP_SUBCC_IMM:
 905                         if (!hppa_check_bits (ins->inst_imm, 11)) {
 906                                 NEW_INS (cfg, temp, OP_ICONST);
 907                                 temp->inst_c0 = ins->inst_imm;
 908                                 temp->dreg = mono_alloc_ireg (cfg);
 909                                 ins->sreg2 = temp->dreg;
 910                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
 911                         }
 912                         break;
 913
 914                 case OP_MUL_IMM:
 915                         if (ins->inst_imm == 1) {
 916                                 ins->opcode = OP_MOVE;
 917                                 break;
 918                         }
 919                         if (ins->inst_imm == 0) {
 920                                 ins->opcode = OP_ICONST;
 921                                 ins->inst_c0 = 0;
 922                                 break;
 923                         }
 924                         imm = mono_is_power_of_two (ins->inst_imm);
 925                         if (imm > 0) {
 926                                 ins->opcode = OP_SHL_IMM;
 927                                 ins->inst_imm = imm;
 928                                 break;
 929                         }
 930                         else {
 931                                 int tmp = mono_alloc_ireg (cfg);
 932                                 NEW_INS (cfg, temp, OP_ICONST);
 933                                 temp->inst_c0 = ins->inst_c0;
 934                                 temp->dreg = tmp;
 935
 936                                 ins->opcode = CEE_MUL;
 937                                 ins->sreg2 = tmp;
 938                                 /* Need to rewrite the CEE_MUL too... */
 939                                 goto loop_start;
 940                         }
 941                         break;
 942
 943                 case CEE_MUL: {
 944                         int freg1 = mono_alloc_freg (cfg);
 945                         int freg2 = mono_alloc_freg (cfg);
 946
 947                         NEW_INS(cfg, temp, OP_STORE_MEMBASE_REG);
 948                         temp->sreg1 = ins->sreg1;
 949                         temp->inst_destbasereg = hppa_sp;
 950                         temp->inst_offset = -16;
 951
 952                         NEW_INS(cfg, temp, OP_LOADR4_MEMBASE);
 953                         temp->dreg = freg1;
 954                         temp->inst_basereg = hppa_sp;
 955                         temp->inst_offset = -16;
 956
 957                         NEW_INS(cfg, temp, OP_STORE_MEMBASE_REG);
 958                         temp->sreg1 = ins->sreg2;
 959                         temp->inst_destbasereg = hppa_sp;
 960                         temp->inst_offset = -16;
 961
 962                         NEW_INS(cfg, temp, OP_LOADR4_MEMBASE);
 963                         temp->dreg = freg2;
 964                         temp->inst_basereg = hppa_sp;
 965                         temp->inst_offset = -16;
 966
 967                         NEW_INS (cfg, temp, OP_HPPA_XMPYU);
 968                         temp->dreg = freg2;
 969                         temp->sreg1 = freg1;
 970                         temp->sreg2 = freg2;
 971
 972                         NEW_INS(cfg, temp, OP_HPPA_STORER4_RIGHT);
 973                         temp->sreg1 = freg2;
 974                         temp->inst_destbasereg = hppa_sp;
 975                         temp->inst_offset = -16;
 976
 977                         ins->opcode = OP_LOAD_MEMBASE;
 978                         ins->inst_basereg = hppa_sp;
 979                         ins->inst_offset = -16;
 980                 }
 981                 break;
 982
 983                 default:
 984                         break;
 985                 }
 986                 last_ins = ins;
 987         }
 988         bb->last_ins = last_ins;
 989         bb->max_vreg = cfg->next_vreg;
 990
 991 }
 992
 993 void
 994 hppa_patch (guint32 *code, const gpointer target)
 995 {
 996         guint32 ins = *code;
 997         gint32 val = (gint32)target;
 998         gint32 disp = (val - (gint32)code - 8) >> 2;
 999         int reg1, reg2;
1000
1001         DEBUG (printf ("patching 0x%08x (0x%08x) to point to 0x%08x (disp = %d)\n", code, ins, val, disp));
1002
1003         switch (*code >> 26) {
1004         case 0x08: /* ldil, next insn can be a ldo, ldw, or ble */
1005                 *code = *code & ~0x1fffff;
1006                 *code = *code | hppa_op_imm21 (hppa_lsel (val));
1007                 code++;
1008
1009                 if ((*code >> 26) == 0x0D) { /* ldo */
1010                         *code = *code & ~0x3fff;
1011                         *code = *code | hppa_op_imm14 (hppa_rsel (val));
1012                 } else if ((*code >> 26) == 0x12) { /* ldw */
1013                         *code = *code & ~0x3fff;
1014                         *code = *code | hppa_op_imm14 (hppa_rsel (val));
1015                 } else if ((*code >> 26) == 0x39) { /* ble */
1016                         *code = *code & ~0x1f1ffd;
1017                         *code = *code | hppa_op_imm17 (hppa_rsel (val));
1018                 }
1019
1020                 break;
1021
1022         case 0x3A: /* bl */
1023                 if (disp == 0) {
1024                         hppa_nop (code);
1025                         break;
1026                 }
1027                 if (!hppa_check_bits (disp, 17))
1028                         goto jump_overflow;
1029                 reg1 = (*code >> 21) & 0x1f;
1030                 *code = (*code & ~0x1f1ffd) | hppa_op_imm17(disp);
1031                 break;
1032
1033         case 0x20: /* combt */
1034         case 0x22: /* combf */
1035                 if (!hppa_check_bits (disp >> 2, 12))
1036                         goto jump_overflow;
1037                 *code = (*code & ~0x1ffd) | hppa_op_imm12(disp);
1038                 break;
1039
1040         default:
1041                 g_warning ("Unpatched opcode %x\n", *code >> 26);
1042         }
1043
1044         return;
1045
1046 jump_overflow:
1047         g_warning ("cannot branch to target, insn is %08x, displacement is %d\n", (int)*code, (int)disp);
1048         g_assert_not_reached ();
1049 }
1050
1051 static guint32 *
1052 emit_float_to_int (MonoCompile *cfg, guint32 *code, int dreg, int sreg, int size, gboolean is_signed)
1053 {
1054         /* sreg is a float, dreg is an integer reg. */
1055         hppa_fcnvfxt (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, sreg, sreg);
1056         hppa_fstws (code, sreg, 0, -16, hppa_sp);
1057         hppa_ldw (code, -16, hppa_sp, dreg);
1058         if (!is_signed) {
1059                 if (size == 1)
1060                         hppa_extru (code, dreg, 31, 8, dreg);
1061                 else if (size == 2)
1062                         hppa_extru (code, dreg, 31, 16, dreg);
1063         } else {
1064                 if (size == 1)
1065                         hppa_extrs (code, dreg, 31, 8, dreg);
1066                 else if (size == 2)
1067                         hppa_extrs (code, dreg, 31, 16, dreg);
1068         }
1069         return code;
1070 }
1071
1072 /* Clobbers r1, r20, r21 */
1073 static guint32 *
1074 emit_memcpy (guint32 *code, int doff, int dreg, int soff, int sreg, int size)
1075 {
1076         /* r20 is the destination */
1077         hppa_set (code, doff, hppa_r20);
1078         hppa_add (code, hppa_r20, dreg, hppa_r20);
1079
1080         /* r21 is the source */
1081         hppa_set (code, soff, hppa_r21);
1082         hppa_add (code, hppa_r21, sreg, hppa_r21);
1083
1084         while (size >= 4) {
1085                 hppa_ldw (code, 0, hppa_r21, hppa_r1);
1086                 hppa_stw (code, hppa_r1, 0, hppa_r20);
1087                 hppa_ldo (code, 4, hppa_r21, hppa_r21);
1088                 hppa_ldo (code, 4, hppa_r20, hppa_r20);
1089                 size -= 4;
1090         }
1091         while (size >= 2) {
1092                 hppa_ldh (code, 0, hppa_r21, hppa_r1);
1093                 hppa_sth (code, hppa_r1, 0, hppa_r20);
1094                 hppa_ldo (code, 2, hppa_r21, hppa_r21);
1095                 hppa_ldo (code, 2, hppa_r20, hppa_r20);
1096                 size -= 2;
1097         }
1098         while (size > 0) {
1099                 hppa_ldb (code, 0, hppa_r21, hppa_r1);
1100                 hppa_stb (code, hppa_r1, 0, hppa_r20);
1101                 hppa_ldo (code, 1, hppa_r21, hppa_r21);
1102                 hppa_ldo (code, 1, hppa_r20, hppa_r20);
1103                 size -= 1;
1104         }
1105
1106         return code;
1107 }
1108
1109 /*
1110  * mono_arch_get_vcall_slot_addr:
1111  *
1112  *  Determine the vtable slot used by a virtual call.
1113  */
1114 gpointer*
1115 mono_arch_get_vcall_slot_addr (guint8 *code8, gpointer *regs)
1116 {
1117         guint32 *code = (guint32*)((unsigned long)code8 & ~3);
1118
1119         DEBUG_FUNC_ENTER();
1120
1121         code -= 2;
1122         /* This is the special virtual call token */
1123         if (code [-1] != 0x34000eee) /* ldo 0x777(r0),r0 */
1124                 return NULL;
1125
1126         if ((code [0] >> 26) == 0x39 &&         /* ble */
1127             (code [-2] >> 26) == 0x12) {        /* ldw */
1128                 guint32 ldw = code [-2];
1129                 guint32 reg = (ldw >> 21) & 0x1f;
1130                 gint32 disp = ((ldw & 1) ? (-1 << 13) : 0) | ((ldw & 0x3fff) >> 1);
1131                 /* FIXME: we are not guaranteed that reg is saved in the LMF.
1132                  * In fact, it probably isn't, since it is allocated as a
1133                  * callee register.  Right now just return an address; this
1134                  * is sufficient for non-AOT operation
1135                  */
1136                 // return (gpointer)((guint8*)regs [reg] + disp);
1137                 return code;
1138         }
1139         else
1140                 g_assert_not_reached ();
1141
1142         DEBUG_FUNC_EXIT();
1143 }
1144
1145 /* ins->dreg = *(ins->inst_desgbasereg + ins->inst_offset) */
1146 #define EMIT_LOAD_MEMBASE(ins, op) do {                         \
1147         if (!hppa_check_bits (ins->inst_offset, 14)) {          \
1148                 hppa_set (code, ins->inst_offset, hppa_r1);     \
1149                 hppa_ ## op ## x (code, hppa_r1, ins->inst_basereg, ins->dreg); \
1150         }                                                       \
1151         else {                                                  \
1152                 hppa_ ## op (code, ins->inst_offset, ins->inst_basereg, ins->dreg); \
1153         }                                                       \
1154 } while (0)
1155
1156 #define EMIT_COND_BRANCH_FLAGS(ins,r1,r2,b0,b1) do {\
1157         if (ins->flags & MONO_INST_BRLABEL) { \
1158                 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_LABEL, ins->inst_i0); \
1159                 if (b0) \
1160                         hppa_combt (code, r1, r2, b1, 0); \
1161                 else \
1162                         hppa_combf (code, r1, r2, b1, 0); \
1163         } else { \
1164                 if (b0) \
1165                         hppa_combf (code, r1, r2, b1, 2); \
1166                 else \
1167                         hppa_combt (code, r1, r2, b1, 2); \
1168                 hppa_nop (code); \
1169                 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \
1170                 hppa_bl (code, 0, hppa_r0); \
1171         } \
1172         hppa_nop (code); \
1173 } while (0)
1174
1175 #define EMIT_COND_BRANCH(ins,r1,r2,cond) EMIT_COND_BRANCH_FLAGS(ins, r1, r2, branch_b0_table [(cond)], branch_b1_table [(cond)])
1176
1177 #define EMIT_FLOAT_COND_BRANCH_FLAGS(ins,r1,r2,b0) do {\
1178         hppa_fcmp (code, HPPA_FP_FMT_DBL, b0, r1, r2); \
1179         hppa_ftest (code, 0); \
1180         if (ins->flags & MONO_INST_BRLABEL) \
1181                 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_LABEL, ins->inst_i0); \
1182         else \
1183                 mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \
1184         hppa_bl (code, 8, hppa_r0); \
1185         hppa_nop (code); \
1186 } while (0)
1187
1188 #define EMIT_FLOAT_COND_BRANCH(ins,r1,r2,cond) EMIT_FLOAT_COND_BRANCH_FLAGS(ins, r1, r2, float_branch_table [cond])
1189
1190 #define EMIT_COND_SYSTEM_EXCEPTION_FLAGS(r1,r2,b0,b1,exc_name)          \
1191 do {                                                                    \
1192         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump)); \
1193         ovfj->data.exception = (exc_name);                      \
1194         ovfj->ip_offset = (guint8*)code - cfg->native_code;     \
1195         hppa_bl (code, 8, hppa_r2);                             \
1196         hppa_depi (code, 0, 31, 2, hppa_r2);                    \
1197         hppa_ldo (code, 8, hppa_r2, hppa_r2);                   \
1198         if (b0)                                                 \
1199                 hppa_combf (code, r1, r2, b1, 2);               \
1200         else                                                    \
1201                 hppa_combt (code, r1, r2, b1, 2);               \
1202         hppa_nop (code);                                        \
1203         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj); \
1204         hppa_bl (code, 0, hppa_r0);                             \
1205         hppa_nop (code);                                        \
1206 } while (0)
1207
1208 #define EMIT_COND_SYSTEM_EXCEPTION(r1,r2,cond,exc_name) EMIT_COND_SYSTEM_EXCEPTION_FLAGS(r1, r2, branch_b0_table [(cond)], branch_b1_table [(cond)], (exc_name))
1209
1210 /* TODO: MEM_INDEX_REG - cannot be r1 */
1211 #define MEM_INDEX_REG hppa_r31
1212 /* *(ins->inst_destbasereg + ins->inst_offset) = ins->inst_imm */
1213 #define EMIT_STORE_MEMBASE_IMM(ins, op) do {                    \
1214         guint32 sreg;                                           \
1215         if (ins->inst_imm == 0)                                 \
1216                 sreg = hppa_r0;                                 \
1217         else {                                                  \
1218                 hppa_set (code, ins->inst_imm, hppa_r1);        \
1219                 sreg = hppa_r1;                                 \
1220         }                                                       \
1221         if (!hppa_check_bits (ins->inst_offset, 14)) {          \
1222                 hppa_set (code, ins->inst_offset, MEM_INDEX_REG); \
1223                 hppa_addl (code, ins->inst_destbasereg, MEM_INDEX_REG, MEM_INDEX_REG); \
1224                 hppa_ ## op (code, sreg, 0, MEM_INDEX_REG);     \
1225         }                                                       \
1226         else {                                                  \
1227                 hppa_ ## op (code, sreg, ins->inst_offset, ins->inst_destbasereg); \
1228         }                                                       \
1229 } while (0)
1230
1231 /* *(ins->inst_destbasereg + ins->inst_offset) = ins->sreg1 */
1232 #define EMIT_STORE_MEMBASE_REG(ins, op) do {                    \
1233         if (!hppa_check_bits (ins->inst_offset, 14)) {          \
1234                 hppa_set (code, ins->inst_offset, MEM_INDEX_REG); \
1235                 hppa_addl (code, ins->inst_destbasereg, MEM_INDEX_REG, MEM_INDEX_REG); \
1236                 hppa_ ## op (code, ins->sreg1, 0, MEM_INDEX_REG);       \
1237         }                                                       \
1238         else {                                                  \
1239                 hppa_ ## op (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); \
1240         }                                                       \
1241 } while (0)
1242
1243 void
1244 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
1245 {
1246         MonoInst *ins;
1247         MonoCallInst *call;
1248         guint offset;
1249         guint32 *code = (guint32*)(cfg->native_code + cfg->code_len);
1250         MonoInst *last_ins = NULL;
1251         int max_len, cpos;
1252         const char *spec;
1253
1254         DEBUG_FUNC_ENTER();
1255
1256         if (cfg->verbose_level > 2)
1257                 g_print ("[%s::%s] Basic block %d starting at offset 0x%x\n", cfg->method->klass->name, cfg->method->name, bb->block_num, bb->native_offset);
1258
1259         cpos = bb->max_offset;
1260
1261         if (cfg->prof_options & MONO_PROFILE_COVERAGE) {
1262                 NOT_IMPLEMENTED;
1263         }
1264
1265         MONO_BB_FOR_EACH_INS (bb, ins) {
1266                 guint8* code_start;
1267
1268                 offset = (guint8*)code - cfg->native_code;
1269
1270                 spec = ins_get_spec (ins->opcode);
1271
1272                 max_len = ((guint8 *)spec) [MONO_INST_LEN];
1273
1274                 if (offset > (cfg->code_size - max_len - 16)) {
1275                         cfg->code_size *= 2;
1276                         cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
1277                         code = (guint32*)(cfg->native_code + offset);
1278                         mono_jit_stats.code_reallocs++;
1279                 }
1280                 code_start = (guint8*)code;
1281                 //      if (ins->cil_code)
1282                 //              g_print ("cil code\n");
1283                 mono_debug_record_line_number (cfg, ins, offset);
1284
1285                 switch (ins->opcode) {
1286                 case OP_RELAXED_NOP:
1287                         break;
1288                 case OP_STOREI1_MEMBASE_IMM:
1289                         EMIT_STORE_MEMBASE_IMM (ins, stb);
1290                         break;
1291                 case OP_STOREI2_MEMBASE_IMM:
1292                         EMIT_STORE_MEMBASE_IMM (ins, sth);
1293                         break;
1294                 case OP_STORE_MEMBASE_IMM:
1295                 case OP_STOREI4_MEMBASE_IMM:
1296                         EMIT_STORE_MEMBASE_IMM (ins, stw);
1297                         break;
1298                 case OP_STOREI1_MEMBASE_REG:
1299                         EMIT_STORE_MEMBASE_REG (ins, stb);
1300                         break;
1301                 case OP_STOREI2_MEMBASE_REG:
1302                         EMIT_STORE_MEMBASE_REG (ins, sth);
1303                         break;
1304                 case OP_STORE_MEMBASE_REG:
1305                 case OP_STOREI4_MEMBASE_REG:
1306                         EMIT_STORE_MEMBASE_REG (ins, stw);
1307                         break;
1308                 case OP_LOADU1_MEMBASE:
1309                         EMIT_LOAD_MEMBASE (ins, ldb);
1310                         break;
1311                 case OP_LOADI1_MEMBASE:
1312                         EMIT_LOAD_MEMBASE (ins, ldb);
1313                         hppa_extrs (code, ins->dreg, 31, 8, ins->dreg);
1314                         break;
1315                 case OP_LOADU2_MEMBASE:
1316                         EMIT_LOAD_MEMBASE (ins, ldh);
1317                         break;
1318                 case OP_LOADI2_MEMBASE:
1319                         EMIT_LOAD_MEMBASE (ins, ldh);
1320                         hppa_extrs (code, ins->dreg, 31, 16, ins->dreg);
1321                         break;
1322                 case OP_LOAD_MEMBASE:
1323                 case OP_LOADI4_MEMBASE:
1324                 case OP_LOADU4_MEMBASE:
1325                         EMIT_LOAD_MEMBASE (ins, ldw);
1326                         break;
1327                 case CEE_CONV_I1:
1328                         hppa_extrs (code, ins->sreg1, 31, 8, ins->dreg);
1329                         break;
1330                 case CEE_CONV_I2:
1331                         hppa_extrs (code, ins->sreg1, 31, 16, ins->dreg);
1332                         break;
1333                 case CEE_CONV_U1:
1334                         hppa_extru (code, ins->sreg1, 31, 8, ins->dreg);
1335                         break;
1336                 case CEE_CONV_U2:
1337                         hppa_extru (code, ins->sreg1, 31, 16, ins->dreg);
1338                         break;
1339                 case CEE_CONV_U:
1340                 case CEE_CONV_I4:
1341                 case CEE_CONV_U4:
1342                 case OP_MOVE:
1343                         if (ins->sreg1 != ins->dreg)
1344                                 hppa_copy (code, ins->sreg1, ins->dreg);
1345                         break;
1346                 case OP_SETLRET:
1347                         hppa_copy (code, ins->sreg1 + 1, ins->dreg);
1348                         hppa_copy (code, ins->sreg1, ins->dreg + 1);
1349                         break;
1350
1351                 case OP_BREAK:
1352                         /* break 4,8 - this is what gdb normally uses... */
1353                         *code++ = 0x00010004;
1354                         break;
1355                 case OP_ADDCC:
1356                 case CEE_ADD:
1357                         hppa_add (code, ins->sreg1, ins->sreg2, ins->dreg);
1358                         break;
1359                 case OP_ADC:
1360                         hppa_addc (code, ins->sreg1, ins->sreg2, ins->dreg);
1361                         break;
1362                 case OP_ADDCC_IMM:
1363                 case OP_ADD_IMM:
1364                         hppa_addi (code, ins->inst_imm, ins->sreg1, ins->dreg);
1365                         break;
1366                 case OP_ADC_IMM:
1367                         hppa_set (code, ins->inst_imm, hppa_r1);
1368                         hppa_addc (code, ins->sreg1, hppa_r1, ins->dreg);
1369                         break;
1370                 case OP_HPPA_ADD_OVF: {
1371                         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1372                         hppa_bl (code, 8, hppa_r2);
1373                         hppa_depi (code, 0, 31, 2, hppa_r2);
1374                         hppa_ldo (code, 12, hppa_r2, hppa_r2);
1375
1376                         if (ins->backend.reg3 == CEE_ADD_OVF)
1377                                 hppa_add_cond (code, HPPA_ADD_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1378                         else
1379                                 hppa_add_cond (code, HPPA_ADD_COND_NUV, ins->sreg1, ins->sreg2, ins->dreg);
1380
1381                         ovfj->data.exception = "OverflowException";
1382                         ovfj->ip_offset = (guint8*)code - cfg->native_code;
1383                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1384                         hppa_bl_n (code, 8, hppa_r0);
1385                         break;
1386                 }
1387                 case OP_HPPA_ADDC_OVF: {
1388                         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1389                         hppa_bl (code, 8, hppa_r2);
1390                         hppa_depi (code, 0, 31, 2, hppa_r2);
1391                         hppa_ldo (code, 12, hppa_r2, hppa_r2);
1392
1393                         if (ins->backend.reg3 == OP_LADD_OVF)
1394                                 hppa_addc_cond (code, HPPA_ADD_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1395                         else
1396                                 hppa_addc_cond (code, HPPA_ADD_COND_NUV, ins->sreg1, ins->sreg2, ins->dreg);
1397
1398                         ovfj->data.exception = "OverflowException";
1399                         ovfj->ip_offset = (guint8*)code - cfg->native_code;
1400                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1401                         hppa_bl_n (code, 8, hppa_r0);
1402                         break;
1403                 }
1404                 case OP_SUBCC:
1405                 case CEE_SUB:
1406                         hppa_sub (code, ins->sreg1, ins->sreg2, ins->dreg);
1407                         break;
1408                 case OP_SUBCC_IMM:
1409                 case OP_SUB_IMM:
1410                         hppa_addi (code, -ins->inst_imm, ins->sreg1, ins->dreg);
1411                         break;
1412                 case OP_SBB:
1413                         hppa_subb (code, ins->sreg1, ins->sreg2, ins->dreg);
1414                         break;
1415                 case OP_SBB_IMM:
1416                         hppa_set (code, ins->inst_imm, hppa_r1);
1417                         hppa_subb (code, ins->sreg1, hppa_r1, ins->dreg);
1418                         break;
1419                 case OP_HPPA_SUB_OVF: {
1420                         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1421                         hppa_bl (code, 8, hppa_r2);
1422                         hppa_depi (code, 0, 31, 2, hppa_r2);
1423                         hppa_ldo (code, 12, hppa_r2, hppa_r2);
1424                         hppa_sub_cond (code, HPPA_SUB_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1425                         ovfj->data.exception = "OverflowException";
1426                         ovfj->ip_offset = (guint8*)code - cfg->native_code;
1427                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1428                         hppa_bl_n (code, 8, hppa_r0);
1429                         break;
1430                 }
1431                 case OP_HPPA_SUBB_OVF: {
1432                         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));
1433                         hppa_bl (code, 8, hppa_r2);
1434                         hppa_depi (code, 0, 31, 2, hppa_r2);
1435                         hppa_ldo (code, 12, hppa_r2, hppa_r2);
1436
1437                         hppa_subb_cond (code, HPPA_SUB_COND_NSV, ins->sreg1, ins->sreg2, ins->dreg);
1438                         ovfj->data.exception = "OverflowException";
1439                         ovfj->ip_offset = (guint8*)code - cfg->native_code;
1440                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj);
1441                         hppa_bl_n (code, 8, hppa_r0);
1442                         break;
1443                 }
1444
1445                 case CEE_AND:
1446                         hppa_and (code, ins->sreg1, ins->sreg2, ins->dreg);
1447                         break;
1448                 case OP_AND_IMM:
1449                         hppa_set (code, ins->inst_imm, hppa_r1);
1450                         hppa_and (code, ins->sreg1, hppa_r1, ins->dreg);
1451                         break;
1452
1453                 case CEE_OR:
1454                         hppa_or (code, ins->sreg1, ins->sreg2, ins->dreg);
1455                         break;
1456
1457                 case OP_OR_IMM:
1458                         hppa_set (code, ins->inst_imm, hppa_r1);
1459                         hppa_or (code, ins->sreg1, hppa_r1, ins->dreg);
1460                         break;
1461
1462                 case CEE_XOR:
1463                         hppa_xor (code, ins->sreg1, ins->sreg2, ins->dreg);
1464                         break;
1465                 case OP_XOR_IMM:
1466                         hppa_set (code, ins->inst_imm, hppa_r1);
1467                         hppa_xor (code, ins->sreg1, hppa_r1, ins->dreg);
1468                         break;
1469                 case CEE_SHL:
1470                         if (ins->sreg1 != ins->dreg) {
1471                                 hppa_shl (code, ins->sreg1, ins->sreg2, ins->dreg);
1472                         }
1473                         else {
1474                                 hppa_copy (code, ins->sreg1, hppa_r1);
1475                                 hppa_shl (code, hppa_r1, ins->sreg2, ins->dreg);
1476                         }
1477                         break;
1478                 case OP_SHL_IMM:
1479                 case OP_ISHL_IMM:
1480                         g_assert (ins->inst_imm < 32);
1481                         if (ins->sreg1 != ins->dreg) {
1482                                 hppa_zdep (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1483                         }
1484                         else {
1485                                 hppa_copy (code, ins->sreg1, hppa_r1);
1486                                 hppa_zdep (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1487                         }
1488                         break;
1489                 case CEE_SHR:
1490                         if (ins->sreg1 != ins->dreg) {
1491                                 hppa_shr (code, ins->sreg1, ins->sreg2, ins->dreg);
1492                         }
1493                         else {
1494                                 hppa_copy (code, ins->sreg1, hppa_r1);
1495                                 hppa_shr (code, hppa_r1, ins->sreg2, ins->dreg);
1496                         }
1497                         break;
1498                 case OP_SHR_IMM:
1499                         g_assert (ins->inst_imm < 32);
1500                         if (ins->sreg1 != ins->dreg) {
1501                                 hppa_extrs (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1502                         }
1503                         else {
1504                                 hppa_copy (code, ins->sreg1, hppa_r1);
1505                                 hppa_extrs (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1506                         }
1507                         break;
1508                 case OP_SHR_UN_IMM:
1509                         g_assert (ins->inst_imm < 32);
1510                         if (ins->sreg1 != ins->dreg) {
1511                                 hppa_extru (code, ins->sreg1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1512                         }
1513                         else {
1514                                 hppa_copy (code, ins->sreg1, hppa_r1);
1515                                 hppa_extru (code, hppa_r1, 31-ins->inst_imm, 32-ins->inst_imm, ins->dreg);
1516                         }
1517                         break;
1518                 case CEE_SHR_UN:
1519                         if (ins->sreg1 != ins->dreg) {
1520                                 hppa_lshr (code, ins->sreg1, ins->sreg2, ins->dreg);
1521                         }
1522                         else {
1523                                 hppa_copy (code, ins->sreg1, hppa_r1);
1524                                 hppa_lshr (code, hppa_r1, ins->sreg2, ins->dreg);
1525                         }
1526                         break;
1527                 case CEE_NOT:
1528                         hppa_not (code, ins->sreg1, ins->dreg);
1529                         break;
1530                 case CEE_NEG:
1531                         hppa_subi (code, 0, ins->sreg1, ins->dreg);
1532                         break;
1533
1534                 case CEE_MUL:
1535                 case OP_MUL_IMM:
1536                         /* Should have been rewritten using xmpyu */
1537                         g_assert_not_reached ();
1538
1539                 case OP_ICONST:
1540                         if ((ins->inst_c0 > 0 && ins->inst_c0 >= (1 << 13)) ||
1541                             (ins->inst_c0 < 0 && ins->inst_c0 < -(1 << 13))) {
1542                                 hppa_ldil (code, hppa_lsel (ins->inst_c0), ins->dreg);
1543                                 hppa_ldo (code, hppa_rsel (ins->inst_c0), ins->dreg, ins->dreg);
1544                         } else {
1545                                 hppa_ldo (code, ins->inst_c0, hppa_r0, ins->dreg);
1546                         }
1547                         break;
1548                 case OP_AOTCONST:
1549                         g_assert_not_reached ();
1550                 /*
1551                         mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
1552                         hppa_set_template (code, ins->dreg);
1553                 */
1554                         g_warning ("unimplemented opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
1555                         NOT_IMPLEMENTED;
1556                         break;
1557                 case OP_FMOVE:
1558                         if (ins->sreg1 != ins->dreg)
1559                                 hppa_fcpy (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->dreg);
1560                         break;
1561
1562                 case OP_HPPA_OUTARG_R4CONST:
1563                         hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1564                         hppa_fldwx (code, hppa_r0, hppa_r1, ins->dreg, 0);
1565                         break;
1566
1567                 case OP_HPPA_OUTARG_REGOFFSET:
1568                         hppa_ldo (code, ins->inst_offset, ins->inst_basereg, ins->dreg);
1569                         break;
1570
1571                 case OP_JMP:
1572                         /*
1573                          * Keep in sync with mono_arch_emit_epilog
1574                          */
1575                         g_assert (!cfg->method->save_lmf);
1576                         mono_add_patch_info (cfg, (guint8*) code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, ins->inst_p0);
1577                         hppa_bl (code, 8, hppa_r0);
1578                         break;
1579                 case OP_CHECK_THIS:
1580                         /* ensure ins->sreg1 is not NULL */
1581                         hppa_ldw (code, 0, ins->sreg1, hppa_r1);
1582                         break;
1583                 case OP_ARGLIST:
1584                         break;
1585                 case OP_FCALL:
1586                 case OP_LCALL:
1587                 case OP_VCALL:
1588                 case OP_VOIDCALL:
1589                 case OP_CALL:
1590                         call = (MonoCallInst*)ins;
1591                         if (ins->flags & MONO_INST_HAS_METHOD)
1592                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_METHOD, call->method);
1593                         else
1594                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, call->fptr);
1595                         hppa_ldil (code, 0, hppa_r1);
1596                         hppa_ldo (code, 0, hppa_r1, hppa_r1);
1597                         /*
1598                          * We may have loaded an actual function address, or
1599                          * it might be a plabel. Check to see if the plabel
1600                          * bit is set, and load the actual fptr from it if
1601                          * needed
1602                          */
1603                         hppa_bb_n (code, HPPA_BIT_COND_MSB_CLR, hppa_r1, 30, 2);
1604                         hppa_depi (code, 0, 31, 2, hppa_r1);
1605                         hppa_ldw (code, 4, hppa_r1, hppa_r19);
1606                         hppa_ldw (code, 0, hppa_r1, hppa_r1);
1607                         hppa_ble (code, 0, hppa_r1);
1608                         hppa_copy (code, hppa_r31, hppa_r2);
1609                         if (call->signature->ret->type == MONO_TYPE_R4)
1610                                 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr4, hppa_fr4);
1611                         break;
1612                 case OP_FCALL_REG:
1613                 case OP_LCALL_REG:
1614                 case OP_VCALL_REG:
1615                 case OP_VOIDCALL_REG:
1616                 case OP_CALL_REG:
1617                         call = (MonoCallInst*)ins;
1618                         g_assert (!call->virtual);
1619                         hppa_copy (code, ins->sreg1, hppa_r1);
1620                         hppa_bb_n (code, HPPA_BIT_COND_MSB_CLR, hppa_r1, 30, 2);
1621                         hppa_depi (code, 0, 31, 2, hppa_r1);
1622                         hppa_ldw (code, 4, hppa_r1, hppa_r19);
1623                         hppa_ldw (code, 0, hppa_r1, hppa_r1);
1624                         hppa_ble (code, 0, hppa_r1);
1625                         hppa_copy (code, hppa_r31, hppa_r2);
1626                         if (call->signature->ret->type == MONO_TYPE_R4)
1627                                 hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr4, hppa_fr4);
1628                         break;
1629                 case OP_FCALL_MEMBASE:
1630                 case OP_LCALL_MEMBASE:
1631                 case OP_VCALL_MEMBASE:
1632                 case OP_VOIDCALL_MEMBASE:
1633                 case OP_CALL_MEMBASE:
1634                         call = (MonoCallInst*)ins;
1635                         /* jump to ins->inst_sreg1 + ins->inst_offset */
1636                         hppa_ldw (code, ins->inst_offset, ins->sreg1, hppa_r1);
1637
1638                         /* For virtual calls, emit a special token that can
1639                          * be used by get_vcall_slot_addr
1640                          */
1641                         if (call->virtual)
1642                                 hppa_ldo (code, 0x777, hppa_r0, hppa_r0);
1643                         hppa_ble (code, 0, hppa_r1);
1644                         hppa_copy (code, hppa_r31, hppa_r2);
1645                         break;
1646                 case OP_LOCALLOC: {
1647                         guint32 size_reg;
1648
1649                         /* Keep alignment */
1650                         hppa_ldo (code, MONO_ARCH_LOCALLOC_ALIGNMENT - 1, ins->sreg1, ins->dreg);
1651                         hppa_depi (code, 0, 31, 6, ins->dreg);
1652                         hppa_copy (code, hppa_sp, hppa_r1);
1653                         hppa_addl (code, ins->dreg, hppa_sp, hppa_sp);
1654                         hppa_copy (code, hppa_r1, ins->dreg);
1655
1656                         if (ins->flags & MONO_INST_INIT) {
1657                                 hppa_stw (code, hppa_r0, 0, hppa_r1);
1658                                 hppa_combt (code, hppa_r1, hppa_sp, HPPA_CMP_COND_ULT, -3);
1659                                 hppa_ldo (code, 4, hppa_r1, hppa_r1);
1660                         }
1661                         break;
1662                 }
1663
1664                 case OP_THROW:
1665                         hppa_copy (code, ins->sreg1, hppa_r26);
1666                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
1667                                              (gpointer)"mono_arch_throw_exception");
1668                         hppa_ldil (code, 0, hppa_r1);
1669                         hppa_ldo (code, 0, hppa_r1, hppa_r1);
1670                         hppa_ble (code, 0, hppa_r1);
1671                         hppa_copy (code, hppa_r31, hppa_r2);
1672                         /* should never return */
1673                         *code++ = 0xffeeddcc;
1674                         break;
1675                 case OP_RETHROW:
1676                         hppa_copy (code, ins->sreg1, hppa_r26);
1677                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
1678                                              (gpointer)"mono_arch_rethrow_exception");
1679                         hppa_ldil (code, 0, hppa_r1);
1680                         hppa_ldo (code, 0, hppa_r1, hppa_r1);
1681                         hppa_ble (code, 0, hppa_r1);
1682                         hppa_copy (code, hppa_r31, hppa_r2);
1683                         /* should never return */
1684                         *code++ = 0xffeeddcc;
1685                         break;
1686                 case OP_START_HANDLER:
1687                         if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1688                                 hppa_stw (code, hppa_r2, ins->inst_left->inst_offset, ins->inst_left->inst_basereg);
1689                         else {
1690                                 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1691                                 hppa_addl (code, ins->inst_left->inst_basereg, hppa_r1, hppa_r1);
1692                                 hppa_stw (code, hppa_r2, 0, hppa_r1);
1693                         }
1694                         break;
1695                 case OP_ENDFILTER:
1696                         if (ins->sreg1 != hppa_r26)
1697                                 hppa_copy (code, ins->sreg1, hppa_r26);
1698                         if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1699                                 hppa_ldw (code, ins->inst_left->inst_offset, ins->inst_left->inst_basereg, hppa_r2);
1700                         else {
1701                                 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1702                                 hppa_ldwx (code, hppa_r1, ins->inst_left->inst_basereg, hppa_r2);
1703                         }
1704                         hppa_bv (code, hppa_r0, hppa_r2);
1705                         hppa_nop (code);
1706                         break;
1707                 case OP_ENDFINALLY:
1708                         if (hppa_check_bits (ins->inst_left->inst_offset, 14))
1709                                 hppa_ldw (code, ins->inst_left->inst_offset, ins->inst_left->inst_basereg, hppa_r1);
1710                         else {
1711                                 hppa_set (code, ins->inst_left->inst_offset, hppa_r1);
1712                                 hppa_ldwx (code, hppa_r1, ins->inst_left->inst_basereg, hppa_r1);
1713                         }
1714                         hppa_bv (code, hppa_r0, hppa_r1);
1715                         hppa_nop (code);
1716                         break;
1717                 case OP_CALL_HANDLER:
1718                         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_target_bb);
1719                         hppa_bl (code, 0, hppa_r2);
1720                         hppa_nop (code);
1721                         break;
1722                 case OP_LABEL:
1723                         ins->inst_c0 = (guint8*)code - cfg->native_code;
1724                         break;
1725                 case OP_BR: {
1726                         guint32 target;
1727                         DEBUG (printf ("target: %p, next: %p, curr: %p, last: %p\n", ins->inst_target_bb, bb->next_bb, ins, bb->last_ins));
1728                         if (ins->flags & MONO_INST_BRLABEL) {
1729                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_LABEL, ins->inst_i0);
1730                         } else {
1731                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_BB, ins->inst_target_bb);
1732                         }
1733                         hppa_bl (code, 8, hppa_r0);
1734                         /* TODO: if the branch is too long, we may need to
1735                          * use a long-branch sequence:
1736                          *      hppa_ldil (code, 0, hppa_r1);
1737                          *      hppa_ldo (code, 0, hppa_r1, hppa_r1);
1738                          *      hppa_bv (code, hppa_r0, hppa_r1);
1739                          */
1740                         hppa_nop (code);
1741                         break;
1742                 }
1743                 case OP_BR_REG:
1744                         hppa_bv (code, hppa_r0, ins->sreg1);
1745                         hppa_nop(code);
1746                         break;
1747
1748                 case OP_SWITCH: {
1749                         int i;
1750
1751                         max_len += 8 * GPOINTER_TO_INT (ins->klass);
1752                         if (offset > (cfg->code_size - max_len - 16)) {
1753                                 cfg->code_size += max_len;
1754                                 cfg->code_size *= 2;
1755                                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
1756                                 code = cfg->native_code + offset;
1757                                 code_start = (guint8*)code;
1758                         }
1759                         hppa_blr (code, ins->sreg1, hppa_r0);
1760                         hppa_nop (code);
1761                         for (i = 0; i < GPOINTER_TO_INT (ins->klass); ++i) {
1762                                 *code++ = 0xdeadbeef;
1763                                 *code++ = 0xdeadbeef;
1764                         }
1765                         break;
1766                 }
1767
1768                 /* comclr is cool :-) */
1769                 case OP_HPPA_CEQ:
1770                         hppa_comclr_cond (code, HPPA_SUB_COND_NE, ins->sreg1, ins->sreg2, ins->dreg);
1771                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
1772                         break;
1773
1774                 case OP_HPPA_CLT:
1775                         hppa_comclr_cond (code, HPPA_SUB_COND_SGE, ins->sreg1, ins->sreg2, ins->dreg);
1776                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
1777                         break;
1778
1779                 case OP_HPPA_CLT_UN:
1780                         hppa_comclr_cond (code, HPPA_SUB_COND_UGE, ins->sreg1, ins->sreg2, ins->dreg);
1781                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
1782                         break;
1783
1784                 case OP_HPPA_CGT:
1785                         hppa_comclr_cond (code, HPPA_SUB_COND_SLE, ins->sreg1, ins->sreg2, ins->dreg);
1786                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
1787                         break;
1788
1789                 case OP_HPPA_CGT_UN:
1790                         hppa_comclr_cond (code, HPPA_SUB_COND_ULE, ins->sreg1, ins->sreg2, ins->dreg);
1791                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
1792                         break;
1793
1794                 case OP_CEQ:
1795                 case OP_CLT:
1796                 case OP_CLT_UN:
1797                 case OP_CGT:
1798                 case OP_CGT_UN:
1799                 case OP_COND_EXC_EQ:
1800                 case OP_COND_EXC_NE_UN:
1801                 case OP_COND_EXC_LT:
1802                 case OP_COND_EXC_LT_UN:
1803                 case OP_COND_EXC_GT:
1804                 case OP_COND_EXC_GT_UN:
1805                 case OP_COND_EXC_GE:
1806                 case OP_COND_EXC_GE_UN:
1807                 case OP_COND_EXC_LE:
1808                 case OP_COND_EXC_LE_UN:
1809                 case OP_COND_EXC_OV:
1810                 case OP_COND_EXC_NO:
1811                 case OP_COND_EXC_C:
1812                 case OP_COND_EXC_NC:
1813                 case OP_COND_EXC_IOV:
1814                 case OP_COND_EXC_IC:
1815                 case CEE_BEQ:
1816                 case CEE_BNE_UN:
1817                 case CEE_BLT:
1818                 case CEE_BLT_UN:
1819                 case CEE_BGT:
1820                 case CEE_BGT_UN:
1821                 case CEE_BGE:
1822                 case CEE_BGE_UN:
1823                 case CEE_BLE:
1824                 case CEE_BLE_UN:
1825                 case OP_COMPARE:
1826                 case OP_LCOMPARE:
1827                 case OP_ICOMPARE:
1828                 case OP_COMPARE_IMM:
1829                 case OP_ICOMPARE_IMM:
1830                         g_warning ("got opcode %s in %s(), should be reduced\n", mono_inst_name (ins->opcode), __FUNCTION__);
1831                         g_assert_not_reached ();
1832                         break;
1833
1834                 case OP_HPPA_BEQ:
1835                 case OP_HPPA_BNE:
1836                 case OP_HPPA_BLT:
1837                 case OP_HPPA_BLT_UN:
1838                 case OP_HPPA_BGT:
1839                 case OP_HPPA_BGT_UN:
1840                 case OP_HPPA_BGE:
1841                 case OP_HPPA_BGE_UN:
1842                 case OP_HPPA_BLE:
1843                 case OP_HPPA_BLE_UN:
1844                         EMIT_COND_BRANCH (ins, ins->sreg1, ins->sreg2, ins->opcode - OP_HPPA_BEQ);
1845                         break;
1846
1847                 case OP_HPPA_COND_EXC_EQ:
1848                 case OP_HPPA_COND_EXC_GE:
1849                 case OP_HPPA_COND_EXC_GT:
1850                 case OP_HPPA_COND_EXC_LE:
1851                 case OP_HPPA_COND_EXC_LT:
1852                 case OP_HPPA_COND_EXC_NE_UN:
1853                 case OP_HPPA_COND_EXC_GE_UN:
1854                 case OP_HPPA_COND_EXC_GT_UN:
1855                 case OP_HPPA_COND_EXC_LE_UN:
1856                 case OP_HPPA_COND_EXC_LT_UN:
1857                         EMIT_COND_SYSTEM_EXCEPTION (ins->sreg1, ins->sreg2, ins->opcode - OP_HPPA_COND_EXC_EQ, ins->inst_p1);
1858                         break;
1859
1860                 case OP_HPPA_COND_EXC_OV:
1861                 case OP_HPPA_COND_EXC_NO:
1862                 case OP_HPPA_COND_EXC_C:
1863                 case OP_HPPA_COND_EXC_NC:
1864                         NOT_IMPLEMENTED;
1865
1866                 /* floating point opcodes */
1867                 case OP_R8CONST:
1868                         hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1869                         hppa_flddx (code, hppa_r0, hppa_r1, ins->dreg);
1870                         break;
1871                 case OP_R4CONST:
1872                         hppa_set (code, (unsigned int)ins->inst_p0, hppa_r1);
1873                         hppa_fldwx (code, hppa_r0, hppa_r1, hppa_fr31, 0);
1874                         hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1875                         break;
1876                 case OP_STORER8_MEMBASE_REG:
1877                         hppa_set (code, ins->inst_offset, hppa_r1);
1878                         hppa_fstdx (code, ins->sreg1, hppa_r1, ins->inst_destbasereg);
1879                         break;
1880                 case OP_LOADR8_MEMBASE:
1881                         hppa_set (code, ins->inst_offset, hppa_r1);
1882                         hppa_flddx (code, hppa_r1, ins->inst_basereg, ins->dreg);
1883                         break;
1884                 case OP_STORER4_MEMBASE_REG:
1885                         hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, hppa_fr31);
1886                         if (hppa_check_bits (ins->inst_offset, 5)) {
1887                                 hppa_fstws (code, hppa_fr31, 0, ins->inst_offset, ins->inst_destbasereg);
1888                         } else {
1889                                 hppa_set (code, ins->inst_offset, hppa_r1);
1890                                 hppa_fstwx (code, hppa_fr31, 0, hppa_r1, ins->inst_destbasereg);
1891                         }
1892                         break;
1893                 case OP_HPPA_STORER4_LEFT:
1894                 case OP_HPPA_STORER4_RIGHT:
1895                         if (hppa_check_bits (ins->inst_offset, 5)) {
1896                                 hppa_fstws (code, ins->sreg1, (ins->opcode == OP_HPPA_STORER4_RIGHT), ins->inst_offset, ins->inst_destbasereg);
1897                         } else {
1898                                 hppa_set (code, ins->inst_offset, hppa_r1);
1899                                 hppa_fstwx (code, ins->sreg1, (ins->opcode == OP_HPPA_STORER4_RIGHT), hppa_r1, ins->inst_destbasereg);
1900                         }
1901                         break;
1902                 case OP_LOADR4_MEMBASE:
1903                         if (hppa_check_bits (ins->inst_offset, 5)) {
1904                                 hppa_fldws (code, ins->inst_offset, ins->inst_basereg, hppa_fr31, 0);
1905                         } else {
1906                                 hppa_set (code, ins->inst_offset, hppa_r1);
1907                                 hppa_fldwx (code, hppa_r1, ins->inst_basereg, hppa_fr31, 0);
1908                         }
1909                         hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1910                         break;
1911                 case OP_HPPA_LOADR4_LEFT:
1912                 case OP_HPPA_LOADR4_RIGHT:
1913                         if (hppa_check_bits (ins->inst_offset, 5)) {
1914                                 hppa_fldws (code, ins->inst_offset, ins->inst_basereg, ins->dreg, (ins->opcode == OP_HPPA_LOADR4_RIGHT));
1915                         } else {
1916                                 hppa_set (code, ins->inst_offset, hppa_r1);
1917                                 hppa_fldwx (code, hppa_r1, ins->inst_basereg, ins->dreg, (ins->opcode == OP_HPPA_LOADR4_RIGHT));
1918                         }
1919                         break;
1920
1921                 case CEE_CONV_R4:
1922                         hppa_stw (code, ins->sreg1, -16, hppa_sp);
1923                         hppa_fldws (code, -16, hppa_sp, hppa_fr31, 0);
1924                         hppa_fcnvxf (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_SGL, hppa_fr31, ins->dreg);
1925                         hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, ins->dreg, ins->dreg);
1926                         break;
1927
1928                 case OP_FCONV_TO_R4:
1929                         /* reduce precision */
1930                         hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, ins->dreg);
1931                         hppa_fcnvff (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, ins->dreg, ins->dreg);
1932                         break;
1933
1934                 case OP_HPPA_SETF4REG:
1935                         hppa_fcnvff (code, HPPA_FP_FMT_DBL, HPPA_FP_FMT_SGL, ins->sreg1, ins->dreg);
1936                         break;
1937                 case CEE_CONV_R8:
1938                         hppa_stw (code, ins->sreg1, -16, hppa_sp);
1939                         hppa_fldws (code, -16, hppa_sp, hppa_fr31, 0);
1940                         hppa_fcnvxf (code, HPPA_FP_FMT_SGL, HPPA_FP_FMT_DBL, hppa_fr31, ins->dreg);
1941                         break;
1942
1943                 case OP_FCONV_TO_I1:
1944                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, TRUE);
1945                         break;
1946                 case OP_FCONV_TO_U1:
1947                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, FALSE);
1948                         break;
1949                 case OP_FCONV_TO_I2:
1950                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, TRUE);
1951                         break;
1952                 case OP_FCONV_TO_U2:
1953                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, FALSE);
1954                         break;
1955                 case OP_FCONV_TO_I4:
1956                 case OP_FCONV_TO_I:
1957                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, TRUE);
1958                         break;
1959                 case OP_FCONV_TO_U4:
1960                 case OP_FCONV_TO_U:
1961                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
1962                         break;
1963
1964                 case OP_FCONV_TO_I8:
1965                 case OP_FCONV_TO_U8:
1966                         g_assert_not_reached ();
1967                         /* Implemented as helper calls */
1968                         break;
1969                 case OP_LCONV_TO_R_UN:
1970                         g_assert_not_reached ();
1971                         /* Implemented as helper calls */
1972                         break;
1973
1974                 case OP_LCONV_TO_OVF_I:
1975                         NOT_IMPLEMENTED;
1976                         break;
1977
1978                 case OP_FADD:
1979                         hppa_fadd (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1980                         break;
1981                 case OP_FSUB:
1982                         hppa_fsub (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1983                         break;
1984                 case OP_FMUL:
1985                         hppa_fmul (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1986                         break;
1987                 case OP_FDIV:
1988                         hppa_fdiv (code, HPPA_FP_FMT_DBL, ins->sreg1, ins->sreg2, ins->dreg);
1989                         break;
1990                 case OP_FREM:
1991                         NOT_IMPLEMENTED;
1992                         break;
1993
1994                 case OP_FCOMPARE:
1995                         g_assert_not_reached();
1996                         break;
1997
1998                 case OP_FCEQ:
1999                 case OP_FCLT:
2000                 case OP_FCLT_UN:
2001                 case OP_FCGT:
2002                 case OP_FCGT_UN:
2003                         hppa_fcmp (code, HPPA_FP_FMT_DBL, float_ceq_table [ins->opcode - OP_FCEQ], ins->sreg1, ins->sreg2);
2004                         hppa_ftest (code, 0);
2005                         hppa_bl (code, 12, hppa_r0);
2006                         hppa_ldo (code, 1, hppa_r0, ins->dreg);
2007                         hppa_ldo (code, 0, hppa_r0, ins->dreg);
2008                         break;
2009
2010                 case OP_FBEQ:
2011                 case OP_FBLT:
2012                 case OP_FBGT:
2013                 case OP_FBGE:
2014                 case OP_FBLE:
2015                 case OP_FBNE_UN:
2016                 case OP_FBLT_UN:
2017                 case OP_FBGT_UN:
2018                 case OP_FBGE_UN:
2019                 case OP_FBLE_UN:
2020                         EMIT_FLOAT_COND_BRANCH (ins, ins->sreg1, ins->sreg2, ins->opcode - OP_FBEQ);
2021                         break;
2022
2023                 case OP_CKFINITE:
2024                 case OP_MEMORY_BARRIER:
2025                         break;
2026
2027                 case OP_HPPA_XMPYU:
2028                         hppa_xmpyu (code, ins->sreg1, ins->sreg2, ins->dreg);
2029                         break;
2030
2031                 default:
2032                         g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
2033                         g_assert_not_reached ();
2034                 }
2035
2036                 if ((((guint8*)code) - code_start) > max_len) {
2037                         g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %d)",
2038                                    mono_inst_name (ins->opcode), max_len, ((guint8*)code) - code_start);
2039                         g_assert_not_reached ();
2040                 }
2041
2042                 cpos += max_len;
2043
2044                 last_ins = ins;
2045         }
2046
2047         cfg->code_len = (guint8*)code - cfg->native_code;
2048         DEBUG_FUNC_EXIT();
2049 }
2050
2051 void
2052 mono_arch_register_lowlevel_calls (void)
2053 {
2054 }
2055
2056 void
2057 mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors)
2058 {
2059         MonoJumpInfo *patch_info;
2060
2061         DEBUG_FUNC_ENTER();
2062         /* FIXME: Move part of this to arch independent code */
2063         for (patch_info = ji; patch_info; patch_info = patch_info->next) {
2064                 unsigned char *ip = patch_info->ip.i + code;
2065                 gpointer target;
2066
2067                 target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
2068                 DEBUG (printf ("patch_info->type = %d, target = %p\n", patch_info->type, target));
2069
2070                 switch (patch_info->type) {
2071                 case MONO_PATCH_INFO_NONE:
2072                 case MONO_PATCH_INFO_BB_OVF:
2073                 case MONO_PATCH_INFO_EXC_OVF:
2074                         continue;
2075
2076                 case MONO_PATCH_INFO_IP:
2077                         hppa_patch ((guint32 *)ip, ip);
2078                         continue;
2079
2080                 case MONO_PATCH_INFO_CLASS_INIT: {
2081                         break;
2082                 }
2083                 case MONO_PATCH_INFO_METHOD_JUMP: {
2084                         break;
2085                 }
2086                 case MONO_PATCH_INFO_SWITCH: {
2087                         int i;
2088                         gpointer *table = (gpointer *)target;
2089                         ip += 8;
2090                         for (i = 0; i < patch_info->data.table->table_size; i++) {
2091                                 DEBUG (printf ("Patching switch table, table[%d] = %p\n", i, table[i]));
2092                                 hppa_ldil (ip, hppa_lsel (table [i]), hppa_r1);
2093                                 hppa_be_n (ip, hppa_rsel (table [i]), hppa_r1);
2094                         }
2095                         continue;
2096                 }
2097                 default:
2098                         break;
2099                 }
2100                 hppa_patch ((guint32 *)ip, target);
2101         }
2102
2103         DEBUG_FUNC_EXIT();
2104 }
2105
2106 void*
2107 mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
2108 {
2109         guint32 *code = (guint32*)p;
2110
2111         DEBUG_FUNC_ENTER();
2112
2113         hppa_set (code, cfg->method, hppa_r26);
2114         hppa_copy (code, hppa_r0, hppa_r25); /* NULL sp for now */
2115         hppa_set (code, func, hppa_r1);
2116         hppa_depi (code, 0, 31, 2, hppa_r1);
2117         hppa_ldw (code, 0, hppa_r1, hppa_r1);
2118         hppa_ble (code, 0, hppa_r1);
2119         hppa_copy (code, hppa_r31, hppa_r2);
2120
2121         DEBUG_FUNC_EXIT();
2122         return code;
2123 }
2124
2125 enum {
2126         SAVE_NONE,
2127         SAVE_STRUCT,
2128         SAVE_ONE,
2129         SAVE_TWO,
2130         SAVE_FP
2131 };
2132
2133 void*
2134 mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
2135 {
2136         guint32 *code = (guint32*)p;
2137         DEBUG_FUNC_ENTER();
2138 #if 0
2139         int save_mode = SAVE_NONE;
2140         MonoMethod *method = cfg->method;
2141
2142         switch (mono_type_get_underlying_type (mono_method_signature (method)->ret)->type) {
2143         case MONO_TYPE_VOID:
2144                 /* special case string .ctor icall */
2145                 if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
2146                         save_mode = SAVE_ONE;
2147                 else
2148                         save_mode = SAVE_NONE;
2149                 break;
2150         case MONO_TYPE_I8:
2151         case MONO_TYPE_U8:
2152 #ifdef SPARCV9
2153                 save_mode = SAVE_ONE;
2154 #else
2155                 save_mode = SAVE_TWO;
2156 #endif
2157                 break;
2158         case MONO_TYPE_R4:
2159         case MONO_TYPE_R8:
2160                 save_mode = SAVE_FP;
2161                 break;
2162         case MONO_TYPE_VALUETYPE:
2163                 save_mode = SAVE_STRUCT;
2164                 break;
2165         default:
2166                 save_mode = SAVE_ONE;
2167                 break;
2168         }
2169
2170         /* Save the result to the stack and also put it into the output registers */
2171
2172         switch (save_mode) {
2173         case SAVE_TWO:
2174                 /* V8 only */
2175                 sparc_st_imm (code, sparc_i0, sparc_fp, 68);
2176                 sparc_st_imm (code, sparc_i0, sparc_fp, 72);
2177                 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2178                 sparc_mov_reg_reg (code, sparc_i1, sparc_o2);
2179                 break;
2180         case SAVE_ONE:
2181                 sparc_sti_imm (code, sparc_i0, sparc_fp, ARGS_OFFSET);
2182                 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2183                 break;
2184         case SAVE_FP:
2185 #ifdef SPARCV9
2186                 sparc_stdf_imm (code, sparc_f0, sparc_fp, ARGS_OFFSET);
2187 #else
2188                 sparc_stdf_imm (code, sparc_f0, sparc_fp, 72);
2189                 sparc_ld_imm (code, sparc_fp, 72, sparc_o1);
2190                 sparc_ld_imm (code, sparc_fp, 72 + 4, sparc_o2);
2191 #endif
2192                 break;
2193         case SAVE_STRUCT:
2194 #ifdef SPARCV9
2195                 sparc_mov_reg_reg (code, sparc_i0, sparc_o1);
2196 #else
2197                 sparc_ld_imm (code, sparc_fp, 64, sparc_o1);
2198 #endif
2199                 break;
2200         case SAVE_NONE:
2201         default:
2202                 break;
2203         }
2204
2205         sparc_set (code, cfg->method, sparc_o0);
2206
2207         mono_add_patch_info (cfg, (guint8*)code - cfg->native_code, MONO_PATCH_INFO_ABS, func);
2208         EMIT_CALL ();
2209
2210         /* Restore result */
2211
2212         switch (save_mode) {
2213         case SAVE_TWO:
2214                 sparc_ld_imm (code, sparc_fp, 68, sparc_i0);
2215                 sparc_ld_imm (code, sparc_fp, 72, sparc_i0);
2216                 break;
2217         case SAVE_ONE:
2218                 sparc_ldi_imm (code, sparc_fp, ARGS_OFFSET, sparc_i0);
2219                 break;
2220         case SAVE_FP:
2221                 sparc_lddf_imm (code, sparc_fp, ARGS_OFFSET, sparc_f0);
2222                 break;
2223         case SAVE_NONE:
2224         default:
2225                 break;
2226         }
2227 #endif
2228         DEBUG_FUNC_EXIT();
2229         return code;
2230 }
2231
2232 /*
2233  * The HPPA stack frame should look like this:
2234  *
2235  * ---------------------
2236  *  incoming params area
2237  * ---------------------
2238  *     linkage area             size = ARGS_OFFSET
2239  * ---------------------        fp = psp
2240  * HPPA_STACK_LMF_OFFSET
2241  * ---------------------
2242  * MonoLMF structure or saved registers
2243  * -------------------
2244  *        locals                size = cfg->stack_offset - cfg->param_area
2245  * ---------------------
2246  *      params area             size = cfg->param_area - ARGS_OFFSET  (aligned)
2247  * ---------------------
2248  *  callee linkage area         size = ARGS_OFFSET
2249  * --------------------- sp
2250  */
2251 guint8 *
2252 mono_arch_emit_prolog (MonoCompile *cfg)
2253 {
2254         MonoMethod *method = cfg->method;
2255         MonoBasicBlock *bb;
2256         MonoMethodSignature *sig;
2257         MonoInst *inst;
2258         int alloc_size, pos, max_offset, i;
2259         guint8 *code;
2260         CallInfo *cinfo;
2261         int tracing = 0;
2262         int lmf_offset = 0;
2263
2264         DEBUG_FUNC_ENTER();
2265         if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
2266                 tracing = 1;
2267
2268         sig = mono_method_signature (method);
2269         cfg->code_size = 512 + sig->param_count * 20;
2270         code = cfg->native_code = g_malloc (cfg->code_size);
2271
2272         /* TODO: enable tail call optimization */
2273         if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
2274                 hppa_stw (code, hppa_r2, -20, hppa_sp);
2275         }
2276
2277         /* locals area */
2278         pos = HPPA_STACK_LMF_OFFSET;
2279
2280         /* figure out how much space we need for spilling */
2281         if (!method->save_lmf) {
2282                 /* spill callee-save registers */
2283                 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2284                 for (i = 0; i < 32; i++) {
2285                         if ((1 << i) & mask)
2286                                 pos += sizeof (gulong);
2287                 }
2288         } else {
2289                 lmf_offset = pos;
2290                 pos += sizeof (MonoLMF);
2291         }
2292
2293         alloc_size = ALIGN_TO (pos + cfg->stack_offset, MONO_ARCH_FRAME_ALIGNMENT);
2294         g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT - 1)) == 0);
2295
2296         cfg->stack_usage = alloc_size;
2297
2298         if (alloc_size) {
2299                 hppa_copy (code, hppa_r3, hppa_r1);
2300                 hppa_copy (code, hppa_sp, hppa_r3);
2301                 if (hppa_check_bits (alloc_size, 14))
2302                         hppa_stwm (code, hppa_r1, alloc_size, hppa_sp);
2303                 else {
2304                         hppa_stwm (code, hppa_r1, 8100, hppa_sp);
2305                         hppa_addil (code, hppa_lsel (alloc_size - 8100), hppa_sp);
2306                         hppa_ldo (code, hppa_rsel (alloc_size - 8100), hppa_r1, hppa_sp);
2307                 }
2308         }
2309
2310         /* compute max_offset in order to use short forward jumps
2311          * we always do it on hppa because the immediate displacement
2312          * for jumps is small
2313          */
2314         max_offset = 0;
2315         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
2316                 MonoInst *ins = bb->code;
2317                 bb->max_offset = max_offset;
2318
2319                 if (cfg->prof_options & MONO_PROFILE_COVERAGE)
2320                         max_offset += 6;
2321
2322                 MONO_BB_FOR_EACH_INS (bb, ins)
2323                         max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
2324         }
2325
2326         DEBUG (printf ("Incoming arguments: \n"));
2327         cinfo = get_call_info (sig, sig->pinvoke);
2328
2329         /* We do this first so that we don't have to worry about the LMF-
2330          * saving code clobbering r28
2331          */
2332         if (cinfo->struct_return)
2333                 hppa_stw (code, hppa_r28, cfg->ret->inst_offset, hppa_sp);
2334
2335         /* Save the LMF or the spilled registers */
2336         pos = HPPA_STACK_LMF_OFFSET;
2337         if (!method->save_lmf) {
2338                 /* spill callee-save registers */
2339                 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2340                 for (i = 0; i < 32; i++) {
2341                         if ((1 << i) & mask) {
2342                                 if (i == hppa_r3) {
2343                                         hppa_ldw (code, 0, hppa_r3, hppa_r1);
2344                                         hppa_stw (code, hppa_r1, pos, hppa_r3);
2345                                 } else
2346                                         hppa_stw (code, i, pos, hppa_r3);
2347                                 pos += sizeof (gulong);
2348                         }
2349                 }
2350         } else {
2351                 int ofs = lmf_offset + G_STRUCT_OFFSET (MonoLMF, regs);
2352                 int reg;
2353
2354                 hppa_ldw (code, 0, hppa_r3, hppa_r1);
2355                 hppa_stw (code, hppa_r1, ofs, hppa_r3);
2356                 ofs += sizeof (gulong);
2357                 for (reg = 4; reg < 32; reg++) {
2358                         if (HPPA_IS_SAVED_GREG (reg)) {
2359                                 hppa_stw (code, reg, ofs, hppa_r3);
2360                                 ofs += sizeof (gulong);
2361                         }
2362                 }
2363                 /* We shouldn't need to save the FP regs.... */
2364                 ofs = ALIGN_TO (ofs, sizeof(double));
2365                 hppa_set (code, ofs, hppa_r1);
2366                 for (reg = 0; reg < 32; reg++) {
2367                         if (HPPA_IS_SAVED_FREG (reg)) {
2368                                 hppa_fstdx (code, reg, hppa_r1, hppa_r3);
2369                                 hppa_ldo (code, sizeof(double), hppa_r1, hppa_r1);
2370                         }
2371                 }
2372
2373                 /* We also spill the arguments onto the stack, because
2374                  * the call to hppa_get_lmf_addr below can clobber them
2375                  *
2376                  * This goes in the param area that is always allocated
2377                  */
2378                 ofs = -36;
2379                 for (reg = hppa_r26; reg >= hppa_r23; reg--) {
2380                         hppa_stw (code, reg, ofs, hppa_sp);
2381                         ofs -= 4;
2382                 }
2383         }
2384
2385         if (cfg->flags & MONO_CFG_HAS_ALLOCA)
2386                 hppa_copy (code, hppa_r30, hppa_r4);
2387
2388         if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
2389                 hppa_set (code, cfg->domain, hppa_r26);
2390                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, (gpointer)"mono_jit_thread_attach");
2391                 hppa_ldil (code, 0, hppa_r1);
2392                 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2393                 hppa_depi (code, 0, 31, 2, hppa_r1);
2394                 hppa_ldw (code, 0, hppa_r1, hppa_r1);
2395                 hppa_ble (code, 0, hppa_r1);
2396                 hppa_copy (code, hppa_r31, hppa_r2);
2397         }
2398
2399         if (method->save_lmf) {
2400                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
2401                                      (gpointer)"mono_get_lmf_addr");
2402                 hppa_ldil (code, 0, hppa_r1);
2403                 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2404                 hppa_depi (code, 0, 31, 2, hppa_r1);
2405                 hppa_ldw (code, 0, hppa_r1, hppa_r1);
2406                 hppa_ble (code, 0, hppa_r1);
2407                 hppa_copy (code, hppa_r31, hppa_r2);
2408
2409                 /* lmf_offset is the offset from the previous stack pointer,
2410                  * The pointer to the struct is put in hppa_r22 (new_lmf).
2411                  * The callee-saved registers are already in the MonoLMF
2412                  * structure
2413                  */
2414
2415                 /* hppa_r22 = new_lmf (on the stack) */
2416                 hppa_ldo (code, lmf_offset, hppa_r3, hppa_r22);
2417                 /* lmf_offset is the offset from the previous stack pointer,
2418                  */
2419                 hppa_stw (code, hppa_r28, G_STRUCT_OFFSET(MonoLMF, lmf_addr), hppa_r22);
2420                 /* new_lmf->previous_lmf = *lmf_addr */
2421                 hppa_ldw (code, 0, hppa_r28, hppa_r1);
2422                 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r22);
2423                 /* *(lmf_addr) = r22 */
2424                 hppa_stw (code, hppa_r22, 0, hppa_r28);
2425                 hppa_set (code, method, hppa_r1);
2426                 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, method), hppa_r22);
2427                 hppa_stw (code, hppa_sp, G_STRUCT_OFFSET(MonoLMF, ebp), hppa_r22);
2428                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_IP, NULL);
2429                 hppa_ldil (code, 0, hppa_r1);
2430                 hppa_ldo (code, 0, hppa_r1, hppa_r1);
2431                 hppa_stw (code, hppa_r1, G_STRUCT_OFFSET(MonoLMF, eip), hppa_r22);
2432
2433                 /* Now reload the arguments from the stack */
2434                 hppa_ldw (code, -36, hppa_sp, hppa_r26);
2435                 hppa_ldw (code, -40, hppa_sp, hppa_r25);
2436                 hppa_ldw (code, -44, hppa_sp, hppa_r24);
2437                 hppa_ldw (code, -48, hppa_sp, hppa_r23);
2438         }
2439
2440         /* load arguments allocated to register from the stack */
2441         pos = 0;
2442
2443         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
2444                 ArgInfo *ainfo = cinfo->args + i;
2445                 inst = cfg->args [pos];
2446
2447                 if (inst->opcode == OP_REGVAR) {
2448                         /* Want the argument in a register */
2449                         switch (ainfo->storage) {
2450                         case ArgInIReg:
2451                                 if (ainfo->reg != inst->dreg)
2452                                         hppa_copy (code, ainfo->reg, inst->dreg);
2453                                 DEBUG (printf ("Argument %d assigned to register %s\n", pos, mono_arch_regname (inst->dreg)));
2454                                 break;
2455
2456                         case ArgInIRegPair:
2457                                 if (ainfo->reg != inst->dreg) {
2458                                         hppa_copy (code, ainfo->reg, inst->dreg);
2459                                         hppa_copy (code, ainfo->reg + 1, inst->dreg + 1);
2460                                 }
2461                                 DEBUG (printf ("Argument %d assigned to register %s, %s\n", pos, mono_arch_regname (inst->dreg), mono_arch_regname (inst->dreg + 1)));
2462                                 break;
2463
2464                         case ArgInFReg:
2465                                 if (ainfo->reg != inst->dreg)
2466                                         hppa_fcpy (code, HPPA_FP_FMT_SGL, ainfo->reg, inst->dreg);
2467                                 DEBUG (printf ("Argument %d assigned to single register %s\n", pos, mono_arch_fregname (inst->dreg)));
2468                                 break;
2469
2470                         case ArgInDReg:
2471                                 if (ainfo->reg != inst->dreg)
2472                                         hppa_fcpy (code, HPPA_FP_FMT_DBL, ainfo->reg, inst->dreg);
2473                                 DEBUG (printf ("Argument %d assigned to double register %s\n", pos, mono_arch_fregname (inst->dreg)));
2474                                 break;
2475
2476                         case ArgOnStack:
2477                                 switch (ainfo->size) {
2478                                 case 1:
2479                                         hppa_ldb (code, ainfo->offset, hppa_r3, inst->dreg);
2480                                         break;
2481                                 case 2:
2482                                         hppa_ldh (code, ainfo->offset, hppa_r3, inst->dreg);
2483                                         break;
2484                                 case 4:
2485                                         hppa_ldw (code, ainfo->offset, hppa_r3, inst->dreg);
2486                                         break;
2487                                 default:
2488                                         g_assert_not_reached ();
2489                                 }
2490
2491
2492                                 DEBUG (printf ("Argument %d loaded from the stack [%s - %d]\n", pos, mono_arch_regname (hppa_r3), -ainfo->offset));
2493                                 break;
2494
2495                         default:
2496                                 g_assert_not_reached ();
2497                         }
2498                 }
2499                 else {
2500                         /* Want the argument on the stack */
2501                         switch (ainfo->storage)
2502                         {
2503                         case ArgInIReg: {
2504                                 int off, reg;
2505                                 DEBUG (printf ("Argument %d stored from register %s to stack [%s + %d]\n", pos, mono_arch_regname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2506                                 if (hppa_check_bits (inst->inst_offset, 14)) {
2507                                         off = inst->inst_offset;
2508                                         reg = inst->inst_basereg;
2509                                 }
2510                                 else {
2511                                         hppa_set (code, inst->inst_offset, hppa_r1);
2512                                         hppa_add (code, hppa_r1, inst->inst_basereg, hppa_r1);
2513                                         off = 0;
2514                                         reg = hppa_r1;
2515                                 }
2516                                 switch (ainfo->size)
2517                                 {
2518                                 case 1:
2519                                         hppa_stb (code, ainfo->reg, off, reg);
2520                                         break;
2521                                 case 2:
2522                                         hppa_sth (code, ainfo->reg, off, reg);
2523                                         break;
2524                                 case 4:
2525                                         hppa_stw (code, ainfo->reg, off, reg);
2526                                         break;
2527                                 default:
2528                                         g_assert_not_reached ();
2529                                 }
2530                                 break;
2531                         }
2532                         case ArgInIRegPair:
2533                                 DEBUG (printf ("Argument %d stored from register (%s,%s) to stack [%s + %d]\n", pos, mono_arch_regname (ainfo->reg), mono_arch_regname (ainfo->reg+1), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2534                                 if (hppa_check_bits (inst->inst_offset + 4, 14)) {
2535                                         hppa_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
2536                                         hppa_stw (code, ainfo->reg + 1, inst->inst_offset + 4, inst->inst_basereg);
2537                                 }
2538                                 else {
2539                                         hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2540                                         hppa_stw (code, ainfo->reg, 0, hppa_r1);
2541                                         hppa_stw (code, ainfo->reg + 1, 4, hppa_r1);
2542                                 }
2543                                 break;
2544
2545                         case ArgInFReg:
2546                                 DEBUG (printf ("Argument %d (float) stored from register %s to stack [%s + %d]\n", pos, mono_arch_fregname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2547                                 hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2548                                 hppa_fstwx (code, ainfo->reg, 0, hppa_r0, hppa_r1);
2549                                 break;
2550
2551                         case ArgInDReg:
2552                                 DEBUG (printf ("Argument %d (double) stored from register %s to stack [%s + %d]\n", pos, mono_arch_fregname (ainfo->reg), mono_arch_regname (inst->inst_basereg), inst->inst_offset));
2553                                 hppa_ldo (code, inst->inst_offset, inst->inst_basereg, hppa_r1);
2554                                 hppa_fstdx (code, ainfo->reg, hppa_r0, hppa_r1);
2555                                 break;
2556
2557                         case ArgOnStack:
2558                                 DEBUG (printf ("Argument %d copied from [%s - %d] to [%s + %d] (size=%d)\n", pos, mono_arch_regname (hppa_r3), -ainfo->offset, mono_arch_regname (inst->inst_basereg), inst->inst_offset, ainfo->size));
2559                                 if (inst->inst_offset != ainfo->offset ||
2560                                     inst->inst_basereg != hppa_r3)
2561                                         code = emit_memcpy (code, inst->inst_offset, inst->inst_basereg, ainfo->offset, hppa_r3, ainfo->size);
2562                                 break;
2563
2564                         default:
2565                                 g_assert_not_reached ();
2566                         }
2567                 }
2568
2569                 pos++;
2570         }
2571
2572
2573         if (tracing)
2574                 code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
2575
2576         if (getenv("HPPA_BREAK")) {
2577                 *(guint32*)code = 0x00010004;
2578                 code += 4;
2579         }
2580
2581         cfg->code_len = code - cfg->native_code;
2582         g_assert (cfg->code_len < cfg->code_size);
2583         g_free (cinfo);
2584
2585         DEBUG_FUNC_EXIT();
2586         return code;
2587 }
2588
2589
2590 void
2591 mono_arch_emit_epilog (MonoCompile *cfg)
2592 {
2593         MonoMethod *method = cfg->method;
2594         MonoMethodSignature *sig;
2595         guint32 *code;
2596         int max_epilog_size = 16 + 20 * 4;
2597         int pos;
2598
2599         DEBUG_FUNC_ENTER();
2600         sig = mono_method_signature (cfg->method);
2601         if (cfg->method->save_lmf)
2602                 max_epilog_size += 128;
2603
2604         if (mono_jit_trace_calls != NULL)
2605                 max_epilog_size += 50;
2606
2607         if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
2608                 max_epilog_size += 50;
2609
2610         while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
2611                 cfg->code_size *= 2;
2612                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2613                 mono_jit_stats.code_reallocs++;
2614         }
2615
2616         code = (guint32*)(cfg->native_code + cfg->code_len);
2617
2618         if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
2619                 code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
2620
2621         pos = HPPA_STACK_LMF_OFFSET;
2622         if (cfg->method->save_lmf) {
2623                 int reg;
2624                 hppa_ldo (code, pos, hppa_r3, hppa_r22);
2625                 hppa_ldw (code, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r22, hppa_r21);
2626                 hppa_ldw (code, G_STRUCT_OFFSET(MonoLMF, lmf_addr), hppa_r22, hppa_r20);
2627                 hppa_stw (code, hppa_r21, G_STRUCT_OFFSET(MonoLMF, previous_lmf), hppa_r20);
2628
2629                 pos += G_STRUCT_OFFSET(MonoLMF, regs) + sizeof (gulong);
2630                 /* We skip the restore of r3 here, it is restored from the
2631                  * stack anyway. This makes the code a bit easier.
2632                  */
2633                 for (reg = 4; reg < 31; reg++) {
2634                         if (HPPA_IS_SAVED_GREG (reg)) {
2635                                 hppa_ldw (code, pos, hppa_r3, reg);
2636                                 pos += sizeof(gulong);
2637                         }
2638                 }
2639
2640                 pos = ALIGN_TO (pos, sizeof (double));
2641                 hppa_set (code, pos, hppa_r1);
2642                 for (reg = 0; reg < 31; reg++) {
2643                         if (HPPA_IS_SAVED_FREG (reg)) {
2644                                 hppa_flddx (code, hppa_r1, hppa_r3, reg);
2645                                 hppa_ldo (code, sizeof (double), hppa_r1, hppa_r1);
2646                                 pos += sizeof (double);
2647                         }
2648                 }
2649         } else {
2650                 guint32 mask = cfg->used_int_regs & MONO_ARCH_CALLEE_SAVED_REGS;
2651                 int i;
2652                 for (i = 0; i < 32; i++) {
2653                         if (i == hppa_r3)
2654                                 continue;
2655                         if ((1 << i) & mask) {
2656                                 hppa_ldw (code, pos, hppa_r3, i);
2657                                 pos += sizeof (gulong);
2658                         }
2659                 }
2660         }
2661
2662         if (sig->ret->type != MONO_TYPE_VOID &&
2663             mono_type_to_stind (sig->ret) == CEE_STOBJ) {
2664                 CallInfo *cinfo = get_call_info (sig, sig->pinvoke);
2665
2666                 switch (cinfo->ret.storage) {
2667                 case ArgInIReg:
2668                         hppa_ldw (code, cfg->ret->inst_offset, hppa_sp, hppa_r28);
2669                         hppa_ldw (code, 0, hppa_r28, hppa_r28);
2670                         break;
2671                 case ArgInIRegPair:
2672                         hppa_ldw (code, cfg->ret->inst_offset, hppa_sp, hppa_r28);
2673                         hppa_ldw (code, 4, hppa_r28, hppa_r29);
2674                         hppa_ldw (code, 0, hppa_r28, hppa_r28);
2675                         break;
2676                 case ArgOnStack:
2677                         /* Nothing to do */
2678                         break;
2679                 default:
2680                         g_assert_not_reached ();
2681                 }
2682                 g_free (cinfo);
2683         }
2684
2685         if (1 || cfg->flags & MONO_CFG_HAS_CALLS)
2686                 hppa_ldw (code, -20, hppa_r3, hppa_r2);
2687         hppa_ldo (code, 64, hppa_r3, hppa_sp);
2688         hppa_bv (code, hppa_r0, hppa_r2);
2689         hppa_ldwm (code, -64, hppa_sp, hppa_r3);
2690
2691         cfg->code_len = (guint8*)code - cfg->native_code;
2692
2693         g_assert (cfg->code_len < cfg->code_size);
2694         DEBUG_FUNC_EXIT();
2695 }
2696
2697 /* remove once throw_exception_by_name is eliminated */
2698 static int
2699 exception_id_by_name (const char *name)
2700 {
2701         if (strcmp (name, "IndexOutOfRangeException") == 0)
2702                 return MONO_EXC_INDEX_OUT_OF_RANGE;
2703         if (strcmp (name, "OverflowException") == 0)
2704                 return MONO_EXC_OVERFLOW;
2705         if (strcmp (name, "ArithmeticException") == 0)
2706                 return MONO_EXC_ARITHMETIC;
2707         if (strcmp (name, "DivideByZeroException") == 0)
2708                 return MONO_EXC_DIVIDE_BY_ZERO;
2709         if (strcmp (name, "InvalidCastException") == 0)
2710                 return MONO_EXC_INVALID_CAST;
2711         if (strcmp (name, "NullReferenceException") == 0)
2712                 return MONO_EXC_NULL_REF;
2713         if (strcmp (name, "ArrayTypeMismatchException") == 0)
2714                 return MONO_EXC_ARRAY_TYPE_MISMATCH;
2715         g_error ("Unknown intrinsic exception %s\n", name);
2716         return 0;
2717 }
2718
2719 void
2720 mono_arch_emit_exceptions (MonoCompile *cfg)
2721 {
2722         MonoJumpInfo *patch_info;
2723         int i;
2724         guint8 *code;
2725         const guint8* exc_throw_pos [MONO_EXC_INTRINS_NUM] = {NULL};
2726         guint8 exc_throw_found [MONO_EXC_INTRINS_NUM] = {0};
2727         int max_epilog_size = 50;
2728
2729         DEBUG_FUNC_ENTER();
2730
2731         /* count the number of exception infos */
2732
2733         /*
2734          * make sure we have enough space for exceptions
2735          */
2736         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
2737                 switch (patch_info->type) {
2738                 case MONO_PATCH_INFO_BB_OVF:
2739                         g_assert_not_reached ();
2740                         break;
2741
2742                 case MONO_PATCH_INFO_EXC_OVF: {
2743                         const MonoOvfJump *ovfj = patch_info->data.target;
2744                         max_epilog_size += 8;
2745                         i = exception_id_by_name (ovfj->data.exception);
2746                         if (!exc_throw_found [i]) {
2747                                 max_epilog_size += 24;
2748                                 exc_throw_found [i] = TRUE;
2749                         }
2750                         break;
2751                 }
2752
2753                 case MONO_PATCH_INFO_EXC:
2754                         i = exception_id_by_name (patch_info->data.target);
2755                         if (!exc_throw_found [i]) {
2756                                 max_epilog_size += 24;
2757                                 exc_throw_found [i] = TRUE;
2758                         }
2759                         break;
2760
2761                 default:
2762                         break;
2763                 }
2764         }
2765
2766         while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
2767                 cfg->code_size *= 2;
2768                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
2769                 mono_jit_stats.code_reallocs++;
2770         }
2771
2772         code = cfg->native_code + cfg->code_len;
2773
2774         /* add code to raise exceptions */
2775         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
2776                 switch (patch_info->type) {
2777                 case MONO_PATCH_INFO_BB_OVF: {
2778                         /* TODO */
2779                         break;
2780                 }
2781                 case MONO_PATCH_INFO_EXC_OVF: {
2782                         const MonoOvfJump *ovfj = patch_info->data.target;
2783                         MonoJumpInfo *newji;
2784                         unsigned char *ip = patch_info->ip.i + cfg->native_code;
2785                         unsigned char *stub = code;
2786
2787                         /* Patch original call, point it at the stub */
2788                         hppa_patch ((guint32 *)ip, code);
2789
2790                         /* Write the stub */
2791                         /* SUBTLE: this has to be PIC, because the code block
2792                          * can be relocated
2793                          */
2794                         hppa_bl_n (code, 8, hppa_r0);
2795                         hppa_nop (code);
2796
2797                         /* Add a patch info to patch the stub to point to the exception code */
2798                         newji = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfo));
2799                         newji->type = MONO_PATCH_INFO_EXC;
2800                         newji->ip.i = stub - cfg->native_code;
2801                         newji->data.target = ovfj->data.exception;
2802                         newji->next = patch_info->next;
2803                         patch_info->next = newji;
2804                         break;
2805                 }
2806                 case MONO_PATCH_INFO_EXC: {
2807                         unsigned char *ip = patch_info->ip.i + cfg->native_code;
2808                         i = exception_id_by_name (patch_info->data.target);
2809                         if (exc_throw_pos [i]) {
2810                                 hppa_patch ((guint32 *)ip, exc_throw_pos [i]);
2811                                 patch_info->type = MONO_PATCH_INFO_NONE;
2812                                 break;
2813                         } else {
2814                                 exc_throw_pos [i] = code;
2815                         }
2816                         hppa_patch ((guint32 *)ip, code);
2817                         hppa_set (code, patch_info->data.target, hppa_r26);
2818                         patch_info->type = MONO_PATCH_INFO_INTERNAL_METHOD;
2819                         patch_info->data.name = "mono_arch_throw_exception_by_name";
2820                         patch_info->ip.i = code - cfg->native_code;
2821
2822                         /* Assume the caller has set r2, we can't set it
2823                          * here based on ip, because the caller may
2824                          * be relocated (also the "ip" may be from an overflow
2825                          * stub)
2826                          */
2827                         hppa_ldil (code, 0, hppa_r1);
2828                         hppa_ldo (code, 0, hppa_r1, hppa_r1);
2829                         hppa_bv (code, hppa_r0, hppa_r1);
2830                         hppa_nop (code);
2831                         break;
2832                 }
2833                 default:
2834                         /* do nothing */
2835                         break;
2836                 }
2837         }
2838
2839         cfg->code_len = code - cfg->native_code;
2840
2841         g_assert (cfg->code_len < cfg->code_size);
2842         DEBUG_FUNC_EXIT();
2843 }
2844
2845 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2846
2847 #error "--with-sigaltstack=yes not supported on hppa"
2848
2849 #endif
2850
2851 void
2852 mono_arch_setup_jit_tls_data (MonoJitTlsData *tls)
2853 {
2854 }
2855
2856 void
2857 mono_arch_free_jit_tls_data (MonoJitTlsData *tls)
2858 {
2859 }
2860
2861 void
2862 mono_arch_emit_this_vret_args (MonoCompile *cfg, MonoCallInst *inst, int this_reg, int this_type, int vt_reg)
2863 {
2864         /* add the this argument */
2865         if (this_reg != -1) {
2866                 MonoInst *this;
2867                 MONO_INST_NEW (cfg, this, OP_MOVE);
2868                 this->type = this_type;
2869                 this->sreg1 = this_reg;
2870                 this->dreg = mono_alloc_ireg (cfg);
2871                 mono_bblock_add_inst (cfg->cbb, this);
2872                 mono_call_inst_add_outarg_reg (cfg, inst, this->dreg, hppa_r26, FALSE);
2873         }
2874
2875         if (vt_reg != -1) {
2876                 MonoInst *vtarg;
2877                 MONO_INST_NEW (cfg, vtarg, OP_MOVE);
2878                 vtarg->type = STACK_MP;
2879                 vtarg->sreg1 = vt_reg;
2880                 vtarg->dreg = mono_alloc_ireg (cfg);
2881                 mono_bblock_add_inst (cfg->cbb, vtarg);
2882                 mono_call_inst_add_outarg_reg (cfg, inst, vtarg->dreg, hppa_r28, FALSE);
2883         }
2884 }
2885
2886
2887 MonoInst*
2888 mono_arch_get_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
2889 {
2890         MonoInst *ins = NULL;
2891         DEBUG_FUNC_ENTER();
2892         DEBUG_FUNC_EXIT();
2893
2894         return ins;
2895 }
2896
2897 /*
2898  * mono_arch_get_argument_info:
2899  * @csig:  a method signature
2900  * @param_count: the number of parameters to consider
2901  * @arg_info: an array to store the result infos
2902  *
2903  * Gathers information on parameters such as size, alignment and
2904  * padding. arg_info should be large enought to hold param_count + 1 entries.
2905  *
2906  * Returns the size of the activation frame.
2907  */
2908 int
2909 mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
2910 {
2911         int k, align;
2912         CallInfo *cinfo;
2913         ArgInfo *ainfo;
2914
2915         DEBUG_FUNC_ENTER();
2916         cinfo = get_call_info (csig, FALSE);
2917
2918         if (csig->hasthis) {
2919                 ainfo = &cinfo->args [0];
2920                 arg_info [0].offset = ainfo->offset;
2921         }
2922
2923         for (k = 0; k < param_count; k++) {
2924                 ainfo = &cinfo->args [k + csig->hasthis];
2925
2926                 arg_info [k + 1].offset = ainfo->offset;
2927                 arg_info [k + 1].size = mono_type_size (csig->params [k], &align);
2928         }
2929
2930         g_free (cinfo);
2931         DEBUG_FUNC_EXIT();
2932 }
2933
2934 gboolean
2935 mono_arch_print_tree (MonoInst *tree, int arity)
2936 {
2937         return 0;
2938 }
2939
2940 MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg)
2941 {
2942         return NULL;
2943 }
2944
2945 MonoInst* mono_arch_get_thread_intrinsic (MonoCompile* cfg)
2946 {
2947         return NULL;
2948 }
2949
2950 gpointer
2951 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
2952 {
2953         /* FIXME: implement */
2954         g_assert_not_reached ();
2955 }