src/vm/jit/emit-common.c

   1 /* src/vm/jit/emit-common.c - common code emitter functions
   2
   3    Copyright (C) 2006, 2007 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: emitfuncs.c 4398 2006-01-31 23:43:08Z twisti $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33
  34 #include "vm/types.h"
  35
  36 #include "arch.h"
  37 #include "codegen.h"
  38
  39 #include "vm/jit/emit-common.h"
  40 #include "vm/jit/jit.h"
  41
  42 #include "vmcore/options.h"
  43 #include "vmcore/statistics.h"
  44
  45
  46 /* emit_load_s1 ****************************************************************
  47
  48    Emits a possible load of the first source operand.
  49
  50 *******************************************************************************/
  51
  52 s4 emit_load_s1(jitdata *jd, instruction *iptr, s4 tempreg)
  53 {
  54         varinfo *src;
  55         s4       reg;
  56
  57         src = VAROP(iptr->s1);
  58
  59         reg = emit_load(jd, iptr, src, tempreg);
  60
  61         return reg;
  62 }
  63
  64
  65 /* emit_load_s2 ****************************************************************
  66
  67    Emits a possible load of the second source operand.
  68
  69 *******************************************************************************/
  70
  71 s4 emit_load_s2(jitdata *jd, instruction *iptr, s4 tempreg)
  72 {
  73         varinfo *src;
  74         s4       reg;
  75
  76         src = VAROP(iptr->sx.s23.s2);
  77
  78         reg = emit_load(jd, iptr, src, tempreg);
  79
  80         return reg;
  81 }
  82
  83
  84 /* emit_load_s3 ****************************************************************
  85
  86    Emits a possible load of the third source operand.
  87
  88 *******************************************************************************/
  89
  90 s4 emit_load_s3(jitdata *jd, instruction *iptr, s4 tempreg)
  91 {
  92         varinfo *src;
  93         s4       reg;
  94
  95         src = VAROP(iptr->sx.s23.s3);
  96
  97         reg = emit_load(jd, iptr, src, tempreg);
  98
  99         return reg;
 100 }
 101
 102
 103 /* emit_load_s1_low ************************************************************
 104
 105    Emits a possible load of the low 32-bits of the first long source
 106    operand.
 107
 108 *******************************************************************************/
 109
 110 #if SIZEOF_VOID_P == 4
 111 s4 emit_load_s1_low(jitdata *jd, instruction *iptr, s4 tempreg)
 112 {
 113         varinfo *src;
 114         s4       reg;
 115
 116         src = VAROP(iptr->s1);
 117
 118         reg = emit_load_low(jd, iptr, src, tempreg);
 119
 120         return reg;
 121 }
 122 #endif
 123
 124
 125 /* emit_load_s2_low ************************************************************
 126
 127    Emits a possible load of the low 32-bits of the second long source
 128    operand.
 129
 130 *******************************************************************************/
 131
 132 #if SIZEOF_VOID_P == 4
 133 s4 emit_load_s2_low(jitdata *jd, instruction *iptr, s4 tempreg)
 134 {
 135         varinfo *src;
 136         s4       reg;
 137
 138         src = VAROP(iptr->sx.s23.s2);
 139
 140         reg = emit_load_low(jd, iptr, src, tempreg);
 141
 142         return reg;
 143 }
 144 #endif
 145
 146
 147 /* emit_load_s3_low ************************************************************
 148
 149    Emits a possible load of the low 32-bits of the third long source
 150    operand.
 151
 152 *******************************************************************************/
 153
 154 #if SIZEOF_VOID_P == 4
 155 s4 emit_load_s3_low(jitdata *jd, instruction *iptr, s4 tempreg)
 156 {
 157         varinfo *src;
 158         s4       reg;
 159
 160         src = VAROP(iptr->sx.s23.s3);
 161
 162         reg = emit_load_low(jd, iptr, src, tempreg);
 163
 164         return reg;
 165 }
 166 #endif
 167
 168
 169 /* emit_load_s1_high ***********************************************************
 170
 171    Emits a possible load of the high 32-bits of the first long source
 172    operand.
 173
 174 *******************************************************************************/
 175
 176 #if SIZEOF_VOID_P == 4
 177 s4 emit_load_s1_high(jitdata *jd, instruction *iptr, s4 tempreg)
 178 {
 179         varinfo *src;
 180         s4       reg;
 181
 182         src = VAROP(iptr->s1);
 183
 184         reg = emit_load_high(jd, iptr, src, tempreg);
 185
 186         return reg;
 187 }
 188 #endif
 189
 190
 191 /* emit_load_s2_high ***********************************************************
 192
 193    Emits a possible load of the high 32-bits of the second long source
 194    operand.
 195
 196 *******************************************************************************/
 197
 198 #if SIZEOF_VOID_P == 4
 199 s4 emit_load_s2_high(jitdata *jd, instruction *iptr, s4 tempreg)
 200 {
 201         varinfo *src;
 202         s4       reg;
 203
 204         src = VAROP(iptr->sx.s23.s2);
 205
 206         reg = emit_load_high(jd, iptr, src, tempreg);
 207
 208         return reg;
 209 }
 210 #endif
 211
 212
 213 /* emit_load_s3_high ***********************************************************
 214
 215    Emits a possible load of the high 32-bits of the third long source
 216    operand.
 217
 218 *******************************************************************************/
 219
 220 #if SIZEOF_VOID_P == 4
 221 s4 emit_load_s3_high(jitdata *jd, instruction *iptr, s4 tempreg)
 222 {
 223         varinfo *src;
 224         s4       reg;
 225
 226         src = VAROP(iptr->sx.s23.s3);
 227
 228         reg = emit_load_high(jd, iptr, src, tempreg);
 229
 230         return reg;
 231 }
 232 #endif
 233
 234
 235 /* emit_store_dst **************************************************************
 236
 237    This function generates the code to store the result of an
 238    operation back into a spilled pseudo-variable.  If the
 239    pseudo-variable has not been spilled in the first place, this
 240    function will generate nothing.
 241
 242 *******************************************************************************/
 243
 244 void emit_store_dst(jitdata *jd, instruction *iptr, s4 d)
 245 {
 246         emit_store(jd, iptr, VAROP(iptr->dst), d);
 247 }
 248
 249
 250 /* emit_bccz *******************************************************************
 251
 252    Emit conditional and unconditional branch instructions on integer
 253    regiseters.
 254
 255 *******************************************************************************/
 256
 257 void emit_bccz(codegendata *cd, basicblock *target, s4 condition, s4 reg, u4 options)
 258 {
 259         s4 branchmpc;
 260         s4 disp;
 261
 262         /* Target basic block already has an PC, so we can generate the
 263            branch immediately. */
 264
 265         if ((target->mpc >= 0)) {
 266                 STATISTICS(count_branches_resolved++);
 267
 268                 /* calculate the mpc of the branch instruction */
 269
 270                 branchmpc = cd->mcodeptr - cd->mcodebase;
 271                 disp      = target->mpc - branchmpc;
 272
 273                 STATISTICS(count_emit_branch++);
 274                 STATISTICS(if ((int8_t)disp == disp)  count_emit_branch_8bit++;
 275                                         else if ((int16_t)disp == disp) count_emit_branch_16bit++;
 276                                         else if ((int32_t)disp == disp) count_emit_branch_32bit++;
 277                         #if (SIZEOF_VOID_P == 8)
 278                                         else if ((int64_t)disp == disp) count_emit_branch_64bit++;
 279                         #endif
 280                 );
 281                 emit_branch(cd, disp, condition, reg, options);
 282         }
 283         else {
 284                 /* current mcodeptr is the correct position,
 285                    afterwards emit the NOPs */
 286
 287                 codegen_add_branch_ref(cd, target, condition, reg, options);
 288
 289                 /* generate NOPs as placeholder for branch code */
 290
 291                 BRANCH_NOPS;
 292         }
 293 }
 294
 295
 296 /* emit_bcc ********************************************************************
 297
 298    Emit conditional and unconditional branch instructions on condition
 299    codes.
 300
 301 *******************************************************************************/
 302
 303 void emit_bcc(codegendata *cd, basicblock *target, s4 condition, u4 options)
 304 {
 305         emit_bccz(cd, target, condition, -1, options);
 306 }
 307
 308
 309 /* emit_br *********************************************************************
 310
 311    Wrapper for unconditional branches.
 312
 313 *******************************************************************************/
 314
 315 void emit_br(codegendata *cd, basicblock *target)
 316 {
 317         emit_bcc(cd, target, BRANCH_UNCONDITIONAL, BRANCH_OPT_NONE);
 318 }
 319
 320
 321 /* emit_bxxz *******************************************************************
 322
 323    Wrappers for branches on one integer register.
 324
 325 *******************************************************************************/
 326
 327 #if SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER
 328
 329 void emit_beqz(codegendata *cd, basicblock *target, s4 reg)
 330 {
 331         emit_bccz(cd, target, BRANCH_EQ, reg, BRANCH_OPT_NONE);
 332 }
 333
 334 void emit_bnez(codegendata *cd, basicblock *target, s4 reg)
 335 {
 336         emit_bccz(cd, target, BRANCH_NE, reg, BRANCH_OPT_NONE);
 337 }
 338
 339 void emit_bltz(codegendata *cd, basicblock *target, s4 reg)
 340 {
 341         emit_bccz(cd, target, BRANCH_LT, reg, BRANCH_OPT_NONE);
 342 }
 343
 344 void emit_bgez(codegendata *cd, basicblock *target, s4 reg)
 345 {
 346         emit_bccz(cd, target, BRANCH_GE, reg, BRANCH_OPT_NONE);
 347 }
 348
 349 void emit_bgtz(codegendata *cd, basicblock *target, s4 reg)
 350 {
 351         emit_bccz(cd, target, BRANCH_GT, reg, BRANCH_OPT_NONE);
 352 }
 353
 354 void emit_blez(codegendata *cd, basicblock *target, s4 reg)
 355 {
 356         emit_bccz(cd, target, BRANCH_LE, reg, BRANCH_OPT_NONE);
 357 }
 358
 359 #endif /* SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER */
 360
 361
 362 /* emit_bxx ********************************************************************
 363
 364    Wrappers for branches on two integer registers.
 365
 366    We use PACK_REGS here, so we don't have to change the branchref
 367    data structure and the emit_bccz function.
 368
 369 *******************************************************************************/
 370
 371 #if SUPPORT_BRANCH_CONDITIONAL_TWO_INTEGER_REGISTERS
 372
 373 void emit_beq(codegendata *cd, basicblock *target, s4 s1, s4 s2)
 374 {
 375         emit_bccz(cd, target, BRANCH_EQ, PACK_REGS(s1, s2), BRANCH_OPT_NONE);
 376 }
 377
 378 void emit_bne(codegendata *cd, basicblock *target, s4 s1, s4 s2)
 379 {
 380         emit_bccz(cd, target, BRANCH_NE, PACK_REGS(s1, s2), BRANCH_OPT_NONE);
 381 }
 382
 383 #endif /* SUPPORT_BRANCH_CONDITIONAL_TWO_INTEGER_REGISTERS */
 384
 385
 386 /* emit_bxx ********************************************************************
 387
 388    Wrappers for branches on condition codes.
 389
 390 *******************************************************************************/
 391
 392 #if SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER
 393
 394 void emit_beq(codegendata *cd, basicblock *target)
 395 {
 396         emit_bcc(cd, target, BRANCH_EQ, BRANCH_OPT_NONE);
 397 }
 398
 399 void emit_bne(codegendata *cd, basicblock *target)
 400 {
 401         emit_bcc(cd, target, BRANCH_NE, BRANCH_OPT_NONE);
 402 }
 403
 404 void emit_blt(codegendata *cd, basicblock *target)
 405 {
 406         emit_bcc(cd, target, BRANCH_LT, BRANCH_OPT_NONE);
 407 }
 408
 409 void emit_bge(codegendata *cd, basicblock *target)
 410 {
 411         emit_bcc(cd, target, BRANCH_GE, BRANCH_OPT_NONE);
 412 }
 413
 414 void emit_bgt(codegendata *cd, basicblock *target)
 415 {
 416         emit_bcc(cd, target, BRANCH_GT, BRANCH_OPT_NONE);
 417 }
 418
 419 void emit_ble(codegendata *cd, basicblock *target)
 420 {
 421         emit_bcc(cd, target, BRANCH_LE, BRANCH_OPT_NONE);
 422 }
 423
 424 #if SUPPORT_BRANCH_CONDITIONAL_UNSIGNED_CONDITIONS
 425 void emit_bult(codegendata *cd, basicblock *target)
 426 {
 427         emit_bcc(cd, target, BRANCH_ULT, BRANCH_OPT_NONE);
 428 }
 429
 430 void emit_bule(codegendata *cd, basicblock *target)
 431 {
 432         emit_bcc(cd, target, BRANCH_ULE, BRANCH_OPT_NONE);
 433 }
 434
 435 void emit_buge(codegendata *cd, basicblock *target)
 436 {
 437         emit_bcc(cd, target, BRANCH_UGE, BRANCH_OPT_NONE);
 438 }
 439
 440 void emit_bugt(codegendata *cd, basicblock *target)
 441 {
 442         emit_bcc(cd, target, BRANCH_UGT, BRANCH_OPT_NONE);
 443 }
 444 #endif
 445
 446 #if defined(__POWERPC__) || defined(__POWERPC64__)
 447 void emit_bnan(codegendata *cd, basicblock *target)
 448 {
 449         emit_bcc(cd, target, BRANCH_NAN, BRANCH_OPT_NONE);
 450 }
 451 #endif
 452
 453 #endif /* SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER */
 454
 455
 456 /* emit_label_bccz *************************************************************
 457
 458    Emit a branch to a label.  Possibly emit the branch, if it is a
 459    backward branch.
 460
 461 *******************************************************************************/
 462
 463 void emit_label_bccz(codegendata *cd, s4 label, s4 condition, s4 reg, u4 options)
 464 {
 465         list_t             *list;
 466         branch_label_ref_t *br;
 467         s4                  mpc;
 468         s4                  disp;
 469
 470         /* get the label list */
 471
 472         list = cd->brancheslabel;
 473
 474         /* search if the label is already in the list */
 475
 476         for (br = list_first_unsynced(list); br != NULL;
 477                  br = list_next_unsynced(list, br)) {
 478                 /* is this entry the correct label? */
 479
 480                 if (br->label == label)
 481                         break;
 482         }
 483
 484         /* a branch reference was found */
 485
 486         if (br != NULL) {
 487                 /* calculate the mpc of the branch instruction */
 488
 489                 mpc  = cd->mcodeptr - cd->mcodebase;
 490                 disp = br->mpc - mpc;
 491
 492                 STATISTICS(count_emit_branch++);
 493                 STATISTICS(if ((int8_t)disp == disp)  count_emit_branch_8bit++;
 494                                         else if ((int16_t)disp == disp) count_emit_branch_16bit++;
 495                                         else if ((int32_t)disp == disp) count_emit_branch_32bit++;
 496                         #if (SIZEOF_VOID_P == 8)
 497                                         else if ((int64_t)disp == disp) count_emit_branch_64bit++;
 498                         #endif
 499                 );
 500                 emit_branch(cd, disp, condition, reg, options);
 501
 502                 /* now remove the branch reference */
 503
 504                 list_remove_unsynced(list, br);
 505         }
 506         else {
 507                 /* current mcodeptr is the correct position,
 508                    afterwards emit the NOPs */
 509
 510                 codegen_branch_label_add(cd, label, condition, reg, options);
 511
 512                 /* generate NOPs as placeholder for branch code */
 513
 514                 BRANCH_NOPS;
 515         }
 516 }
 517
 518
 519 /* emit_label ******************************************************************
 520
 521    Emit a label for a branch.  Possibly emit the branch, if it is a
 522    forward branch.
 523
 524 *******************************************************************************/
 525
 526 void emit_label(codegendata *cd, s4 label)
 527 {
 528         list_t             *list;
 529         branch_label_ref_t *br;
 530         s4                  mpc;
 531         s4                  disp;
 532         u1                 *mcodeptr;
 533
 534         /* get the label list */
 535
 536         list = cd->brancheslabel;
 537
 538         /* search if the label is already in the list */
 539
 540         for (br = list_first_unsynced(list); br != NULL;
 541                  br = list_next_unsynced(list, br)) {
 542                 /* is this entry the correct label? */
 543
 544                 if (br->label == label)
 545                         break;
 546         }
 547
 548         /* a branch reference was found */
 549
 550         if (br != NULL) {
 551                 /* calculate the mpc of the branch instruction */
 552
 553                 mpc  = cd->mcodeptr - cd->mcodebase;
 554                 disp = mpc - br->mpc;
 555
 556                 /* temporary set the mcodeptr */
 557
 558                 mcodeptr     = cd->mcodeptr;
 559                 cd->mcodeptr = cd->mcodebase + br->mpc;
 560
 561                 STATISTICS(count_emit_branch++);
 562                 STATISTICS(if ((int8_t)disp == disp)  count_emit_branch_8bit++;
 563                                         else if ((int16_t)disp == disp) count_emit_branch_16bit++;
 564                                         else if ((int32_t)disp == disp) count_emit_branch_32bit++;
 565                         #if (SIZEOF_VOID_P == 8)
 566                                         else if ((int64_t)disp == disp) count_emit_branch_64bit++;
 567                         #endif
 568                 );
 569                 emit_branch(cd, disp, br->condition, br->reg, br->options);
 570
 571                 /* restore mcodeptr */
 572
 573                 cd->mcodeptr = mcodeptr;
 574
 575                 /* now remove the branch reference */
 576
 577                 list_remove_unsynced(list, br);
 578         }
 579         else {
 580                 /* add the label to the list (use invalid values for condition
 581                    and register) */
 582
 583                 codegen_branch_label_add(cd, label, -1, -1, BRANCH_OPT_NONE );
 584         }
 585 }
 586
 587
 588 /* emit_label_bcc **************************************************************
 589
 590    Emit conditional and unconditional label-branch instructions on
 591    condition codes.
 592
 593 *******************************************************************************/
 594
 595 void emit_label_bcc(codegendata *cd, s4 label, s4 condition, u4 options)
 596 {
 597         emit_label_bccz(cd, label, condition, -1, options);
 598 }
 599
 600
 601 /* emit_label_br ***************************************************************
 602
 603    Wrapper for unconditional label-branches.
 604
 605 *******************************************************************************/
 606
 607 void emit_label_br(codegendata *cd, s4 label)
 608 {
 609         emit_label_bcc(cd, label, BRANCH_UNCONDITIONAL, BRANCH_OPT_NONE);
 610 }
 611
 612
 613 /* emit_label_bxxz *************************************************************
 614
 615    Wrappers for label-branches on one integer register.
 616
 617 *******************************************************************************/
 618
 619 #if SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER
 620
 621 void emit_label_beqz(codegendata *cd, s4 label, s4 reg)
 622 {
 623         emit_label_bccz(cd, label, BRANCH_EQ, reg, BRANCH_OPT_NONE);
 624 }
 625
 626 #endif /* SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER */
 627
 628
 629 /* emit_label_bxx **************************************************************
 630
 631    Wrappers for label-branches on condition codes.
 632
 633 *******************************************************************************/
 634
 635 #if SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER
 636
 637 void emit_label_beq(codegendata *cd, s4 label)
 638 {
 639         emit_label_bcc(cd, label, BRANCH_EQ, BRANCH_OPT_NONE);
 640 }
 641
 642 void emit_label_bne(codegendata *cd, s4 label)
 643 {
 644         emit_label_bcc(cd, label, BRANCH_NE, BRANCH_OPT_NONE);
 645 }
 646
 647 void emit_label_blt(codegendata *cd, s4 label)
 648 {
 649         emit_label_bcc(cd, label, BRANCH_LT, BRANCH_OPT_NONE);
 650 }
 651
 652 void emit_label_bge(codegendata *cd, s4 label)
 653 {
 654         emit_label_bcc(cd, label, BRANCH_GE, BRANCH_OPT_NONE);
 655 }
 656
 657 void emit_label_bgt(codegendata *cd, s4 label)
 658 {
 659         emit_label_bcc(cd, label, BRANCH_GT, BRANCH_OPT_NONE);
 660 }
 661
 662 void emit_label_ble(codegendata *cd, s4 label)
 663 {
 664         emit_label_bcc(cd, label, BRANCH_LE, BRANCH_OPT_NONE);
 665 }
 666
 667 #endif /* SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER */
 668
 669
 670 /*
 671  * These are local overrides for various environment variables in Emacs.
 672  * Please do not remove this and leave it at the end of the file, where
 673  * Emacs will automagically detect them.
 674  * ---------------------------------------------------------------------
 675  * Local variables:
 676  * mode: c
 677  * indent-tabs-mode: t
 678  * c-basic-offset: 4
 679  * tab-width: 4
 680  * End:
 681  * vim:noexpandtab:sw=4:ts=4:
 682  */