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                 emit_branch(cd, disp, condition, reg, options);
 274         }
 275         else {
 276                 /* current mcodeptr is the correct position,
 277                    afterwards emit the NOPs */
 278
 279                 codegen_add_branch_ref(cd, target, condition, reg, options);
 280
 281                 /* generate NOPs as placeholder for branch code */
 282
 283                 BRANCH_NOPS;
 284         }
 285 }
 286
 287
 288 /* emit_bcc ********************************************************************
 289
 290    Emit conditional and unconditional branch instructions on condition
 291    codes.
 292
 293 *******************************************************************************/
 294
 295 void emit_bcc(codegendata *cd, basicblock *target, s4 condition, u4 options)
 296 {
 297         emit_bccz(cd, target, condition, -1, options);
 298 }
 299
 300
 301 /* emit_br *********************************************************************
 302
 303    Wrapper for unconditional branches.
 304
 305 *******************************************************************************/
 306
 307 void emit_br(codegendata *cd, basicblock *target)
 308 {
 309         emit_bcc(cd, target, BRANCH_UNCONDITIONAL, BRANCH_OPT_NONE);
 310 }
 311
 312
 313 /* emit_bxxz *******************************************************************
 314
 315    Wrappers for branches on one integer register.
 316
 317 *******************************************************************************/
 318
 319 #if SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER
 320
 321 void emit_beqz(codegendata *cd, basicblock *target, s4 reg)
 322 {
 323         emit_bccz(cd, target, BRANCH_EQ, reg, BRANCH_OPT_NONE);
 324 }
 325
 326 void emit_bnez(codegendata *cd, basicblock *target, s4 reg)
 327 {
 328         emit_bccz(cd, target, BRANCH_NE, reg, BRANCH_OPT_NONE);
 329 }
 330
 331 void emit_bltz(codegendata *cd, basicblock *target, s4 reg)
 332 {
 333         emit_bccz(cd, target, BRANCH_LT, reg, BRANCH_OPT_NONE);
 334 }
 335
 336 void emit_bgez(codegendata *cd, basicblock *target, s4 reg)
 337 {
 338         emit_bccz(cd, target, BRANCH_GE, reg, BRANCH_OPT_NONE);
 339 }
 340
 341 void emit_bgtz(codegendata *cd, basicblock *target, s4 reg)
 342 {
 343         emit_bccz(cd, target, BRANCH_GT, reg, BRANCH_OPT_NONE);
 344 }
 345
 346 void emit_blez(codegendata *cd, basicblock *target, s4 reg)
 347 {
 348         emit_bccz(cd, target, BRANCH_LE, reg, BRANCH_OPT_NONE);
 349 }
 350
 351 #endif /* SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER */
 352
 353
 354 /* emit_bxx ********************************************************************
 355
 356    Wrappers for branches on two integer registers.
 357
 358    We use PACK_REGS here, so we don't have to change the branchref
 359    data structure and the emit_bccz function.
 360
 361 *******************************************************************************/
 362
 363 #if SUPPORT_BRANCH_CONDITIONAL_TWO_INTEGER_REGISTERS
 364
 365 void emit_beq(codegendata *cd, basicblock *target, s4 s1, s4 s2)
 366 {
 367         emit_bccz(cd, target, BRANCH_EQ, PACK_REGS(s1, s2), BRANCH_OPT_NONE);
 368 }
 369
 370 void emit_bne(codegendata *cd, basicblock *target, s4 s1, s4 s2)
 371 {
 372         emit_bccz(cd, target, BRANCH_NE, PACK_REGS(s1, s2), BRANCH_OPT_NONE);
 373 }
 374
 375 #endif /* SUPPORT_BRANCH_CONDITIONAL_TWO_INTEGER_REGISTERS */
 376
 377
 378 /* emit_bxx ********************************************************************
 379
 380    Wrappers for branches on condition codes.
 381
 382 *******************************************************************************/
 383
 384 #if SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER
 385
 386 void emit_beq(codegendata *cd, basicblock *target)
 387 {
 388         emit_bcc(cd, target, BRANCH_EQ, BRANCH_OPT_NONE);
 389 }
 390
 391 void emit_bne(codegendata *cd, basicblock *target)
 392 {
 393         emit_bcc(cd, target, BRANCH_NE, BRANCH_OPT_NONE);
 394 }
 395
 396 void emit_blt(codegendata *cd, basicblock *target)
 397 {
 398         emit_bcc(cd, target, BRANCH_LT, BRANCH_OPT_NONE);
 399 }
 400
 401 void emit_bge(codegendata *cd, basicblock *target)
 402 {
 403         emit_bcc(cd, target, BRANCH_GE, BRANCH_OPT_NONE);
 404 }
 405
 406 void emit_bgt(codegendata *cd, basicblock *target)
 407 {
 408         emit_bcc(cd, target, BRANCH_GT, BRANCH_OPT_NONE);
 409 }
 410
 411 void emit_ble(codegendata *cd, basicblock *target)
 412 {
 413         emit_bcc(cd, target, BRANCH_LE, BRANCH_OPT_NONE);
 414 }
 415
 416 #if SUPPORT_BRANCH_CONDITIONAL_UNSIGNED_CONDITIONS
 417 void emit_bult(codegendata *cd, basicblock *target)
 418 {
 419         emit_bcc(cd, target, BRANCH_ULT, BRANCH_OPT_NONE);
 420 }
 421
 422 void emit_bule(codegendata *cd, basicblock *target)
 423 {
 424         emit_bcc(cd, target, BRANCH_ULE, BRANCH_OPT_NONE);
 425 }
 426
 427 void emit_buge(codegendata *cd, basicblock *target)
 428 {
 429         emit_bcc(cd, target, BRANCH_UGE, BRANCH_OPT_NONE);
 430 }
 431
 432 void emit_bugt(codegendata *cd, basicblock *target)
 433 {
 434         emit_bcc(cd, target, BRANCH_UGT, BRANCH_OPT_NONE);
 435 }
 436 #endif
 437
 438 #if defined(__POWERPC__) || defined(__POWERPC64__)
 439 void emit_bnan(codegendata *cd, basicblock *target)
 440 {
 441         emit_bcc(cd, target, BRANCH_NAN, BRANCH_OPT_NONE);
 442 }
 443 #endif
 444
 445 #endif /* SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER */
 446
 447
 448 /* emit_label_bccz *************************************************************
 449
 450    Emit a branch to a label.  Possibly emit the branch, if it is a
 451    backward branch.
 452
 453 *******************************************************************************/
 454
 455 void emit_label_bccz(codegendata *cd, s4 label, s4 condition, s4 reg, u4 options)
 456 {
 457         list               *list;
 458         branch_label_ref_t *br;
 459         s4                  mpc;
 460         s4                  disp;
 461
 462         /* get the label list */
 463
 464         list = cd->brancheslabel;
 465
 466         /* search if the label is already in the list */
 467
 468         for (br = list_first_unsynced(list); br != NULL;
 469                  br = list_next_unsynced(list, br)) {
 470                 /* is this entry the correct label? */
 471
 472                 if (br->label == label)
 473                         break;
 474         }
 475
 476         /* a branch reference was found */
 477
 478         if (br != NULL) {
 479                 /* calculate the mpc of the branch instruction */
 480
 481                 mpc  = cd->mcodeptr - cd->mcodebase;
 482                 disp = br->mpc - mpc;
 483
 484                 emit_branch(cd, disp, condition, reg, options);
 485
 486                 /* now remove the branch reference */
 487
 488                 list_remove_unsynced(list, br);
 489         }
 490         else {
 491                 /* current mcodeptr is the correct position,
 492                    afterwards emit the NOPs */
 493
 494                 codegen_branch_label_add(cd, label, condition, reg, options);
 495
 496                 /* generate NOPs as placeholder for branch code */
 497
 498                 BRANCH_NOPS;
 499         }
 500 }
 501
 502
 503 /* emit_label ******************************************************************
 504
 505    Emit a label for a branch.  Possibly emit the branch, if it is a
 506    forward branch.
 507
 508 *******************************************************************************/
 509
 510 void emit_label(codegendata *cd, s4 label)
 511 {
 512         list               *list;
 513         branch_label_ref_t *br;
 514         s4                  mpc;
 515         s4                  disp;
 516         u1                 *mcodeptr;
 517
 518         /* get the label list */
 519
 520         list = cd->brancheslabel;
 521
 522         /* search if the label is already in the list */
 523
 524         for (br = list_first_unsynced(list); br != NULL;
 525                  br = list_next_unsynced(list, br)) {
 526                 /* is this entry the correct label? */
 527
 528                 if (br->label == label)
 529                         break;
 530         }
 531
 532         /* a branch reference was found */
 533
 534         if (br != NULL) {
 535                 /* calculate the mpc of the branch instruction */
 536
 537                 mpc  = cd->mcodeptr - cd->mcodebase;
 538                 disp = mpc - br->mpc;
 539
 540                 /* temporary set the mcodeptr */
 541
 542                 mcodeptr     = cd->mcodeptr;
 543                 cd->mcodeptr = cd->mcodebase + br->mpc;
 544
 545                 emit_branch(cd, disp, br->condition, br->reg, br->options);
 546
 547                 /* restore mcodeptr */
 548
 549                 cd->mcodeptr = mcodeptr;
 550
 551                 /* now remove the branch reference */
 552
 553                 list_remove_unsynced(list, br);
 554         }
 555         else {
 556                 /* add the label to the list (use invalid values for condition
 557                    and register) */
 558
 559                 codegen_branch_label_add(cd, label, -1, -1, BRANCH_OPT_NONE );
 560         }
 561 }
 562
 563
 564 /* emit_label_bcc **************************************************************
 565
 566    Emit conditional and unconditional label-branch instructions on
 567    condition codes.
 568
 569 *******************************************************************************/
 570
 571 void emit_label_bcc(codegendata *cd, s4 label, s4 condition, u4 options)
 572 {
 573         emit_label_bccz(cd, label, condition, -1, options);
 574 }
 575
 576
 577 /* emit_label_br ***************************************************************
 578
 579    Wrapper for unconditional label-branches.
 580
 581 *******************************************************************************/
 582
 583 void emit_label_br(codegendata *cd, s4 label)
 584 {
 585         emit_label_bcc(cd, label, BRANCH_UNCONDITIONAL, BRANCH_OPT_NONE);
 586 }
 587
 588
 589 /* emit_label_bxxz *************************************************************
 590
 591    Wrappers for label-branches on one integer register.
 592
 593 *******************************************************************************/
 594
 595 #if SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER
 596
 597 void emit_label_beqz(codegendata *cd, s4 label, s4 reg)
 598 {
 599         emit_label_bccz(cd, label, BRANCH_EQ, reg, BRANCH_OPT_NONE);
 600 }
 601
 602 #endif /* SUPPORT_BRANCH_CONDITIONAL_ONE_INTEGER_REGISTER */
 603
 604
 605 /* emit_label_bxx **************************************************************
 606
 607    Wrappers for label-branches on condition codes.
 608
 609 *******************************************************************************/
 610
 611 #if SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER
 612
 613 void emit_label_beq(codegendata *cd, s4 label)
 614 {
 615         emit_label_bcc(cd, label, BRANCH_EQ, BRANCH_OPT_NONE);
 616 }
 617
 618 void emit_label_bne(codegendata *cd, s4 label)
 619 {
 620         emit_label_bcc(cd, label, BRANCH_NE, BRANCH_OPT_NONE);
 621 }
 622
 623 void emit_label_blt(codegendata *cd, s4 label)
 624 {
 625         emit_label_bcc(cd, label, BRANCH_LT, BRANCH_OPT_NONE);
 626 }
 627
 628 void emit_label_bge(codegendata *cd, s4 label)
 629 {
 630         emit_label_bcc(cd, label, BRANCH_GE, BRANCH_OPT_NONE);
 631 }
 632
 633 void emit_label_bgt(codegendata *cd, s4 label)
 634 {
 635         emit_label_bcc(cd, label, BRANCH_GT, BRANCH_OPT_NONE);
 636 }
 637
 638 void emit_label_ble(codegendata *cd, s4 label)
 639 {
 640         emit_label_bcc(cd, label, BRANCH_LE, BRANCH_OPT_NONE);
 641 }
 642
 643 #endif /* SUPPORT_BRANCH_CONDITIONAL_CONDITION_REGISTER */
 644
 645
 646 /*
 647  * These are local overrides for various environment variables in Emacs.
 648  * Please do not remove this and leave it at the end of the file, where
 649  * Emacs will automagically detect them.
 650  * ---------------------------------------------------------------------
 651  * Local variables:
 652  * mode: c
 653  * indent-tabs-mode: t
 654  * c-basic-offset: 4
 655  * tab-width: 4
 656  * End:
 657  * vim:noexpandtab:sw=4:ts=4:
 658  */