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