jit/reg.c

   1 /* jit/reg.c *******************************************************************
   2
   3         Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
   4
   5         See file COPYRIGHT for information on usage and disclaimer of warranties
   6
   7         The register-manager.
   8
   9         Authors:  Andreas  Krall      EMAIL: cacao@complang.tuwien.ac.at
  10
  11         Last Change: 1998/11/09
  12
  13 *******************************************************************************/
  14
  15 static varinfo5 *locals;
  16 static varinfo5 *interfaces;
  17
  18 static int intregsnum;              /* absolute number of integer registers   */
  19 static int floatregsnum;            /* absolute number of float registers     */
  20
  21 static int intreg_ret;              /* register to return integer values      */
  22 static int intreg_argnum;           /* number of integer argument registers   */
  23
  24 static int floatreg_ret;            /* register for return float values       */
  25 static int fltreg_argnum;           /* number of float argument registers     */
  26
  27
  28 static int *argintregs;             /* scratch integer registers              */
  29 static int *tmpintregs = NULL;      /* scratch integer registers              */
  30 static int *savintregs;             /* saved integer registers                */
  31 static int *argfltregs;             /* scratch float registers                */
  32 static int *tmpfltregs;             /* scratch float registers                */
  33 static int *savfltregs;             /* saved float registers                  */
  34 static int *freetmpintregs;         /* free scratch integer registers         */
  35 static int *freesavintregs;         /* free saved integer registers           */
  36 static int *freetmpfltregs;         /* free scratch float registers           */
  37 static int *freesavfltregs;         /* free saved float registers             */
  38
  39 static int *freemem;                /* free scratch memory                    */
  40 static int memuse;                  /* used memory count                      */
  41 static int ifmemuse;                /* interface used memory count            */
  42 static int maxmemuse;               /* maximal used memory count (spills)     */
  43 static int freememtop;              /* free memory count                      */
  44
  45 static int tmpintregcnt;            /* scratch integer register count         */
  46 static int savintregcnt;            /* saved integer register count           */
  47 static int tmpfltregcnt;            /* scratch float register count           */
  48 static int savfltregcnt;            /* saved float register count             */
  49
  50 static int iftmpintregcnt;          /* iface scratch integer register count   */
  51 static int ifsavintregcnt;          /* iface saved integer register count     */
  52 static int iftmpfltregcnt;          /* iface scratch float register count     */
  53 static int ifsavfltregcnt;          /* iface saved float register count       */
  54
  55 static int tmpintreguse;            /* used scratch integer register count    */
  56 static int savintreguse;            /* used saved integer register count      */
  57 static int tmpfltreguse;            /* used scratch float register count      */
  58 static int savfltreguse;            /* used saved float register count        */
  59
  60 static int maxtmpintreguse;         /* max used scratch int register count    */
  61 static int maxsavintreguse;         /* max used saved int register count      */
  62 static int maxtmpfltreguse;         /* max used scratch float register count  */
  63 static int maxsavfltreguse;         /* max used saved float register count    */
  64
  65 static int freetmpinttop;           /* free scratch integer register count    */
  66 static int freesavinttop;           /* free saved integer register count      */
  67 static int freetmpflttop;           /* free scratch float register count      */
  68 static int freesavflttop;           /* free saved float register count        */
  69
  70 static int savedregs_num;       /* total number of registers to be saved      */
  71 static int arguments_num;       /* size of parameter field in the stackframe  */
  72
  73
  74
  75 /* function reg_init ***********************************************************
  76
  77         initialises the register-allocator
  78
  79 *******************************************************************************/
  80
  81 static void reg_init()
  82 {
  83         int n;
  84
  85         if (!tmpintregs) {
  86
  87                 if (TYPE_INT != 0 || TYPE_ADR != 4)
  88                         panic ("JAVA-Basictypes have been changed");
  89
  90                 intreg_argnum = 0;
  91                 tmpintregcnt = 0;
  92                 savintregcnt = 0;
  93
  94                 for (intregsnum = 0; nregdescint[intregsnum] != REG_END; intregsnum++) {
  95                         switch (nregdescint[intregsnum]) {
  96                                 case REG_SAV: savintregcnt++;
  97                                               break;
  98                                 case REG_TMP: tmpintregcnt++;
  99                                               break;
 100                                 case REG_ARG: intreg_argnum++;
 101                                 }
 102                         }
 103
 104                 argintregs = MNEW (int, intreg_argnum);
 105                 tmpintregs = MNEW (int, tmpintregcnt);
 106                 savintregs = MNEW (int, savintregcnt);
 107                 freetmpintregs = MNEW (int, tmpintregcnt);
 108                 freesavintregs = MNEW (int, savintregcnt);
 109
 110                 intreg_argnum = 0;
 111                 tmpintreguse = 0;
 112                 savintreguse = 0;
 113
 114                 for (n = 0; n < intregsnum; n++) {
 115                         switch (nregdescint[n]) {
 116                                 case REG_RET: intreg_ret = n;
 117                                               break;
 118                                 case REG_SAV: savintregs[savintreguse++] = n;
 119                                               break;
 120                                 case REG_TMP: tmpintregs[tmpintreguse++] = n;
 121                                               break;
 122                                 case REG_ARG: argintregs[intreg_argnum++] = n;
 123                                               break;
 124                                 }
 125                         }
 126
 127
 128                 fltreg_argnum = 0;
 129                 tmpfltregcnt = 0;
 130                 savfltregcnt = 0;
 131
 132                 for (floatregsnum = 0; nregdescfloat[floatregsnum] != REG_END; floatregsnum++) {
 133                         switch (nregdescfloat[floatregsnum]) {
 134                                 case REG_SAV: savfltregcnt++;
 135                                               break;
 136                                 case REG_TMP: tmpfltregcnt++;
 137                                               break;
 138                                 case REG_ARG: fltreg_argnum++;
 139                                               break;
 140                                 }
 141                         }
 142
 143                 argfltregs = MNEW (int, fltreg_argnum);
 144                 tmpfltregs = MNEW (int, tmpfltregcnt);
 145                 savfltregs = MNEW (int, savfltregcnt);
 146                 freetmpfltregs = MNEW (int, tmpfltregcnt);
 147                 freesavfltregs = MNEW (int, savfltregcnt);
 148
 149                 fltreg_argnum = 0;
 150                 tmpfltreguse = 0;
 151                 savfltreguse = 0;
 152
 153                 for (n = 0; n < floatregsnum; n++) {
 154                         switch (nregdescfloat[n]) {
 155                                 case REG_RET: floatreg_ret = n;
 156                                               break;
 157                                 case REG_SAV: savfltregs[savfltreguse++] = n;
 158                                               break;
 159                                 case REG_TMP: tmpfltregs[tmpfltreguse++] = n;
 160                                               break;
 161                                 case REG_ARG: argfltregs[fltreg_argnum++] = n;
 162                                               break;
 163                                 }
 164                         }
 165
 166                 }
 167
 168 }
 169
 170
 171 /* function reg_close **********************************************************
 172
 173         releases all allocated space for registers
 174
 175 *******************************************************************************/
 176
 177 static void reg_close ()
 178 {
 179         if (argintregs) MFREE (argintregs, int, intreg_argnum);
 180         if (argfltregs) MFREE (argfltregs, int, fltreg_argnum);
 181         if (tmpintregs) MFREE (tmpintregs, int, tmpintregcnt);
 182         if (savintregs) MFREE (savintregs, int, savintregcnt);
 183         if (tmpfltregs) MFREE (tmpfltregs, int, tmpfltregcnt);
 184         if (savfltregs) MFREE (savfltregs, int, savfltregcnt);
 185
 186         if (freetmpintregs) MFREE (freetmpintregs, int, tmpintregcnt);
 187         if (freesavintregs) MFREE (freesavintregs, int, savintregcnt);
 188         if (freetmpfltregs) MFREE (freetmpfltregs, int, tmpfltregcnt);
 189         if (freesavfltregs) MFREE (freesavfltregs, int, savfltregcnt);
 190 }
 191
 192
 193 /* function local_init *********************************************************
 194
 195         initialises the local variable and interfaces table
 196
 197 *******************************************************************************/
 198
 199 static void local_init()
 200 {
 201         int i;
 202         varinfo5 *v;
 203
 204         freemem    = DMNEW(int, maxstack);
 205         locals     = DMNEW(varinfo5, maxlocals);
 206         interfaces = DMNEW(varinfo5, maxstack);
 207
 208         for (v = locals, i = maxlocals; i > 0; v++, i--) {
 209                 v[0][TYPE_INT].type = -1;
 210                 v[0][TYPE_LNG].type = -1;
 211                 v[0][TYPE_FLT].type = -1;
 212                 v[0][TYPE_DBL].type = -1;
 213                 v[0][TYPE_ADR].type = -1;
 214                 }
 215
 216         for (v = interfaces, i = maxstack; i > 0; v++, i--) {
 217                 v[0][TYPE_INT].type = -1;
 218                 v[0][TYPE_INT].flags = 0;
 219                 v[0][TYPE_LNG].type = -1;
 220                 v[0][TYPE_LNG].flags = 0;
 221                 v[0][TYPE_FLT].type = -1;
 222                 v[0][TYPE_FLT].flags = 0;
 223                 v[0][TYPE_DBL].type = -1;
 224                 v[0][TYPE_DBL].flags = 0;
 225                 v[0][TYPE_ADR].type = -1;
 226                 v[0][TYPE_ADR].flags = 0;
 227                 }
 228 }
 229
 230
 231 /* function interface_regalloc *************************************************
 232
 233         allocates registers for all interface variables
 234
 235 *******************************************************************************/
 236
 237 static void interface_regalloc ()
 238 {
 239         int     s, t, saved;
 240         int     intalloc, fltalloc;
 241         varinfo *v;
 242
 243         /* allocate stack space for passing arguments to called methods */
 244
 245         if (arguments_num > intreg_argnum)
 246                 ifmemuse = arguments_num - intreg_argnum;
 247         else
 248                 ifmemuse = 0;
 249
 250         iftmpintregcnt = tmpintregcnt;
 251         ifsavintregcnt = savintregcnt;
 252         iftmpfltregcnt = tmpfltregcnt;
 253         ifsavfltregcnt = savfltregcnt;
 254
 255         for (s = 0; s < maxstack; s++) {
 256                 intalloc = -1; fltalloc = -1;
 257                 saved = (interfaces[s][TYPE_INT].flags | interfaces[s][TYPE_LNG].flags |
 258                          interfaces[s][TYPE_FLT].flags | interfaces[s][TYPE_DBL].flags |
 259                          interfaces[s][TYPE_ADR].flags) & SAVEDVAR;
 260                 for (t = TYPE_INT; t <= TYPE_ADR; t++) {
 261                         v = &interfaces[s][t];
 262                         if (v->type >= 0) {
 263                                 if (!saved) {
 264                                         if (IS_FLT_DBL_TYPE(t)) {
 265                                                 if (fltalloc >= 0) {
 266                                                         v->flags |= interfaces[s][fltalloc].flags & INMEMORY;
 267                                                         v->regoff = interfaces[s][fltalloc].regoff;
 268                                                         }
 269                                                 else if (iftmpfltregcnt > 0) {
 270                                                         iftmpfltregcnt--;
 271                                                         v->regoff = tmpfltregs[iftmpfltregcnt];
 272                                                         }
 273                                                 else if (ifsavfltregcnt > 0) {
 274                                                         ifsavfltregcnt--;
 275                                                         v->regoff = savfltregs[ifsavfltregcnt];
 276                                                         }
 277                                                 else {
 278                                                         v->flags |= INMEMORY;
 279                                                         v->regoff = ifmemuse++;
 280                                                         }
 281                                                 fltalloc = t;
 282                                                 }
 283                                         else {
 284                                                 if (intalloc >= 0) {
 285                                                         v->flags |= interfaces[s][intalloc].flags & INMEMORY;
 286                                                         v->regoff = interfaces[s][intalloc].regoff;
 287                                                         }
 288                                                 else if (iftmpintregcnt > 0) {
 289                                                         iftmpintregcnt--;
 290                                                         v->regoff = tmpintregs[iftmpintregcnt];
 291                                                         }
 292                                                 else if (ifsavintregcnt > 0) {
 293                                                         ifsavintregcnt--;
 294                                                         v->regoff = savintregs[ifsavintregcnt];
 295                                                         }
 296                                                 else {
 297                                                         v->flags |= INMEMORY;
 298                                                         v->regoff = ifmemuse++;
 299                                                         }
 300                                                 intalloc = t;
 301                                                 }
 302                                         }
 303                                 else {
 304                                         if (IS_FLT_DBL_TYPE(t)) {
 305                                                 if (fltalloc >= 0) {
 306                                                         v->flags |= interfaces[s][fltalloc].flags & INMEMORY;
 307                                                         v->regoff = interfaces[s][fltalloc].regoff;
 308                                                         }
 309                                                 else if (ifsavfltregcnt > 0) {
 310                                                         ifsavfltregcnt--;
 311                                                         v->regoff = savfltregs[ifsavfltregcnt];
 312                                                         }
 313                                                 else {
 314                                                         v->flags |= INMEMORY;
 315                                                         v->regoff = ifmemuse++;
 316                                                         }
 317                                                 fltalloc = t;
 318                                                 }
 319                                         else {
 320                                                 if (intalloc >= 0) {
 321                                                         v->flags |= interfaces[s][intalloc].flags & INMEMORY;
 322                                                         v->regoff = interfaces[s][intalloc].regoff;
 323                                                         }
 324                                                 else if (ifsavintregcnt > 0) {
 325                                                         ifsavintregcnt--;
 326                                                         v->regoff = savintregs[ifsavintregcnt];
 327                                                         }
 328                                                 else {
 329                                                         v->flags |= INMEMORY;
 330                                                         v->regoff = ifmemuse++;
 331                                                         }
 332                                                 intalloc = t;
 333                                                 }
 334                                         }
 335                                 } /* if (type >= 0) */
 336                         }     /* for t */
 337                 }         /* for s */
 338         maxmemuse = ifmemuse;
 339         maxtmpintreguse = iftmpintregcnt;
 340         maxsavintreguse = ifsavintregcnt;
 341         maxtmpfltreguse = iftmpfltregcnt;
 342         maxsavfltreguse = ifsavfltregcnt;
 343 }
 344
 345
 346 /* function local_regalloc *****************************************************
 347
 348         allocates registers for all local variables
 349
 350 *******************************************************************************/
 351
 352 static void local_regalloc ()
 353 {
 354         int     s, t;
 355         int     intalloc, fltalloc;
 356         varinfo *v;
 357
 358         if (isleafmethod) {
 359                 for (s = 0; s < maxlocals; s++) {
 360                         intalloc = -1; fltalloc = -1;
 361                         for (t = TYPE_INT; t <= TYPE_ADR; t++) {
 362                                 v = &locals[s][t];
 363                                 if (v->type >= 0) {
 364                                         if (IS_FLT_DBL_TYPE(t)) {
 365                                                 if (fltalloc >= 0) {
 366                                                         v->flags = locals[s][fltalloc].flags;
 367                                                         v->regoff = locals[s][fltalloc].regoff;
 368                                                         }
 369                                                 else if (s < fltreg_argnum) {
 370                                                         v->flags = 0;
 371                                                         v->regoff = argfltregs[s];
 372                                                         }
 373                                                 else if (maxtmpfltreguse > 0) {
 374                                                         maxtmpfltreguse--;
 375                                                         v->flags = 0;
 376                                                         v->regoff = tmpfltregs[maxtmpfltreguse];
 377                                                         }
 378                                                 else if (maxsavfltreguse > 0) {
 379                                                         maxsavfltreguse--;
 380                                                         v->flags = 0;
 381                                                         v->regoff = savfltregs[maxsavfltreguse];
 382                                                         }
 383                                                 else {
 384                                                         v->flags = INMEMORY;
 385                                                         v->regoff = maxmemuse++;
 386                                                         }
 387                                                 fltalloc = t;
 388                                                 }
 389                                         else {
 390                                                 if (intalloc >= 0) {
 391                                                         v->flags = locals[s][intalloc].flags;
 392                                                         v->regoff = locals[s][intalloc].regoff;
 393                                                         }
 394                                                 else if (s < intreg_argnum) {
 395                                                         v->flags = 0;
 396                                                         v->regoff = argintregs[s];
 397                                                         }
 398                                                 else if (maxtmpintreguse > 0) {
 399                                                         maxtmpintreguse--;
 400                                                         v->flags = 0;
 401                                                         v->regoff = tmpintregs[maxtmpintreguse];
 402                                                         }
 403                                                 else if (maxsavintreguse > 0) {
 404                                                         maxsavintreguse--;
 405                                                         v->flags = 0;
 406                                                         v->regoff = savintregs[maxsavintreguse];
 407                                                         }
 408                                                 else {
 409                                                         v->flags = INMEMORY;
 410                                                         v->regoff = maxmemuse++;
 411                                                         }
 412                                                 intalloc = t;
 413                                                 }
 414                                         }
 415                                 }
 416                         }
 417                 return;
 418                 }
 419         for (s = 0; s < maxlocals; s++) {
 420                 intalloc = -1; fltalloc = -1;
 421                 for (t=TYPE_INT; t<=TYPE_ADR; t++) {
 422                         v = &locals[s][t];
 423                         if (v->type >= 0) {
 424                                 if (IS_FLT_DBL_TYPE(t)) {
 425                                         if (fltalloc >= 0) {
 426                                                 v->flags = locals[s][fltalloc].flags;
 427                                                 v->regoff = locals[s][fltalloc].regoff;
 428                                                 }
 429                                         else if (maxsavfltreguse > 0) {
 430                                                 maxsavfltreguse--;
 431                                                 v->flags = 0;
 432                                                 v->regoff = savfltregs[maxsavfltreguse];
 433                                                 }
 434                                         else {
 435                                                 v->flags = INMEMORY;
 436                                                 v->regoff = maxmemuse++;
 437                                                 }
 438                                         fltalloc = t;
 439                                         }
 440                                 else {
 441                                         if (intalloc >= 0) {
 442                                                 v->flags = locals[s][intalloc].flags;
 443                                                 v->regoff = locals[s][intalloc].regoff;
 444                                                 }
 445                                         else if (maxsavintreguse > 0) {
 446                                                 maxsavintreguse--;
 447                                                 v->flags = 0;
 448                                                 v->regoff = savintregs[maxsavintreguse];
 449                                                 }
 450                                         else {
 451                                                 v->flags = INMEMORY;
 452                                                 v->regoff = maxmemuse++;
 453                                                 }
 454                                         intalloc = t;
 455                                         }
 456                                 }
 457                         }
 458                 }
 459 }
 460
 461
 462 static void reg_init_temp()
 463 {
 464         freememtop = 0;
 465         memuse = ifmemuse;
 466
 467         freetmpinttop = 0;
 468         freesavinttop = 0;
 469         freetmpflttop = 0;
 470         freesavflttop = 0;
 471         tmpintreguse = iftmpintregcnt;
 472         savintreguse = ifsavintregcnt;
 473         tmpfltreguse = iftmpfltregcnt;
 474         savfltreguse = ifsavfltregcnt;
 475 }
 476
 477
 478 #define reg_new_temp(s) if(s->varkind==TEMPVAR)reg_new_temp_func(s)
 479
 480 static void reg_new_temp_func(stackptr s)
 481 {
 482 if (s->flags & SAVEDVAR) {
 483         if (IS_FLT_DBL_TYPE(s->type)) {
 484                 if (freesavflttop > 0) {
 485                         freesavflttop--;
 486                         s->regoff = freesavfltregs[freesavflttop];
 487                         return;
 488                         }
 489                 else if (savfltreguse > 0) {
 490                         savfltreguse--;
 491                         if (savfltreguse < maxsavfltreguse)
 492                                 maxsavfltreguse = savfltreguse;
 493                         s->regoff = savfltregs[savfltreguse];
 494                         return;
 495                         }
 496                 }
 497         else {
 498                 if (freesavinttop > 0) {
 499                         freesavinttop--;
 500                         s->regoff = freesavintregs[freesavinttop];
 501                         return;
 502                         }
 503                 else if (savintreguse > 0) {
 504                         savintreguse--;
 505                         if (savintreguse < maxsavintreguse)
 506                                 maxsavintreguse = savintreguse;
 507                         s->regoff = savintregs[savintreguse];
 508                         return;
 509                         }
 510                 }
 511         }
 512 else {
 513         if (IS_FLT_DBL_TYPE(s->type)) {
 514                 if (freetmpflttop > 0) {
 515                         freetmpflttop--;
 516                         s->regoff = freetmpfltregs[freetmpflttop];
 517                         return;
 518                         }
 519                 else if (tmpfltreguse > 0) {
 520                         tmpfltreguse--;
 521                         if (tmpfltreguse < maxtmpfltreguse)
 522                                 maxtmpfltreguse = tmpfltreguse;
 523                         s->regoff = tmpfltregs[tmpfltreguse];
 524                         return;
 525                         }
 526                 }
 527         else {
 528                 if (freetmpinttop > 0) {
 529                         freetmpinttop--;
 530                         s->regoff = freetmpintregs[freetmpinttop];
 531                         return;
 532                         }
 533                 else if (tmpintreguse > 0) {
 534                         tmpintreguse--;
 535                         if (tmpintreguse < maxtmpintreguse)
 536                                 maxtmpintreguse = tmpintreguse;
 537                         s->regoff = tmpintregs[tmpintreguse];
 538                         return;
 539                         }
 540                 }
 541         }
 542 if (freememtop > 0) {
 543         freememtop--;
 544         s->regoff = freemem[freememtop];
 545         }
 546 else {
 547         s->regoff = memuse++;
 548         if (memuse > maxmemuse)
 549                 maxmemuse = memuse;
 550         }
 551 s->flags |= INMEMORY;
 552 }
 553
 554
 555 #define reg_free_temp(s) if(s->varkind==TEMPVAR)reg_free_temp_func(s)
 556
 557 static void reg_free_temp_func(stackptr s)
 558 {
 559 if (s->flags & INMEMORY)
 560         freemem[freememtop++] = s->regoff;
 561 else if (IS_FLT_DBL_TYPE(s->type)) {
 562         if (s->flags & SAVEDVAR)
 563                 freesavfltregs[freesavflttop++] = s->regoff;
 564         else
 565                 freetmpfltregs[freetmpflttop++] = s->regoff;
 566         }
 567 else
 568         if (s->flags & SAVEDVAR)
 569                 freesavintregs[freesavinttop++] = s->regoff;
 570         else
 571                 freetmpintregs[freetmpinttop++] = s->regoff;
 572 }
 573
 574
 575 static void allocate_scratch_registers()
 576 {
 577         int b_count;
 578         int opcode, i, len;
 579         stackptr    src, dst;
 580         instruction *iptr = instr;
 581         basicblock  *bptr;
 582
 583         b_count = block_count;
 584         bptr = block;
 585         while (--b_count >= 0) {
 586                 if (bptr->flags >= BBREACHED) {
 587                         dst = bptr->instack;
 588                         reg_init_temp();
 589                         iptr = bptr->iinstr;
 590                         len = bptr->icount;
 591                         while (--len >= 0)  {
 592                                 src = dst;
 593                                 dst = iptr->dst;
 594                                 opcode = iptr->opc;
 595                                 switch (opcode) {
 596
 597                                         /* pop 0 push 0 */
 598
 599                                         case ICMD_NOP:
 600                                         case ICMD_ELSE_ICONST:
 601                                         case ICMD_CHECKASIZE:
 602                                         case ICMD_IINC:
 603                                         case ICMD_JSR:
 604                                         case ICMD_RET:
 605                                         case ICMD_RETURN:
 606                                         case ICMD_GOTO:
 607                                                 break;
 608
 609                                         /* pop 0 push 1 const */
 610
 611                                         case ICMD_ICONST:
 612                                         case ICMD_LCONST:
 613                                         case ICMD_FCONST:
 614                                         case ICMD_DCONST:
 615                                         case ICMD_ACONST:
 616
 617                                         /* pop 0 push 1 load */
 618
 619                                         case ICMD_ILOAD:
 620                                         case ICMD_LLOAD:
 621                                         case ICMD_FLOAD:
 622                                         case ICMD_DLOAD:
 623                                         case ICMD_ALOAD:
 624                                                 reg_new_temp(dst);
 625                                                 break;
 626
 627                                         /* pop 2 push 1 */
 628
 629                                         case ICMD_IALOAD:
 630                                         case ICMD_LALOAD:
 631                                         case ICMD_FALOAD:
 632                                         case ICMD_DALOAD:
 633                                         case ICMD_AALOAD:
 634
 635                                         case ICMD_BALOAD:
 636                                         case ICMD_CALOAD:
 637                                         case ICMD_SALOAD:
 638                                                 reg_free_temp(src);
 639                                                 reg_free_temp(src->prev);
 640                                                 reg_new_temp(dst);
 641                                                 break;
 642
 643                                         /* pop 3 push 0 */
 644
 645                                         case ICMD_IASTORE:
 646                                         case ICMD_LASTORE:
 647                                         case ICMD_FASTORE:
 648                                         case ICMD_DASTORE:
 649                                         case ICMD_AASTORE:
 650
 651                                         case ICMD_BASTORE:
 652                                         case ICMD_CASTORE:
 653                                         case ICMD_SASTORE:
 654                                                 reg_free_temp(src);
 655                                                 reg_free_temp(src->prev);
 656                                                 reg_free_temp(src->prev->prev);
 657                                                 break;
 658
 659                                         /* pop 1 push 0 store */
 660
 661                                         case ICMD_ISTORE:
 662                                         case ICMD_LSTORE:
 663                                         case ICMD_FSTORE:
 664                                         case ICMD_DSTORE:
 665                                         case ICMD_ASTORE:
 666
 667                                         /* pop 1 push 0 */
 668
 669                                         case ICMD_POP:
 670
 671                                         case ICMD_IRETURN:
 672                                         case ICMD_LRETURN:
 673                                         case ICMD_FRETURN:
 674                                         case ICMD_DRETURN:
 675                                         case ICMD_ARETURN:
 676
 677                                         case ICMD_ATHROW:
 678
 679                                         case ICMD_PUTSTATIC:
 680
 681                                         /* pop 1 push 0 branch */
 682
 683                                         case ICMD_IFNULL:
 684                                         case ICMD_IFNONNULL:
 685
 686                                         case ICMD_IFEQ:
 687                                         case ICMD_IFNE:
 688                                         case ICMD_IFLT:
 689                                         case ICMD_IFGE:
 690                                         case ICMD_IFGT:
 691                                         case ICMD_IFLE:
 692
 693                                         case ICMD_IF_LEQ:
 694                                         case ICMD_IF_LNE:
 695                                         case ICMD_IF_LLT:
 696                                         case ICMD_IF_LGE:
 697                                         case ICMD_IF_LGT:
 698                                         case ICMD_IF_LLE:
 699
 700                                         /* pop 1 push 0 table branch */
 701
 702                                         case ICMD_TABLESWITCH:
 703                                         case ICMD_LOOKUPSWITCH:
 704
 705                                         case ICMD_NULLCHECKPOP:
 706                                         case ICMD_MONITORENTER:
 707                                         case ICMD_MONITOREXIT:
 708                                                 reg_free_temp(src);
 709                                                 break;
 710
 711                                         /* pop 2 push 0 branch */
 712
 713                                         case ICMD_IF_ICMPEQ:
 714                                         case ICMD_IF_ICMPNE:
 715                                         case ICMD_IF_ICMPLT:
 716                                         case ICMD_IF_ICMPGE:
 717                                         case ICMD_IF_ICMPGT:
 718                                         case ICMD_IF_ICMPLE:
 719
 720                                         case ICMD_IF_LCMPEQ:
 721                                         case ICMD_IF_LCMPNE:
 722                                         case ICMD_IF_LCMPLT:
 723                                         case ICMD_IF_LCMPGE:
 724                                         case ICMD_IF_LCMPGT:
 725                                         case ICMD_IF_LCMPLE:
 726
 727                                         case ICMD_IF_ACMPEQ:
 728                                         case ICMD_IF_ACMPNE:
 729
 730                                         /* pop 2 push 0 */
 731
 732                                         case ICMD_POP2:
 733
 734                                         case ICMD_PUTFIELD:
 735                                                 reg_free_temp(src);
 736                                                 reg_free_temp(src->prev);
 737                                                 break;
 738
 739                                         /* pop 0 push 1 dup */
 740
 741                                         case ICMD_DUP:
 742                                                 reg_new_temp(dst);
 743                                                 break;
 744
 745                                         /* pop 0 push 2 dup */
 746
 747                                         case ICMD_DUP2:
 748                                                 reg_new_temp(dst->prev);
 749                                                 reg_new_temp(dst);
 750                                                 break;
 751
 752                                         /* pop 2 push 3 dup */
 753
 754                                         case ICMD_DUP_X1:
 755                                                 reg_new_temp(dst->prev->prev);
 756                                                 reg_new_temp(dst->prev);
 757                                                 reg_new_temp(dst);
 758                                                 reg_free_temp(src);
 759                                                 reg_free_temp(src->prev);
 760                                                 break;
 761
 762                                         /* pop 3 push 4 dup */
 763
 764                                         case ICMD_DUP_X2:
 765                                                 reg_new_temp(dst->prev->prev->prev);
 766                                                 reg_new_temp(dst->prev->prev);
 767                                                 reg_new_temp(dst->prev);
 768                                                 reg_new_temp(dst);
 769                                                 reg_free_temp(src);
 770                                                 reg_free_temp(src->prev);
 771                                                 reg_free_temp(src->prev->prev);
 772                                                 break;
 773
 774                                         /* pop 3 push 5 dup */
 775
 776                                         case ICMD_DUP2_X1:
 777                                                 reg_new_temp(dst->prev->prev->prev->prev);
 778                                                 reg_new_temp(dst->prev->prev->prev);
 779                                                 reg_new_temp(dst->prev->prev);
 780                                                 reg_new_temp(dst->prev);
 781                                                 reg_new_temp(dst);
 782                                                 reg_free_temp(src);
 783                                                 reg_free_temp(src->prev);
 784                                                 reg_free_temp(src->prev->prev);
 785                                                 break;
 786
 787                                         /* pop 4 push 6 dup */
 788
 789                                         case ICMD_DUP2_X2:
 790                                                 reg_new_temp(dst->prev->prev->prev->prev->prev);
 791                                                 reg_new_temp(dst->prev->prev->prev->prev);
 792                                                 reg_new_temp(dst->prev->prev->prev);
 793                                                 reg_new_temp(dst->prev->prev);
 794                                                 reg_new_temp(dst->prev);
 795                                                 reg_new_temp(dst);
 796                                                 reg_free_temp(src);
 797                                                 reg_free_temp(src->prev);
 798                                                 reg_free_temp(src->prev->prev);
 799                                                 reg_free_temp(src->prev->prev->prev);
 800                                                 break;
 801
 802                                         /* pop 2 push 2 swap */
 803
 804                                         case ICMD_SWAP:
 805                                                 reg_new_temp(dst->prev);
 806                                                 reg_new_temp(dst);
 807                                                 reg_free_temp(src);
 808                                                 reg_free_temp(src->prev);
 809                                                 break;
 810
 811                                         /* pop 2 push 1 */
 812
 813                                         case ICMD_IADD:
 814                                         case ICMD_ISUB:
 815                                         case ICMD_IMUL:
 816                                         case ICMD_IDIV:
 817                                         case ICMD_IREM:
 818
 819                                         case ICMD_ISHL:
 820                                         case ICMD_ISHR:
 821                                         case ICMD_IUSHR:
 822                                         case ICMD_IAND:
 823                                         case ICMD_IOR:
 824                                         case ICMD_IXOR:
 825
 826                                         case ICMD_LADD:
 827                                         case ICMD_LSUB:
 828                                         case ICMD_LMUL:
 829                                         case ICMD_LDIV:
 830                                         case ICMD_LREM:
 831
 832                                         case ICMD_LOR:
 833                                         case ICMD_LAND:
 834                                         case ICMD_LXOR:
 835
 836                                         case ICMD_LSHL:
 837                                         case ICMD_LSHR:
 838                                         case ICMD_LUSHR:
 839
 840                                         case ICMD_FADD:
 841                                         case ICMD_FSUB:
 842                                         case ICMD_FMUL:
 843                                         case ICMD_FDIV:
 844                                         case ICMD_FREM:
 845
 846                                         case ICMD_DADD:
 847                                         case ICMD_DSUB:
 848                                         case ICMD_DMUL:
 849                                         case ICMD_DDIV:
 850                                         case ICMD_DREM:
 851
 852                                         case ICMD_LCMP:
 853                                         case ICMD_FCMPL:
 854                                         case ICMD_FCMPG:
 855                                         case ICMD_DCMPL:
 856                                         case ICMD_DCMPG:
 857                                                 reg_free_temp(src);
 858                                                 reg_free_temp(src->prev);
 859                                                 reg_new_temp(dst);
 860                                                 break;
 861
 862                                         /* pop 1 push 1 */
 863
 864                                         case ICMD_IADDCONST:
 865                                         case ICMD_ISUBCONST:
 866                                         case ICMD_IMULCONST:
 867                                         case ICMD_IDIVPOW2:
 868                                         case ICMD_IREMPOW2:
 869                                         case ICMD_IREM0X10001:
 870                                         case ICMD_IANDCONST:
 871                                         case ICMD_IORCONST:
 872                                         case ICMD_IXORCONST:
 873                                         case ICMD_ISHLCONST:
 874                                         case ICMD_ISHRCONST:
 875                                         case ICMD_IUSHRCONST:
 876
 877                                         case ICMD_LADDCONST:
 878                                         case ICMD_LSUBCONST:
 879                                         case ICMD_LMULCONST:
 880                                         case ICMD_LDIVPOW2:
 881                                         case ICMD_LREMPOW2:
 882                                         case ICMD_LREM0X10001:
 883                                         case ICMD_LANDCONST:
 884                                         case ICMD_LORCONST:
 885                                         case ICMD_LXORCONST:
 886                                         case ICMD_LSHLCONST:
 887                                         case ICMD_LSHRCONST:
 888                                         case ICMD_LUSHRCONST:
 889
 890                                         case ICMD_IFEQ_ICONST:
 891                                         case ICMD_IFNE_ICONST:
 892                                         case ICMD_IFLT_ICONST:
 893                                         case ICMD_IFGE_ICONST:
 894                                         case ICMD_IFGT_ICONST:
 895                                         case ICMD_IFLE_ICONST:
 896
 897                                         case ICMD_INEG:
 898                                         case ICMD_INT2BYTE:
 899                                         case ICMD_INT2CHAR:
 900                                         case ICMD_INT2SHORT:
 901                                         case ICMD_LNEG:
 902                                         case ICMD_FNEG:
 903                                         case ICMD_DNEG:
 904
 905                                         case ICMD_I2L:
 906                                         case ICMD_I2F:
 907                                         case ICMD_I2D:
 908                                         case ICMD_L2I:
 909                                         case ICMD_L2F:
 910                                         case ICMD_L2D:
 911                                         case ICMD_F2I:
 912                                         case ICMD_F2L:
 913                                         case ICMD_F2D:
 914                                         case ICMD_D2I:
 915                                         case ICMD_D2L:
 916                                         case ICMD_D2F:
 917
 918                                         case ICMD_CHECKCAST:
 919
 920                                         case ICMD_ARRAYLENGTH:
 921                                         case ICMD_INSTANCEOF:
 922
 923                                         case ICMD_NEWARRAY:
 924                                         case ICMD_ANEWARRAY:
 925
 926                                         case ICMD_GETFIELD:
 927                                                 reg_free_temp(src);
 928                                                 reg_new_temp(dst);
 929                                                 break;
 930
 931                                         /* pop 0 push 1 */
 932
 933                                         case ICMD_GETSTATIC:
 934
 935                                         case ICMD_NEW:
 936
 937                                                 reg_new_temp(dst);
 938                                                 break;
 939
 940                                         /* pop many push any */
 941
 942                                         case ICMD_INVOKEVIRTUAL:
 943                                         case ICMD_INVOKESPECIAL:
 944                                         case ICMD_INVOKESTATIC:
 945                                         case ICMD_INVOKEINTERFACE:
 946                                                 {
 947                                                 i = iptr->op1;
 948                                                 while (--i >= 0) {
 949                                                         reg_free_temp(src);
 950                                                         src = src->prev;
 951                                                         }
 952                                                 if (((methodinfo*)iptr->val.a)->returntype != TYPE_VOID)
 953                                                         reg_new_temp(dst);
 954                                                 break;
 955                                                 }
 956
 957                                         case ICMD_BUILTIN3:
 958                                                 reg_free_temp(src);
 959                                                 src = src->prev;
 960                                         case ICMD_BUILTIN2:
 961                                                 reg_free_temp(src);
 962                                                 src = src->prev;
 963                                         case ICMD_BUILTIN1:
 964                                                 reg_free_temp(src);
 965                                                 src = src->prev;
 966                                                 if (iptr->op1 != TYPE_VOID)
 967                                                         reg_new_temp(dst);
 968                                                 break;
 969
 970                                         case ICMD_MULTIANEWARRAY:
 971                                                 i = iptr->op1;
 972                                                 while (--i >= 0) {
 973                                                         reg_free_temp(src);
 974                                                         src = src->prev;
 975                                                         }
 976                                                 reg_new_temp(dst);
 977                                                 break;
 978
 979                                         default:
 980                                                 printf("ICMD %d at %d\n", iptr->opc, (int)(iptr-instr));
 981                                                 panic("Missing ICMD code during register allocation");
 982                                         } /* switch */
 983                                 iptr++;
 984                                 } /* while instructions */
 985                         } /* if */
 986                 bptr++;
 987         } /* while blocks */
 988 }
 989
 990
 991 /*
 992  * These are local overrides for various environment variables in Emacs.
 993  * Please do not remove this and leave it at the end of the file, where
 994  * Emacs will automagically detect them.
 995  * ---------------------------------------------------------------------
 996  * Local variables:
 997  * mode: c
 998  * indent-tabs-mode: t
 999  * c-basic-offset: 4
1000  * tab-width: 4
1001  * End:
1002  */