![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to expr.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Convert tree expression to rtl instructions, for GNU compiler. ! 2: Copyright (C) 1988, 1992 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is free software; you can redistribute it and/or modify ! 7: it under the terms of the GNU General Public License as published by ! 8: the Free Software Foundation; either version 2, or (at your option) ! 9: any later version. ! 10: ! 11: GNU CC is distributed in the hope that it will be useful, ! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: GNU General Public License for more details. ! 15: ! 16: You should have received a copy of the GNU General Public License ! 17: along with GNU CC; see the file COPYING. If not, write to ! 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 19: ! 20: ! 21: #include "config.h" ! 22: #include "rtl.h" ! 23: #include "tree.h" ! 24: #include "flags.h" ! 25: #include "function.h" ! 26: #include "insn-flags.h" ! 27: #include "insn-codes.h" ! 28: #include "expr.h" ! 29: #include "insn-config.h" ! 30: #include "recog.h" ! 31: #include "output.h" ! 32: #include "gvarargs.h" ! 33: #include "typeclass.h" ! 34: ! 35: #define CEIL(x,y) (((x) + (y) - 1) / (y)) ! 36: ! 37: /* Decide whether a function's arguments should be processed ! 38: from first to last or from last to first. */ ! 39: ! 40: #ifdef STACK_GROWS_DOWNWARD ! 41: #ifdef PUSH_ROUNDING ! 42: #define PUSH_ARGS_REVERSED /* If it's last to first */ ! 43: #endif ! 44: #endif ! 45: ! 46: #ifndef STACK_PUSH_CODE ! 47: #ifdef STACK_GROWS_DOWNWARD ! 48: #define STACK_PUSH_CODE PRE_DEC ! 49: #else ! 50: #define STACK_PUSH_CODE PRE_INC ! 51: #endif ! 52: #endif ! 53: ! 54: /* Like STACK_BOUNDARY but in units of bytes, not bits. */ ! 55: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) ! 56: ! 57: /* If this is nonzero, we do not bother generating VOLATILE ! 58: around volatile memory references, and we are willing to ! 59: output indirect addresses. If cse is to follow, we reject ! 60: indirect addresses so a useful potential cse is generated; ! 61: if it is used only once, instruction combination will produce ! 62: the same indirect address eventually. */ ! 63: int cse_not_expected; ! 64: ! 65: /* Nonzero to generate code for all the subroutines within an ! 66: expression before generating the upper levels of the expression. ! 67: Nowadays this is never zero. */ ! 68: int do_preexpand_calls = 1; ! 69: ! 70: /* Number of units that we should eventually pop off the stack. ! 71: These are the arguments to function calls that have already returned. */ ! 72: int pending_stack_adjust; ! 73: ! 74: /* Nonzero means stack pops must not be deferred, and deferred stack ! 75: pops must not be output. It is nonzero inside a function call, ! 76: inside a conditional expression, inside a statement expression, ! 77: and in other cases as well. */ ! 78: int inhibit_defer_pop; ! 79: ! 80: /* A list of all cleanups which belong to the arguments of ! 81: function calls being expanded by expand_call. */ ! 82: tree cleanups_this_call; ! 83: ! 84: /* Nonzero means __builtin_saveregs has already been done in this function. ! 85: The value is the pseudoreg containing the value __builtin_saveregs ! 86: returned. */ ! 87: static rtx saveregs_value; ! 88: ! 89: rtx store_expr (); ! 90: static void store_constructor (); ! 91: static rtx store_field (); ! 92: static rtx expand_builtin (); ! 93: static rtx compare (); ! 94: static rtx do_store_flag (); ! 95: static void preexpand_calls (); ! 96: static rtx expand_increment (); ! 97: static void init_queue (); ! 98: ! 99: void do_pending_stack_adjust (); ! 100: static void do_jump_for_compare (); ! 101: static void do_jump_by_parts_equality (); ! 102: static void do_jump_by_parts_equality_rtx (); ! 103: static void do_jump_by_parts_greater (); ! 104: ! 105: /* MOVE_RATIO is the number of move instructions that is better than ! 106: a block move. */ ! 107: ! 108: #ifndef MOVE_RATIO ! 109: #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) ! 110: #define MOVE_RATIO 2 ! 111: #else ! 112: /* A value of around 6 would minimize code size; infinity would minimize ! 113: execution time. */ ! 114: #define MOVE_RATIO 15 ! 115: #endif ! 116: #endif ! 117: ! 118: /* This is run at the start of compiling a function. */ ! 119: ! 120: void ! 121: init_expr () ! 122: { ! 123: init_queue (); ! 124: ! 125: pending_stack_adjust = 0; ! 126: inhibit_defer_pop = 0; ! 127: cleanups_this_call = 0; ! 128: saveregs_value = 0; ! 129: } ! 130: ! 131: /* Save all variables describing the current status into the structure *P. ! 132: This is used before starting a nested function. */ ! 133: ! 134: void ! 135: save_expr_status (p) ! 136: struct function *p; ! 137: { ! 138: /* Instead of saving the postincrement queue, empty it. */ ! 139: emit_queue (); ! 140: ! 141: p->pending_stack_adjust = pending_stack_adjust; ! 142: p->inhibit_defer_pop = inhibit_defer_pop; ! 143: p->cleanups_this_call = cleanups_this_call; ! 144: p->saveregs_value = saveregs_value; ! 145: ! 146: pending_stack_adjust = 0; ! 147: inhibit_defer_pop = 0; ! 148: cleanups_this_call = 0; ! 149: saveregs_value = 0; ! 150: } ! 151: ! 152: /* Restore all variables describing the current status from the structure *P. ! 153: This is used after a nested function. */ ! 154: ! 155: void ! 156: restore_expr_status (p) ! 157: struct function *p; ! 158: { ! 159: pending_stack_adjust = p->pending_stack_adjust; ! 160: inhibit_defer_pop = p->inhibit_defer_pop; ! 161: cleanups_this_call = p->cleanups_this_call; ! 162: saveregs_value = p->saveregs_value; ! 163: } ! 164: ! 165: /* Manage the queue of increment instructions to be output ! 166: for POSTINCREMENT_EXPR expressions, etc. */ ! 167: ! 168: static rtx pending_chain; ! 169: ! 170: /* Queue up to increment (or change) VAR later. BODY says how: ! 171: BODY should be the same thing you would pass to emit_insn ! 172: to increment right away. It will go to emit_insn later on. ! 173: ! 174: The value is a QUEUED expression to be used in place of VAR ! 175: where you want to guarantee the pre-incrementation value of VAR. */ ! 176: ! 177: static rtx ! 178: enqueue_insn (var, body) ! 179: rtx var, body; ! 180: { ! 181: pending_chain = gen_rtx (QUEUED, GET_MODE (var), ! 182: var, 0, 0, body, pending_chain); ! 183: return pending_chain; ! 184: } ! 185: ! 186: /* Use protect_from_queue to convert a QUEUED expression ! 187: into something that you can put immediately into an instruction. ! 188: If the queued incrementation has not happened yet, ! 189: protect_from_queue returns the variable itself. ! 190: If the incrementation has happened, protect_from_queue returns a temp ! 191: that contains a copy of the old value of the variable. ! 192: ! 193: Any time an rtx which might possibly be a QUEUED is to be put ! 194: into an instruction, it must be passed through protect_from_queue first. ! 195: QUEUED expressions are not meaningful in instructions. ! 196: ! 197: Do not pass a value through protect_from_queue and then hold ! 198: on to it for a while before putting it in an instruction! ! 199: If the queue is flushed in between, incorrect code will result. */ ! 200: ! 201: rtx ! 202: protect_from_queue (x, modify) ! 203: register rtx x; ! 204: int modify; ! 205: { ! 206: register RTX_CODE code = GET_CODE (x); ! 207: ! 208: #if 0 /* A QUEUED can hang around after the queue is forced out. */ ! 209: /* Shortcut for most common case. */ ! 210: if (pending_chain == 0) ! 211: return x; ! 212: #endif ! 213: ! 214: if (code != QUEUED) ! 215: { ! 216: /* A special hack for read access to (MEM (QUEUED ...)) ! 217: to facilitate use of autoincrement. ! 218: Make a copy of the contents of the memory location ! 219: rather than a copy of the address, but not ! 220: if the value is of mode BLKmode. */ ! 221: if (code == MEM && GET_MODE (x) != BLKmode ! 222: && GET_CODE (XEXP (x, 0)) == QUEUED && !modify) ! 223: { ! 224: register rtx y = XEXP (x, 0); ! 225: XEXP (x, 0) = QUEUED_VAR (y); ! 226: if (QUEUED_INSN (y)) ! 227: { ! 228: register rtx temp = gen_reg_rtx (GET_MODE (x)); ! 229: emit_insn_before (gen_move_insn (temp, x), ! 230: QUEUED_INSN (y)); ! 231: return temp; ! 232: } ! 233: return x; ! 234: } ! 235: /* Otherwise, recursively protect the subexpressions of all ! 236: the kinds of rtx's that can contain a QUEUED. */ ! 237: if (code == MEM) ! 238: XEXP (x, 0) = protect_from_queue (XEXP (x, 0), 0); ! 239: else if (code == PLUS || code == MULT) ! 240: { ! 241: XEXP (x, 0) = protect_from_queue (XEXP (x, 0), 0); ! 242: XEXP (x, 1) = protect_from_queue (XEXP (x, 1), 0); ! 243: } ! 244: return x; ! 245: } ! 246: /* If the increment has not happened, use the variable itself. */ ! 247: if (QUEUED_INSN (x) == 0) ! 248: return QUEUED_VAR (x); ! 249: /* If the increment has happened and a pre-increment copy exists, ! 250: use that copy. */ ! 251: if (QUEUED_COPY (x) != 0) ! 252: return QUEUED_COPY (x); ! 253: /* The increment has happened but we haven't set up a pre-increment copy. ! 254: Set one up now, and use it. */ ! 255: QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x))); ! 256: emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)), ! 257: QUEUED_INSN (x)); ! 258: return QUEUED_COPY (x); ! 259: } ! 260: ! 261: /* Return nonzero if X contains a QUEUED expression: ! 262: if it contains anything that will be altered by a queued increment. ! 263: We handle only combinations of MEM, PLUS, MINUS and MULT operators ! 264: since memory addresses generally contain only those. */ ! 265: ! 266: static int ! 267: queued_subexp_p (x) ! 268: rtx x; ! 269: { ! 270: register enum rtx_code code = GET_CODE (x); ! 271: switch (code) ! 272: { ! 273: case QUEUED: ! 274: return 1; ! 275: case MEM: ! 276: return queued_subexp_p (XEXP (x, 0)); ! 277: case MULT: ! 278: case PLUS: ! 279: case MINUS: ! 280: return queued_subexp_p (XEXP (x, 0)) ! 281: || queued_subexp_p (XEXP (x, 1)); ! 282: } ! 283: return 0; ! 284: } ! 285: ! 286: /* Perform all the pending incrementations. */ ! 287: ! 288: void ! 289: emit_queue () ! 290: { ! 291: register rtx p; ! 292: while (p = pending_chain) ! 293: { ! 294: QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p)); ! 295: pending_chain = QUEUED_NEXT (p); ! 296: } ! 297: } ! 298: ! 299: static void ! 300: init_queue () ! 301: { ! 302: if (pending_chain) ! 303: abort (); ! 304: } ! 305: ! 306: /* Copy data from FROM to TO, where the machine modes are not the same. ! 307: Both modes may be integer, or both may be floating. ! 308: UNSIGNEDP should be nonzero if FROM is an unsigned type. ! 309: This causes zero-extension instead of sign-extension. */ ! 310: ! 311: void ! 312: convert_move (to, from, unsignedp) ! 313: register rtx to, from; ! 314: int unsignedp; ! 315: { ! 316: enum machine_mode to_mode = GET_MODE (to); ! 317: enum machine_mode from_mode = GET_MODE (from); ! 318: int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT; ! 319: int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT; ! 320: enum insn_code code; ! 321: rtx libcall; ! 322: ! 323: /* rtx code for making an equivalent value. */ ! 324: enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND); ! 325: ! 326: to = protect_from_queue (to, 1); ! 327: from = protect_from_queue (from, 0); ! 328: ! 329: if (to_real != from_real) ! 330: abort (); ! 331: ! 332: if (to_mode == from_mode ! 333: || (from_mode == VOIDmode && CONSTANT_P (from))) ! 334: { ! 335: emit_move_insn (to, from); ! 336: return; ! 337: } ! 338: ! 339: if (to_real) ! 340: { ! 341: #ifdef HAVE_extendsfdf2 ! 342: if (HAVE_extendsfdf2 && from_mode == SFmode && to_mode == DFmode) ! 343: { ! 344: emit_unop_insn (CODE_FOR_extendsfdf2, to, from, UNKNOWN); ! 345: return; ! 346: } ! 347: #endif ! 348: #ifdef HAVE_extendsftf2 ! 349: if (HAVE_extendsftf2 && from_mode == SFmode && to_mode == TFmode) ! 350: { ! 351: emit_unop_insn (CODE_FOR_extendsftf2, to, from, UNKNOWN); ! 352: return; ! 353: } ! 354: #endif ! 355: #ifdef HAVE_extenddftf2 ! 356: if (HAVE_extenddftf2 && from_mode == DFmode && to_mode == TFmode) ! 357: { ! 358: emit_unop_insn (CODE_FOR_extenddftf2, to, from, UNKNOWN); ! 359: return; ! 360: } ! 361: #endif ! 362: #ifdef HAVE_truncdfsf2 ! 363: if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode) ! 364: { ! 365: emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN); ! 366: return; ! 367: } ! 368: #endif ! 369: #ifdef HAVE_trunctfsf2 ! 370: if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode) ! 371: { ! 372: emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN); ! 373: return; ! 374: } ! 375: #endif ! 376: #ifdef HAVE_trunctfdf2 ! 377: if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode) ! 378: { ! 379: emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN); ! 380: return; ! 381: } ! 382: #endif ! 383: ! 384: if (from_mode == SFmode && to_mode == DFmode) ! 385: libcall = extendsfdf2_libfunc; ! 386: else if (from_mode == DFmode && to_mode == SFmode) ! 387: libcall = truncdfsf2_libfunc; ! 388: else ! 389: /* This conversion is not implemented yet. There aren't any TFmode ! 390: library calls. */ ! 391: abort (); ! 392: ! 393: emit_library_call (libcall, 0, to_mode, 1, from, from_mode); ! 394: emit_move_insn (to, hard_libcall_value (to_mode)); ! 395: return; ! 396: } ! 397: ! 398: /* Now both modes are integers. */ ! 399: ! 400: /* Handle expanding beyond a word. */ ! 401: if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode) ! 402: && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD) ! 403: { ! 404: rtx insns; ! 405: rtx lowpart; ! 406: rtx fill_value; ! 407: rtx lowfrom; ! 408: int i; ! 409: enum machine_mode lowpart_mode; ! 410: int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD); ! 411: ! 412: /* Try converting directly if the insn is supported. */ ! 413: if ((code = can_extend_p (to_mode, from_mode, unsignedp)) ! 414: != CODE_FOR_nothing) ! 415: { ! 416: emit_unop_insn (code, to, from, equiv_code); ! 417: return; ! 418: } ! 419: /* Next, try converting via full word. */ ! 420: else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD ! 421: && ((code = can_extend_p (to_mode, word_mode, unsignedp)) ! 422: != CODE_FOR_nothing)) ! 423: { ! 424: convert_move (gen_lowpart (word_mode, to), from, unsignedp); ! 425: emit_unop_insn (code, to, ! 426: gen_lowpart (word_mode, to), equiv_code); ! 427: return; ! 428: } ! 429: ! 430: /* No special multiword conversion insn; do it by hand. */ ! 431: start_sequence (); ! 432: ! 433: /* Get a copy of FROM widened to a word, if necessary. */ ! 434: if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD) ! 435: lowpart_mode = word_mode; ! 436: else ! 437: lowpart_mode = from_mode; ! 438: ! 439: lowfrom = convert_to_mode (lowpart_mode, from, unsignedp); ! 440: ! 441: lowpart = gen_lowpart (lowpart_mode, to); ! 442: emit_move_insn (lowpart, lowfrom); ! 443: ! 444: /* Compute the value to put in each remaining word. */ ! 445: if (unsignedp) ! 446: fill_value = const0_rtx; ! 447: else ! 448: { ! 449: #ifdef HAVE_slt ! 450: if (HAVE_slt ! 451: && insn_operand_mode[(int) CODE_FOR_slt][0] == word_mode ! 452: && STORE_FLAG_VALUE == -1) ! 453: { ! 454: emit_cmp_insn (lowfrom, const0_rtx, NE, 0, lowpart_mode, 0, 0); ! 455: fill_value = gen_reg_rtx (word_mode); ! 456: emit_insn (gen_slt (fill_value)); ! 457: } ! 458: else ! 459: #endif ! 460: { ! 461: fill_value ! 462: = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom, ! 463: size_int (GET_MODE_BITSIZE (lowpart_mode) - 1), ! 464: 0, 0); ! 465: fill_value = convert_to_mode (word_mode, fill_value, 1); ! 466: } ! 467: } ! 468: ! 469: /* Fill the remaining words. */ ! 470: for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++) ! 471: { ! 472: int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i); ! 473: rtx subword = operand_subword (to, index, 1, to_mode); ! 474: ! 475: if (subword == 0) ! 476: abort (); ! 477: ! 478: if (fill_value != subword) ! 479: emit_move_insn (subword, fill_value); ! 480: } ! 481: ! 482: insns = get_insns (); ! 483: end_sequence (); ! 484: ! 485: emit_no_conflict_block (insns, to, from, 0, ! 486: gen_rtx (equiv_code, to_mode, from)); ! 487: return; ! 488: } ! 489: ! 490: if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD) ! 491: { ! 492: convert_move (to, gen_lowpart (word_mode, from), 0); ! 493: return; ! 494: } ! 495: ! 496: /* Handle pointer conversion */ /* SPEE 900220 */ ! 497: if (to_mode == PSImode) ! 498: { ! 499: if (from_mode != SImode) ! 500: from = convert_to_mode (SImode, from, unsignedp); ! 501: ! 502: #ifdef HAVE_truncsipsi ! 503: if (HAVE_truncsipsi) ! 504: { ! 505: emit_unop_insn (CODE_FOR_truncsipsi, to, from, UNKNOWN); ! 506: return; ! 507: } ! 508: #endif /* HAVE_truncsipsi */ ! 509: abort (); ! 510: } ! 511: ! 512: if (from_mode == PSImode) ! 513: { ! 514: if (to_mode != SImode) ! 515: { ! 516: from = convert_to_mode (SImode, from, unsignedp); ! 517: from_mode = SImode; ! 518: } ! 519: else ! 520: { ! 521: #ifdef HAVE_extendpsisi ! 522: if (HAVE_extendpsisi) ! 523: { ! 524: emit_unop_insn (CODE_FOR_extendpsisi, to, from, UNKNOWN); ! 525: return; ! 526: } ! 527: #endif /* HAVE_extendpsisi */ ! 528: abort (); ! 529: } ! 530: } ! 531: ! 532: /* Now follow all the conversions between integers ! 533: no more than a word long. */ ! 534: ! 535: /* For truncation, usually we can just refer to FROM in a narrower mode. */ ! 536: if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode) ! 537: && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode), ! 538: GET_MODE_BITSIZE (from_mode)) ! 539: && ((GET_CODE (from) == MEM ! 540: && ! MEM_VOLATILE_P (from) ! 541: && ! mode_dependent_address_p (XEXP (from, 0))) ! 542: || GET_CODE (from) == REG ! 543: || GET_CODE (from) == SUBREG)) ! 544: { ! 545: emit_move_insn (to, gen_lowpart (to_mode, from)); ! 546: return; ! 547: } ! 548: ! 549: /* For truncation, usually we can just refer to FROM in a narrower mode. */ ! 550: if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode)) ! 551: { ! 552: /* Convert directly if that works. */ ! 553: if ((code = can_extend_p (to_mode, from_mode, unsignedp)) ! 554: != CODE_FOR_nothing) ! 555: { ! 556: emit_unop_insn (code, to, from, equiv_code); ! 557: return; ! 558: } ! 559: else ! 560: { ! 561: enum machine_mode intermediate; ! 562: ! 563: /* Search for a mode to convert via. */ ! 564: for (intermediate = from_mode; intermediate != VOIDmode; ! 565: intermediate = GET_MODE_WIDER_MODE (intermediate)) ! 566: if ((can_extend_p (to_mode, intermediate, unsignedp) ! 567: != CODE_FOR_nothing) ! 568: && (can_extend_p (intermediate, from_mode, unsignedp) ! 569: != CODE_FOR_nothing)) ! 570: { ! 571: convert_move (to, convert_to_mode (intermediate, from, ! 572: unsignedp), unsignedp); ! 573: return; ! 574: } ! 575: ! 576: /* No suitable intermediate mode. */ ! 577: abort (); ! 578: } ! 579: } ! 580: ! 581: /* Support special truncate insns for certain modes. */ ! 582: ! 583: if (from_mode == DImode && to_mode == SImode) ! 584: { ! 585: #ifdef HAVE_truncdisi2 ! 586: if (HAVE_truncdisi2) ! 587: { ! 588: emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN); ! 589: return; ! 590: } ! 591: #endif ! 592: convert_move (to, force_reg (from_mode, from), unsignedp); ! 593: return; ! 594: } ! 595: ! 596: if (from_mode == DImode && to_mode == HImode) ! 597: { ! 598: #ifdef HAVE_truncdihi2 ! 599: if (HAVE_truncdihi2) ! 600: { ! 601: emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN); ! 602: return; ! 603: } ! 604: #endif ! 605: convert_move (to, force_reg (from_mode, from), unsignedp); ! 606: return; ! 607: } ! 608: ! 609: if (from_mode == DImode && to_mode == QImode) ! 610: { ! 611: #ifdef HAVE_truncdiqi2 ! 612: if (HAVE_truncdiqi2) ! 613: { ! 614: emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN); ! 615: return; ! 616: } ! 617: #endif ! 618: convert_move (to, force_reg (from_mode, from), unsignedp); ! 619: return; ! 620: } ! 621: ! 622: if (from_mode == SImode && to_mode == HImode) ! 623: { ! 624: #ifdef HAVE_truncsihi2 ! 625: if (HAVE_truncsihi2) ! 626: { ! 627: emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN); ! 628: return; ! 629: } ! 630: #endif ! 631: convert_move (to, force_reg (from_mode, from), unsignedp); ! 632: return; ! 633: } ! 634: ! 635: if (from_mode == SImode && to_mode == QImode) ! 636: { ! 637: #ifdef HAVE_truncsiqi2 ! 638: if (HAVE_truncsiqi2) ! 639: { ! 640: emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN); ! 641: return; ! 642: } ! 643: #endif ! 644: convert_move (to, force_reg (from_mode, from), unsignedp); ! 645: return; ! 646: } ! 647: ! 648: if (from_mode == HImode && to_mode == QImode) ! 649: { ! 650: #ifdef HAVE_trunchiqi2 ! 651: if (HAVE_trunchiqi2) ! 652: { ! 653: emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN); ! 654: return; ! 655: } ! 656: #endif ! 657: convert_move (to, force_reg (from_mode, from), unsignedp); ! 658: return; ! 659: } ! 660: ! 661: /* Handle truncation of volatile memrefs, and so on; ! 662: the things that couldn't be truncated directly, ! 663: and for which there was no special instruction. */ ! 664: if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)) ! 665: { ! 666: rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from)); ! 667: emit_move_insn (to, temp); ! 668: return; ! 669: } ! 670: ! 671: /* Mode combination is not recognized. */ ! 672: abort (); ! 673: } ! 674: ! 675: /* Return an rtx for a value that would result ! 676: from converting X to mode MODE. ! 677: Both X and MODE may be floating, or both integer. ! 678: UNSIGNEDP is nonzero if X is an unsigned value. ! 679: This can be done by referring to a part of X in place ! 680: or by copying to a new temporary with conversion. */ ! 681: ! 682: rtx ! 683: convert_to_mode (mode, x, unsignedp) ! 684: enum machine_mode mode; ! 685: rtx x; ! 686: int unsignedp; ! 687: { ! 688: register rtx temp; ! 689: ! 690: x = protect_from_queue (x, 0); ! 691: ! 692: if (mode == GET_MODE (x)) ! 693: return x; ! 694: ! 695: /* There is one case that we must handle specially: If we are converting ! 696: a CONST_INT into a mode whose size is twice HOST_BITS_PER_INT and ! 697: we are to interpret the constant as unsigned, gen_lowpart will do ! 698: the wrong if the constant appears negative. What we want to do is ! 699: make the high-order word of the constant zero, not all ones. */ ! 700: ! 701: if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT ! 702: && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_INT ! 703: && GET_CODE (x) == CONST_INT && INTVAL (x) < 0) ! 704: return immed_double_const (INTVAL (x), 0, mode); ! 705: ! 706: /* We can do this with a gen_lowpart if both desired and current modes ! 707: are integer, and this is either a constant integer, a register, or a ! 708: non-volatile MEM. Except for the constant case, we must be narrowing ! 709: the operand. */ ! 710: ! 711: if (GET_CODE (x) == CONST_INT ! 712: || (GET_MODE_CLASS (mode) == MODE_INT ! 713: && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT ! 714: && (GET_CODE (x) == CONST_DOUBLE ! 715: || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (GET_MODE (x)) ! 716: && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)) ! 717: || GET_CODE (x) == REG))))) ! 718: return gen_lowpart (mode, x); ! 719: ! 720: temp = gen_reg_rtx (mode); ! 721: convert_move (temp, x, unsignedp); ! 722: return temp; ! 723: } ! 724: ! 725: /* Generate several move instructions to copy LEN bytes ! 726: from block FROM to block TO. (These are MEM rtx's with BLKmode). ! 727: The caller must pass FROM and TO ! 728: through protect_from_queue before calling. ! 729: ALIGN (in bytes) is maximum alignment we can assume. */ ! 730: ! 731: struct move_by_pieces ! 732: { ! 733: rtx to; ! 734: rtx to_addr; ! 735: int autinc_to; ! 736: int explicit_inc_to; ! 737: rtx from; ! 738: rtx from_addr; ! 739: int autinc_from; ! 740: int explicit_inc_from; ! 741: int len; ! 742: int offset; ! 743: int reverse; ! 744: }; ! 745: ! 746: static void move_by_pieces_1 (); ! 747: static int move_by_pieces_ninsns (); ! 748: ! 749: static void ! 750: move_by_pieces (to, from, len, align) ! 751: rtx to, from; ! 752: int len, align; ! 753: { ! 754: struct move_by_pieces data; ! 755: rtx to_addr = XEXP (to, 0), from_addr = XEXP (from, 0); ! 756: int max_size = 10000; ! 757: ! 758: data.offset = 0; ! 759: data.to_addr = to_addr; ! 760: data.from_addr = from_addr; ! 761: data.to = to; ! 762: data.from = from; ! 763: data.autinc_to ! 764: = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC ! 765: || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC); ! 766: data.autinc_from ! 767: = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC ! 768: || GET_CODE (from_addr) == POST_INC ! 769: || GET_CODE (from_addr) == POST_DEC); ! 770: ! 771: data.explicit_inc_from = 0; ! 772: data.explicit_inc_to = 0; ! 773: data.reverse ! 774: = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC); ! 775: if (data.reverse) data.offset = len; ! 776: data.len = len; ! 777: ! 778: /* If copying requires more than two move insns, ! 779: copy addresses to registers (to make displacements shorter) ! 780: and use post-increment if available. */ ! 781: if (!(data.autinc_from && data.autinc_to) ! 782: && move_by_pieces_ninsns (len, align) > 2) ! 783: { ! 784: #ifdef HAVE_PRE_DECREMENT ! 785: if (data.reverse && ! data.autinc_from) ! 786: { ! 787: data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len)); ! 788: data.autinc_from = 1; ! 789: data.explicit_inc_from = -1; ! 790: } ! 791: #endif ! 792: #ifdef HAVE_POST_INCREMENT ! 793: if (! data.autinc_from) ! 794: { ! 795: data.from_addr = copy_addr_to_reg (from_addr); ! 796: data.autinc_from = 1; ! 797: data.explicit_inc_from = 1; ! 798: } ! 799: #endif ! 800: if (!data.autinc_from && CONSTANT_P (from_addr)) ! 801: data.from_addr = copy_addr_to_reg (from_addr); ! 802: #ifdef HAVE_PRE_DECREMENT ! 803: if (data.reverse && ! data.autinc_to) ! 804: { ! 805: data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len)); ! 806: data.autinc_to = 1; ! 807: data.explicit_inc_to = -1; ! 808: } ! 809: #endif ! 810: #ifdef HAVE_POST_INCREMENT ! 811: if (! data.reverse && ! data.autinc_to) ! 812: { ! 813: data.to_addr = copy_addr_to_reg (to_addr); ! 814: data.autinc_to = 1; ! 815: data.explicit_inc_to = 1; ! 816: } ! 817: #endif ! 818: if (!data.autinc_to && CONSTANT_P (to_addr)) ! 819: data.to_addr = copy_addr_to_reg (to_addr); ! 820: } ! 821: ! 822: #if defined (STRICT_ALIGNMENT) || defined (SLOW_UNALIGNED_ACCESS) ! 823: if (align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT) ! 824: align = MOVE_MAX; ! 825: #else ! 826: align = MOVE_MAX; ! 827: #endif ! 828: ! 829: /* First move what we can in the largest integer mode, then go to ! 830: successively smaller modes. */ ! 831: ! 832: while (max_size > 1) ! 833: { ! 834: enum machine_mode mode = VOIDmode, tmode; ! 835: enum insn_code icode; ! 836: ! 837: for (tmode = VOIDmode; (int) tmode < (int) MAX_MACHINE_MODE; ! 838: tmode = (enum machine_mode) ((int) tmode + 1)) ! 839: if (GET_MODE_CLASS (tmode) == MODE_INT ! 840: && GET_MODE_SIZE (tmode) < max_size) ! 841: mode = tmode; ! 842: ! 843: if (mode == VOIDmode) ! 844: break; ! 845: ! 846: icode = mov_optab->handlers[(int) mode].insn_code; ! 847: if (icode != CODE_FOR_nothing ! 848: && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT, ! 849: GET_MODE_SIZE (mode))) ! 850: move_by_pieces_1 (GEN_FCN (icode), mode, &data); ! 851: ! 852: max_size = GET_MODE_SIZE (mode); ! 853: } ! 854: ! 855: /* The code above should have handled everything. */ ! 856: if (data.len != 0) ! 857: abort (); ! 858: } ! 859: ! 860: /* Return number of insns required to move L bytes by pieces. ! 861: ALIGN (in bytes) is maximum alignment we can assume. */ ! 862: ! 863: static int ! 864: move_by_pieces_ninsns (l, align) ! 865: unsigned int l; ! 866: int align; ! 867: { ! 868: register int n_insns = 0; ! 869: int max_size = 10000; ! 870: ! 871: #if defined (STRICT_ALIGNMENT) || defined (SLOW_UNALIGNED_ACCESS) ! 872: if (align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT) ! 873: align = MOVE_MAX; ! 874: #else ! 875: align = MOVE_MAX; ! 876: #endif ! 877: ! 878: while (max_size > 1) ! 879: { ! 880: enum machine_mode mode = VOIDmode, tmode; ! 881: enum insn_code icode; ! 882: ! 883: for (tmode = VOIDmode; (int) tmode < (int) MAX_MACHINE_MODE; ! 884: tmode = (enum machine_mode) ((int) tmode + 1)) ! 885: if (GET_MODE_CLASS (tmode) == MODE_INT ! 886: && GET_MODE_SIZE (tmode) < max_size) ! 887: mode = tmode; ! 888: ! 889: if (mode == VOIDmode) ! 890: break; ! 891: ! 892: icode = mov_optab->handlers[(int) mode].insn_code; ! 893: if (icode != CODE_FOR_nothing ! 894: && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT, ! 895: GET_MODE_SIZE (mode))) ! 896: n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode); ! 897: ! 898: max_size = GET_MODE_SIZE (mode); ! 899: } ! 900: ! 901: return n_insns; ! 902: } ! 903: ! 904: /* Subroutine of move_by_pieces. Move as many bytes as appropriate ! 905: with move instructions for mode MODE. GENFUN is the gen_... function ! 906: to make a move insn for that mode. DATA has all the other info. */ ! 907: ! 908: static void ! 909: move_by_pieces_1 (genfun, mode, data) ! 910: rtx (*genfun) (); ! 911: enum machine_mode mode; ! 912: struct move_by_pieces *data; ! 913: { ! 914: register int size = GET_MODE_SIZE (mode); ! 915: register rtx to1, from1; ! 916: ! 917: while (data->len >= size) ! 918: { ! 919: if (data->reverse) data->offset -= size; ! 920: ! 921: to1 = (data->autinc_to ! 922: ? gen_rtx (MEM, mode, data->to_addr) ! 923: : change_address (data->to, mode, ! 924: plus_constant (data->to_addr, data->offset))); ! 925: from1 = ! 926: (data->autinc_from ! 927: ? gen_rtx (MEM, mode, data->from_addr) ! 928: : change_address (data->from, mode, ! 929: plus_constant (data->from_addr, data->offset))); ! 930: ! 931: #ifdef HAVE_PRE_DECREMENT ! 932: if (data->explicit_inc_to < 0) ! 933: emit_insn (gen_sub2_insn (data->to_addr, ! 934: gen_rtx (CONST_INT, VOIDmode, size))); ! 935: if (data->explicit_inc_from < 0) ! 936: emit_insn (gen_sub2_insn (data->from_addr, ! 937: gen_rtx (CONST_INT, VOIDmode, size))); ! 938: #endif ! 939: ! 940: emit_insn ((*genfun) (to1, from1)); ! 941: #ifdef HAVE_POST_INCREMENT ! 942: if (data->explicit_inc_to > 0) ! 943: emit_insn (gen_add2_insn (data->to_addr, ! 944: gen_rtx (CONST_INT, VOIDmode, size))); ! 945: if (data->explicit_inc_from > 0) ! 946: emit_insn (gen_add2_insn (data->from_addr, ! 947: gen_rtx (CONST_INT, VOIDmode, size))); ! 948: #endif ! 949: ! 950: if (! data->reverse) data->offset += size; ! 951: ! 952: data->len -= size; ! 953: } ! 954: } ! 955: ! 956: /* Emit code to move a block Y to a block X. ! 957: This may be done with string-move instructions, ! 958: with multiple scalar move instructions, or with a library call. ! 959: ! 960: Both X and Y must be MEM rtx's (perhaps inside VOLATILE) ! 961: with mode BLKmode. ! 962: SIZE is an rtx that says how long they are. ! 963: ALIGN is the maximum alignment we can assume they have, ! 964: measured in bytes. */ ! 965: ! 966: void ! 967: emit_block_move (x, y, size, align) ! 968: rtx x, y; ! 969: rtx size; ! 970: int align; ! 971: { ! 972: if (GET_MODE (x) != BLKmode) ! 973: abort (); ! 974: ! 975: if (GET_MODE (y) != BLKmode) ! 976: abort (); ! 977: ! 978: x = protect_from_queue (x, 1); ! 979: y = protect_from_queue (y, 0); ! 980: ! 981: if (GET_CODE (x) != MEM) ! 982: abort (); ! 983: if (GET_CODE (y) != MEM) ! 984: abort (); ! 985: if (size == 0) ! 986: abort (); ! 987: ! 988: if (GET_CODE (size) == CONST_INT ! 989: && (move_by_pieces_ninsns ((unsigned) INTVAL (size), align) ! 990: < MOVE_RATIO)) ! 991: move_by_pieces (x, y, INTVAL (size), align); ! 992: else ! 993: { ! 994: /* Try the most limited insn first, because there's no point ! 995: including more than one in the machine description unless ! 996: the more limited one has some advantage. */ ! 997: #ifdef HAVE_movstrqi ! 998: if (HAVE_movstrqi ! 999: && GET_CODE (size) == CONST_INT ! 1000: && ((unsigned) INTVAL (size) ! 1001: < (1 << (GET_MODE_BITSIZE (QImode) - 1)))) ! 1002: { ! 1003: rtx insn = gen_movstrqi (x, y, size, ! 1004: gen_rtx (CONST_INT, VOIDmode, align)); ! 1005: if (insn) ! 1006: { ! 1007: emit_insn (insn); ! 1008: return; ! 1009: } ! 1010: } ! 1011: #endif ! 1012: #ifdef HAVE_movstrhi ! 1013: if (HAVE_movstrhi ! 1014: && GET_CODE (size) == CONST_INT ! 1015: && ((unsigned) INTVAL (size) ! 1016: < (1 << (GET_MODE_BITSIZE (HImode) - 1)))) ! 1017: { ! 1018: rtx insn = gen_movstrhi (x, y, size, ! 1019: gen_rtx (CONST_INT, VOIDmode, align)); ! 1020: if (insn) ! 1021: { ! 1022: emit_insn (insn); ! 1023: return; ! 1024: } ! 1025: } ! 1026: #endif ! 1027: #ifdef HAVE_movstrsi ! 1028: if (HAVE_movstrsi) ! 1029: { ! 1030: rtx insn = gen_movstrsi (x, y, size, ! 1031: gen_rtx (CONST_INT, VOIDmode, align)); ! 1032: if (insn) ! 1033: { ! 1034: emit_insn (insn); ! 1035: return; ! 1036: } ! 1037: } ! 1038: #endif ! 1039: #ifdef HAVE_movstrdi ! 1040: if (HAVE_movstrdi) ! 1041: { ! 1042: rtx insn = gen_movstrdi (x, y, size, ! 1043: gen_rtx (CONST_INT, VOIDmode, align)); ! 1044: if (insn) ! 1045: { ! 1046: emit_insn (insn); ! 1047: return; ! 1048: } ! 1049: } ! 1050: #endif ! 1051: ! 1052: #ifdef TARGET_MEM_FUNCTIONS ! 1053: emit_library_call (memcpy_libfunc, 0, ! 1054: VOIDmode, 3, XEXP (x, 0), Pmode, ! 1055: XEXP (y, 0), Pmode, ! 1056: size, Pmode); ! 1057: #else ! 1058: emit_library_call (bcopy_libfunc, 0, ! 1059: VOIDmode, 3, XEXP (y, 0), Pmode, ! 1060: XEXP (x, 0), Pmode, ! 1061: size, Pmode); ! 1062: #endif ! 1063: } ! 1064: } ! 1065: ! 1066: /* Copy all or part of a value X into registers starting at REGNO. ! 1067: The number of registers to be filled is NREGS. */ ! 1068: ! 1069: void ! 1070: move_block_to_reg (regno, x, nregs, mode) ! 1071: int regno; ! 1072: rtx x; ! 1073: int nregs; ! 1074: enum machine_mode mode; ! 1075: { ! 1076: int i; ! 1077: rtx pat, last; ! 1078: ! 1079: if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x)) ! 1080: x = validize_mem (force_const_mem (mode, x)); ! 1081: ! 1082: /* See if the machine can do this with a load multiple insn. */ ! 1083: #ifdef HAVE_load_multiple ! 1084: last = get_last_insn (); ! 1085: pat = gen_load_multiple (gen_rtx (REG, word_mode, regno), x, ! 1086: gen_rtx (CONST_INT, VOIDmode, nregs)); ! 1087: if (pat) ! 1088: { ! 1089: emit_insn (pat); ! 1090: return; ! 1091: } ! 1092: else ! 1093: delete_insns_since (last); ! 1094: #endif ! 1095: ! 1096: for (i = 0; i < nregs; i++) ! 1097: emit_move_insn (gen_rtx (REG, word_mode, regno + i), ! 1098: operand_subword_force (x, i, mode)); ! 1099: } ! 1100: ! 1101: /* Copy all or part of a BLKmode value X out of registers starting at REGNO. ! 1102: The number of registers to be filled is NREGS. */ ! 1103: ! 1104: void ! 1105: move_block_from_reg (regno, x, nregs) ! 1106: int regno; ! 1107: rtx x; ! 1108: int nregs; ! 1109: { ! 1110: int i; ! 1111: rtx pat, last; ! 1112: ! 1113: /* See if the machine can do this with a store multiple insn. */ ! 1114: #ifdef HAVE_store_multiple ! 1115: last = get_last_insn (); ! 1116: pat = gen_store_multiple (x, gen_rtx (REG, word_mode, regno), ! 1117: gen_rtx (CONST_INT, VOIDmode, nregs)); ! 1118: if (pat) ! 1119: { ! 1120: emit_insn (pat); ! 1121: return; ! 1122: } ! 1123: else ! 1124: delete_insns_since (last); ! 1125: #endif ! 1126: ! 1127: for (i = 0; i < nregs; i++) ! 1128: { ! 1129: rtx tem = operand_subword (x, i, 1, BLKmode); ! 1130: ! 1131: if (tem == 0) ! 1132: abort (); ! 1133: ! 1134: emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i)); ! 1135: } ! 1136: } ! 1137: ! 1138: /* Mark NREGS consecutive regs, starting at REGNO, as being live now. */ ! 1139: ! 1140: void ! 1141: use_regs (regno, nregs) ! 1142: int regno; ! 1143: int nregs; ! 1144: { ! 1145: int i; ! 1146: ! 1147: for (i = 0; i < nregs; i++) ! 1148: emit_insn (gen_rtx (USE, VOIDmode, gen_rtx (REG, word_mode, regno + i))); ! 1149: } ! 1150: ! 1151: /* Write zeros through the storage of OBJECT. ! 1152: If OBJECT has BLKmode, SIZE is its length in bytes. */ ! 1153: ! 1154: void ! 1155: clear_storage (object, size) ! 1156: rtx object; ! 1157: int size; ! 1158: { ! 1159: if (GET_MODE (object) == BLKmode) ! 1160: { ! 1161: #ifdef TARGET_MEM_FUNCTIONS ! 1162: emit_library_call (memset_libfunc, 0, ! 1163: VOIDmode, 3, ! 1164: XEXP (object, 0), Pmode, const0_rtx, Pmode, ! 1165: gen_rtx (CONST_INT, VOIDmode, size), Pmode); ! 1166: #else ! 1167: emit_library_call (bzero_libfunc, 0, ! 1168: VOIDmode, 2, ! 1169: XEXP (object, 0), Pmode, ! 1170: gen_rtx (CONST_INT, VOIDmode, size), Pmode); ! 1171: #endif ! 1172: } ! 1173: else ! 1174: emit_move_insn (object, const0_rtx); ! 1175: } ! 1176: ! 1177: /* Generate code to copy Y into X. ! 1178: Both Y and X must have the same mode, except that ! 1179: Y can be a constant with VOIDmode. ! 1180: This mode cannot be BLKmode; use emit_block_move for that. ! 1181: ! 1182: Return the last instruction emitted. */ ! 1183: ! 1184: rtx ! 1185: emit_move_insn (x, y) ! 1186: rtx x, y; ! 1187: { ! 1188: enum machine_mode mode = GET_MODE (x); ! 1189: int i; ! 1190: ! 1191: x = protect_from_queue (x, 1); ! 1192: y = protect_from_queue (y, 0); ! 1193: ! 1194: if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode)) ! 1195: abort (); ! 1196: ! 1197: if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y)) ! 1198: y = force_const_mem (mode, y); ! 1199: ! 1200: /* If X or Y are memory references, verify that their addresses are valid ! 1201: for the machine. */ ! 1202: if (GET_CODE (x) == MEM ! 1203: && ((! memory_address_p (GET_MODE (x), XEXP (x, 0)) ! 1204: && ! push_operand (x, GET_MODE (x))) ! 1205: || (flag_force_addr ! 1206: && CONSTANT_ADDRESS_P (XEXP (x, 0))))) ! 1207: x = change_address (x, VOIDmode, XEXP (x, 0)); ! 1208: ! 1209: if (GET_CODE (y) == MEM ! 1210: && (! memory_address_p (GET_MODE (y), XEXP (y, 0)) ! 1211: || (flag_force_addr ! 1212: && CONSTANT_ADDRESS_P (XEXP (y, 0))))) ! 1213: y = change_address (y, VOIDmode, XEXP (y, 0)); ! 1214: ! 1215: if (mode == BLKmode) ! 1216: abort (); ! 1217: ! 1218: if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) ! 1219: return ! 1220: emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y)); ! 1221: ! 1222: /* This will handle any multi-word mode that lacks a move_insn pattern. ! 1223: However, you will get better code if you define such patterns, ! 1224: even if they must turn into multiple assembler instructions. */ ! 1225: else if (GET_MODE_SIZE (mode) >= UNITS_PER_WORD) ! 1226: { ! 1227: rtx last_insn = 0; ! 1228: ! 1229: for (i = 0; ! 1230: i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD; ! 1231: i++) ! 1232: { ! 1233: rtx xpart = operand_subword (x, i, 1, mode); ! 1234: rtx ypart = operand_subword (y, i, 1, mode); ! 1235: ! 1236: /* If we can't get a part of Y, put Y into memory if it is a ! 1237: constant. Otherwise, force it into a register. If we still ! 1238: can't get a part of Y, abort. */ ! 1239: if (ypart == 0 && CONSTANT_P (y)) ! 1240: { ! 1241: y = force_const_mem (mode, y); ! 1242: ypart = operand_subword (y, i, 1, mode); ! 1243: } ! 1244: else if (ypart == 0) ! 1245: ypart = operand_subword_force (y, i, mode); ! 1246: ! 1247: if (xpart == 0 || ypart == 0) ! 1248: abort (); ! 1249: ! 1250: last_insn = emit_move_insn (xpart, ypart); ! 1251: } ! 1252: return last_insn; ! 1253: } ! 1254: else ! 1255: abort (); ! 1256: } ! 1257: ! 1258: /* Pushing data onto the stack. */ ! 1259: ! 1260: /* Push a block of length SIZE (perhaps variable) ! 1261: and return an rtx to address the beginning of the block. ! 1262: Note that it is not possible for the value returned to be a QUEUED. ! 1263: The value may be virtual_outgoing_args_rtx. ! 1264: ! 1265: EXTRA is the number of bytes of padding to push in addition to SIZE. ! 1266: BELOW nonzero means this padding comes at low addresses; ! 1267: otherwise, the padding comes at high addresses. */ ! 1268: ! 1269: rtx ! 1270: push_block (size, extra, below) ! 1271: rtx size; ! 1272: int extra, below; ! 1273: { ! 1274: register rtx temp; ! 1275: if (CONSTANT_P (size)) ! 1276: anti_adjust_stack (plus_constant (size, extra)); ! 1277: else if (GET_CODE (size) == REG && extra == 0) ! 1278: anti_adjust_stack (size); ! 1279: else ! 1280: { ! 1281: rtx temp = copy_to_mode_reg (Pmode, size); ! 1282: if (extra != 0) ! 1283: temp = expand_binop (Pmode, add_optab, ! 1284: temp, ! 1285: gen_rtx (CONST_INT, VOIDmode, extra), ! 1286: temp, 0, OPTAB_LIB_WIDEN); ! 1287: anti_adjust_stack (temp); ! 1288: } ! 1289: ! 1290: #ifdef STACK_GROWS_DOWNWARD ! 1291: temp = virtual_outgoing_args_rtx; ! 1292: if (extra != 0 && below) ! 1293: temp = plus_constant (temp, extra); ! 1294: #else ! 1295: if (GET_CODE (size) == CONST_INT) ! 1296: temp = plus_constant (virtual_outgoing_args_rtx, ! 1297: - INTVAL (size) - (below ? 0 : extra)); ! 1298: else if (extra != 0 && !below) ! 1299: temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx, ! 1300: negate_rtx (Pmode, plus_constant (size, extra))); ! 1301: else ! 1302: temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx, ! 1303: negate_rtx (Pmode, size)); ! 1304: #endif ! 1305: ! 1306: return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp); ! 1307: } ! 1308: ! 1309: static rtx ! 1310: gen_push_operand () ! 1311: { ! 1312: return gen_rtx (STACK_PUSH_CODE, Pmode, stack_pointer_rtx); ! 1313: } ! 1314: ! 1315: /* Generate code to push X onto the stack, assuming it has mode MODE and ! 1316: type TYPE. ! 1317: MODE is redundant except when X is a CONST_INT (since they don't ! 1318: carry mode info). ! 1319: SIZE is an rtx for the size of data to be copied (in bytes), ! 1320: needed only if X is BLKmode. ! 1321: ! 1322: ALIGN (in bytes) is maximum alignment we can assume. ! 1323: ! 1324: If PARTIAL is nonzero, then copy that many of the first words ! 1325: of X into registers starting with REG, and push the rest of X. ! 1326: The amount of space pushed is decreased by PARTIAL words, ! 1327: rounded *down* to a multiple of PARM_BOUNDARY. ! 1328: REG must be a hard register in this case. ! 1329: ! 1330: EXTRA is the amount in bytes of extra space to leave next to this arg. ! 1331: This is ignored if an argument block has already been allocted. ! 1332: ! 1333: On a machine that lacks real push insns, ARGS_ADDR is the address of ! 1334: the bottom of the argument block for this call. We use indexing off there ! 1335: to store the arg. On machines with push insns, ARGS_ADDR is 0 when a ! 1336: argument block has not been preallocated. ! 1337: ! 1338: ARGS_SO_FAR is the size of args previously pushed for this call. */ ! 1339: ! 1340: void ! 1341: emit_push_insn (x, mode, type, size, align, partial, reg, extra, ! 1342: args_addr, args_so_far) ! 1343: register rtx x; ! 1344: enum machine_mode mode; ! 1345: tree type; ! 1346: rtx size; ! 1347: int align; ! 1348: int partial; ! 1349: rtx reg; ! 1350: int extra; ! 1351: rtx args_addr; ! 1352: rtx args_so_far; ! 1353: { ! 1354: rtx xinner; ! 1355: enum direction stack_direction ! 1356: #ifdef STACK_GROWS_DOWNWARD ! 1357: = downward; ! 1358: #else ! 1359: = upward; ! 1360: #endif ! 1361: ! 1362: /* Decide where to pad the argument: `downward' for below, ! 1363: `upward' for above, or `none' for don't pad it. ! 1364: Default is below for small data on big-endian machines; else above. */ ! 1365: enum direction where_pad = FUNCTION_ARG_PADDING (mode, type); ! 1366: ! 1367: /* Invert direction if stack is post-update. */ ! 1368: if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC) ! 1369: if (where_pad != none) ! 1370: where_pad = (where_pad == downward ? upward : downward); ! 1371: ! 1372: xinner = x = protect_from_queue (x, 0); ! 1373: ! 1374: if (mode == BLKmode) ! 1375: { ! 1376: /* Copy a block into the stack, entirely or partially. */ ! 1377: ! 1378: register rtx temp; ! 1379: int used = partial * UNITS_PER_WORD; ! 1380: int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT); ! 1381: int skip; ! 1382: ! 1383: if (size == 0) ! 1384: abort (); ! 1385: ! 1386: used -= offset; ! 1387: ! 1388: /* USED is now the # of bytes we need not copy to the stack ! 1389: because registers will take care of them. */ ! 1390: ! 1391: if (partial != 0) ! 1392: xinner = change_address (xinner, BLKmode, ! 1393: plus_constant (XEXP (xinner, 0), used)); ! 1394: ! 1395: /* If the partial register-part of the arg counts in its stack size, ! 1396: skip the part of stack space corresponding to the registers. ! 1397: Otherwise, start copying to the beginning of the stack space, ! 1398: by setting SKIP to 0. */ ! 1399: #ifndef REG_PARM_STACK_SPACE ! 1400: skip = 0; ! 1401: #else ! 1402: skip = used; ! 1403: #endif ! 1404: ! 1405: #ifdef PUSH_ROUNDING ! 1406: /* Do it with several push insns if that doesn't take lots of insns ! 1407: and if there is no difficulty with push insns that skip bytes ! 1408: on the stack for alignment purposes. */ ! 1409: if (args_addr == 0 ! 1410: && GET_CODE (size) == CONST_INT ! 1411: && skip == 0 ! 1412: && (move_by_pieces_ninsns ((unsigned) INTVAL (size) - used, align) ! 1413: < MOVE_RATIO) ! 1414: #if defined (STRICT_ALIGNMENT) || defined (SLOW_UNALIGNED_ACCESS) ! 1415: /* Here we avoid the case of a structure whose weak alignment ! 1416: forces many pushes of a small amount of data, ! 1417: and such small pushes do rounding that causes trouble. */ ! 1418: && (align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT ! 1419: || PUSH_ROUNDING (align) == align) ! 1420: #endif ! 1421: && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size)) ! 1422: { ! 1423: /* Push padding now if padding above and stack grows down, ! 1424: or if padding below and stack grows up. ! 1425: But if space already allocated, this has already been done. */ ! 1426: if (extra && args_addr == 0 ! 1427: && where_pad != none && where_pad != stack_direction) ! 1428: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra)); ! 1429: ! 1430: move_by_pieces (gen_rtx (MEM, BLKmode, gen_push_operand ()), xinner, ! 1431: INTVAL (size) - used, align); ! 1432: } ! 1433: else ! 1434: #endif /* PUSH_ROUNDING */ ! 1435: { ! 1436: /* Otherwise make space on the stack and copy the data ! 1437: to the address of that space. */ ! 1438: ! 1439: /* Deduct words put into registers from the size we must copy. */ ! 1440: if (partial != 0) ! 1441: { ! 1442: if (GET_CODE (size) == CONST_INT) ! 1443: size = gen_rtx (CONST_INT, VOIDmode, INTVAL (size) - used); ! 1444: else ! 1445: size = expand_binop (GET_MODE (size), sub_optab, size, ! 1446: gen_rtx (CONST_INT, VOIDmode, used), ! 1447: 0, 0, OPTAB_LIB_WIDEN); ! 1448: } ! 1449: ! 1450: /* Get the address of the stack space. ! 1451: In this case, we do not deal with EXTRA separately. ! 1452: A single stack adjust will do. */ ! 1453: if (! args_addr) ! 1454: { ! 1455: temp = push_block (size, extra, where_pad == downward); ! 1456: extra = 0; ! 1457: } ! 1458: else if (GET_CODE (args_so_far) == CONST_INT) ! 1459: temp = memory_address (BLKmode, ! 1460: plus_constant (args_addr, ! 1461: skip + INTVAL (args_so_far))); ! 1462: else ! 1463: temp = memory_address (BLKmode, ! 1464: plus_constant (gen_rtx (PLUS, Pmode, ! 1465: args_addr, args_so_far), ! 1466: skip)); ! 1467: ! 1468: /* TEMP is the address of the block. Copy the data there. */ ! 1469: if (GET_CODE (size) == CONST_INT ! 1470: && (move_by_pieces_ninsns ((unsigned) INTVAL (size), align) ! 1471: < MOVE_RATIO)) ! 1472: { ! 1473: move_by_pieces (gen_rtx (MEM, BLKmode, temp), xinner, ! 1474: INTVAL (size), align); ! 1475: goto ret; ! 1476: } ! 1477: /* Try the most limited insn first, because there's no point ! 1478: including more than one in the machine description unless ! 1479: the more limited one has some advantage. */ ! 1480: #ifdef HAVE_movstrqi ! 1481: if (HAVE_movstrqi ! 1482: && GET_CODE (size) == CONST_INT ! 1483: && ((unsigned) INTVAL (size) ! 1484: < (1 << (GET_MODE_BITSIZE (QImode) - 1)))) ! 1485: { ! 1486: emit_insn (gen_movstrqi (gen_rtx (MEM, BLKmode, temp), ! 1487: xinner, size, ! 1488: gen_rtx (CONST_INT, VOIDmode, align))); ! 1489: goto ret; ! 1490: } ! 1491: #endif ! 1492: #ifdef HAVE_movstrhi ! 1493: if (HAVE_movstrhi ! 1494: && GET_CODE (size) == CONST_INT ! 1495: && ((unsigned) INTVAL (size) ! 1496: < (1 << (GET_MODE_BITSIZE (HImode) - 1)))) ! 1497: { ! 1498: emit_insn (gen_movstrhi (gen_rtx (MEM, BLKmode, temp), ! 1499: xinner, size, ! 1500: gen_rtx (CONST_INT, VOIDmode, align))); ! 1501: goto ret; ! 1502: } ! 1503: #endif ! 1504: #ifdef HAVE_movstrsi ! 1505: if (HAVE_movstrsi) ! 1506: { ! 1507: emit_insn (gen_movstrsi (gen_rtx (MEM, BLKmode, temp), ! 1508: xinner, size, ! 1509: gen_rtx (CONST_INT, VOIDmode, align))); ! 1510: goto ret; ! 1511: } ! 1512: #endif ! 1513: #ifdef HAVE_movstrdi ! 1514: if (HAVE_movstrdi) ! 1515: { ! 1516: emit_insn (gen_movstrdi (gen_rtx (MEM, BLKmode, temp), ! 1517: xinner, size, ! 1518: gen_rtx (CONST_INT, VOIDmode, align))); ! 1519: goto ret; ! 1520: } ! 1521: #endif ! 1522: ! 1523: #ifndef ACCUMULATE_OUTGOING_ARGS ! 1524: /* If the source is referenced relative to the stack pointer, ! 1525: copy it to another register to stabilize it. We do not need ! 1526: to do this if we know that we won't be changing sp. */ ! 1527: ! 1528: if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp) ! 1529: || reg_mentioned_p (virtual_outgoing_args_rtx, temp)) ! 1530: temp = copy_to_reg (temp); ! 1531: #endif ! 1532: ! 1533: /* Make inhibit_defer_pop nonzero around the library call ! 1534: to force it to pop the bcopy-arguments right away. */ ! 1535: NO_DEFER_POP; ! 1536: #ifdef TARGET_MEM_FUNCTIONS ! 1537: emit_library_call (memcpy_libfunc, 0, ! 1538: VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode, ! 1539: size, Pmode); ! 1540: #else ! 1541: emit_library_call (bcopy_libfunc, 0, ! 1542: VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode, ! 1543: size, Pmode); ! 1544: #endif ! 1545: OK_DEFER_POP; ! 1546: } ! 1547: } ! 1548: else if (partial > 0) ! 1549: { ! 1550: /* Scalar partly in registers. */ ! 1551: ! 1552: int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD; ! 1553: int i; ! 1554: int not_stack; ! 1555: /* # words of start of argument ! 1556: that we must make space for but need not store. */ ! 1557: int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD); ! 1558: int args_offset = INTVAL (args_so_far); ! 1559: int skip; ! 1560: ! 1561: /* Push padding now if padding above and stack grows down, ! 1562: or if padding below and stack grows up. ! 1563: But if space already allocated, this has already been done. */ ! 1564: if (extra && args_addr == 0 ! 1565: && where_pad != none && where_pad != stack_direction) ! 1566: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra)); ! 1567: ! 1568: /* If we make space by pushing it, we might as well push ! 1569: the real data. Otherwise, we can leave OFFSET nonzero ! 1570: and leave the space uninitialized. */ ! 1571: if (args_addr == 0) ! 1572: offset = 0; ! 1573: ! 1574: /* Now NOT_STACK gets the number of words that we don't need to ! 1575: allocate on the stack. */ ! 1576: not_stack = partial - offset; ! 1577: ! 1578: /* If the partial register-part of the arg counts in its stack size, ! 1579: skip the part of stack space corresponding to the registers. ! 1580: Otherwise, start copying to the beginning of the stack space, ! 1581: by setting SKIP to 0. */ ! 1582: #ifndef REG_PARM_STACK_SPACE ! 1583: skip = 0; ! 1584: #else ! 1585: skip = not_stack; ! 1586: #endif ! 1587: ! 1588: if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x)) ! 1589: x = validize_mem (force_const_mem (mode, x)); ! 1590: ! 1591: /* If X is a hard register in a non-integer mode, copy it into a pseudo; ! 1592: SUBREGs of such registers are not allowed. */ ! 1593: if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER ! 1594: && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT)) ! 1595: x = copy_to_reg (x); ! 1596: ! 1597: /* Loop over all the words allocated on the stack for this arg. */ ! 1598: /* We can do it by words, because any scalar bigger than a word ! 1599: has a size a multiple of a word. */ ! 1600: #ifndef PUSH_ARGS_REVERSED ! 1601: for (i = not_stack; i < size; i++) ! 1602: #else ! 1603: for (i = size - 1; i >= not_stack; i--) ! 1604: #endif ! 1605: if (i >= not_stack + offset) ! 1606: emit_push_insn (operand_subword_force (x, i, mode), ! 1607: word_mode, 0, 0, align, 0, 0, 0, args_addr, ! 1608: gen_rtx (CONST_INT, VOIDmode, ! 1609: args_offset + ((i - not_stack + skip) ! 1610: * UNITS_PER_WORD))); ! 1611: } ! 1612: else ! 1613: { ! 1614: rtx addr; ! 1615: ! 1616: /* Push padding now if padding above and stack grows down, ! 1617: or if padding below and stack grows up. ! 1618: But if space already allocated, this has already been done. */ ! 1619: if (extra && args_addr == 0 ! 1620: && where_pad != none && where_pad != stack_direction) ! 1621: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra)); ! 1622: ! 1623: #ifdef PUSH_ROUNDING ! 1624: if (args_addr == 0) ! 1625: addr = gen_push_operand (); ! 1626: else ! 1627: #endif ! 1628: if (GET_CODE (args_so_far) == CONST_INT) ! 1629: addr ! 1630: = memory_address (mode, ! 1631: plus_constant (args_addr, INTVAL (args_so_far))); ! 1632: else ! 1633: addr = memory_address (mode, gen_rtx (PLUS, Pmode, args_addr, ! 1634: args_so_far)); ! 1635: ! 1636: emit_move_insn (gen_rtx (MEM, mode, addr), x); ! 1637: } ! 1638: ! 1639: ret: ! 1640: /* If part should go in registers, copy that part ! 1641: into the appropriate registers. Do this now, at the end, ! 1642: since mem-to-mem copies above may do function calls. */ ! 1643: if (partial > 0) ! 1644: move_block_to_reg (REGNO (reg), x, partial, mode); ! 1645: ! 1646: if (extra && args_addr == 0 && where_pad == stack_direction) ! 1647: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra)); ! 1648: } ! 1649: ! 1650: /* Output a library call to function FUN (a SYMBOL_REF rtx) ! 1651: (emitting the queue unless NO_QUEUE is nonzero), ! 1652: for a value of mode OUTMODE, ! 1653: with NARGS different arguments, passed as alternating rtx values ! 1654: and machine_modes to convert them to. ! 1655: The rtx values should have been passed through protect_from_queue already. ! 1656: ! 1657: NO_QUEUE will be true if and only if the library call is a `const' call ! 1658: which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent ! 1659: to the variable is_const in expand_call. */ ! 1660: ! 1661: void ! 1662: emit_library_call (va_alist) ! 1663: va_dcl ! 1664: { ! 1665: va_list p; ! 1666: struct args_size args_size; ! 1667: register int argnum; ! 1668: enum machine_mode outmode; ! 1669: int nargs; ! 1670: rtx fun; ! 1671: rtx orgfun; ! 1672: int inc; ! 1673: int count; ! 1674: rtx argblock = 0; ! 1675: CUMULATIVE_ARGS args_so_far; ! 1676: struct arg { rtx value; enum machine_mode mode; rtx reg; int partial; ! 1677: struct args_size offset; struct args_size size; }; ! 1678: struct arg *argvec; ! 1679: int old_inhibit_defer_pop = inhibit_defer_pop; ! 1680: int no_queue = 0; ! 1681: rtx use_insns; ! 1682: ! 1683: va_start (p); ! 1684: orgfun = fun = va_arg (p, rtx); ! 1685: no_queue = va_arg (p, int); ! 1686: outmode = va_arg (p, enum machine_mode); ! 1687: nargs = va_arg (p, int); ! 1688: ! 1689: /* Copy all the libcall-arguments out of the varargs data ! 1690: and into a vector ARGVEC. ! 1691: ! 1692: Compute how to pass each argument. We only support a very small subset ! 1693: of the full argument passing conventions to limit complexity here since ! 1694: library functions shouldn't have many args. */ ! 1695: ! 1696: argvec = (struct arg *) alloca (nargs * sizeof (struct arg)); ! 1697: ! 1698: INIT_CUMULATIVE_ARGS (args_so_far, (tree)0, fun); ! 1699: ! 1700: args_size.constant = 0; ! 1701: args_size.var = 0; ! 1702: ! 1703: for (count = 0; count < nargs; count++) ! 1704: { ! 1705: rtx val = va_arg (p, rtx); ! 1706: enum machine_mode mode = va_arg (p, enum machine_mode); ! 1707: ! 1708: /* We cannot convert the arg value to the mode the library wants here; ! 1709: must do it earlier where we know the signedness of the arg. */ ! 1710: if (mode == BLKmode ! 1711: || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode)) ! 1712: abort (); ! 1713: ! 1714: /* On some machines, there's no way to pass a float to a library fcn. ! 1715: Pass it as a double instead. */ ! 1716: #ifdef LIBGCC_NEEDS_DOUBLE ! 1717: if (LIBGCC_NEEDS_DOUBLE && mode == SFmode) ! 1718: val = convert_to_mode (DFmode, val), mode = DFmode; ! 1719: #endif ! 1720: ! 1721: /* Make sure it is a reasonable operand for a move or push insn. */ ! 1722: if (GET_CODE (val) != REG && GET_CODE (val) != MEM ! 1723: && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val))) ! 1724: val = force_operand (val, 0); ! 1725: ! 1726: argvec[count].value = val; ! 1727: argvec[count].mode = mode; ! 1728: ! 1729: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE ! 1730: if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, (tree)0, 1)) ! 1731: abort (); ! 1732: #endif ! 1733: ! 1734: argvec[count].reg = FUNCTION_ARG (args_so_far, mode, (tree)0, 1); ! 1735: if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST) ! 1736: abort (); ! 1737: #ifdef FUNCTION_ARG_PARTIAL_NREGS ! 1738: argvec[count].partial ! 1739: = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, (tree)0, 1); ! 1740: #else ! 1741: argvec[count].partial = 0; ! 1742: #endif ! 1743: ! 1744: locate_and_pad_parm (mode, 0, ! 1745: argvec[count].reg && argvec[count].partial == 0, ! 1746: 0, &args_size, &argvec[count].offset, ! 1747: &argvec[count].size); ! 1748: ! 1749: if (argvec[count].size.var) ! 1750: abort (); ! 1751: ! 1752: #ifndef REG_PARM_STACK_SPACE ! 1753: if (argvec[count].partial) ! 1754: argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD; ! 1755: #endif ! 1756: ! 1757: if (argvec[count].reg == 0 || argvec[count].partial != 0 ! 1758: #ifdef REG_PARM_STACK_SPACE ! 1759: || 1 ! 1760: #endif ! 1761: ) ! 1762: args_size.constant += argvec[count].size.constant; ! 1763: ! 1764: #ifdef ACCUMULATE_OUTGOING_ARGS ! 1765: /* If this arg is actually passed on the stack, it might be ! 1766: clobbering something we already put there (this library call might ! 1767: be inside the evaluation of an argument to a function whose call ! 1768: requires the stack). This will only occur when the library call ! 1769: has sufficient args to run out of argument registers. Abort in ! 1770: this case; if this ever occurs, code must be added to save and ! 1771: restore the arg slot. */ ! 1772: ! 1773: if (argvec[count].reg == 0 || argvec[count].partial != 0) ! 1774: abort (); ! 1775: #endif ! 1776: ! 1777: FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1); ! 1778: } ! 1779: va_end (p); ! 1780: ! 1781: /* If this machine requires an external definition for library ! 1782: functions, write one out. */ ! 1783: assemble_external_libcall (fun); ! 1784: ! 1785: #ifdef STACK_BOUNDARY ! 1786: args_size.constant = (((args_size.constant + (STACK_BYTES - 1)) ! 1787: / STACK_BYTES) * STACK_BYTES); ! 1788: #endif ! 1789: ! 1790: #ifdef REG_PARM_STACK_SPACE ! 1791: args_size.constant = MAX (args_size.constant, ! 1792: REG_PARM_STACK_SPACE ((tree) 0)); ! 1793: #endif ! 1794: ! 1795: #ifdef ACCUMULATE_OUTGOING_ARGS ! 1796: if (args_size.constant > current_function_outgoing_args_size) ! 1797: current_function_outgoing_args_size = args_size.constant; ! 1798: args_size.constant = 0; ! 1799: #endif ! 1800: ! 1801: #ifndef PUSH_ROUNDING ! 1802: argblock = push_block (gen_rtx (CONST_INT, VOIDmode, args_size.constant), ! 1803: 0, 0); ! 1804: #endif ! 1805: ! 1806: #ifdef PUSH_ARGS_REVERSED ! 1807: inc = -1; ! 1808: argnum = nargs - 1; ! 1809: #else ! 1810: inc = 1; ! 1811: argnum = 0; ! 1812: #endif ! 1813: ! 1814: /* Push the args that need to be pushed. */ ! 1815: ! 1816: for (count = 0; count < nargs; count++, argnum += inc) ! 1817: { ! 1818: register enum machine_mode mode = argvec[argnum].mode; ! 1819: register rtx val = argvec[argnum].value; ! 1820: rtx reg = argvec[argnum].reg; ! 1821: int partial = argvec[argnum].partial; ! 1822: ! 1823: if (! (reg != 0 && partial == 0)) ! 1824: emit_push_insn (val, mode, 0, 0, 0, partial, reg, 0, argblock, ! 1825: gen_rtx (CONST_INT, VOIDmode, ! 1826: argvec[count].offset.constant)); ! 1827: NO_DEFER_POP; ! 1828: } ! 1829: ! 1830: #ifdef PUSH_ARGS_REVERSED ! 1831: argnum = nargs - 1; ! 1832: #else ! 1833: argnum = 0; ! 1834: #endif ! 1835: ! 1836: /* Now load any reg parms into their regs. */ ! 1837: ! 1838: for (count = 0; count < nargs; count++, argnum += inc) ! 1839: { ! 1840: register enum machine_mode mode = argvec[argnum].mode; ! 1841: register rtx val = argvec[argnum].value; ! 1842: rtx reg = argvec[argnum].reg; ! 1843: int partial = argvec[argnum].partial; ! 1844: ! 1845: if (reg != 0 && partial == 0) ! 1846: emit_move_insn (reg, val); ! 1847: NO_DEFER_POP; ! 1848: } ! 1849: ! 1850: /* For version 1.37, try deleting this entirely. */ ! 1851: if (! no_queue) ! 1852: emit_queue (); ! 1853: ! 1854: /* Any regs containing parms remain in use through the call. */ ! 1855: start_sequence (); ! 1856: for (count = 0; count < nargs; count++) ! 1857: if (argvec[count].reg != 0) ! 1858: emit_insn (gen_rtx (USE, VOIDmode, argvec[count].reg)); ! 1859: ! 1860: use_insns = get_insns (); ! 1861: end_sequence (); ! 1862: ! 1863: fun = prepare_call_address (fun, 0, &use_insns); ! 1864: ! 1865: /* Don't allow popping to be deferred, since then ! 1866: cse'ing of library calls could delete a call and leave the pop. */ ! 1867: NO_DEFER_POP; ! 1868: ! 1869: /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which ! 1870: will set inhibit_defer_pop to that value. */ ! 1871: ! 1872: emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), args_size.constant, 0, ! 1873: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), ! 1874: outmode != VOIDmode ? hard_libcall_value (outmode) : 0, ! 1875: old_inhibit_defer_pop + 1, use_insns, no_queue); ! 1876: ! 1877: /* Now restore inhibit_defer_pop to its actual original value. */ ! 1878: OK_DEFER_POP; ! 1879: } ! 1880: ! 1881: /* Expand an assignment that stores the value of FROM into TO. ! 1882: If WANT_VALUE is nonzero, return an rtx for the value of TO. ! 1883: (This may contain a QUEUED rtx.) ! 1884: Otherwise, the returned value is not meaningful. ! 1885: ! 1886: SUGGEST_REG is no longer actually used. ! 1887: It used to mean, copy the value through a register ! 1888: and return that register, if that is possible. ! 1889: But now we do this if WANT_VALUE. ! 1890: ! 1891: If the value stored is a constant, we return the constant. */ ! 1892: ! 1893: rtx ! 1894: expand_assignment (to, from, want_value, suggest_reg) ! 1895: tree to, from; ! 1896: int want_value; ! 1897: int suggest_reg; ! 1898: { ! 1899: register rtx to_rtx = 0; ! 1900: rtx result; ! 1901: ! 1902: /* Don't crash if the lhs of the assignment was erroneous. */ ! 1903: ! 1904: if (TREE_CODE (to) == ERROR_MARK) ! 1905: return expand_expr (from, 0, VOIDmode, 0); ! 1906: ! 1907: /* Assignment of a structure component needs special treatment ! 1908: if the structure component's rtx is not simply a MEM. ! 1909: Assignment of an array element at a constant index ! 1910: has the same problem. */ ! 1911: ! 1912: if (TREE_CODE (to) == COMPONENT_REF ! 1913: || TREE_CODE (to) == BIT_FIELD_REF ! 1914: || (TREE_CODE (to) == ARRAY_REF ! 1915: && TREE_CODE (TREE_OPERAND (to, 1)) == INTEGER_CST ! 1916: && TREE_CODE (TYPE_SIZE (TREE_TYPE (to))) == INTEGER_CST)) ! 1917: { ! 1918: enum machine_mode mode1; ! 1919: int bitsize; ! 1920: int bitpos; ! 1921: int unsignedp; ! 1922: int volatilep = 0; ! 1923: tree tem = get_inner_reference (to, &bitsize, &bitpos, ! 1924: &mode1, &unsignedp, &volatilep); ! 1925: ! 1926: /* If we are going to use store_bit_field and extract_bit_field, ! 1927: make sure to_rtx will be safe for multiple use. */ ! 1928: ! 1929: if (mode1 == VOIDmode && want_value) ! 1930: tem = stabilize_reference (tem); ! 1931: ! 1932: to_rtx = expand_expr (tem, 0, VOIDmode, 0); ! 1933: if (volatilep) ! 1934: { ! 1935: if (GET_CODE (to_rtx) == MEM) ! 1936: MEM_VOLATILE_P (to_rtx) = 1; ! 1937: #if 0 /* This was turned off because, when a field is volatile ! 1938: in an object which is not volatile, the object may be in a register, ! 1939: and then we would abort over here. */ ! 1940: else ! 1941: abort (); ! 1942: #endif ! 1943: } ! 1944: ! 1945: result = store_field (to_rtx, bitsize, bitpos, mode1, from, ! 1946: (want_value ! 1947: /* Spurious cast makes HPUX compiler happy. */ ! 1948: ? (enum machine_mode) TYPE_MODE (TREE_TYPE (to)) ! 1949: : VOIDmode), ! 1950: unsignedp, ! 1951: /* Required alignment of containing datum. */ ! 1952: TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT, ! 1953: int_size_in_bytes (TREE_TYPE (tem))); ! 1954: preserve_temp_slots (result); ! 1955: free_temp_slots (); ! 1956: ! 1957: return result; ! 1958: } ! 1959: ! 1960: /* Ordinary treatment. Expand TO to get a REG or MEM rtx. ! 1961: Don't re-expand if it was expanded already (in COMPONENT_REF case). */ ! 1962: ! 1963: if (to_rtx == 0) ! 1964: to_rtx = expand_expr (to, 0, VOIDmode, 0); ! 1965: ! 1966: /* In case we are returning the contents of an object which overlaps ! 1967: the place the value is being stored, use a safe function when copying ! 1968: a value through a pointer into a structure value return block. */ ! 1969: if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF ! 1970: && current_function_returns_struct ! 1971: && !current_function_returns_pcc_struct) ! 1972: { ! 1973: rtx from_rtx = expand_expr (from, 0, VOIDmode, 0); ! 1974: rtx size = expr_size (from); ! 1975: ! 1976: #ifdef TARGET_MEM_FUNCTIONS ! 1977: emit_library_call (memcpy_libfunc, 0, ! 1978: VOIDmode, 3, XEXP (to_rtx, 0), Pmode, ! 1979: XEXP (from_rtx, 0), Pmode, ! 1980: size, Pmode); ! 1981: #else ! 1982: emit_library_call (bcopy_libfunc, 0, ! 1983: VOIDmode, 3, XEXP (from_rtx, 0), Pmode, ! 1984: XEXP (to_rtx, 0), Pmode, ! 1985: size, Pmode); ! 1986: #endif ! 1987: ! 1988: preserve_temp_slots (to_rtx); ! 1989: free_temp_slots (); ! 1990: return to_rtx; ! 1991: } ! 1992: ! 1993: /* Compute FROM and store the value in the rtx we got. */ ! 1994: ! 1995: result = store_expr (from, to_rtx, want_value); ! 1996: preserve_temp_slots (result); ! 1997: free_temp_slots (); ! 1998: return result; ! 1999: } ! 2000: ! 2001: /* Generate code for computing expression EXP, ! 2002: and storing the value into TARGET. ! 2003: Returns TARGET or an equivalent value. ! 2004: TARGET may contain a QUEUED rtx. ! 2005: ! 2006: If SUGGEST_REG is nonzero, copy the value through a register ! 2007: and return that register, if that is possible. ! 2008: ! 2009: If the value stored is a constant, we return the constant. */ ! 2010: ! 2011: rtx ! 2012: store_expr (exp, target, suggest_reg) ! 2013: register tree exp; ! 2014: register rtx target; ! 2015: int suggest_reg; ! 2016: { ! 2017: register rtx temp; ! 2018: int dont_return_target = 0; ! 2019: ! 2020: if (TREE_CODE (exp) == COMPOUND_EXPR) ! 2021: { ! 2022: /* Perform first part of compound expression, then assign from second ! 2023: part. */ ! 2024: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0); ! 2025: emit_queue (); ! 2026: return store_expr (TREE_OPERAND (exp, 1), target, suggest_reg); ! 2027: } ! 2028: else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode) ! 2029: { ! 2030: /* For conditional expression, get safe form of the target. Then ! 2031: test the condition, doing the appropriate assignment on either ! 2032: side. This avoids the creation of unnecessary temporaries. ! 2033: For non-BLKmode, it is more efficient not to do this. */ ! 2034: ! 2035: rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx (); ! 2036: ! 2037: emit_queue (); ! 2038: target = protect_from_queue (target, 1); ! 2039: ! 2040: NO_DEFER_POP; ! 2041: jumpifnot (TREE_OPERAND (exp, 0), lab1); ! 2042: store_expr (TREE_OPERAND (exp, 1), target, suggest_reg); ! 2043: emit_queue (); ! 2044: emit_jump_insn (gen_jump (lab2)); ! 2045: emit_barrier (); ! 2046: emit_label (lab1); ! 2047: store_expr (TREE_OPERAND (exp, 2), target, suggest_reg); ! 2048: emit_queue (); ! 2049: emit_label (lab2); ! 2050: OK_DEFER_POP; ! 2051: return target; ! 2052: } ! 2053: else if (suggest_reg && GET_CODE (target) == MEM ! 2054: && GET_MODE (target) != BLKmode) ! 2055: /* If target is in memory and caller wants value in a register instead, ! 2056: arrange that. Pass TARGET as target for expand_expr so that, ! 2057: if EXP is another assignment, SUGGEST_REG will be nonzero for it. ! 2058: We know expand_expr will not use the target in that case. */ ! 2059: { ! 2060: temp = expand_expr (exp, cse_not_expected ? 0 : target, ! 2061: GET_MODE (target), 0); ! 2062: if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode) ! 2063: temp = copy_to_reg (temp); ! 2064: dont_return_target = 1; ! 2065: } ! 2066: else if (queued_subexp_p (target)) ! 2067: /* If target contains a postincrement, it is not safe ! 2068: to use as the returned value. It would access the wrong ! 2069: place by the time the queued increment gets output. ! 2070: So copy the value through a temporary and use that temp ! 2071: as the result. */ ! 2072: { ! 2073: if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode) ! 2074: { ! 2075: /* Expand EXP into a new pseudo. */ ! 2076: temp = gen_reg_rtx (GET_MODE (target)); ! 2077: temp = expand_expr (exp, temp, GET_MODE (target), 0); ! 2078: } ! 2079: else ! 2080: temp = expand_expr (exp, 0, GET_MODE (target), 0); ! 2081: dont_return_target = 1; ! 2082: } ! 2083: else ! 2084: { ! 2085: temp = expand_expr (exp, target, GET_MODE (target), 0); ! 2086: /* DO return TARGET if it's a specified hardware register. ! 2087: expand_return relies on this. */ ! 2088: if (!(target && GET_CODE (target) == REG ! 2089: && REGNO (target) < FIRST_PSEUDO_REGISTER) ! 2090: && CONSTANT_P (temp)) ! 2091: dont_return_target = 1; ! 2092: } ! 2093: ! 2094: /* If value was not generated in the target, store it there. ! 2095: Convert the value to TARGET's type first if nec. */ ! 2096: ! 2097: if (temp != target && TREE_CODE (exp) != ERROR_MARK) ! 2098: { ! 2099: target = protect_from_queue (target, 1); ! 2100: if (GET_MODE (temp) != GET_MODE (target) ! 2101: && GET_MODE (temp) != VOIDmode) ! 2102: { ! 2103: int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp)); ! 2104: if (dont_return_target) ! 2105: { ! 2106: /* In this case, we will return TEMP, ! 2107: so make sure it has the proper mode. ! 2108: But don't forget to store the value into TARGET. */ ! 2109: temp = convert_to_mode (GET_MODE (target), temp, unsignedp); ! 2110: emit_move_insn (target, temp); ! 2111: } ! 2112: else ! 2113: convert_move (target, temp, unsignedp); ! 2114: } ! 2115: ! 2116: else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST) ! 2117: { ! 2118: /* Handle copying a string constant into an array. ! 2119: The string constant may be shorter than the array. ! 2120: So copy just the string's actual length, and clear the rest. */ ! 2121: rtx size; ! 2122: ! 2123: emit_block_move (target, temp, ! 2124: gen_rtx (CONST_INT, VOIDmode, ! 2125: TREE_STRING_LENGTH (exp)), ! 2126: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT); ! 2127: ! 2128: temp = plus_constant (XEXP (target, 0), TREE_STRING_LENGTH (exp)); ! 2129: size = plus_constant (expr_size (exp), - TREE_STRING_LENGTH (exp)); ! 2130: if (size != const0_rtx) ! 2131: { ! 2132: #ifdef TARGET_MEM_FUNCTIONS ! 2133: emit_library_call (memset_libfunc, 0, VOIDmode, 3, ! 2134: temp, Pmode, const0_rtx, Pmode, size, Pmode); ! 2135: #else ! 2136: emit_library_call (bzero_libfunc, 0, VOIDmode, 2, ! 2137: temp, Pmode, size, Pmode); ! 2138: #endif ! 2139: } ! 2140: } ! 2141: else if (GET_MODE (temp) == BLKmode) ! 2142: emit_block_move (target, temp, expr_size (exp), ! 2143: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT); ! 2144: else ! 2145: emit_move_insn (target, temp); ! 2146: } ! 2147: if (dont_return_target) ! 2148: return temp; ! 2149: return target; ! 2150: } ! 2151: ! 2152: /* Store the value of constructor EXP into the rtx TARGET. ! 2153: TARGET is either a REG or a MEM. */ ! 2154: ! 2155: static void ! 2156: store_constructor (exp, target) ! 2157: tree exp; ! 2158: rtx target; ! 2159: { ! 2160: /* We know our target cannot conflict, since safe_from_p has been called. */ ! 2161: #if 0 ! 2162: /* Don't try copying piece by piece into a hard register ! 2163: since that is vulnerable to being clobbered by EXP. ! 2164: Instead, construct in a pseudo register and then copy it all. */ ! 2165: if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER) ! 2166: { ! 2167: rtx temp = gen_reg_rtx (GET_MODE (target)); ! 2168: store_constructor (exp, temp); ! 2169: emit_move_insn (target, temp); ! 2170: return; ! 2171: } ! 2172: #endif ! 2173: ! 2174: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE ! 2175: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE) ! 2176: { ! 2177: register tree elt; ! 2178: ! 2179: if (TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE) ! 2180: /* Inform later passes that the whole union value is dead. */ ! 2181: emit_insn (gen_rtx (CLOBBER, VOIDmode, target)); ! 2182: /* If the constructor has fewer fields than the structure, ! 2183: clear the whole structure first. */ ! 2184: else if (list_length (CONSTRUCTOR_ELTS (exp)) ! 2185: != list_length (TYPE_FIELDS (TREE_TYPE (exp)))) ! 2186: clear_storage (target, int_size_in_bytes (TREE_TYPE (exp))); ! 2187: else ! 2188: /* Inform later passes that the old value is dead. */ ! 2189: emit_insn (gen_rtx (CLOBBER, VOIDmode, target)); ! 2190: ! 2191: /* Store each element of the constructor into ! 2192: the corresponding field of TARGET. */ ! 2193: ! 2194: for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt)) ! 2195: { ! 2196: register tree field = TREE_PURPOSE (elt); ! 2197: register enum machine_mode mode; ! 2198: int bitsize; ! 2199: int bitpos; ! 2200: int unsignedp; ! 2201: ! 2202: bitsize = TREE_INT_CST_LOW (DECL_SIZE (field)); ! 2203: unsignedp = TREE_UNSIGNED (field); ! 2204: mode = DECL_MODE (field); ! 2205: if (DECL_BIT_FIELD (field)) ! 2206: mode = VOIDmode; ! 2207: ! 2208: if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST) ! 2209: /* ??? This case remains to be written. */ ! 2210: abort (); ! 2211: ! 2212: bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)); ! 2213: ! 2214: store_field (target, bitsize, bitpos, mode, TREE_VALUE (elt), ! 2215: /* The alignment of TARGET is ! 2216: at least what its type requires. */ ! 2217: VOIDmode, 0, ! 2218: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT, ! 2219: int_size_in_bytes (TREE_TYPE (exp))); ! 2220: } ! 2221: } ! 2222: else if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE) ! 2223: { ! 2224: register tree elt; ! 2225: register int i; ! 2226: tree domain = TYPE_DOMAIN (TREE_TYPE (exp)); ! 2227: int minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)); ! 2228: int maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)); ! 2229: tree elttype = TREE_TYPE (TREE_TYPE (exp)); ! 2230: ! 2231: /* If the constructor has fewer fields than the structure, ! 2232: clear the whole structure first. */ ! 2233: ! 2234: if (list_length (CONSTRUCTOR_ELTS (exp)) < maxelt - minelt + 1) ! 2235: clear_storage (target, maxelt - minelt + 1); ! 2236: else ! 2237: /* Inform later passes that the old value is dead. */ ! 2238: emit_insn (gen_rtx (CLOBBER, VOIDmode, target)); ! 2239: ! 2240: /* Store each element of the constructor into ! 2241: the corresponding element of TARGET, determined ! 2242: by counting the elements. */ ! 2243: for (elt = CONSTRUCTOR_ELTS (exp), i = 0; ! 2244: elt; ! 2245: elt = TREE_CHAIN (elt), i++) ! 2246: { ! 2247: register enum machine_mode mode; ! 2248: int bitsize; ! 2249: int bitpos; ! 2250: int unsignedp; ! 2251: ! 2252: mode = TYPE_MODE (elttype); ! 2253: bitsize = GET_MODE_BITSIZE (mode); ! 2254: unsignedp = TREE_UNSIGNED (elttype); ! 2255: ! 2256: bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype))); ! 2257: ! 2258: store_field (target, bitsize, bitpos, mode, TREE_VALUE (elt), ! 2259: /* The alignment of TARGET is ! 2260: at least what its type requires. */ ! 2261: VOIDmode, 0, ! 2262: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT, ! 2263: int_size_in_bytes (TREE_TYPE (exp))); ! 2264: } ! 2265: } ! 2266: ! 2267: else ! 2268: abort (); ! 2269: } ! 2270: ! 2271: /* Store the value of EXP (an expression tree) ! 2272: into a subfield of TARGET which has mode MODE and occupies ! 2273: BITSIZE bits, starting BITPOS bits from the start of TARGET. ! 2274: If MODE is VOIDmode, it means that we are storing into a bit-field. ! 2275: ! 2276: If VALUE_MODE is VOIDmode, return nothing in particular. ! 2277: UNSIGNEDP is not used in this case. ! 2278: ! 2279: Otherwise, return an rtx for the value stored. This rtx ! 2280: has mode VALUE_MODE if that is convenient to do. ! 2281: In this case, UNSIGNEDP must be nonzero if the value is an unsigned type. ! 2282: ! 2283: ALIGN is the alignment that TARGET is known to have, measured in bytes. ! 2284: TOTAL_SIZE is the size in bytes of the structure, or -1 if varying. */ ! 2285: ! 2286: static rtx ! 2287: store_field (target, bitsize, bitpos, mode, exp, value_mode, ! 2288: unsignedp, align, total_size) ! 2289: rtx target; ! 2290: int bitsize, bitpos; ! 2291: enum machine_mode mode; ! 2292: tree exp; ! 2293: enum machine_mode value_mode; ! 2294: int unsignedp; ! 2295: int align; ! 2296: int total_size; ! 2297: { ! 2298: int width_mask = 0; ! 2299: ! 2300: if (bitsize < HOST_BITS_PER_INT) ! 2301: width_mask = (1 << bitsize) - 1; ! 2302: ! 2303: /* If we are storing into an unaligned field of an aligned union that is ! 2304: in a register, we may have the mode of TARGET being an integer mode but ! 2305: MODE == BLKmode. In that case, get an aligned object whose size and ! 2306: alignment are the same as TARGET and store TARGET into it (we can avoid ! 2307: the store if the field being stored is the entire width of TARGET). Then ! 2308: call ourselves recursively to store the field into a BLKmode version of ! 2309: that object. Finally, load from the object into TARGET. This is not ! 2310: very efficient in general, but should only be slightly more expensive ! 2311: than the otherwise-required unaligned accesses. Perhaps this can be ! 2312: cleaned up later. */ ! 2313: ! 2314: if (mode == BLKmode ! 2315: && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG)) ! 2316: { ! 2317: rtx object = assign_stack_temp (GET_MODE (target), ! 2318: GET_MODE_SIZE (GET_MODE (target)), 0); ! 2319: rtx blk_object = copy_rtx (object); ! 2320: ! 2321: PUT_MODE (blk_object, BLKmode); ! 2322: ! 2323: if (bitsize != GET_MODE_BITSIZE (GET_MODE (target))) ! 2324: emit_move_insn (object, target); ! 2325: ! 2326: store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0, ! 2327: align, total_size); ! 2328: ! 2329: emit_move_insn (target, object); ! 2330: ! 2331: return target; ! 2332: } ! 2333: ! 2334: /* If the structure is in a register or if the component ! 2335: is a bit field, we cannot use addressing to access it. ! 2336: Use bit-field techniques or SUBREG to store in it. */ ! 2337: ! 2338: if (mode == VOIDmode || GET_CODE (target) == REG ! 2339: || GET_CODE (target) == SUBREG) ! 2340: { ! 2341: rtx temp = expand_expr (exp, 0, VOIDmode, 0); ! 2342: /* Store the value in the bitfield. */ ! 2343: store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size); ! 2344: if (value_mode != VOIDmode) ! 2345: { ! 2346: /* The caller wants an rtx for the value. */ ! 2347: /* If possible, avoid refetching from the bitfield itself. */ ! 2348: if (width_mask != 0 ! 2349: && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))) ! 2350: return expand_and (temp, ! 2351: gen_rtx (CONST_INT, VOIDmode, width_mask), 0); ! 2352: return extract_bit_field (target, bitsize, bitpos, unsignedp, ! 2353: 0, value_mode, 0, align, total_size); ! 2354: } ! 2355: return const0_rtx; ! 2356: } ! 2357: else ! 2358: { ! 2359: rtx addr = XEXP (target, 0); ! 2360: rtx to_rtx; ! 2361: ! 2362: /* If a value is wanted, it must be the lhs; ! 2363: so make the address stable for multiple use. */ ! 2364: ! 2365: if (value_mode != VOIDmode && GET_CODE (addr) != REG ! 2366: && ! CONSTANT_ADDRESS_P (addr) ! 2367: /* A frame-pointer reference is already stable. */ ! 2368: && ! (GET_CODE (addr) == PLUS ! 2369: && GET_CODE (XEXP (addr, 1)) == CONST_INT ! 2370: && (XEXP (addr, 0) == virtual_incoming_args_rtx ! 2371: || XEXP (addr, 0) == virtual_stack_vars_rtx))) ! 2372: addr = copy_to_reg (addr); ! 2373: ! 2374: /* Now build a reference to just the desired component. */ ! 2375: ! 2376: to_rtx = change_address (target, mode, ! 2377: plus_constant (addr, (bitpos / BITS_PER_UNIT))); ! 2378: MEM_IN_STRUCT_P (to_rtx) = 1; ! 2379: ! 2380: return store_expr (exp, to_rtx, value_mode != VOIDmode); ! 2381: } ! 2382: } ! 2383: ! 2384: /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF, ! 2385: or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or ! 2386: ARRAY_REFs at constant positions and find the ultimate containing object, ! 2387: which we return. ! 2388: ! 2389: We set *PBITSIZE to the size in bits that we want, *PBITPOS to the ! 2390: bit position, and *PUNSIGNEDP to the signedness of the field. ! 2391: ! 2392: If any of the extraction expressions is volatile, ! 2393: we store 1 in *PVOLATILEP. Otherwise we don't change that. ! 2394: ! 2395: If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it ! 2396: is a mode that can be used to access the field. In that case, *PBITSIZE ! 2397: is redundant. */ ! 2398: ! 2399: tree ! 2400: get_inner_reference (exp, pbitsize, pbitpos, pmode, punsignedp, pvolatilep) ! 2401: tree exp; ! 2402: int *pbitsize; ! 2403: int *pbitpos; ! 2404: enum machine_mode *pmode; ! 2405: int *punsignedp; ! 2406: int *pvolatilep; ! 2407: { ! 2408: tree size_tree = 0; ! 2409: enum machine_mode mode = VOIDmode; ! 2410: ! 2411: if (TREE_CODE (exp) == COMPONENT_REF) ! 2412: { ! 2413: size_tree = DECL_SIZE (TREE_OPERAND (exp, 1)); ! 2414: if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1))) ! 2415: mode = DECL_MODE (TREE_OPERAND (exp, 1)); ! 2416: *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1)); ! 2417: } ! 2418: else if (TREE_CODE (exp) == BIT_FIELD_REF) ! 2419: { ! 2420: size_tree = TREE_OPERAND (exp, 1); ! 2421: *punsignedp = TREE_UNSIGNED (exp); ! 2422: } ! 2423: else ! 2424: { ! 2425: mode = TYPE_MODE (TREE_TYPE (exp)); ! 2426: *pbitsize = GET_MODE_BITSIZE (mode); ! 2427: *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp)); ! 2428: } ! 2429: ! 2430: if (size_tree) ! 2431: { ! 2432: if (TREE_CODE (size_tree) != INTEGER_CST) ! 2433: abort (); ! 2434: ! 2435: *pbitsize = TREE_INT_CST_LOW (size_tree); ! 2436: } ! 2437: ! 2438: /* Compute cumulative bit-offset for nested component-refs and array-refs, ! 2439: and find the ultimate containing object. */ ! 2440: ! 2441: *pbitpos = 0; ! 2442: ! 2443: while (1) ! 2444: { ! 2445: if (TREE_CODE (exp) == COMPONENT_REF) ! 2446: { ! 2447: tree field = TREE_OPERAND (exp, 1); ! 2448: ! 2449: if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST) ! 2450: /* ??? This case remains to be written. */ ! 2451: abort (); ! 2452: ! 2453: *pbitpos += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)); ! 2454: if (TREE_THIS_VOLATILE (exp)) ! 2455: *pvolatilep = 1; ! 2456: } ! 2457: else if (TREE_CODE (exp) == BIT_FIELD_REF) ! 2458: { ! 2459: if (TREE_CODE (TREE_OPERAND (exp, 2)) != INTEGER_CST) ! 2460: /* ??? This case remains to be written. */ ! 2461: abort (); ! 2462: ! 2463: *pbitpos += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2)); ! 2464: if (TREE_THIS_VOLATILE (exp)) ! 2465: *pvolatilep = 1; ! 2466: } ! 2467: else if (TREE_CODE (exp) == ARRAY_REF ! 2468: && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST ! 2469: && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST) ! 2470: { ! 2471: *pbitpos += (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) ! 2472: * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))); ! 2473: if (TREE_THIS_VOLATILE (exp)) ! 2474: *pvolatilep = 1; ! 2475: } ! 2476: else if (TREE_CODE (exp) != NON_LVALUE_EXPR ! 2477: && ! ((TREE_CODE (exp) == NOP_EXPR ! 2478: || TREE_CODE (exp) == CONVERT_EXPR) ! 2479: && (TYPE_MODE (TREE_TYPE (exp)) ! 2480: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))) ! 2481: break; ! 2482: exp = TREE_OPERAND (exp, 0); ! 2483: } ! 2484: ! 2485: /* If this was a bit-field, see if there is a mode that allows direct ! 2486: access in case EXP is in memory. */ ! 2487: if (mode == VOIDmode && *pbitpos % *pbitsize == 0) ! 2488: { ! 2489: mode = mode_for_size (*pbitsize, MODE_INT, 0); ! 2490: if (mode == BLKmode) ! 2491: mode = VOIDmode; ! 2492: } ! 2493: ! 2494: *pmode = mode; ! 2495: ! 2496: return exp; ! 2497: } ! 2498: ! 2499: /* Given an rtx VALUE that may contain additions and multiplications, ! 2500: return an equivalent value that just refers to a register or memory. ! 2501: This is done by generating instructions to perform the arithmetic ! 2502: and returning a pseudo-register containing the value. */ ! 2503: ! 2504: rtx ! 2505: force_operand (value, target) ! 2506: rtx value, target; ! 2507: { ! 2508: register optab binoptab = 0; ! 2509: /* Use a temporary to force order of execution of calls to ! 2510: `force_operand'. */ ! 2511: rtx tmp; ! 2512: register rtx op2; ! 2513: /* Use subtarget as the target for operand 0 of a binary operation. */ ! 2514: register rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0); ! 2515: ! 2516: if (GET_CODE (value) == PLUS) ! 2517: binoptab = add_optab; ! 2518: else if (GET_CODE (value) == MINUS) ! 2519: binoptab = sub_optab; ! 2520: else if (GET_CODE (value) == MULT) ! 2521: { ! 2522: op2 = XEXP (value, 1); ! 2523: if (!CONSTANT_P (op2) ! 2524: && !(GET_CODE (op2) == REG && op2 != subtarget)) ! 2525: subtarget = 0; ! 2526: tmp = force_operand (XEXP (value, 0), subtarget); ! 2527: return expand_mult (GET_MODE (value), tmp, ! 2528: force_operand (op2, 0), ! 2529: target, 0); ! 2530: } ! 2531: ! 2532: if (binoptab) ! 2533: { ! 2534: op2 = XEXP (value, 1); ! 2535: if (!CONSTANT_P (op2) ! 2536: && !(GET_CODE (op2) == REG && op2 != subtarget)) ! 2537: subtarget = 0; ! 2538: if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT) ! 2539: { ! 2540: binoptab = add_optab; ! 2541: op2 = negate_rtx (GET_MODE (value), op2); ! 2542: } ! 2543: ! 2544: /* Check for an addition with OP2 a constant integer and our first ! 2545: operand a PLUS of a virtual register and something else. In that ! 2546: case, we want to emit the sum of the virtual register and the ! 2547: constant first and then add the other value. This allows virtual ! 2548: register instantiation to simply modify the constant rather than ! 2549: creating another one around this addition. */ ! 2550: if (binoptab == add_optab && GET_CODE (op2) == CONST_INT ! 2551: && GET_CODE (XEXP (value, 0)) == PLUS ! 2552: && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG ! 2553: && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER ! 2554: && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER) ! 2555: { ! 2556: rtx temp = expand_binop (GET_MODE (value), binoptab, ! 2557: XEXP (XEXP (value, 0), 0), op2, ! 2558: subtarget, 0, OPTAB_LIB_WIDEN); ! 2559: return expand_binop (GET_MODE (value), binoptab, temp, ! 2560: force_operand (XEXP (XEXP (value, 0), 1), 0), ! 2561: target, 0, OPTAB_LIB_WIDEN); ! 2562: } ! 2563: ! 2564: tmp = force_operand (XEXP (value, 0), subtarget); ! 2565: return expand_binop (GET_MODE (value), binoptab, tmp, ! 2566: force_operand (op2, 0), ! 2567: target, 0, OPTAB_LIB_WIDEN); ! 2568: /* We give UNSIGNEP = 0 to expand_binop ! 2569: because the only operations we are expanding here are signed ones. */ ! 2570: } ! 2571: return value; ! 2572: } ! 2573: ! 2574: /* Subroutine of expand_expr: ! 2575: save the non-copied parts (LIST) of an expr (LHS), and return a list ! 2576: which can restore these values to their previous values, ! 2577: should something modify their storage. */ ! 2578: ! 2579: static tree ! 2580: save_noncopied_parts (lhs, list) ! 2581: tree lhs; ! 2582: tree list; ! 2583: { ! 2584: tree tail; ! 2585: tree parts = 0; ! 2586: ! 2587: for (tail = list; tail; tail = TREE_CHAIN (tail)) ! 2588: if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST) ! 2589: parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail))); ! 2590: else ! 2591: { ! 2592: tree part = TREE_VALUE (tail); ! 2593: tree part_type = TREE_TYPE (part); ! 2594: tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part, 0); ! 2595: rtx target = assign_stack_temp (TYPE_MODE (part_type), ! 2596: int_size_in_bytes (part_type), 0); ! 2597: if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0))) ! 2598: target = change_address (target, TYPE_MODE (part_type), 0); ! 2599: parts = tree_cons (to_be_saved, ! 2600: build (RTL_EXPR, part_type, 0, (tree) target), ! 2601: parts); ! 2602: store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0); ! 2603: } ! 2604: return parts; ! 2605: } ! 2606: ! 2607: /* Subroutine of expand_expr: ! 2608: record the non-copied parts (LIST) of an expr (LHS), and return a list ! 2609: which specifies the initial values of these parts. */ ! 2610: ! 2611: static tree ! 2612: init_noncopied_parts (lhs, list) ! 2613: tree lhs; ! 2614: tree list; ! 2615: { ! 2616: tree tail; ! 2617: tree parts = 0; ! 2618: ! 2619: for (tail = list; tail; tail = TREE_CHAIN (tail)) ! 2620: if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST) ! 2621: parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail))); ! 2622: else ! 2623: { ! 2624: tree part = TREE_VALUE (tail); ! 2625: tree part_type = TREE_TYPE (part); ! 2626: tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part, 0); ! 2627: parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts); ! 2628: } ! 2629: return parts; ! 2630: } ! 2631: ! 2632: /* Subroutine of expand_expr: return nonzero iff there is no way that ! 2633: EXP can reference X, which is being modified. */ ! 2634: ! 2635: static int ! 2636: safe_from_p (x, exp) ! 2637: rtx x; ! 2638: tree exp; ! 2639: { ! 2640: rtx exp_rtl = 0; ! 2641: int i, nops; ! 2642: ! 2643: if (x == 0) ! 2644: return 1; ! 2645: ! 2646: /* If this is a subreg of a hard register, declare it unsafe, otherwise, ! 2647: find the underlying pseudo. */ ! 2648: if (GET_CODE (x) == SUBREG) ! 2649: { ! 2650: x = SUBREG_REG (x); ! 2651: if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER) ! 2652: return 0; ! 2653: } ! 2654: ! 2655: /* If X is a location in the outgoing argument area, it is always safe. */ ! 2656: if (GET_CODE (x) == MEM ! 2657: && (XEXP (x, 0) == virtual_outgoing_args_rtx ! 2658: || (GET_CODE (XEXP (x, 0)) == PLUS ! 2659: && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))) ! 2660: return 1; ! 2661: ! 2662: switch (TREE_CODE_CLASS (TREE_CODE (exp))) ! 2663: { ! 2664: case 'd': ! 2665: exp_rtl = DECL_RTL (exp); ! 2666: break; ! 2667: ! 2668: case 'c': ! 2669: return 1; ! 2670: ! 2671: case 'x': ! 2672: if (TREE_CODE (exp) == TREE_LIST) ! 2673: return (safe_from_p (x, TREE_VALUE (exp)) ! 2674: && (TREE_CHAIN (exp) == 0 ! 2675: || safe_from_p (x, TREE_CHAIN (exp)))); ! 2676: else ! 2677: return 0; ! 2678: ! 2679: case '1': ! 2680: return safe_from_p (x, TREE_OPERAND (exp, 0)); ! 2681: ! 2682: case '2': ! 2683: case '<': ! 2684: return (safe_from_p (x, TREE_OPERAND (exp, 0)) ! 2685: && safe_from_p (x, TREE_OPERAND (exp, 1))); ! 2686: ! 2687: case 'e': ! 2688: case 'r': ! 2689: /* Now do code-specific tests. EXP_RTL is set to any rtx we find in ! 2690: the expression. If it is set, we conflict iff we are that rtx or ! 2691: both are in memory. Otherwise, we check all operands of the ! 2692: expression recursively. */ ! 2693: ! 2694: switch (TREE_CODE (exp)) ! 2695: { ! 2696: case ADDR_EXPR: ! 2697: return staticp (TREE_OPERAND (exp, 0)); ! 2698: ! 2699: case INDIRECT_REF: ! 2700: if (GET_CODE (x) == MEM) ! 2701: return 0; ! 2702: break; ! 2703: ! 2704: case CALL_EXPR: ! 2705: exp_rtl = CALL_EXPR_RTL (exp); ! 2706: if (exp_rtl == 0) ! 2707: { ! 2708: /* Assume that the call will clobber all hard registers and ! 2709: all of memory. */ ! 2710: if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER) ! 2711: || GET_CODE (x) == MEM) ! 2712: return 0; ! 2713: } ! 2714: ! 2715: break; ! 2716: ! 2717: case RTL_EXPR: ! 2718: exp_rtl = RTL_EXPR_RTL (exp); ! 2719: if (exp_rtl == 0) ! 2720: /* We don't know what this can modify. */ ! 2721: return 0; ! 2722: ! 2723: break; ! 2724: ! 2725: case WITH_CLEANUP_EXPR: ! 2726: exp_rtl = RTL_EXPR_RTL (exp); ! 2727: break; ! 2728: ! 2729: case SAVE_EXPR: ! 2730: exp_rtl = SAVE_EXPR_RTL (exp); ! 2731: break; ! 2732: ! 2733: case METHOD_CALL_EXPR: ! 2734: /* This takes a rtx argument, but shouldn't appear here. */ ! 2735: abort (); ! 2736: } ! 2737: ! 2738: /* If we have an rtx, we do not need to scan our operands. */ ! 2739: if (exp_rtl) ! 2740: break; ! 2741: ! 2742: nops = tree_code_length[(int) TREE_CODE (exp)]; ! 2743: for (i = 0; i < nops; i++) ! 2744: if (TREE_OPERAND (exp, i) != 0 ! 2745: && ! safe_from_p (x, TREE_OPERAND (exp, i))) ! 2746: return 0; ! 2747: } ! 2748: ! 2749: /* If we have an rtl, find any enclosed object. Then see if we conflict ! 2750: with it. */ ! 2751: if (exp_rtl) ! 2752: { ! 2753: if (GET_CODE (exp_rtl) == SUBREG) ! 2754: { ! 2755: exp_rtl = SUBREG_REG (exp_rtl); ! 2756: if (GET_CODE (exp_rtl) == REG ! 2757: && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER) ! 2758: return 0; ! 2759: } ! 2760: ! 2761: /* If the rtl is X, then it is not safe. Otherwise, it is unless both ! 2762: are memory and EXP is not readonly. */ ! 2763: return ! (rtx_equal_p (x, exp_rtl) ! 2764: || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM ! 2765: && ! TREE_READONLY (exp))); ! 2766: } ! 2767: ! 2768: /* If we reach here, it is safe. */ ! 2769: return 1; ! 2770: } ! 2771: ! 2772: /* Subroutine of expand_expr: return nonzero iff EXP is an ! 2773: expression whose type is statically determinable. */ ! 2774: ! 2775: static int ! 2776: fixed_type_p (exp) ! 2777: tree exp; ! 2778: { ! 2779: if (TREE_CODE (exp) == PARM_DECL ! 2780: || TREE_CODE (exp) == VAR_DECL ! 2781: || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR ! 2782: || TREE_CODE (exp) == COMPONENT_REF ! 2783: || TREE_CODE (exp) == ARRAY_REF) ! 2784: return 1; ! 2785: return 0; ! 2786: } ! 2787: ! 2788: /* expand_expr: generate code for computing expression EXP. ! 2789: An rtx for the computed value is returned. The value is never null. ! 2790: In the case of a void EXP, const0_rtx is returned. ! 2791: ! 2792: The value may be stored in TARGET if TARGET is nonzero. ! 2793: TARGET is just a suggestion; callers must assume that ! 2794: the rtx returned may not be the same as TARGET. ! 2795: ! 2796: If TARGET is CONST0_RTX, it means that the value will be ignored. ! 2797: ! 2798: If TMODE is not VOIDmode, it suggests generating the ! 2799: result in mode TMODE. But this is done only when convenient. ! 2800: Otherwise, TMODE is ignored and the value generated in its natural mode. ! 2801: TMODE is just a suggestion; callers must assume that ! 2802: the rtx returned may not have mode TMODE. ! 2803: ! 2804: EXPAND_CONST_ADDRESS says that it is okay to return a MEM ! 2805: with a constant address even if that address is not normally legitimate. ! 2806: EXPAND_INITIALIZER and EXPAND_SUM also have this effect. ! 2807: ! 2808: If MODIFIER is EXPAND_SUM then when EXP is an addition ! 2809: we can return an rtx of the form (MULT (REG ...) (CONST_INT ...)) ! 2810: or a nest of (PLUS ...) and (MINUS ...) where the terms are ! 2811: products as above, or REG or MEM, or constant. ! 2812: Ordinarily in such cases we would output mul or add instructions ! 2813: and then return a pseudo reg containing the sum. ! 2814: ! 2815: EXPAND_INITIALIZER is much like EXPAND_SUM except that ! 2816: it also marks a label as absolutely required (it can't be dead). ! 2817: This is used for outputting expressions used in intializers. */ ! 2818: ! 2819: rtx ! 2820: expand_expr (exp, target, tmode, modifier) ! 2821: register tree exp; ! 2822: rtx target; ! 2823: enum machine_mode tmode; ! 2824: enum expand_modifier modifier; ! 2825: { ! 2826: register rtx op0, op1, temp; ! 2827: tree type = TREE_TYPE (exp); ! 2828: int unsignedp = TREE_UNSIGNED (type); ! 2829: register enum machine_mode mode = TYPE_MODE (type); ! 2830: register enum tree_code code = TREE_CODE (exp); ! 2831: optab this_optab; ! 2832: /* Use subtarget as the target for operand 0 of a binary operation. */ ! 2833: rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0); ! 2834: rtx original_target = target; ! 2835: int ignore = target == const0_rtx; ! 2836: tree context; ! 2837: ! 2838: /* Don't use hard regs as subtargets, because the combiner ! 2839: can only handle pseudo regs. */ ! 2840: if (subtarget && REGNO (subtarget) < FIRST_PSEUDO_REGISTER) ! 2841: subtarget = 0; ! 2842: /* Avoid subtargets inside loops, ! 2843: since they hide some invariant expressions. */ ! 2844: if (preserve_subexpressions_p ()) ! 2845: subtarget = 0; ! 2846: ! 2847: if (ignore) target = 0, original_target = 0; ! 2848: ! 2849: /* If will do cse, generate all results into pseudo registers ! 2850: since 1) that allows cse to find more things ! 2851: and 2) otherwise cse could produce an insn the machine ! 2852: cannot support. */ ! 2853: ! 2854: if (! cse_not_expected && mode != BLKmode && target ! 2855: && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER)) ! 2856: target = subtarget; ! 2857: ! 2858: /* Ensure we reference a volatile object even if value is ignored. */ ! 2859: if (ignore && TREE_THIS_VOLATILE (exp) ! 2860: && mode != VOIDmode && mode != BLKmode) ! 2861: { ! 2862: target = gen_reg_rtx (mode); ! 2863: temp = expand_expr (exp, target, VOIDmode, modifier); ! 2864: if (temp != target) ! 2865: emit_move_insn (target, temp); ! 2866: return target; ! 2867: } ! 2868: ! 2869: switch (code) ! 2870: { ! 2871: case LABEL_DECL: ! 2872: if (modifier == EXPAND_INITIALIZER) ! 2873: forced_labels = gen_rtx (EXPR_LIST, VOIDmode, ! 2874: label_rtx (exp), forced_labels); ! 2875: return gen_rtx (MEM, FUNCTION_MODE, ! 2876: gen_rtx (LABEL_REF, Pmode, label_rtx (exp))); ! 2877: ! 2878: case PARM_DECL: ! 2879: if (DECL_RTL (exp) == 0) ! 2880: { ! 2881: error_with_decl (exp, "prior parameter's size depends on `%s'"); ! 2882: return const0_rtx; ! 2883: } ! 2884: ! 2885: case FUNCTION_DECL: ! 2886: case VAR_DECL: ! 2887: case RESULT_DECL: ! 2888: if (DECL_RTL (exp) == 0) ! 2889: abort (); ! 2890: /* Ensure variable marked as used ! 2891: even if it doesn't go through a parser. */ ! 2892: TREE_USED (exp) = 1; ! 2893: /* Handle variables inherited from containing functions. */ ! 2894: context = decl_function_context (exp); ! 2895: ! 2896: /* We treat inline_function_decl as an alias for the current function ! 2897: because that is the inline function whose vars, types, etc. ! 2898: are being merged into the current function. ! 2899: See expand_inline_function. */ ! 2900: if (context != 0 && context != current_function_decl ! 2901: && context != inline_function_decl ! 2902: /* If var is static, we don't need a static chain to access it. */ ! 2903: && ! (GET_CODE (DECL_RTL (exp)) == MEM ! 2904: && CONSTANT_P (XEXP (DECL_RTL (exp), 0)))) ! 2905: { ! 2906: rtx addr; ! 2907: ! 2908: /* Mark as non-local and addressable. */ ! 2909: TREE_NONLOCAL (exp) = 1; ! 2910: mark_addressable (exp); ! 2911: if (GET_CODE (DECL_RTL (exp)) != MEM) ! 2912: abort (); ! 2913: addr = XEXP (DECL_RTL (exp), 0); ! 2914: if (GET_CODE (addr) == MEM) ! 2915: addr = gen_rtx (MEM, Pmode, fix_lexical_addr (XEXP (addr, 0), exp)); ! 2916: else ! 2917: addr = fix_lexical_addr (addr, exp); ! 2918: return change_address (DECL_RTL (exp), mode, addr); ! 2919: } ! 2920: /* This is the case of an array whose size is to be determined ! 2921: from its initializer, while the initializer is still being parsed. ! 2922: See expand_decl. */ ! 2923: if (GET_CODE (DECL_RTL (exp)) == MEM ! 2924: && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG) ! 2925: return change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)), ! 2926: XEXP (DECL_RTL (exp), 0)); ! 2927: if (GET_CODE (DECL_RTL (exp)) == MEM ! 2928: && modifier != EXPAND_CONST_ADDRESS ! 2929: && modifier != EXPAND_SUM ! 2930: && modifier != EXPAND_INITIALIZER) ! 2931: { ! 2932: /* DECL_RTL probably contains a constant address. ! 2933: On RISC machines where a constant address isn't valid, ! 2934: make some insns to get that address into a register. */ ! 2935: if (!memory_address_p (DECL_MODE (exp), XEXP (DECL_RTL (exp), 0)) ! 2936: || (flag_force_addr ! 2937: && CONSTANT_ADDRESS_P (XEXP (DECL_RTL (exp), 0)))) ! 2938: return change_address (DECL_RTL (exp), VOIDmode, ! 2939: copy_rtx (XEXP (DECL_RTL (exp), 0))); ! 2940: } ! 2941: return DECL_RTL (exp); ! 2942: ! 2943: case INTEGER_CST: ! 2944: return immed_double_const (TREE_INT_CST_LOW (exp), ! 2945: TREE_INT_CST_HIGH (exp), ! 2946: mode); ! 2947: ! 2948: case CONST_DECL: ! 2949: return expand_expr (DECL_INITIAL (exp), target, VOIDmode, 0); ! 2950: ! 2951: case REAL_CST: ! 2952: /* If optimized, generate immediate CONST_DOUBLE ! 2953: which will be turned into memory by reload if necessary. ! 2954: ! 2955: We used to force a register so that loop.c could see it. But ! 2956: this does not allow gen_* patterns to perform optimizations with ! 2957: the constants. It also produces two insns in cases like "x = 1.0;". ! 2958: On most machines, floating-point constants are not permitted in ! 2959: many insns, so we'd end up copying it to a register in any case. ! 2960: ! 2961: Now, we do the copying in expand_binop, if appropriate. */ ! 2962: return immed_real_const (exp); ! 2963: ! 2964: case COMPLEX_CST: ! 2965: case STRING_CST: ! 2966: if (! TREE_CST_RTL (exp)) ! 2967: output_constant_def (exp); ! 2968: ! 2969: /* TREE_CST_RTL probably contains a constant address. ! 2970: On RISC machines where a constant address isn't valid, ! 2971: make some insns to get that address into a register. */ ! 2972: if (GET_CODE (TREE_CST_RTL (exp)) == MEM ! 2973: && modifier != EXPAND_CONST_ADDRESS ! 2974: && modifier != EXPAND_INITIALIZER ! 2975: && modifier != EXPAND_SUM ! 2976: && !memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))) ! 2977: return change_address (TREE_CST_RTL (exp), VOIDmode, ! 2978: copy_rtx (XEXP (TREE_CST_RTL (exp), 0))); ! 2979: return TREE_CST_RTL (exp); ! 2980: ! 2981: case SAVE_EXPR: ! 2982: context = decl_function_context (exp); ! 2983: /* We treat inline_function_decl as an alias for the current function ! 2984: because that is the inline function whose vars, types, etc. ! 2985: are being merged into the current function. ! 2986: See expand_inline_function. */ ! 2987: if (context == current_function_decl || context == inline_function_decl) ! 2988: context = 0; ! 2989: ! 2990: /* If this is non-local, handle it. */ ! 2991: if (context) ! 2992: { ! 2993: temp = SAVE_EXPR_RTL (exp); ! 2994: if (temp && GET_CODE (temp) == REG) ! 2995: { ! 2996: put_var_into_stack (exp); ! 2997: temp = SAVE_EXPR_RTL (exp); ! 2998: } ! 2999: if (temp == 0 || GET_CODE (temp) != MEM) ! 3000: abort (); ! 3001: return change_address (temp, mode, ! 3002: fix_lexical_addr (XEXP (temp, 0), exp)); ! 3003: } ! 3004: if (SAVE_EXPR_RTL (exp) == 0) ! 3005: { ! 3006: if (mode == BLKmode) ! 3007: temp ! 3008: = assign_stack_temp (mode, ! 3009: int_size_in_bytes (TREE_TYPE (exp)), 0); ! 3010: else ! 3011: temp = gen_reg_rtx (mode); ! 3012: SAVE_EXPR_RTL (exp) = temp; ! 3013: store_expr (TREE_OPERAND (exp, 0), temp, 0); ! 3014: if (!optimize && GET_CODE (temp) == REG) ! 3015: save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, temp, ! 3016: save_expr_regs); ! 3017: } ! 3018: return SAVE_EXPR_RTL (exp); ! 3019: ! 3020: case EXIT_EXPR: ! 3021: /* Exit the current loop if the body-expression is true. */ ! 3022: { ! 3023: rtx label = gen_label_rtx (); ! 3024: do_jump (TREE_OPERAND (exp, 0), label, 0); ! 3025: expand_exit_loop (0); ! 3026: emit_label (label); ! 3027: } ! 3028: return const0_rtx; ! 3029: ! 3030: case LOOP_EXPR: ! 3031: expand_start_loop (1); ! 3032: expand_expr_stmt (TREE_OPERAND (exp, 0)); ! 3033: expand_end_loop (); ! 3034: ! 3035: return const0_rtx; ! 3036: ! 3037: case BIND_EXPR: ! 3038: { ! 3039: tree vars = TREE_OPERAND (exp, 0); ! 3040: int vars_need_expansion = 0; ! 3041: ! 3042: /* Need to open a binding contour here because ! 3043: if there are any cleanups they most be contained here. */ ! 3044: expand_start_bindings (0); ! 3045: ! 3046: /* Mark the corresponding BLOCK for output. */ ! 3047: if (TREE_OPERAND (exp, 2) != 0) ! 3048: TREE_USED (TREE_OPERAND (exp, 2)) = 1; ! 3049: ! 3050: /* If VARS have not yet been expanded, expand them now. */ ! 3051: while (vars) ! 3052: { ! 3053: if (DECL_RTL (vars) == 0) ! 3054: { ! 3055: vars_need_expansion = 1; ! 3056: expand_decl (vars); ! 3057: } ! 3058: expand_decl_init (vars); ! 3059: vars = TREE_CHAIN (vars); ! 3060: } ! 3061: ! 3062: temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, modifier); ! 3063: ! 3064: expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0); ! 3065: ! 3066: return temp; ! 3067: } ! 3068: ! 3069: case RTL_EXPR: ! 3070: if (RTL_EXPR_SEQUENCE (exp) == const0_rtx) ! 3071: abort (); ! 3072: emit_insns (RTL_EXPR_SEQUENCE (exp)); ! 3073: RTL_EXPR_SEQUENCE (exp) = const0_rtx; ! 3074: return RTL_EXPR_RTL (exp); ! 3075: ! 3076: case CONSTRUCTOR: ! 3077: /* All elts simple constants => refer to a constant in memory. */ ! 3078: if (TREE_STATIC (exp)) ! 3079: /* For aggregate types with non-BLKmode modes, ! 3080: this should ideally construct a CONST_INT. */ ! 3081: { ! 3082: rtx constructor = output_constant_def (exp); ! 3083: if (! memory_address_p (GET_MODE (constructor), ! 3084: XEXP (constructor, 0))) ! 3085: constructor = change_address (constructor, VOIDmode, ! 3086: XEXP (constructor, 0)); ! 3087: return constructor; ! 3088: } ! 3089: ! 3090: if (ignore) ! 3091: { ! 3092: tree elt; ! 3093: for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt)) ! 3094: expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode, 0); ! 3095: return const0_rtx; ! 3096: } ! 3097: else ! 3098: { ! 3099: if (target == 0 || ! safe_from_p (target, exp)) ! 3100: { ! 3101: if (mode != BLKmode && ! TREE_ADDRESSABLE (exp)) ! 3102: target = gen_reg_rtx (mode); ! 3103: else ! 3104: { ! 3105: rtx safe_target = assign_stack_temp (mode, int_size_in_bytes (type), 0); ! 3106: if (target) ! 3107: MEM_IN_STRUCT_P (safe_target) = MEM_IN_STRUCT_P (target); ! 3108: target = safe_target; ! 3109: } ! 3110: } ! 3111: store_constructor (exp, target); ! 3112: return target; ! 3113: } ! 3114: ! 3115: case INDIRECT_REF: ! 3116: { ! 3117: tree exp1 = TREE_OPERAND (exp, 0); ! 3118: tree exp2; ! 3119: ! 3120: /* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated ! 3121: for *PTR += ANYTHING where PTR is put inside the SAVE_EXPR. ! 3122: This code has the same general effect as simply doing ! 3123: expand_expr on the save expr, except that the expression PTR ! 3124: is computed for use as a memory address. This means different ! 3125: code, suitable for indexing, may be generated. */ ! 3126: if (TREE_CODE (exp1) == SAVE_EXPR ! 3127: && SAVE_EXPR_RTL (exp1) == 0 ! 3128: && TREE_CODE (exp2 = TREE_OPERAND (exp1, 0)) != ERROR_MARK ! 3129: && TYPE_MODE (TREE_TYPE (exp1)) == Pmode ! 3130: && TYPE_MODE (TREE_TYPE (exp2)) == Pmode) ! 3131: { ! 3132: temp = expand_expr (TREE_OPERAND (exp1, 0), 0, VOIDmode, EXPAND_SUM); ! 3133: op0 = memory_address (mode, temp); ! 3134: op0 = copy_all_regs (op0); ! 3135: SAVE_EXPR_RTL (exp1) = op0; ! 3136: } ! 3137: else ! 3138: { ! 3139: op0 = expand_expr (exp1, 0, VOIDmode, EXPAND_SUM); ! 3140: op0 = memory_address (mode, op0); ! 3141: } ! 3142: } ! 3143: temp = gen_rtx (MEM, mode, op0); ! 3144: /* If address was computed by addition, ! 3145: mark this as an element of an aggregate. */ ! 3146: if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR ! 3147: || (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR ! 3148: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == PLUS_EXPR) ! 3149: || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE ! 3150: || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE ! 3151: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE) ! 3152: MEM_IN_STRUCT_P (temp) = 1; ! 3153: MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) || flag_volatile; ! 3154: #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that ! 3155: a location is accessed through a pointer to const does not mean ! 3156: that the value there can never change. */ ! 3157: RTX_UNCHANGING_P (temp) = TREE_READONLY (exp); ! 3158: #endif ! 3159: return temp; ! 3160: ! 3161: case ARRAY_REF: ! 3162: if (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST ! 3163: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) ! 3164: { ! 3165: /* Nonconstant array index or nonconstant element size. ! 3166: Generate the tree for *(&array+index) and expand that, ! 3167: except do it in a language-independent way ! 3168: and don't complain about non-lvalue arrays. ! 3169: `mark_addressable' should already have been called ! 3170: for any array for which this case will be reached. */ ! 3171: ! 3172: /* Don't forget the const or volatile flag from the array element. */ ! 3173: tree variant_type = build_type_variant (type, ! 3174: TREE_READONLY (exp), ! 3175: TREE_THIS_VOLATILE (exp)); ! 3176: tree array_adr = build1 (ADDR_EXPR, build_pointer_type (variant_type), ! 3177: TREE_OPERAND (exp, 0)); ! 3178: tree index = TREE_OPERAND (exp, 1); ! 3179: tree elt; ! 3180: ! 3181: /* Convert the integer argument to a type the same size as a pointer ! 3182: so the multiply won't overflow spuriously. */ ! 3183: if (TYPE_PRECISION (TREE_TYPE (index)) != POINTER_SIZE) ! 3184: index = convert (type_for_size (POINTER_SIZE, 0), index); ! 3185: ! 3186: /* Don't think the address has side effects ! 3187: just because the array does. ! 3188: (In some cases the address might have side effects, ! 3189: and we fail to record that fact here. However, it should not ! 3190: matter, since expand_expr should not care.) */ ! 3191: TREE_SIDE_EFFECTS (array_adr) = 0; ! 3192: ! 3193: elt = build1 (INDIRECT_REF, type, ! 3194: fold (build (PLUS_EXPR, TYPE_POINTER_TO (variant_type), ! 3195: array_adr, ! 3196: fold (build (MULT_EXPR, ! 3197: TYPE_POINTER_TO (variant_type), ! 3198: index, size_in_bytes (type)))))); ! 3199: ! 3200: /* Volatility, etc., of new expression is same as old expression. */ ! 3201: TREE_SIDE_EFFECTS (elt) = TREE_SIDE_EFFECTS (exp); ! 3202: TREE_THIS_VOLATILE (elt) = TREE_THIS_VOLATILE (exp); ! 3203: TREE_READONLY (elt) = TREE_READONLY (exp); ! 3204: ! 3205: return expand_expr (elt, target, tmode, modifier); ! 3206: } ! 3207: ! 3208: /* Fold an expression like: "foo"[2]. ! 3209: This is not done in fold so it won't happen inside &. */ ! 3210: { ! 3211: int i; ! 3212: tree arg0 = TREE_OPERAND (exp, 0); ! 3213: tree arg1 = TREE_OPERAND (exp, 1); ! 3214: ! 3215: if (TREE_CODE (arg0) == STRING_CST ! 3216: && TREE_CODE (arg1) == INTEGER_CST ! 3217: && !TREE_INT_CST_HIGH (arg1) ! 3218: && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0)) ! 3219: { ! 3220: if (TREE_TYPE (TREE_TYPE (arg0)) == integer_type_node) ! 3221: { ! 3222: exp = build_int_2 (((int *)TREE_STRING_POINTER (arg0))[i], 0); ! 3223: TREE_TYPE (exp) = integer_type_node; ! 3224: return expand_expr (exp, target, tmode, modifier); ! 3225: } ! 3226: if (TREE_TYPE (TREE_TYPE (arg0)) == char_type_node) ! 3227: { ! 3228: exp = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0); ! 3229: TREE_TYPE (exp) = integer_type_node; ! 3230: return expand_expr (convert (TREE_TYPE (TREE_TYPE (arg0)), exp), target, tmode, modifier); ! 3231: } ! 3232: } ! 3233: } ! 3234: ! 3235: /* If this is a constant index into a constant array, ! 3236: just get the value from the array. */ ! 3237: if (TREE_READONLY (TREE_OPERAND (exp, 0)) ! 3238: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)) ! 3239: && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == ARRAY_TYPE ! 3240: && TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL ! 3241: && DECL_INITIAL (TREE_OPERAND (exp, 0)) ! 3242: && TREE_CODE (DECL_INITIAL (TREE_OPERAND (exp, 0))) != ERROR_MARK) ! 3243: { ! 3244: tree index = fold (TREE_OPERAND (exp, 1)); ! 3245: if (TREE_CODE (index) == INTEGER_CST) ! 3246: { ! 3247: int i = TREE_INT_CST_LOW (index); ! 3248: tree init = CONSTRUCTOR_ELTS (DECL_INITIAL (TREE_OPERAND (exp, 0))); ! 3249: ! 3250: while (init && i--) ! 3251: init = TREE_CHAIN (init); ! 3252: if (init) ! 3253: return expand_expr (fold (TREE_VALUE (init)), target, tmode, modifier); ! 3254: } ! 3255: } ! 3256: /* Treat array-ref with constant index as a component-ref. */ ! 3257: ! 3258: case COMPONENT_REF: ! 3259: case BIT_FIELD_REF: ! 3260: { ! 3261: enum machine_mode mode1; ! 3262: int bitsize; ! 3263: int bitpos; ! 3264: int volatilep = 0; ! 3265: tree tem = get_inner_reference (exp, &bitsize, &bitpos, ! 3266: &mode1, &unsignedp, &volatilep); ! 3267: ! 3268: /* In some cases, we will be offsetting OP0's address by a constant. ! 3269: So get it as a sum, if possible. If we will be using it ! 3270: directly in an insn, we validate it. */ ! 3271: op0 = expand_expr (tem, 0, VOIDmode, EXPAND_SUM); ! 3272: ! 3273: /* Don't forget about volatility even if this is a bitfield. */ ! 3274: if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0)) ! 3275: { ! 3276: op0 = copy_rtx (op0); ! 3277: MEM_VOLATILE_P (op0) = 1; ! 3278: } ! 3279: ! 3280: if (mode1 == VOIDmode ! 3281: || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG) ! 3282: { ! 3283: /* In cases where an aligned union has an unaligned object ! 3284: as a field, we might be extracting a BLKmode value from ! 3285: an integer-mode (e.g., SImode) object. Handle this case ! 3286: by doing the extract into an object as wide as the field ! 3287: (which we know to be the width of a basic mode), then ! 3288: storing into memory, and changing the mode to BLKmode. */ ! 3289: enum machine_mode ext_mode = mode; ! 3290: ! 3291: if (ext_mode == BLKmode) ! 3292: ext_mode = mode_for_size (bitsize, MODE_INT, 1); ! 3293: ! 3294: if (ext_mode == BLKmode) ! 3295: abort (); ! 3296: ! 3297: op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos, ! 3298: unsignedp, target, ext_mode, ext_mode, ! 3299: TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT, ! 3300: int_size_in_bytes (TREE_TYPE (tem))); ! 3301: if (mode == BLKmode) ! 3302: { ! 3303: rtx new = assign_stack_temp (ext_mode, ! 3304: bitsize / BITS_PER_UNIT, 0); ! 3305: ! 3306: emit_move_insn (new, op0); ! 3307: op0 = copy_rtx (new); ! 3308: PUT_MODE (op0, BLKmode); ! 3309: } ! 3310: ! 3311: return op0; ! 3312: } ! 3313: ! 3314: /* Get a reference to just this component. */ ! 3315: if (modifier == EXPAND_CONST_ADDRESS ! 3316: || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER) ! 3317: op0 = gen_rtx (MEM, mode1, plus_constant (XEXP (op0, 0), ! 3318: (bitpos / BITS_PER_UNIT))); ! 3319: else ! 3320: op0 = change_address (op0, mode1, ! 3321: plus_constant (XEXP (op0, 0), ! 3322: (bitpos / BITS_PER_UNIT))); ! 3323: MEM_IN_STRUCT_P (op0) = 1; ! 3324: MEM_VOLATILE_P (op0) |= volatilep; ! 3325: if (mode == mode1 || mode1 == BLKmode || mode1 == tmode) ! 3326: return op0; ! 3327: if (target == 0) ! 3328: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode); ! 3329: convert_move (target, op0, unsignedp); ! 3330: return target; ! 3331: } ! 3332: ! 3333: case OFFSET_REF: ! 3334: { ! 3335: tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0); ! 3336: tree addr = build (PLUS_EXPR, type, base, TREE_OPERAND (exp, 1)); ! 3337: op0 = expand_expr (addr, 0, VOIDmode, EXPAND_SUM); ! 3338: temp = gen_rtx (MEM, mode, memory_address (mode, op0)); ! 3339: MEM_IN_STRUCT_P (temp) = 1; ! 3340: MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) || flag_volatile; ! 3341: #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that ! 3342: a location is accessed through a pointer to const does not mean ! 3343: that the value there can never change. */ ! 3344: RTX_UNCHANGING_P (temp) = TREE_READONLY (exp); ! 3345: #endif ! 3346: return temp; ! 3347: } ! 3348: ! 3349: /* Intended for a reference to a buffer of a file-object in Pascal. ! 3350: But it's not certain that a special tree code will really be ! 3351: necessary for these. INDIRECT_REF might work for them. */ ! 3352: case BUFFER_REF: ! 3353: abort (); ! 3354: ! 3355: case WITH_CLEANUP_EXPR: ! 3356: if (RTL_EXPR_RTL (exp) == 0) ! 3357: { ! 3358: RTL_EXPR_RTL (exp) ! 3359: = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier); ! 3360: cleanups_this_call = tree_cons (0, TREE_OPERAND (exp, 2), cleanups_this_call); ! 3361: /* That's it for this cleanup. */ ! 3362: TREE_OPERAND (exp, 2) = 0; ! 3363: } ! 3364: return RTL_EXPR_RTL (exp); ! 3365: ! 3366: case CALL_EXPR: ! 3367: /* Check for a built-in function. */ ! 3368: if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR ! 3369: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == FUNCTION_DECL ! 3370: && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) ! 3371: return expand_builtin (exp, target, subtarget, tmode, ignore); ! 3372: /* If this call was expanded already by preexpand_calls, ! 3373: just return the result we got. */ ! 3374: if (CALL_EXPR_RTL (exp) != 0) ! 3375: return CALL_EXPR_RTL (exp); ! 3376: return expand_call (exp, target, ignore, modifier); ! 3377: ! 3378: case NON_LVALUE_EXPR: ! 3379: case NOP_EXPR: ! 3380: case CONVERT_EXPR: ! 3381: case REFERENCE_EXPR: ! 3382: if (TREE_CODE (type) == VOID_TYPE || ignore) ! 3383: { ! 3384: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier); ! 3385: return const0_rtx; ! 3386: } ! 3387: if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 3388: return expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, modifier); ! 3389: if (TREE_CODE (type) == UNION_TYPE) ! 3390: { ! 3391: tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0)); ! 3392: if (target == 0) ! 3393: { ! 3394: if (mode == BLKmode) ! 3395: { ! 3396: if (TYPE_SIZE (type) == 0 ! 3397: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) ! 3398: abort (); ! 3399: target = assign_stack_temp (BLKmode, ! 3400: (TREE_INT_CST_LOW (TYPE_SIZE (type)) ! 3401: + BITS_PER_UNIT - 1) ! 3402: / BITS_PER_UNIT, 0); ! 3403: } ! 3404: else ! 3405: target = gen_reg_rtx (mode); ! 3406: } ! 3407: if (GET_CODE (target) == MEM) ! 3408: /* Store data into beginning of memory target. */ ! 3409: store_expr (TREE_OPERAND (exp, 0), ! 3410: change_address (target, TYPE_MODE (valtype), 0), 0); ! 3411: else if (GET_CODE (target) == REG) ! 3412: /* Store this field into a union of the proper type. */ ! 3413: store_field (target, GET_MODE_BITSIZE (TYPE_MODE (valtype)), 0, ! 3414: TYPE_MODE (valtype), TREE_OPERAND (exp, 0), ! 3415: VOIDmode, 0, 1, ! 3416: int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)))); ! 3417: else ! 3418: abort (); ! 3419: ! 3420: /* Return the entire union. */ ! 3421: return target; ! 3422: } ! 3423: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, mode, 0); ! 3424: if (GET_MODE (op0) == mode || GET_MODE (op0) == VOIDmode) ! 3425: return op0; ! 3426: if (flag_force_mem && GET_CODE (op0) == MEM) ! 3427: op0 = copy_to_reg (op0); ! 3428: ! 3429: if (target == 0) ! 3430: return convert_to_mode (mode, op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))); ! 3431: else ! 3432: convert_move (target, op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))); ! 3433: return target; ! 3434: ! 3435: case PLUS_EXPR: ! 3436: /* We come here from MINUS_EXPR when the second operand is a constant. */ ! 3437: plus_expr: ! 3438: this_optab = add_optab; ! 3439: ! 3440: /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and ! 3441: something else, make sure we add the register to the constant and ! 3442: then to the other thing. This case can occur during strength ! 3443: reduction and doing it this way will produce better code if the ! 3444: frame pointer or argument pointer is eliminated. ! 3445: ! 3446: fold-const.c will ensure that the constant is always in the inner ! 3447: PLUS_EXPR, so the only case we need to do anything about is if ! 3448: sp, ap, or fp is our second argument, in which case we must swap ! 3449: the innermost first argument and our second argument. */ ! 3450: ! 3451: if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR ! 3452: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST ! 3453: && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR ! 3454: && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx ! 3455: || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx ! 3456: || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx)) ! 3457: { ! 3458: tree t = TREE_OPERAND (exp, 1); ! 3459: ! 3460: TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0); ! 3461: TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t; ! 3462: } ! 3463: ! 3464: /* If the result is to be Pmode and we are adding an integer to ! 3465: something, we might be forming a constant. So try to use ! 3466: plus_constant. If it produces a sum and we can't accept it, ! 3467: use force_operand. This allows P = &ARR[const] to generate ! 3468: efficient code on machines where a SYMBOL_REF is not a valid ! 3469: address. ! 3470: ! 3471: If this is an EXPAND_SUM call, always return the sum. */ ! 3472: if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST ! 3473: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT ! 3474: && (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER ! 3475: || mode == Pmode)) ! 3476: { ! 3477: op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode, ! 3478: EXPAND_SUM); ! 3479: op1 = plus_constant (op1, TREE_INT_CST_LOW (TREE_OPERAND (exp, 0))); ! 3480: if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER) ! 3481: op1 = force_operand (op1, target); ! 3482: return op1; ! 3483: } ! 3484: ! 3485: else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST ! 3486: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT ! 3487: && (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER ! 3488: || mode == Pmode)) ! 3489: { ! 3490: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, ! 3491: EXPAND_SUM); ! 3492: op0 = plus_constant (op0, TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))); ! 3493: if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER) ! 3494: op0 = force_operand (op0, target); ! 3495: return op0; ! 3496: } ! 3497: ! 3498: /* No sense saving up arithmetic to be done ! 3499: if it's all in the wrong mode to form part of an address. ! 3500: And force_operand won't know whether to sign-extend or ! 3501: zero-extend. */ ! 3502: if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER) ! 3503: || mode != Pmode) goto binop; ! 3504: ! 3505: preexpand_calls (exp); ! 3506: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 3507: subtarget = 0; ! 3508: ! 3509: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, modifier); ! 3510: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, modifier); ! 3511: /* Put a sum last, to simplify what follows. */ ! 3512: #ifdef OLD_INDEXING ! 3513: if (GET_CODE (op1) == MULT) ! 3514: { ! 3515: temp = op0; ! 3516: op0 = op1; ! 3517: op1 = temp; ! 3518: } ! 3519: #endif ! 3520: #ifndef OLD_INDEXING ! 3521: /* Make sure any term that's a sum with a constant comes last. */ ! 3522: if (GET_CODE (op0) == PLUS ! 3523: && CONSTANT_P (XEXP (op0, 1))) ! 3524: { ! 3525: temp = op0; ! 3526: op0 = op1; ! 3527: op1 = temp; ! 3528: } ! 3529: /* If adding to a sum including a constant, ! 3530: associate it to put the constant outside. */ ! 3531: if (GET_CODE (op1) == PLUS ! 3532: && CONSTANT_P (XEXP (op1, 1))) ! 3533: { ! 3534: rtx tem; ! 3535: int constant_term = 0; ! 3536: ! 3537: op0 = gen_rtx (PLUS, mode, XEXP (op1, 0), op0); ! 3538: /* Let's also eliminate constants from op0 if possible. */ ! 3539: tem = eliminate_constant_term (op0, &constant_term); ! 3540: if (GET_CODE (XEXP (op1, 1)) == CONST_INT) ! 3541: { ! 3542: if (constant_term != 0) ! 3543: return plus_constant (tem, INTVAL (XEXP (op1, 1)) + constant_term); ! 3544: else ! 3545: return plus_constant (op0, INTVAL (XEXP (op1, 1))); ! 3546: } ! 3547: else ! 3548: return gen_rtx (PLUS, mode, op0, XEXP (op1, 1)); ! 3549: } ! 3550: #endif ! 3551: /* Put a constant term last. */ ! 3552: if (CONSTANT_P (op0)) ! 3553: return gen_rtx (PLUS, mode, op1, op0); ! 3554: else ! 3555: return gen_rtx (PLUS, mode, op0, op1); ! 3556: ! 3557: case MINUS_EXPR: ! 3558: /* Handle difference of two symbolic constants, ! 3559: for the sake of an initializer. */ ! 3560: if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER) ! 3561: && really_constant_p (TREE_OPERAND (exp, 0)) ! 3562: && really_constant_p (TREE_OPERAND (exp, 1))) ! 3563: { ! 3564: rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, modifier); ! 3565: rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, modifier); ! 3566: return gen_rtx (MINUS, mode, op0, op1); ! 3567: } ! 3568: /* Convert A - const to A + (-const). */ ! 3569: if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST) ! 3570: { ! 3571: exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), ! 3572: fold (build1 (NEGATE_EXPR, type, ! 3573: TREE_OPERAND (exp, 1)))); ! 3574: goto plus_expr; ! 3575: } ! 3576: this_optab = sub_optab; ! 3577: goto binop; ! 3578: ! 3579: case MULT_EXPR: ! 3580: preexpand_calls (exp); ! 3581: /* If first operand is constant, swap them. ! 3582: Thus the following special case checks need only ! 3583: check the second operand. */ ! 3584: if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST) ! 3585: { ! 3586: register tree t1 = TREE_OPERAND (exp, 0); ! 3587: TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1); ! 3588: TREE_OPERAND (exp, 1) = t1; ! 3589: } ! 3590: ! 3591: /* Attempt to return something suitable for generating an ! 3592: indexed address, for machines that support that. */ ! 3593: ! 3594: if (modifier == EXPAND_SUM && mode == Pmode ! 3595: && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST ! 3596: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT) ! 3597: { ! 3598: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, EXPAND_SUM); ! 3599: ! 3600: /* Apply distributive law if OP0 is x+c. */ ! 3601: if (GET_CODE (op0) == PLUS ! 3602: && GET_CODE (XEXP (op0, 1)) == CONST_INT) ! 3603: return gen_rtx (PLUS, mode, ! 3604: gen_rtx (MULT, mode, XEXP (op0, 0), ! 3605: gen_rtx (CONST_INT, VOIDmode, ! 3606: TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))), ! 3607: gen_rtx (CONST_INT, VOIDmode, ! 3608: (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) ! 3609: * INTVAL (XEXP (op0, 1))))); ! 3610: ! 3611: if (GET_CODE (op0) != REG) ! 3612: op0 = force_operand (op0, 0); ! 3613: if (GET_CODE (op0) != REG) ! 3614: op0 = copy_to_mode_reg (mode, op0); ! 3615: ! 3616: return gen_rtx (MULT, mode, op0, ! 3617: gen_rtx (CONST_INT, VOIDmode, ! 3618: TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))); ! 3619: } ! 3620: ! 3621: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 3622: subtarget = 0; ! 3623: ! 3624: /* Check for multiplying things that have been extended ! 3625: from a narrower type. If this machine supports multiplying ! 3626: in that narrower type with a result in the desired type, ! 3627: do it that way, and avoid the explicit type-conversion. */ ! 3628: if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR ! 3629: && TREE_CODE (type) == INTEGER_TYPE ! 3630: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) ! 3631: < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 3632: && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST ! 3633: && int_fits_type_p (TREE_OPERAND (exp, 1), ! 3634: TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) ! 3635: /* Don't use a widening multiply if a shift will do. */ ! 3636: && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)))) ! 3637: > HOST_BITS_PER_INT) ! 3638: || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0)) ! 3639: || ! 3640: (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR ! 3641: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))) ! 3642: == ! 3643: TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))) ! 3644: /* If both operands are extended, they must either both ! 3645: be zero-extended or both be sign-extended. */ ! 3646: && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))) ! 3647: == ! 3648: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))))) ! 3649: { ! 3650: enum machine_mode innermode ! 3651: = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))); ! 3652: this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) ! 3653: ? umul_widen_optab : smul_widen_optab); ! 3654: if (mode == GET_MODE_WIDER_MODE (innermode) ! 3655: && this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) ! 3656: { ! 3657: op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0), ! 3658: 0, VOIDmode, 0); ! 3659: if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST) ! 3660: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 3661: else ! 3662: op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0), ! 3663: 0, VOIDmode, 0); ! 3664: goto binop2; ! 3665: } ! 3666: } ! 3667: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3668: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 3669: return expand_mult (mode, op0, op1, target, unsignedp); ! 3670: ! 3671: case TRUNC_DIV_EXPR: ! 3672: case FLOOR_DIV_EXPR: ! 3673: case CEIL_DIV_EXPR: ! 3674: case ROUND_DIV_EXPR: ! 3675: case EXACT_DIV_EXPR: ! 3676: preexpand_calls (exp); ! 3677: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 3678: subtarget = 0; ! 3679: /* Possible optimization: compute the dividend with EXPAND_SUM ! 3680: then if the divisor is constant can optimize the case ! 3681: where some terms of the dividend have coeffs divisible by it. */ ! 3682: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3683: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 3684: return expand_divmod (0, code, mode, op0, op1, target, unsignedp); ! 3685: ! 3686: case RDIV_EXPR: ! 3687: this_optab = flodiv_optab; ! 3688: goto binop; ! 3689: ! 3690: case TRUNC_MOD_EXPR: ! 3691: case FLOOR_MOD_EXPR: ! 3692: case CEIL_MOD_EXPR: ! 3693: case ROUND_MOD_EXPR: ! 3694: preexpand_calls (exp); ! 3695: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 3696: subtarget = 0; ! 3697: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3698: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 3699: return expand_divmod (1, code, mode, op0, op1, target, unsignedp); ! 3700: ! 3701: case FIX_ROUND_EXPR: ! 3702: case FIX_FLOOR_EXPR: ! 3703: case FIX_CEIL_EXPR: ! 3704: abort (); /* Not used for C. */ ! 3705: ! 3706: case FIX_TRUNC_EXPR: ! 3707: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0); ! 3708: if (target == 0) ! 3709: target = gen_reg_rtx (mode); ! 3710: expand_fix (target, op0, unsignedp); ! 3711: return target; ! 3712: ! 3713: case FLOAT_EXPR: ! 3714: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0); ! 3715: if (target == 0) ! 3716: target = gen_reg_rtx (mode); ! 3717: /* expand_float can't figure out what to do if FROM has VOIDmode. ! 3718: So give it the correct mode. With -O, cse will optimize this. */ ! 3719: if (GET_MODE (op0) == VOIDmode) ! 3720: op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))), ! 3721: op0); ! 3722: expand_float (target, op0, ! 3723: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))); ! 3724: return target; ! 3725: ! 3726: case NEGATE_EXPR: ! 3727: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0); ! 3728: temp = expand_unop (mode, neg_optab, op0, target, 0); ! 3729: if (temp == 0) ! 3730: abort (); ! 3731: return temp; ! 3732: ! 3733: case ABS_EXPR: ! 3734: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3735: ! 3736: /* Unsigned abs is simply the operand. Testing here means we don't ! 3737: risk generating incorrect code below. */ ! 3738: if (TREE_UNSIGNED (type)) ! 3739: return op0; ! 3740: ! 3741: /* First try to do it with a special abs instruction. */ ! 3742: temp = expand_unop (mode, abs_optab, op0, target, 0); ! 3743: if (temp != 0) ! 3744: return temp; ! 3745: ! 3746: /* If this machine has expensive jumps, we can do integer absolute ! 3747: value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)), ! 3748: where W is the width of MODE. */ ! 3749: ! 3750: if (GET_MODE_CLASS (mode) == MODE_INT && BRANCH_COST >= 2) ! 3751: { ! 3752: rtx extended = expand_shift (RSHIFT_EXPR, mode, op0, ! 3753: size_int (GET_MODE_BITSIZE (mode) - 1), ! 3754: 0, 0); ! 3755: ! 3756: temp = expand_binop (mode, xor_optab, extended, op0, target, 0, ! 3757: OPTAB_LIB_WIDEN); ! 3758: if (temp != 0) ! 3759: temp = expand_binop (mode, sub_optab, temp, extended, target, 0, ! 3760: OPTAB_LIB_WIDEN); ! 3761: ! 3762: if (temp != 0) ! 3763: return temp; ! 3764: } ! 3765: ! 3766: /* If that does not win, use conditional jump and negate. */ ! 3767: target = original_target; ! 3768: temp = gen_label_rtx (); ! 3769: if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 0)) ! 3770: || (GET_CODE (target) == REG ! 3771: && REGNO (target) < FIRST_PSEUDO_REGISTER)) ! 3772: target = gen_reg_rtx (mode); ! 3773: emit_move_insn (target, op0); ! 3774: emit_cmp_insn (target, ! 3775: expand_expr (convert (type, integer_zero_node), ! 3776: 0, VOIDmode, 0), ! 3777: GE, 0, mode, 0, 0); ! 3778: NO_DEFER_POP; ! 3779: emit_jump_insn (gen_bge (temp)); ! 3780: op0 = expand_unop (mode, neg_optab, target, target, 0); ! 3781: if (op0 != target) ! 3782: emit_move_insn (target, op0); ! 3783: emit_label (temp); ! 3784: OK_DEFER_POP; ! 3785: return target; ! 3786: ! 3787: case MAX_EXPR: ! 3788: case MIN_EXPR: ! 3789: target = original_target; ! 3790: if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1)) ! 3791: || (GET_CODE (target) == REG ! 3792: && REGNO (target) < FIRST_PSEUDO_REGISTER)) ! 3793: target = gen_reg_rtx (mode); ! 3794: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 3795: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0); ! 3796: ! 3797: /* First try to do it with a special MIN or MAX instruction. ! 3798: If that does not win, use a conditional jump to select the proper ! 3799: value. */ ! 3800: this_optab = (TREE_UNSIGNED (type) ! 3801: ? (code == MIN_EXPR ? umin_optab : umax_optab) ! 3802: : (code == MIN_EXPR ? smin_optab : smax_optab)); ! 3803: ! 3804: temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp, ! 3805: OPTAB_WIDEN); ! 3806: if (temp != 0) ! 3807: return temp; ! 3808: ! 3809: if (target != op0) ! 3810: emit_move_insn (target, op0); ! 3811: op0 = gen_label_rtx (); ! 3812: if (code == MAX_EXPR) ! 3813: temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))) ! 3814: ? compare_from_rtx (target, op1, GEU, 1, mode, 0, 0) ! 3815: : compare_from_rtx (target, op1, GE, 0, mode, 0, 0)); ! 3816: else ! 3817: temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))) ! 3818: ? compare_from_rtx (target, op1, LEU, 1, mode, 0, 0) ! 3819: : compare_from_rtx (target, op1, LE, 0, mode, 0, 0)); ! 3820: if (temp == const0_rtx) ! 3821: emit_move_insn (target, op1); ! 3822: else if (temp != const_true_rtx) ! 3823: { ! 3824: if (bcc_gen_fctn[(int) GET_CODE (temp)] != 0) ! 3825: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (temp)]) (op0)); ! 3826: else ! 3827: abort (); ! 3828: emit_move_insn (target, op1); ! 3829: } ! 3830: emit_label (op0); ! 3831: return target; ! 3832: ! 3833: /* ??? Can optimize when the operand of this is a bitwise operation, ! 3834: by using a different bitwise operation. */ ! 3835: case BIT_NOT_EXPR: ! 3836: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3837: temp = expand_unop (mode, one_cmpl_optab, op0, target, 1); ! 3838: if (temp == 0) ! 3839: abort (); ! 3840: return temp; ! 3841: ! 3842: case FFS_EXPR: ! 3843: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3844: temp = expand_unop (mode, ffs_optab, op0, target, 1); ! 3845: if (temp == 0) ! 3846: abort (); ! 3847: return temp; ! 3848: ! 3849: /* ??? Can optimize bitwise operations with one arg constant. ! 3850: Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b) ! 3851: and (a bitwise1 b) bitwise2 b (etc) ! 3852: but that is probably not worth while. */ ! 3853: ! 3854: /* BIT_AND_EXPR is for bitwise anding. ! 3855: TRUTH_AND_EXPR is for anding two boolean values ! 3856: when we want in all cases to compute both of them. ! 3857: In general it is fastest to do TRUTH_AND_EXPR by ! 3858: computing both operands as actual zero-or-1 values ! 3859: and then bitwise anding. In cases where there cannot ! 3860: be any side effects, better code would be made by ! 3861: treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; ! 3862: but the question is how to recognize those cases. */ ! 3863: ! 3864: case TRUTH_AND_EXPR: ! 3865: case BIT_AND_EXPR: ! 3866: this_optab = and_optab; ! 3867: goto binop; ! 3868: ! 3869: /* See comment above about TRUTH_AND_EXPR; it applies here too. */ ! 3870: case TRUTH_OR_EXPR: ! 3871: case BIT_IOR_EXPR: ! 3872: this_optab = ior_optab; ! 3873: goto binop; ! 3874: ! 3875: case BIT_XOR_EXPR: ! 3876: this_optab = xor_optab; ! 3877: goto binop; ! 3878: ! 3879: case LSHIFT_EXPR: ! 3880: case RSHIFT_EXPR: ! 3881: case LROTATE_EXPR: ! 3882: case RROTATE_EXPR: ! 3883: preexpand_calls (exp); ! 3884: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 3885: subtarget = 0; ! 3886: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 3887: return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target, ! 3888: unsignedp); ! 3889: ! 3890: /* Could determine the answer when only additive constants differ. ! 3891: Also, the addition of one can be handled by changing the condition. */ ! 3892: case LT_EXPR: ! 3893: case LE_EXPR: ! 3894: case GT_EXPR: ! 3895: case GE_EXPR: ! 3896: case EQ_EXPR: ! 3897: case NE_EXPR: ! 3898: preexpand_calls (exp); ! 3899: temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0); ! 3900: if (temp != 0) ! 3901: return temp; ! 3902: /* For foo != 0, load foo, and if it is nonzero load 1 instead. */ ! 3903: if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1)) ! 3904: && original_target ! 3905: && GET_CODE (original_target) == REG ! 3906: && (GET_MODE (original_target) ! 3907: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 3908: { ! 3909: temp = expand_expr (TREE_OPERAND (exp, 0), original_target, VOIDmode, 0); ! 3910: if (temp != original_target) ! 3911: temp = copy_to_reg (temp); ! 3912: op1 = gen_label_rtx (); ! 3913: emit_cmp_insn (temp, const0_rtx, EQ, 0, ! 3914: GET_MODE (temp), unsignedp, 0); ! 3915: emit_jump_insn (gen_beq (op1)); ! 3916: emit_move_insn (temp, const1_rtx); ! 3917: emit_label (op1); ! 3918: return temp; ! 3919: } ! 3920: /* If no set-flag instruction, must generate a conditional ! 3921: store into a temporary variable. Drop through ! 3922: and handle this like && and ||. */ ! 3923: ! 3924: case TRUTH_ANDIF_EXPR: ! 3925: case TRUTH_ORIF_EXPR: ! 3926: if (target == 0 || ! safe_from_p (target, exp) ! 3927: /* Make sure we don't have a hard reg (such as function's return ! 3928: value) live across basic blocks, if not optimizing. */ ! 3929: || (!optimize && GET_CODE (target) == REG ! 3930: && REGNO (target) < FIRST_PSEUDO_REGISTER)) ! 3931: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode); ! 3932: emit_clr_insn (target); ! 3933: op1 = gen_label_rtx (); ! 3934: jumpifnot (exp, op1); ! 3935: emit_0_to_1_insn (target); ! 3936: emit_label (op1); ! 3937: return target; ! 3938: ! 3939: case TRUTH_NOT_EXPR: ! 3940: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0); ! 3941: /* The parser is careful to generate TRUTH_NOT_EXPR ! 3942: only with operands that are always zero or one. */ ! 3943: temp = expand_binop (mode, xor_optab, op0, ! 3944: gen_rtx (CONST_INT, mode, 1), ! 3945: target, 1, OPTAB_LIB_WIDEN); ! 3946: if (temp == 0) ! 3947: abort (); ! 3948: return temp; ! 3949: ! 3950: case COMPOUND_EXPR: ! 3951: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0); ! 3952: emit_queue (); ! 3953: return expand_expr (TREE_OPERAND (exp, 1), ! 3954: (ignore ? const0_rtx : target), ! 3955: VOIDmode, 0); ! 3956: ! 3957: case COND_EXPR: ! 3958: { ! 3959: /* Note that COND_EXPRs whose type is a structure or union ! 3960: are required to be constructed to contain assignments of ! 3961: a temporary variable, so that we can evaluate them here ! 3962: for side effect only. If type is void, we must do likewise. */ ! 3963: ! 3964: /* If an arm of the branch requires a cleanup, ! 3965: only that cleanup is performed. */ ! 3966: ! 3967: tree singleton = 0; ! 3968: tree binary_op = 0, unary_op = 0; ! 3969: tree old_cleanups = cleanups_this_call; ! 3970: cleanups_this_call = 0; ! 3971: ! 3972: /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and ! 3973: convert it to our mode, if necessary. */ ! 3974: if (integer_onep (TREE_OPERAND (exp, 1)) ! 3975: && integer_zerop (TREE_OPERAND (exp, 2)) ! 3976: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<') ! 3977: { ! 3978: op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, modifier); ! 3979: if (GET_MODE (op0) == mode) ! 3980: return op0; ! 3981: if (target == 0) ! 3982: target = gen_reg_rtx (mode); ! 3983: convert_move (target, op0, unsignedp); ! 3984: return target; ! 3985: } ! 3986: ! 3987: /* If we are not to produce a result, we have no target. Otherwise, ! 3988: if a target was specified use it; it will not be used as an ! 3989: intermediate target unless it is safe. If no target, use a ! 3990: temporary. */ ! 3991: ! 3992: if (mode == VOIDmode || ignore) ! 3993: temp = 0; ! 3994: else if (original_target ! 3995: && safe_from_p (original_target, TREE_OPERAND (exp, 0))) ! 3996: temp = original_target; ! 3997: else if (mode == BLKmode) ! 3998: { ! 3999: if (TYPE_SIZE (type) == 0 ! 4000: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) ! 4001: abort (); ! 4002: temp = assign_stack_temp (BLKmode, ! 4003: (TREE_INT_CST_LOW (TYPE_SIZE (type)) ! 4004: + BITS_PER_UNIT - 1) ! 4005: / BITS_PER_UNIT, 0); ! 4006: } ! 4007: else ! 4008: temp = gen_reg_rtx (mode); ! 4009: ! 4010: /* Check for X ? A + B : A. If we have this, we can copy ! 4011: A to the output and conditionally add B. Similarly for unary ! 4012: operations. Don't do this if X has side-effects because ! 4013: those side effects might affect A or B and the "?" operation is ! 4014: a sequence point in ANSI. (We test for side effects later.) */ ! 4015: ! 4016: if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2' ! 4017: && operand_equal_p (TREE_OPERAND (exp, 2), ! 4018: TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0)) ! 4019: singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1); ! 4020: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2' ! 4021: && operand_equal_p (TREE_OPERAND (exp, 1), ! 4022: TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0)) ! 4023: singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2); ! 4024: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1' ! 4025: && operand_equal_p (TREE_OPERAND (exp, 2), ! 4026: TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0)) ! 4027: singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1); ! 4028: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1' ! 4029: && operand_equal_p (TREE_OPERAND (exp, 1), ! 4030: TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0)) ! 4031: singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2); ! 4032: ! 4033: /* If we had X ? A + 1 : A and we can do the test of X as a store-flag ! 4034: operation, do this as A + (X != 0). Similarly for other simple ! 4035: binary operators. */ ! 4036: if (singleton && binary_op ! 4037: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)) ! 4038: && (TREE_CODE (binary_op) == PLUS_EXPR ! 4039: || TREE_CODE (binary_op) == MINUS_EXPR ! 4040: || TREE_CODE (binary_op) == BIT_IOR_EXPR ! 4041: || TREE_CODE (binary_op) == BIT_XOR_EXPR ! 4042: || TREE_CODE (binary_op) == BIT_AND_EXPR) ! 4043: && integer_onep (TREE_OPERAND (binary_op, 1)) ! 4044: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<') ! 4045: { ! 4046: rtx result; ! 4047: optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR ? add_optab ! 4048: : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab ! 4049: : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab ! 4050: : TREE_CODE (binary_op) == BIT_XOR_EXPR ? xor_optab ! 4051: : and_optab); ! 4052: ! 4053: /* If we had X ? A : A + 1, do this as A + (X == 0). ! 4054: ! 4055: We have to invert the truth value here and then put it ! 4056: back later if do_store_flag fails. We cannot simply copy ! 4057: TREE_OPERAND (exp, 0) to another variable and modify that ! 4058: because invert_truthvalue can modify the tree pointed to ! 4059: by its argument. */ ! 4060: if (singleton == TREE_OPERAND (exp, 1)) ! 4061: TREE_OPERAND (exp, 0) ! 4062: = invert_truthvalue (TREE_OPERAND (exp, 0)); ! 4063: ! 4064: result = do_store_flag (TREE_OPERAND (exp, 0), ! 4065: safe_from_p (temp, singleton) ? temp : 0, ! 4066: mode, BRANCH_COST <= 1); ! 4067: ! 4068: if (result) ! 4069: { ! 4070: op1 = expand_expr (singleton, 0, VOIDmode, 0); ! 4071: return expand_binop (mode, boptab, op1, result, temp, ! 4072: unsignedp, OPTAB_LIB_WIDEN); ! 4073: } ! 4074: else if (singleton == TREE_OPERAND (exp, 1)) ! 4075: TREE_OPERAND (exp, 0) ! 4076: = invert_truthvalue (TREE_OPERAND (exp, 0)); ! 4077: } ! 4078: ! 4079: NO_DEFER_POP; ! 4080: op0 = gen_label_rtx (); ! 4081: ! 4082: if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))) ! 4083: { ! 4084: if (temp != 0) ! 4085: { ! 4086: /* If the target conflicts with the other operand of the ! 4087: binary op, we can't use it. Also, we can't use the target ! 4088: if it is a hard register, because evaluating the condition ! 4089: might clobber it. */ ! 4090: if ((binary_op ! 4091: && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1))) ! 4092: || (GET_CODE (temp) == REG ! 4093: && REGNO (temp) < FIRST_PSEUDO_REGISTER)) ! 4094: temp = gen_reg_rtx (mode); ! 4095: store_expr (singleton, temp, 0); ! 4096: } ! 4097: else ! 4098: expand_expr (singleton, ignore ? const1_rtx : 0, VOIDmode, 0); ! 4099: if (cleanups_this_call) ! 4100: { ! 4101: sorry ("aggregate value in COND_EXPR"); ! 4102: cleanups_this_call = 0; ! 4103: } ! 4104: if (singleton == TREE_OPERAND (exp, 1)) ! 4105: jumpif (TREE_OPERAND (exp, 0), op0); ! 4106: else ! 4107: jumpifnot (TREE_OPERAND (exp, 0), op0); ! 4108: ! 4109: if (binary_op && temp == 0) ! 4110: /* Just touch the other operand. */ ! 4111: expand_expr (TREE_OPERAND (binary_op, 1), ! 4112: ignore ? const0_rtx : 0, VOIDmode, 0); ! 4113: else if (binary_op) ! 4114: store_expr (build (TREE_CODE (binary_op), type, ! 4115: make_tree (type, temp), ! 4116: TREE_OPERAND (binary_op, 1)), ! 4117: temp, 0); ! 4118: else ! 4119: store_expr (build1 (TREE_CODE (unary_op), type, ! 4120: make_tree (type, temp)), ! 4121: temp, 0); ! 4122: op1 = op0; ! 4123: } ! 4124: #if 0 ! 4125: /* This is now done in jump.c and is better done there because it ! 4126: produces shorter register lifetimes. */ ! 4127: ! 4128: /* Check for both possibilities either constants or variables ! 4129: in registers (but not the same as the target!). If so, can ! 4130: save branches by assigning one, branching, and assigning the ! 4131: other. */ ! 4132: else if (temp && GET_MODE (temp) != BLKmode ! 4133: && (TREE_CONSTANT (TREE_OPERAND (exp, 1)) ! 4134: || ((TREE_CODE (TREE_OPERAND (exp, 1)) == PARM_DECL ! 4135: || TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL) ! 4136: && DECL_RTL (TREE_OPERAND (exp, 1)) ! 4137: && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 1))) == REG ! 4138: && DECL_RTL (TREE_OPERAND (exp, 1)) != temp)) ! 4139: && (TREE_CONSTANT (TREE_OPERAND (exp, 2)) ! 4140: || ((TREE_CODE (TREE_OPERAND (exp, 2)) == PARM_DECL ! 4141: || TREE_CODE (TREE_OPERAND (exp, 2)) == VAR_DECL) ! 4142: && DECL_RTL (TREE_OPERAND (exp, 2)) ! 4143: && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 2))) == REG ! 4144: && DECL_RTL (TREE_OPERAND (exp, 2)) != temp))) ! 4145: { ! 4146: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER) ! 4147: temp = gen_reg_rtx (mode); ! 4148: store_expr (TREE_OPERAND (exp, 2), temp, 0); ! 4149: jumpifnot (TREE_OPERAND (exp, 0), op0); ! 4150: store_expr (TREE_OPERAND (exp, 1), temp, 0); ! 4151: op1 = op0; ! 4152: } ! 4153: #endif ! 4154: /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any ! 4155: comparison operator. If we have one of these cases, set the ! 4156: output to A, branch on A (cse will merge these two references), ! 4157: then set the output to FOO. */ ! 4158: else if (temp ! 4159: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<' ! 4160: && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) ! 4161: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0), ! 4162: TREE_OPERAND (exp, 1), 0) ! 4163: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)) ! 4164: && safe_from_p (temp, TREE_OPERAND (exp, 2))) ! 4165: { ! 4166: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER) ! 4167: temp = gen_reg_rtx (mode); ! 4168: store_expr (TREE_OPERAND (exp, 1), temp, 0); ! 4169: jumpif (TREE_OPERAND (exp, 0), op0); ! 4170: store_expr (TREE_OPERAND (exp, 2), temp, 0); ! 4171: op1 = op0; ! 4172: } ! 4173: else if (temp ! 4174: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<' ! 4175: && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) ! 4176: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0), ! 4177: TREE_OPERAND (exp, 2), 0) ! 4178: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)) ! 4179: && safe_from_p (temp, TREE_OPERAND (exp, 1))) ! 4180: { ! 4181: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER) ! 4182: temp = gen_reg_rtx (mode); ! 4183: store_expr (TREE_OPERAND (exp, 2), temp, 0); ! 4184: jumpifnot (TREE_OPERAND (exp, 0), op0); ! 4185: store_expr (TREE_OPERAND (exp, 1), temp, 0); ! 4186: op1 = op0; ! 4187: } ! 4188: else ! 4189: { ! 4190: op1 = gen_label_rtx (); ! 4191: jumpifnot (TREE_OPERAND (exp, 0), op0); ! 4192: if (temp != 0) ! 4193: store_expr (TREE_OPERAND (exp, 1), temp, 0); ! 4194: else ! 4195: expand_expr (TREE_OPERAND (exp, 1), ignore ? const0_rtx : 0, ! 4196: VOIDmode, 0); ! 4197: if (cleanups_this_call) ! 4198: { ! 4199: sorry ("aggregate value in COND_EXPR"); ! 4200: cleanups_this_call = 0; ! 4201: } ! 4202: ! 4203: emit_queue (); ! 4204: emit_jump_insn (gen_jump (op1)); ! 4205: emit_barrier (); ! 4206: emit_label (op0); ! 4207: if (temp != 0) ! 4208: store_expr (TREE_OPERAND (exp, 2), temp, 0); ! 4209: else ! 4210: expand_expr (TREE_OPERAND (exp, 2), ignore ? const0_rtx : 0, ! 4211: VOIDmode, 0); ! 4212: } ! 4213: ! 4214: if (cleanups_this_call) ! 4215: { ! 4216: sorry ("aggregate value in COND_EXPR"); ! 4217: cleanups_this_call = 0; ! 4218: } ! 4219: ! 4220: emit_queue (); ! 4221: emit_label (op1); ! 4222: OK_DEFER_POP; ! 4223: cleanups_this_call = old_cleanups; ! 4224: return temp; ! 4225: } ! 4226: ! 4227: case TARGET_EXPR: ! 4228: { ! 4229: /* Something needs to be initialized, but we didn't know ! 4230: where that thing was when building the tree. For example, ! 4231: it could be the return value of a function, or a parameter ! 4232: to a function which lays down in the stack, or a temporary ! 4233: variable which must be passed by reference. ! 4234: ! 4235: We guarantee that the expression will either be constructed ! 4236: or copied into our original target. */ ! 4237: ! 4238: tree slot = TREE_OPERAND (exp, 0); ! 4239: ! 4240: if (TREE_CODE (slot) != VAR_DECL) ! 4241: abort (); ! 4242: ! 4243: if (target == 0) ! 4244: { ! 4245: if (DECL_RTL (slot) != 0) ! 4246: target = DECL_RTL (slot); ! 4247: else ! 4248: { ! 4249: target = assign_stack_temp (mode, int_size_in_bytes (type), 0); ! 4250: /* All temp slots at this level must not conflict. */ ! 4251: preserve_temp_slots (target); ! 4252: DECL_RTL (slot) = target; ! 4253: } ! 4254: ! 4255: #if 0 ! 4256: /* Since SLOT is not known to the called function ! 4257: to belong to its stack frame, we must build an explicit ! 4258: cleanup. This case occurs when we must build up a reference ! 4259: to pass the reference as an argument. In this case, ! 4260: it is very likely that such a reference need not be ! 4261: built here. */ ! 4262: ! 4263: if (TREE_OPERAND (exp, 2) == 0) ! 4264: TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot); ! 4265: if (TREE_OPERAND (exp, 2)) ! 4266: cleanups_this_call = tree_cons (0, TREE_OPERAND (exp, 2), ! 4267: cleanups_this_call); ! 4268: #endif ! 4269: } ! 4270: else ! 4271: { ! 4272: /* This case does occur, when expanding a parameter which ! 4273: needs to be constructed on the stack. The target ! 4274: is the actual stack address that we want to initialize. ! 4275: The function we call will perform the cleanup in this case. */ ! 4276: ! 4277: DECL_RTL (slot) = target; ! 4278: } ! 4279: ! 4280: return expand_expr (TREE_OPERAND (exp, 1), target, tmode, modifier); ! 4281: } ! 4282: ! 4283: case INIT_EXPR: ! 4284: { ! 4285: tree lhs = TREE_OPERAND (exp, 0); ! 4286: tree rhs = TREE_OPERAND (exp, 1); ! 4287: tree noncopied_parts = 0; ! 4288: tree lhs_type = TREE_TYPE (lhs); ! 4289: ! 4290: temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0); ! 4291: if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs)) ! 4292: noncopied_parts = init_noncopied_parts (stabilize_reference (lhs), ! 4293: TYPE_NONCOPIED_PARTS (lhs_type)); ! 4294: while (noncopied_parts != 0) ! 4295: { ! 4296: expand_assignment (TREE_VALUE (noncopied_parts), ! 4297: TREE_PURPOSE (noncopied_parts), 0, 0); ! 4298: noncopied_parts = TREE_CHAIN (noncopied_parts); ! 4299: } ! 4300: return temp; ! 4301: } ! 4302: ! 4303: case MODIFY_EXPR: ! 4304: { ! 4305: /* If lhs is complex, expand calls in rhs before computing it. ! 4306: That's so we don't compute a pointer and save it over a call. ! 4307: If lhs is simple, compute it first so we can give it as a ! 4308: target if the rhs is just a call. This avoids an extra temp and copy ! 4309: and that prevents a partial-subsumption which makes bad code. ! 4310: Actually we could treat component_ref's of vars like vars. */ ! 4311: ! 4312: tree lhs = TREE_OPERAND (exp, 0); ! 4313: tree rhs = TREE_OPERAND (exp, 1); ! 4314: tree noncopied_parts = 0; ! 4315: tree lhs_type = TREE_TYPE (lhs); ! 4316: ! 4317: temp = 0; ! 4318: ! 4319: if (TREE_CODE (lhs) != VAR_DECL ! 4320: && TREE_CODE (lhs) != RESULT_DECL ! 4321: && TREE_CODE (lhs) != PARM_DECL) ! 4322: preexpand_calls (exp); ! 4323: ! 4324: /* Check for |= or &= of a bitfield of size one into another bitfield ! 4325: of size 1. In this case, (unless we need the result of the ! 4326: assignment) we can do this more efficiently with a ! 4327: test followed by an assignment, if necessary. ! 4328: ! 4329: ??? At this point, we can't get a BIT_FIELD_REF here. But if ! 4330: things change so we do, this code should be enhanced to ! 4331: support it. */ ! 4332: if (ignore ! 4333: && TREE_CODE (lhs) == COMPONENT_REF ! 4334: && (TREE_CODE (rhs) == BIT_IOR_EXPR ! 4335: || TREE_CODE (rhs) == BIT_AND_EXPR) ! 4336: && TREE_OPERAND (rhs, 0) == lhs ! 4337: && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF ! 4338: && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs, 1))) == 1 ! 4339: && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))) == 1) ! 4340: { ! 4341: rtx label = gen_label_rtx (); ! 4342: ! 4343: do_jump (TREE_OPERAND (rhs, 1), ! 4344: TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0, ! 4345: TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0); ! 4346: expand_assignment (lhs, convert (TREE_TYPE (rhs), ! 4347: (TREE_CODE (rhs) == BIT_IOR_EXPR ! 4348: ? integer_one_node ! 4349: : integer_zero_node)), ! 4350: 0, 0); ! 4351: emit_label (label); ! 4352: return const0_rtx; ! 4353: } ! 4354: ! 4355: if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 ! 4356: && ! (fixed_type_p (lhs) && fixed_type_p (rhs))) ! 4357: noncopied_parts = save_noncopied_parts (stabilize_reference (lhs), ! 4358: TYPE_NONCOPIED_PARTS (lhs_type)); ! 4359: ! 4360: temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0); ! 4361: while (noncopied_parts != 0) ! 4362: { ! 4363: expand_assignment (TREE_PURPOSE (noncopied_parts), ! 4364: TREE_VALUE (noncopied_parts), 0, 0); ! 4365: noncopied_parts = TREE_CHAIN (noncopied_parts); ! 4366: } ! 4367: return temp; ! 4368: } ! 4369: ! 4370: case PREINCREMENT_EXPR: ! 4371: case PREDECREMENT_EXPR: ! 4372: return expand_increment (exp, 0); ! 4373: ! 4374: case POSTINCREMENT_EXPR: ! 4375: case POSTDECREMENT_EXPR: ! 4376: /* Faster to treat as pre-increment if result is not used. */ ! 4377: return expand_increment (exp, ! ignore); ! 4378: ! 4379: case ADDR_EXPR: ! 4380: /* Are we taking the address of a nested function? */ ! 4381: if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL ! 4382: && decl_function_context (TREE_OPERAND (exp, 0)) != 0) ! 4383: { ! 4384: op0 = trampoline_address (TREE_OPERAND (exp, 0)); ! 4385: op0 = force_operand (op0, target); ! 4386: } ! 4387: else ! 4388: { ! 4389: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, ! 4390: (modifier == EXPAND_INITIALIZER ! 4391: ? modifier : EXPAND_CONST_ADDRESS)); ! 4392: if (GET_CODE (op0) != MEM) ! 4393: abort (); ! 4394: ! 4395: if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER) ! 4396: return XEXP (op0, 0); ! 4397: op0 = force_operand (XEXP (op0, 0), target); ! 4398: } ! 4399: if (flag_force_addr && GET_CODE (op0) != REG) ! 4400: return force_reg (Pmode, op0); ! 4401: return op0; ! 4402: ! 4403: case ENTRY_VALUE_EXPR: ! 4404: abort (); ! 4405: ! 4406: case ERROR_MARK: ! 4407: return const0_rtx; ! 4408: ! 4409: default: ! 4410: return (*lang_expand_expr) (exp, target, tmode, modifier); ! 4411: } ! 4412: ! 4413: /* Here to do an ordinary binary operator, generating an instruction ! 4414: from the optab already placed in `this_optab'. */ ! 4415: binop: ! 4416: preexpand_calls (exp); ! 4417: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1))) ! 4418: subtarget = 0; ! 4419: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0); ! 4420: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 4421: binop2: ! 4422: temp = expand_binop (mode, this_optab, op0, op1, target, ! 4423: unsignedp, OPTAB_LIB_WIDEN); ! 4424: if (temp == 0) ! 4425: abort (); ! 4426: return temp; ! 4427: } ! 4428: ! 4429: /* Return the alignment of EXP, a pointer valued expression for the mem* ! 4430: builtin functions. Alignments greater than MAX_ALIGN are not significant. ! 4431: The alignment returned is, by default, the alignment of the thing that ! 4432: EXP points to (if it is not a POINTER_TYPE, 0 is returned). ! 4433: ! 4434: Otherwise, look at the expression to see if we can do better, i.e., if the ! 4435: expression is actually pointing at an object whose alignment is tighter. */ ! 4436: ! 4437: static int ! 4438: get_pointer_alignment (exp, max_align) ! 4439: tree exp; ! 4440: unsigned max_align; ! 4441: { ! 4442: unsigned align, inner; ! 4443: ! 4444: if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE) ! 4445: return 0; ! 4446: ! 4447: align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))); ! 4448: align = MIN (align, max_align); ! 4449: ! 4450: while (1) ! 4451: { ! 4452: switch (TREE_CODE (exp)) ! 4453: { ! 4454: case NOP_EXPR: ! 4455: case CONVERT_EXPR: ! 4456: case NON_LVALUE_EXPR: ! 4457: exp = TREE_OPERAND (exp, 0); ! 4458: if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE) ! 4459: return align; ! 4460: inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))); ! 4461: inner = MIN (inner, max_align); ! 4462: align = MAX (align, inner); ! 4463: break; ! 4464: ! 4465: case PLUS_EXPR: ! 4466: /* If sum of pointer + int, restrict our maximum alignment to that ! 4467: imposed by the integer. If not, we can't do any better than ! 4468: ALIGN. */ ! 4469: if (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST) ! 4470: return align; ! 4471: ! 4472: while ((TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) ! 4473: & (max_align - 1)) != 0) ! 4474: max_align >>= 1; ! 4475: ! 4476: exp = TREE_OPERAND (exp, 0); ! 4477: break; ! 4478: ! 4479: case ADDR_EXPR: ! 4480: /* See what we are pointing at and look at its alignment. */ ! 4481: exp = TREE_OPERAND (exp, 0); ! 4482: if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd') ! 4483: align = MAX (align, DECL_ALIGN (exp)); ! 4484: #ifdef CONSTANT_ALIGNMENT ! 4485: else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c') ! 4486: align = CONSTANT_ALIGNMENT (exp, align); ! 4487: #endif ! 4488: return MIN (align, max_align); ! 4489: ! 4490: default: ! 4491: return align; ! 4492: } ! 4493: } ! 4494: } ! 4495: ! 4496: /* Return the tree node and offset if a given argument corresponds to ! 4497: a string constant. */ ! 4498: ! 4499: static tree ! 4500: string_constant (arg, ptr_offset) ! 4501: tree arg; ! 4502: tree *ptr_offset; ! 4503: { ! 4504: STRIP_NOPS (arg); ! 4505: ! 4506: if (TREE_CODE (arg) == ADDR_EXPR ! 4507: && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST) ! 4508: { ! 4509: *ptr_offset = integer_zero_node; ! 4510: return TREE_OPERAND (arg, 0); ! 4511: } ! 4512: else if (TREE_CODE (arg) == PLUS_EXPR) ! 4513: { ! 4514: tree arg0 = TREE_OPERAND (arg, 0); ! 4515: tree arg1 = TREE_OPERAND (arg, 1); ! 4516: ! 4517: STRIP_NOPS (arg0); ! 4518: STRIP_NOPS (arg1); ! 4519: ! 4520: if (TREE_CODE (arg0) == ADDR_EXPR ! 4521: && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST) ! 4522: { ! 4523: *ptr_offset = arg1; ! 4524: return TREE_OPERAND (arg0, 0); ! 4525: } ! 4526: else if (TREE_CODE (arg1) == ADDR_EXPR ! 4527: && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST) ! 4528: { ! 4529: *ptr_offset = arg0; ! 4530: return TREE_OPERAND (arg1, 0); ! 4531: } ! 4532: } ! 4533: ! 4534: return 0; ! 4535: } ! 4536: ! 4537: /* Compute the length of a C string. TREE_STRING_LENGTH is not the right ! 4538: way, because it could contain a zero byte in the middle. ! 4539: TREE_STRING_LENGTH is the size of the character array, not the string. ! 4540: ! 4541: Unfortunately, string_constant can't access the values of const char ! 4542: arrays with initializers, so neither can we do so here. */ ! 4543: ! 4544: static tree ! 4545: c_strlen (src) ! 4546: tree src; ! 4547: { ! 4548: tree offset_node; ! 4549: int offset, max; ! 4550: char *ptr; ! 4551: ! 4552: src = string_constant (src, &offset_node); ! 4553: if (src == 0) ! 4554: return 0; ! 4555: max = TREE_STRING_LENGTH (src); ! 4556: ptr = TREE_STRING_POINTER (src); ! 4557: if (offset_node && TREE_CODE (offset_node) != INTEGER_CST) ! 4558: { ! 4559: /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't ! 4560: compute the offset to the following null if we don't know where to ! 4561: start searching for it. */ ! 4562: int i; ! 4563: for (i = 0; i < max; i++) ! 4564: if (ptr[i] == 0) ! 4565: return 0; ! 4566: /* We don't know the starting offset, but we do know that the string ! 4567: has no internal zero bytes. We can assume that the offset falls ! 4568: within the bounds of the string; otherwise, the programmer deserves ! 4569: what he gets. Subtract the offset from the length of the string, ! 4570: and return that. */ ! 4571: /* This would perhaps not be valid if we were dealing with named ! 4572: arrays in addition to literal string constants. */ ! 4573: return size_binop (MINUS_EXPR, size_int (max), offset_node); ! 4574: } ! 4575: ! 4576: /* We have a known offset into the string. Start searching there for ! 4577: a null character. */ ! 4578: if (offset_node == 0) ! 4579: offset = 0; ! 4580: else ! 4581: { ! 4582: /* Did we get a long long offset? If so, punt. */ ! 4583: if (TREE_INT_CST_HIGH (offset_node) != 0) ! 4584: return 0; ! 4585: offset = TREE_INT_CST_LOW (offset_node); ! 4586: } ! 4587: /* If the offset is known to be out of bounds, warn, and call strlen at ! 4588: runtime. */ ! 4589: if (offset < 0 || offset > max) ! 4590: { ! 4591: warning ("offset outside bounds of constant string"); ! 4592: return 0; ! 4593: } ! 4594: /* Use strlen to search for the first zero byte. Since any strings ! 4595: constructed with build_string will have nulls appended, we win even ! 4596: if we get handed something like (char[4])"abcd". ! 4597: ! 4598: Since OFFSET is our starting index into the string, no further ! 4599: calculation is needed. */ ! 4600: return size_int (strlen (ptr + offset)); ! 4601: } ! 4602: ! 4603: /* Expand an expression EXP that calls a built-in function, ! 4604: with result going to TARGET if that's convenient ! 4605: (and in mode MODE if that's convenient). ! 4606: SUBTARGET may be used as the target for computing one of EXP's operands. ! 4607: IGNORE is nonzero if the value is to be ignored. */ ! 4608: ! 4609: static rtx ! 4610: expand_builtin (exp, target, subtarget, mode, ignore) ! 4611: tree exp; ! 4612: rtx target; ! 4613: rtx subtarget; ! 4614: enum machine_mode mode; ! 4615: int ignore; ! 4616: { ! 4617: tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0); ! 4618: tree arglist = TREE_OPERAND (exp, 1); ! 4619: rtx op0; ! 4620: enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp)); ! 4621: ! 4622: switch (DECL_FUNCTION_CODE (fndecl)) ! 4623: { ! 4624: case BUILT_IN_ABS: ! 4625: case BUILT_IN_LABS: ! 4626: case BUILT_IN_FABS: ! 4627: /* build_function_call changes these into ABS_EXPR. */ ! 4628: abort (); ! 4629: ! 4630: case BUILT_IN_SAVEREGS: ! 4631: /* Don't do __builtin_saveregs more than once in a function. ! 4632: Save the result of the first call and reuse it. */ ! 4633: if (saveregs_value != 0) ! 4634: return saveregs_value; ! 4635: { ! 4636: /* When this function is called, it means that registers must be ! 4637: saved on entry to this function. So we migrate the ! 4638: call to the first insn of this function. */ ! 4639: rtx temp; ! 4640: rtx seq; ! 4641: rtx valreg, saved_valreg; ! 4642: ! 4643: /* Now really call the function. `expand_call' does not call ! 4644: expand_builtin, so there is no danger of infinite recursion here. */ ! 4645: start_sequence (); ! 4646: ! 4647: #ifdef EXPAND_BUILTIN_SAVEREGS ! 4648: /* Do whatever the machine needs done in this case. */ ! 4649: temp = EXPAND_BUILTIN_SAVEREGS (arglist); ! 4650: #else ! 4651: /* The register where the function returns its value ! 4652: is likely to have something else in it, such as an argument. ! 4653: So preserve that register around the call. */ ! 4654: if (value_mode != VOIDmode) ! 4655: { ! 4656: valreg = hard_libcall_value (value_mode); ! 4657: saved_valreg = gen_reg_rtx (value_mode); ! 4658: emit_move_insn (saved_valreg, valreg); ! 4659: } ! 4660: ! 4661: /* Generate the call, putting the value in a pseudo. */ ! 4662: temp = expand_call (exp, target, ignore); ! 4663: ! 4664: if (value_mode != VOIDmode) ! 4665: emit_move_insn (valreg, saved_valreg); ! 4666: #endif ! 4667: ! 4668: seq = get_insns (); ! 4669: end_sequence (); ! 4670: ! 4671: saveregs_value = temp; ! 4672: ! 4673: /* This won't work inside a SEQUENCE--it really has to be ! 4674: at the start of the function. */ ! 4675: if (in_sequence_p ()) ! 4676: { ! 4677: /* Better to do this than to crash. */ ! 4678: error ("`va_start' used within `({...})'"); ! 4679: return temp; ! 4680: } ! 4681: ! 4682: /* Put the sequence after the NOTE that starts the function. */ ! 4683: emit_insns_before (seq, NEXT_INSN (get_insns ())); ! 4684: return temp; ! 4685: } ! 4686: ! 4687: /* __builtin_args_info (N) returns word N of the arg space info ! 4688: for the current function. The number and meanings of words ! 4689: is controlled by the definition of CUMULATIVE_ARGS. */ ! 4690: case BUILT_IN_ARGS_INFO: ! 4691: { ! 4692: int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int); ! 4693: int i; ! 4694: int *word_ptr = (int *) ¤t_function_args_info; ! 4695: tree type, elts, result; ! 4696: ! 4697: if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0) ! 4698: fatal ("CUMULATIVE_ARGS type defined badly; see %s, line %d", ! 4699: __FILE__, __LINE__); ! 4700: ! 4701: if (arglist != 0) ! 4702: { ! 4703: tree arg = TREE_VALUE (arglist); ! 4704: if (TREE_CODE (arg) != INTEGER_CST) ! 4705: error ("argument of __builtin_args_info must be constant"); ! 4706: else ! 4707: { ! 4708: int wordnum = TREE_INT_CST_LOW (arg); ! 4709: ! 4710: if (wordnum < 0 || wordnum >= nwords) ! 4711: error ("argument of __builtin_args_info out of range"); ! 4712: else ! 4713: return gen_rtx (CONST_INT, VOIDmode, word_ptr[wordnum]); ! 4714: } ! 4715: } ! 4716: else ! 4717: error ("missing argument in __builtin_args_info"); ! 4718: ! 4719: return const0_rtx; ! 4720: ! 4721: #if 0 ! 4722: for (i = 0; i < nwords; i++) ! 4723: elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0)); ! 4724: ! 4725: type = build_array_type (integer_type_node, ! 4726: build_index_type (build_int_2 (nwords, 0))); ! 4727: result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts)); ! 4728: TREE_CONSTANT (result) = 1; ! 4729: TREE_STATIC (result) = 1; ! 4730: result = build (INDIRECT_REF, build_pointer_type (type), result); ! 4731: TREE_CONSTANT (result) = 1; ! 4732: return expand_expr (result, 0, VOIDmode, 0); ! 4733: #endif ! 4734: } ! 4735: ! 4736: /* Return the address of the first anonymous stack arg. */ ! 4737: case BUILT_IN_NEXT_ARG: ! 4738: { ! 4739: tree fntype = TREE_TYPE (current_function_decl); ! 4740: if (!(TYPE_ARG_TYPES (fntype) != 0 ! 4741: && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) ! 4742: != void_type_node))) ! 4743: { ! 4744: error ("`va_start' used in function with fixed args"); ! 4745: return const0_rtx; ! 4746: } ! 4747: } ! 4748: ! 4749: return expand_binop (Pmode, add_optab, ! 4750: current_function_internal_arg_pointer, ! 4751: current_function_arg_offset_rtx, ! 4752: 0, 0, OPTAB_LIB_WIDEN); ! 4753: ! 4754: case BUILT_IN_CLASSIFY_TYPE: ! 4755: if (arglist != 0) ! 4756: { ! 4757: tree type = TREE_TYPE (TREE_VALUE (arglist)); ! 4758: enum tree_code code = TREE_CODE (type); ! 4759: if (code == VOID_TYPE) ! 4760: return gen_rtx (CONST_INT, VOIDmode, void_type_class); ! 4761: if (code == INTEGER_TYPE) ! 4762: return gen_rtx (CONST_INT, VOIDmode, integer_type_class); ! 4763: if (code == CHAR_TYPE) ! 4764: return gen_rtx (CONST_INT, VOIDmode, char_type_class); ! 4765: if (code == ENUMERAL_TYPE) ! 4766: return gen_rtx (CONST_INT, VOIDmode, enumeral_type_class); ! 4767: if (code == BOOLEAN_TYPE) ! 4768: return gen_rtx (CONST_INT, VOIDmode, boolean_type_class); ! 4769: if (code == POINTER_TYPE) ! 4770: return gen_rtx (CONST_INT, VOIDmode, pointer_type_class); ! 4771: if (code == REFERENCE_TYPE) ! 4772: return gen_rtx (CONST_INT, VOIDmode, reference_type_class); ! 4773: if (code == OFFSET_TYPE) ! 4774: return gen_rtx (CONST_INT, VOIDmode, offset_type_class); ! 4775: if (code == REAL_TYPE) ! 4776: return gen_rtx (CONST_INT, VOIDmode, real_type_class); ! 4777: if (code == COMPLEX_TYPE) ! 4778: return gen_rtx (CONST_INT, VOIDmode, complex_type_class); ! 4779: if (code == FUNCTION_TYPE) ! 4780: return gen_rtx (CONST_INT, VOIDmode, function_type_class); ! 4781: if (code == METHOD_TYPE) ! 4782: return gen_rtx (CONST_INT, VOIDmode, method_type_class); ! 4783: if (code == RECORD_TYPE) ! 4784: return gen_rtx (CONST_INT, VOIDmode, record_type_class); ! 4785: if (code == UNION_TYPE) ! 4786: return gen_rtx (CONST_INT, VOIDmode, union_type_class); ! 4787: if (code == ARRAY_TYPE) ! 4788: return gen_rtx (CONST_INT, VOIDmode, array_type_class); ! 4789: if (code == STRING_TYPE) ! 4790: return gen_rtx (CONST_INT, VOIDmode, string_type_class); ! 4791: if (code == SET_TYPE) ! 4792: return gen_rtx (CONST_INT, VOIDmode, set_type_class); ! 4793: if (code == FILE_TYPE) ! 4794: return gen_rtx (CONST_INT, VOIDmode, file_type_class); ! 4795: if (code == LANG_TYPE) ! 4796: return gen_rtx (CONST_INT, VOIDmode, lang_type_class); ! 4797: } ! 4798: return gen_rtx (CONST_INT, VOIDmode, no_type_class); ! 4799: ! 4800: case BUILT_IN_CONSTANT_P: ! 4801: if (arglist == 0) ! 4802: return const0_rtx; ! 4803: else ! 4804: return (TREE_CODE_CLASS (TREE_VALUE (arglist)) == 'c' ! 4805: ? const1_rtx : const0_rtx); ! 4806: ! 4807: case BUILT_IN_FRAME_ADDRESS: ! 4808: /* The argument must be a nonnegative integer constant. ! 4809: It counts the number of frames to scan up the stack. ! 4810: The value is the address of that frame. */ ! 4811: case BUILT_IN_RETURN_ADDRESS: ! 4812: /* The argument must be a nonnegative integer constant. ! 4813: It counts the number of frames to scan up the stack. ! 4814: The value is the return address saved in that frame. */ ! 4815: if (arglist == 0) ! 4816: /* Warning about missing arg was already issued. */ ! 4817: return const0_rtx; ! 4818: else if (TREE_CODE (TREE_VALUE (arglist)) != INTEGER_CST) ! 4819: { ! 4820: error ("invalid arg to __builtin_return_address"); ! 4821: return const0_rtx; ! 4822: } ! 4823: else if (tree_int_cst_lt (TREE_VALUE (arglist), integer_zero_node)) ! 4824: { ! 4825: error ("invalid arg to __builtin_return_address"); ! 4826: return const0_rtx; ! 4827: } ! 4828: else ! 4829: { ! 4830: int count = TREE_INT_CST_LOW (TREE_VALUE (arglist)); ! 4831: rtx tem = frame_pointer_rtx; ! 4832: int i; ! 4833: ! 4834: /* Scan back COUNT frames to the specified frame. */ ! 4835: for (i = 0; i < count; i++) ! 4836: { ! 4837: /* Assume the dynamic chain pointer is in the word that ! 4838: the frame address points to, unless otherwise specified. */ ! 4839: #ifdef DYNAMIC_CHAIN_ADDRESS ! 4840: tem = DYNAMIC_CHAIN_ADDRESS (tem); ! 4841: #endif ! 4842: tem = memory_address (Pmode, tem); ! 4843: tem = copy_to_reg (gen_rtx (MEM, Pmode, tem)); ! 4844: } ! 4845: ! 4846: /* For __builtin_frame_address, return what we've got. */ ! 4847: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS) ! 4848: return tem; ! 4849: ! 4850: /* For __builtin_return_address, ! 4851: Get the return address from that frame. */ ! 4852: #ifdef RETURN_ADDR_RTX ! 4853: return RETURN_ADDR_RTX (count, tem); ! 4854: #else ! 4855: tem = memory_address (Pmode, ! 4856: plus_constant (tem, GET_MODE_SIZE (Pmode))); ! 4857: return copy_to_reg (gen_rtx (MEM, Pmode, tem)); ! 4858: #endif ! 4859: } ! 4860: ! 4861: case BUILT_IN_ALLOCA: ! 4862: if (arglist == 0 ! 4863: /* Arg could be non-integer if user redeclared this fcn wrong. */ ! 4864: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE) ! 4865: return const0_rtx; ! 4866: current_function_calls_alloca = 1; ! 4867: /* Compute the argument. */ ! 4868: op0 = expand_expr (TREE_VALUE (arglist), 0, VOIDmode, 0); ! 4869: ! 4870: /* Allocate the desired space. */ ! 4871: target = allocate_dynamic_stack_space (op0, target); ! 4872: ! 4873: /* Record the new stack level for nonlocal gotos. */ ! 4874: if (nonlocal_goto_stack_level != 0) ! 4875: emit_move_insn (nonlocal_goto_stack_level, stack_pointer_rtx); ! 4876: return target; ! 4877: ! 4878: case BUILT_IN_FFS: ! 4879: /* If not optimizing, call the library function. */ ! 4880: if (!optimize) ! 4881: break; ! 4882: ! 4883: if (arglist == 0 ! 4884: /* Arg could be non-integer if user redeclared this fcn wrong. */ ! 4885: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE) ! 4886: return const0_rtx; ! 4887: ! 4888: /* Compute the argument. */ ! 4889: op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0); ! 4890: /* Compute ffs, into TARGET if possible. ! 4891: Set TARGET to wherever the result comes back. */ ! 4892: target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))), ! 4893: ffs_optab, op0, target, 1); ! 4894: if (target == 0) ! 4895: abort (); ! 4896: return target; ! 4897: ! 4898: case BUILT_IN_STRLEN: ! 4899: /* If not optimizing, call the library function. */ ! 4900: if (!optimize) ! 4901: break; ! 4902: ! 4903: if (arglist == 0 ! 4904: /* Arg could be non-pointer if user redeclared this fcn wrong. */ ! 4905: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE) ! 4906: return const0_rtx; ! 4907: else ! 4908: { ! 4909: tree len = c_strlen (TREE_VALUE (arglist)); ! 4910: ! 4911: if (len == 0) ! 4912: break; ! 4913: return expand_expr (len, target, mode, 0); ! 4914: } ! 4915: ! 4916: case BUILT_IN_STRCPY: ! 4917: /* If not optimizing, call the library function. */ ! 4918: if (!optimize) ! 4919: break; ! 4920: ! 4921: if (arglist == 0 ! 4922: /* Arg could be non-pointer if user redeclared this fcn wrong. */ ! 4923: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE ! 4924: || TREE_CHAIN (arglist) == 0 ! 4925: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE) ! 4926: return const0_rtx; ! 4927: else ! 4928: { ! 4929: tree len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist))); ! 4930: ! 4931: if (len == 0) ! 4932: break; ! 4933: ! 4934: len = size_binop (PLUS_EXPR, len, integer_one_node); ! 4935: ! 4936: chainon (arglist, build_tree_list (0, len)); ! 4937: } ! 4938: ! 4939: /* Drops in. */ ! 4940: case BUILT_IN_MEMCPY: ! 4941: /* If not optimizing, call the library function. */ ! 4942: if (!optimize) ! 4943: break; ! 4944: ! 4945: if (arglist == 0 ! 4946: /* Arg could be non-pointer if user redeclared this fcn wrong. */ ! 4947: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE ! 4948: || TREE_CHAIN (arglist) == 0 ! 4949: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE ! 4950: || TREE_CHAIN (TREE_CHAIN (arglist)) == 0 ! 4951: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE) ! 4952: return const0_rtx; ! 4953: else ! 4954: { ! 4955: tree dest = TREE_VALUE (arglist); ! 4956: tree src = TREE_VALUE (TREE_CHAIN (arglist)); ! 4957: tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))); ! 4958: ! 4959: int src_align ! 4960: = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; ! 4961: int dest_align ! 4962: = get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; ! 4963: rtx dest_rtx; ! 4964: ! 4965: /* If either SRC or DEST is not a pointer type, don't do ! 4966: this operation in-line. */ ! 4967: if (src_align == 0 || dest_align == 0) ! 4968: { ! 4969: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCPY) ! 4970: TREE_CHAIN (TREE_CHAIN (arglist)) = 0; ! 4971: break; ! 4972: } ! 4973: ! 4974: dest_rtx = expand_expr (dest, 0, Pmode, EXPAND_NORMAL); ! 4975: ! 4976: /* Copy word part most expediently. */ ! 4977: emit_block_move (gen_rtx (MEM, BLKmode, ! 4978: memory_address (BLKmode, dest_rtx)), ! 4979: gen_rtx (MEM, BLKmode, ! 4980: memory_address (BLKmode, ! 4981: expand_expr (src, 0, Pmode, ! 4982: EXPAND_NORMAL))), ! 4983: expand_expr (len, 0, VOIDmode, 0), ! 4984: MIN (src_align, dest_align)); ! 4985: return dest_rtx; ! 4986: } ! 4987: ! 4988: /* These comparison functions need an instruction that returns an actual ! 4989: index. An ordinary compare that just sets the condition codes ! 4990: is not enough. */ ! 4991: #ifdef HAVE_cmpstrsi ! 4992: case BUILT_IN_STRCMP: ! 4993: /* If not optimizing, call the library function. */ ! 4994: if (!optimize) ! 4995: break; ! 4996: ! 4997: if (arglist == 0 ! 4998: /* Arg could be non-pointer if user redeclared this fcn wrong. */ ! 4999: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE ! 5000: || TREE_CHAIN (arglist) == 0 ! 5001: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE) ! 5002: return const0_rtx; ! 5003: else if (!HAVE_cmpstrsi) ! 5004: break; ! 5005: { ! 5006: tree arg1 = TREE_VALUE (arglist); ! 5007: tree arg2 = TREE_VALUE (TREE_CHAIN (arglist)); ! 5008: tree offset; ! 5009: tree len, len2; ! 5010: ! 5011: len = c_strlen (arg1); ! 5012: if (len) ! 5013: len = size_binop (PLUS_EXPR, integer_one_node, len); ! 5014: len2 = c_strlen (arg2); ! 5015: if (len2) ! 5016: len2 = size_binop (PLUS_EXPR, integer_one_node, len2); ! 5017: ! 5018: /* If we don't have a constant length for the first, use the length ! 5019: of the second, if we know it. We don't require a constant for ! 5020: this case; some cost analysis could be done if both are available ! 5021: but neither is constant. For now, assume they're equally cheap. ! 5022: ! 5023: If both strings have constant lengths, use the smaller. This ! 5024: could arise if optimization results in strcpy being called with ! 5025: two fixed strings, or if the code was machine-generated. We should ! 5026: add some code to the `memcmp' handler below to deal with such ! 5027: situations, someday. */ ! 5028: if (!len || TREE_CODE (len) != INTEGER_CST) ! 5029: { ! 5030: if (len2) ! 5031: len = len2; ! 5032: else if (len == 0) ! 5033: break; ! 5034: } ! 5035: else if (len2 && TREE_CODE (len2) == INTEGER_CST) ! 5036: { ! 5037: if (tree_int_cst_lt (len2, len)) ! 5038: len = len2; ! 5039: } ! 5040: ! 5041: chainon (arglist, build_tree_list (0, len)); ! 5042: } ! 5043: ! 5044: /* Drops in. */ ! 5045: case BUILT_IN_MEMCMP: ! 5046: /* If not optimizing, call the library function. */ ! 5047: if (!optimize) ! 5048: break; ! 5049: ! 5050: if (arglist == 0 ! 5051: /* Arg could be non-pointer if user redeclared this fcn wrong. */ ! 5052: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE ! 5053: || TREE_CHAIN (arglist) == 0 ! 5054: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE ! 5055: || TREE_CHAIN (TREE_CHAIN (arglist)) == 0 ! 5056: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE) ! 5057: return const0_rtx; ! 5058: else if (!HAVE_cmpstrsi) ! 5059: break; ! 5060: { ! 5061: tree arg1 = TREE_VALUE (arglist); ! 5062: tree arg2 = TREE_VALUE (TREE_CHAIN (arglist)); ! 5063: tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))); ! 5064: rtx result; ! 5065: ! 5066: int arg1_align ! 5067: = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; ! 5068: int arg2_align ! 5069: = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; ! 5070: enum machine_mode insn_mode ! 5071: = insn_operand_mode[(int) CODE_FOR_cmpstrsi][0]; ! 5072: ! 5073: /* If we don't have POINTER_TYPE, call the function. */ ! 5074: if (arg1_align == 0 || arg2_align == 0) ! 5075: { ! 5076: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCMP) ! 5077: TREE_CHAIN (TREE_CHAIN (arglist)) = 0; ! 5078: break; ! 5079: } ! 5080: ! 5081: /* Make a place to write the result of the instruction. */ ! 5082: result = target; ! 5083: if (! (result != 0 ! 5084: && GET_CODE (result) == REG && GET_MODE (result) == insn_mode ! 5085: && REGNO (result) >= FIRST_PSEUDO_REGISTER)) ! 5086: result = gen_reg_rtx (insn_mode); ! 5087: ! 5088: emit_insn (gen_cmpstrsi (result, ! 5089: gen_rtx (MEM, BLKmode, ! 5090: expand_expr (arg1, 0, Pmode, EXPAND_NORMAL)), ! 5091: gen_rtx (MEM, BLKmode, ! 5092: expand_expr (arg2, 0, Pmode, EXPAND_NORMAL)), ! 5093: expand_expr (len, 0, VOIDmode, 0), ! 5094: gen_rtx (CONST_INT, VOIDmode, ! 5095: MIN (arg1_align, arg2_align)))); ! 5096: ! 5097: /* Return the value in the proper mode for this function. */ ! 5098: mode = TYPE_MODE (TREE_TYPE (exp)); ! 5099: if (GET_MODE (result) == mode) ! 5100: return result; ! 5101: else if (target != 0) ! 5102: { ! 5103: convert_move (target, result, 0); ! 5104: return target; ! 5105: } ! 5106: else ! 5107: return convert_to_mode (mode, result, 0); ! 5108: } ! 5109: #else ! 5110: case BUILT_IN_STRCMP: ! 5111: case BUILT_IN_MEMCMP: ! 5112: break; ! 5113: #endif ! 5114: ! 5115: default: /* just do library call, if unknown builtin */ ! 5116: error ("built-in function %s not currently supported", ! 5117: IDENTIFIER_POINTER (DECL_NAME (fndecl))); ! 5118: } ! 5119: ! 5120: /* The switch statement above can drop through to cause the function ! 5121: to be called normally. */ ! 5122: ! 5123: return expand_call (exp, target, ignore); ! 5124: } ! 5125: ! 5126: /* Expand code for a post- or pre- increment or decrement ! 5127: and return the RTX for the result. ! 5128: POST is 1 for postinc/decrements and 0 for preinc/decrements. */ ! 5129: ! 5130: static rtx ! 5131: expand_increment (exp, post) ! 5132: register tree exp; ! 5133: int post; ! 5134: { ! 5135: register rtx op0, op1; ! 5136: register rtx temp, value; ! 5137: register tree incremented = TREE_OPERAND (exp, 0); ! 5138: optab this_optab = add_optab; ! 5139: int icode; ! 5140: enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); ! 5141: int op0_is_copy = 0; ! 5142: ! 5143: /* Stabilize any component ref that might need to be ! 5144: evaluated more than once below. */ ! 5145: if (TREE_CODE (incremented) == BIT_FIELD_REF ! 5146: || (TREE_CODE (incremented) == COMPONENT_REF ! 5147: && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF ! 5148: || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1))))) ! 5149: incremented = stabilize_reference (incremented); ! 5150: ! 5151: /* Compute the operands as RTX. ! 5152: Note whether OP0 is the actual lvalue or a copy of it: ! 5153: I believe it is a copy iff it is a register and insns were ! 5154: generated in computing it. */ ! 5155: temp = get_last_insn (); ! 5156: op0 = expand_expr (incremented, 0, VOIDmode, 0); ! 5157: if (temp != get_last_insn ()) ! 5158: op0_is_copy = (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG); ! 5159: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 5160: ! 5161: /* Decide whether incrementing or decrementing. */ ! 5162: if (TREE_CODE (exp) == POSTDECREMENT_EXPR ! 5163: || TREE_CODE (exp) == PREDECREMENT_EXPR) ! 5164: this_optab = sub_optab; ! 5165: ! 5166: /* If OP0 is not the actual lvalue, but rather a copy in a register, ! 5167: then we cannot just increment OP0. We must ! 5168: therefore contrive to increment the original value. ! 5169: Then we can return OP0 since it is a copy of the old value. */ ! 5170: if (op0_is_copy) ! 5171: { ! 5172: /* This is the easiest way to increment the value wherever it is. ! 5173: Problems with multiple evaluation of INCREMENTED ! 5174: are prevented because either (1) it is a component_ref, ! 5175: in which case it was stabilized above, or (2) it is an array_ref ! 5176: with constant index in an array in a register, which is ! 5177: safe to reevaluate. */ ! 5178: tree newexp = build ((this_optab == add_optab ! 5179: ? PLUS_EXPR : MINUS_EXPR), ! 5180: TREE_TYPE (exp), ! 5181: incremented, ! 5182: TREE_OPERAND (exp, 1)); ! 5183: temp = expand_assignment (incremented, newexp, ! post, 0); ! 5184: return post ? op0 : temp; ! 5185: } ! 5186: ! 5187: /* Convert decrement by a constant into a negative increment. */ ! 5188: if (this_optab == sub_optab ! 5189: && GET_CODE (op1) == CONST_INT) ! 5190: { ! 5191: op1 = gen_rtx (CONST_INT, VOIDmode, - INTVAL (op1)); ! 5192: this_optab = add_optab; ! 5193: } ! 5194: ! 5195: if (post) ! 5196: { ! 5197: /* We have a true reference to the value in OP0. ! 5198: If there is an insn to add or subtract in this mode, queue it. */ ! 5199: ! 5200: #if 0 /* Turned off to avoid making extra insn for indexed memref. */ ! 5201: op0 = stabilize (op0); ! 5202: #endif ! 5203: ! 5204: icode = (int) this_optab->handlers[(int) mode].insn_code; ! 5205: if (icode != (int) CODE_FOR_nothing ! 5206: /* Make sure that OP0 is valid for operands 0 and 1 ! 5207: of the insn we want to queue. */ ! 5208: && (*insn_operand_predicate[icode][0]) (op0, mode) ! 5209: && (*insn_operand_predicate[icode][1]) (op0, mode)) ! 5210: { ! 5211: if (! (*insn_operand_predicate[icode][2]) (op1, mode)) ! 5212: op1 = force_reg (mode, op1); ! 5213: ! 5214: return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1)); ! 5215: } ! 5216: } ! 5217: ! 5218: /* Preincrement, or we can't increment with one simple insn. */ ! 5219: if (post) ! 5220: /* Save a copy of the value before inc or dec, to return it later. */ ! 5221: temp = value = copy_to_reg (op0); ! 5222: else ! 5223: /* Arrange to return the incremented value. */ ! 5224: /* Copy the rtx because expand_binop will protect from the queue, ! 5225: and the results of that would be invalid for us to return ! 5226: if our caller does emit_queue before using our result. */ ! 5227: temp = copy_rtx (value = op0); ! 5228: ! 5229: /* Increment however we can. */ ! 5230: op1 = expand_binop (mode, this_optab, value, op1, op0, ! 5231: TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN); ! 5232: /* Make sure the value is stored into OP0. */ ! 5233: if (op1 != op0) ! 5234: emit_move_insn (op0, op1); ! 5235: ! 5236: return temp; ! 5237: } ! 5238: ! 5239: /* Expand all function calls contained within EXP, innermost ones first. ! 5240: But don't look within expressions that have sequence points. ! 5241: For each CALL_EXPR, record the rtx for its value ! 5242: in the CALL_EXPR_RTL field. */ ! 5243: ! 5244: static void ! 5245: preexpand_calls (exp) ! 5246: tree exp; ! 5247: { ! 5248: register int nops, i; ! 5249: int type = TREE_CODE_CLASS (TREE_CODE (exp)); ! 5250: ! 5251: if (! do_preexpand_calls) ! 5252: return; ! 5253: ! 5254: /* Only expressions and references can contain calls. */ ! 5255: ! 5256: if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r') ! 5257: return; ! 5258: ! 5259: switch (TREE_CODE (exp)) ! 5260: { ! 5261: case CALL_EXPR: ! 5262: /* Do nothing if already expanded. */ ! 5263: if (CALL_EXPR_RTL (exp) != 0) ! 5264: return; ! 5265: ! 5266: /* Do nothing to built-in functions. */ ! 5267: if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR ! 5268: || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL ! 5269: || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) ! 5270: CALL_EXPR_RTL (exp) = expand_call (exp, 0, 0, 0); ! 5271: return; ! 5272: ! 5273: case COMPOUND_EXPR: ! 5274: case COND_EXPR: ! 5275: case TRUTH_ANDIF_EXPR: ! 5276: case TRUTH_ORIF_EXPR: ! 5277: /* If we find one of these, then we can be sure ! 5278: the adjust will be done for it (since it makes jumps). ! 5279: Do it now, so that if this is inside an argument ! 5280: of a function, we don't get the stack adjustment ! 5281: after some other args have already been pushed. */ ! 5282: do_pending_stack_adjust (); ! 5283: return; ! 5284: ! 5285: case BLOCK: ! 5286: case RTL_EXPR: ! 5287: case WITH_CLEANUP_EXPR: ! 5288: return; ! 5289: ! 5290: case SAVE_EXPR: ! 5291: if (SAVE_EXPR_RTL (exp) != 0) ! 5292: return; ! 5293: } ! 5294: ! 5295: nops = tree_code_length[(int) TREE_CODE (exp)]; ! 5296: for (i = 0; i < nops; i++) ! 5297: if (TREE_OPERAND (exp, i) != 0) ! 5298: { ! 5299: type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i))); ! 5300: if (type == 'e' || type == '<' || type == '1' || type == '2' ! 5301: || type == 'r') ! 5302: preexpand_calls (TREE_OPERAND (exp, i)); ! 5303: } ! 5304: } ! 5305: ! 5306: /* At the start of a function, record that we have no previously-pushed ! 5307: arguments waiting to be popped. */ ! 5308: ! 5309: void ! 5310: init_pending_stack_adjust () ! 5311: { ! 5312: pending_stack_adjust = 0; ! 5313: } ! 5314: ! 5315: /* When exiting from function, if safe, clear out any pending stack adjust ! 5316: so the adjustment won't get done. */ ! 5317: ! 5318: void ! 5319: clear_pending_stack_adjust () ! 5320: { ! 5321: #ifdef EXIT_IGNORE_STACK ! 5322: if (!flag_omit_frame_pointer && EXIT_IGNORE_STACK ! 5323: && ! (TREE_INLINE (current_function_decl) && optimize) ! 5324: && ! flag_inline_functions) ! 5325: pending_stack_adjust = 0; ! 5326: #endif ! 5327: } ! 5328: ! 5329: /* Pop any previously-pushed arguments that have not been popped yet. */ ! 5330: ! 5331: void ! 5332: do_pending_stack_adjust () ! 5333: { ! 5334: if (inhibit_defer_pop == 0) ! 5335: { ! 5336: if (pending_stack_adjust != 0) ! 5337: adjust_stack (gen_rtx (CONST_INT, VOIDmode, pending_stack_adjust)); ! 5338: pending_stack_adjust = 0; ! 5339: } ! 5340: } ! 5341: ! 5342: /* Expand all cleanups up to OLD_CLEANUPS. ! 5343: Needed here, and also for language-dependent calls. */ ! 5344: ! 5345: void ! 5346: expand_cleanups_to (old_cleanups) ! 5347: tree old_cleanups; ! 5348: { ! 5349: while (cleanups_this_call != old_cleanups) ! 5350: { ! 5351: expand_expr (TREE_VALUE (cleanups_this_call), 0, VOIDmode, 0); ! 5352: cleanups_this_call = TREE_CHAIN (cleanups_this_call); ! 5353: } ! 5354: } ! 5355: ! 5356: /* Expand conditional expressions. */ ! 5357: ! 5358: /* Generate code to evaluate EXP and jump to LABEL if the value is zero. ! 5359: LABEL is an rtx of code CODE_LABEL, in this function and all the ! 5360: functions here. */ ! 5361: ! 5362: void ! 5363: jumpifnot (exp, label) ! 5364: tree exp; ! 5365: rtx label; ! 5366: { ! 5367: do_jump (exp, label, 0); ! 5368: } ! 5369: ! 5370: /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ ! 5371: ! 5372: void ! 5373: jumpif (exp, label) ! 5374: tree exp; ! 5375: rtx label; ! 5376: { ! 5377: do_jump (exp, 0, label); ! 5378: } ! 5379: ! 5380: /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if ! 5381: the result is zero, or IF_TRUE_LABEL if the result is one. ! 5382: Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero, ! 5383: meaning fall through in that case. ! 5384: ! 5385: This function is responsible for optimizing cases such as ! 5386: &&, || and comparison operators in EXP. */ ! 5387: ! 5388: void ! 5389: do_jump (exp, if_false_label, if_true_label) ! 5390: tree exp; ! 5391: rtx if_false_label, if_true_label; ! 5392: { ! 5393: register enum tree_code code = TREE_CODE (exp); ! 5394: /* Some cases need to create a label to jump to ! 5395: in order to properly fall through. ! 5396: These cases set DROP_THROUGH_LABEL nonzero. */ ! 5397: rtx drop_through_label = 0; ! 5398: rtx temp; ! 5399: rtx comparison = 0; ! 5400: int i; ! 5401: tree type; ! 5402: ! 5403: emit_queue (); ! 5404: ! 5405: switch (code) ! 5406: { ! 5407: case ERROR_MARK: ! 5408: break; ! 5409: ! 5410: case INTEGER_CST: ! 5411: temp = integer_zerop (exp) ? if_false_label : if_true_label; ! 5412: if (temp) ! 5413: emit_jump (temp); ! 5414: break; ! 5415: ! 5416: #if 0 ! 5417: /* This is not true with #pragma weak */ ! 5418: case ADDR_EXPR: ! 5419: /* The address of something can never be zero. */ ! 5420: if (if_true_label) ! 5421: emit_jump (if_true_label); ! 5422: break; ! 5423: #endif ! 5424: ! 5425: case NOP_EXPR: ! 5426: if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF ! 5427: || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF ! 5428: || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF) ! 5429: goto normal; ! 5430: case CONVERT_EXPR: ! 5431: /* If we are narrowing the operand, we have to do the compare in the ! 5432: narrower mode. */ ! 5433: if ((TYPE_PRECISION (TREE_TYPE (exp)) ! 5434: < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5435: goto normal; ! 5436: case NON_LVALUE_EXPR: ! 5437: case REFERENCE_EXPR: ! 5438: case ABS_EXPR: ! 5439: case NEGATE_EXPR: ! 5440: case LROTATE_EXPR: ! 5441: case RROTATE_EXPR: ! 5442: /* These cannot change zero->non-zero or vice versa. */ ! 5443: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label); ! 5444: break; ! 5445: ! 5446: #if 0 ! 5447: /* This is never less insns than evaluating the PLUS_EXPR followed by ! 5448: a test and can be longer if the test is eliminated. */ ! 5449: case PLUS_EXPR: ! 5450: /* Reduce to minus. */ ! 5451: exp = build (MINUS_EXPR, TREE_TYPE (exp), ! 5452: TREE_OPERAND (exp, 0), ! 5453: fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)), ! 5454: TREE_OPERAND (exp, 1)))); ! 5455: /* Process as MINUS. */ ! 5456: #endif ! 5457: ! 5458: case MINUS_EXPR: ! 5459: /* Non-zero iff operands of minus differ. */ ! 5460: comparison = compare (build (NE_EXPR, TREE_TYPE (exp), ! 5461: TREE_OPERAND (exp, 0), ! 5462: TREE_OPERAND (exp, 1)), ! 5463: NE, NE); ! 5464: break; ! 5465: ! 5466: case BIT_AND_EXPR: ! 5467: /* If we are AND'ing with a small constant, do this comparison in the ! 5468: smallest type that fits. If the machine doesn't have comparisons ! 5469: that small, it will be converted back to the wider comparison. ! 5470: This helps if we are testing the sign bit of a narrower object. ! 5471: combine can't do this for us because it can't know whether a ! 5472: ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */ ! 5473: ! 5474: if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST ! 5475: && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_INT ! 5476: && (i = floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))) >= 0 ! 5477: && (type = type_for_size (i + 1, 1)) != 0 ! 5478: && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))) ! 5479: { ! 5480: do_jump (convert (type, exp), if_false_label, if_true_label); ! 5481: break; ! 5482: } ! 5483: goto normal; ! 5484: ! 5485: case TRUTH_NOT_EXPR: ! 5486: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label); ! 5487: break; ! 5488: ! 5489: case TRUTH_ANDIF_EXPR: ! 5490: if (if_false_label == 0) ! 5491: if_false_label = drop_through_label = gen_label_rtx (); ! 5492: do_jump (TREE_OPERAND (exp, 0), if_false_label, 0); ! 5493: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); ! 5494: break; ! 5495: ! 5496: case TRUTH_ORIF_EXPR: ! 5497: if (if_true_label == 0) ! 5498: if_true_label = drop_through_label = gen_label_rtx (); ! 5499: do_jump (TREE_OPERAND (exp, 0), 0, if_true_label); ! 5500: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); ! 5501: break; ! 5502: ! 5503: case COMPOUND_EXPR: ! 5504: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0); ! 5505: free_temp_slots (); ! 5506: emit_queue (); ! 5507: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); ! 5508: break; ! 5509: ! 5510: case COMPONENT_REF: ! 5511: case BIT_FIELD_REF: ! 5512: case ARRAY_REF: ! 5513: { ! 5514: int bitsize, bitpos, unsignedp; ! 5515: enum machine_mode mode; ! 5516: tree type; ! 5517: int volatilep = 0; ! 5518: ! 5519: /* Get description of this reference. We don't actually care ! 5520: about the underlying object here. */ ! 5521: get_inner_reference (exp, &bitsize, &bitpos, &mode, &unsignedp, ! 5522: &volatilep); ! 5523: ! 5524: type = type_for_size (bitsize, unsignedp); ! 5525: if (type != 0 ! 5526: && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))) ! 5527: { ! 5528: do_jump (convert (type, exp), if_false_label, if_true_label); ! 5529: break; ! 5530: } ! 5531: goto normal; ! 5532: } ! 5533: ! 5534: case COND_EXPR: ! 5535: /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */ ! 5536: if (integer_onep (TREE_OPERAND (exp, 1)) ! 5537: && integer_zerop (TREE_OPERAND (exp, 2))) ! 5538: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label); ! 5539: ! 5540: else if (integer_zerop (TREE_OPERAND (exp, 1)) ! 5541: && integer_onep (TREE_OPERAND (exp, 2))) ! 5542: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label); ! 5543: ! 5544: else ! 5545: { ! 5546: register rtx label1 = gen_label_rtx (); ! 5547: drop_through_label = gen_label_rtx (); ! 5548: do_jump (TREE_OPERAND (exp, 0), label1, 0); ! 5549: /* Now the THEN-expression. */ ! 5550: do_jump (TREE_OPERAND (exp, 1), ! 5551: if_false_label ? if_false_label : drop_through_label, ! 5552: if_true_label ? if_true_label : drop_through_label); ! 5553: emit_label (label1); ! 5554: /* Now the ELSE-expression. */ ! 5555: do_jump (TREE_OPERAND (exp, 2), ! 5556: if_false_label ? if_false_label : drop_through_label, ! 5557: if_true_label ? if_true_label : drop_through_label); ! 5558: } ! 5559: break; ! 5560: ! 5561: case EQ_EXPR: ! 5562: if (integer_zerop (TREE_OPERAND (exp, 1))) ! 5563: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label); ! 5564: else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5565: == MODE_INT) ! 5566: && ! 5567: !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5568: do_jump_by_parts_equality (exp, if_false_label, if_true_label); ! 5569: else ! 5570: comparison = compare (exp, EQ, EQ); ! 5571: break; ! 5572: ! 5573: case NE_EXPR: ! 5574: if (integer_zerop (TREE_OPERAND (exp, 1))) ! 5575: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label); ! 5576: else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5577: == MODE_INT) ! 5578: && ! 5579: !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5580: do_jump_by_parts_equality (exp, if_true_label, if_false_label); ! 5581: else ! 5582: comparison = compare (exp, NE, NE); ! 5583: break; ! 5584: ! 5585: case LT_EXPR: ! 5586: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5587: == MODE_INT) ! 5588: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5589: do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label); ! 5590: else ! 5591: comparison = compare (exp, LT, LTU); ! 5592: break; ! 5593: ! 5594: case LE_EXPR: ! 5595: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5596: == MODE_INT) ! 5597: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5598: do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label); ! 5599: else ! 5600: comparison = compare (exp, LE, LEU); ! 5601: break; ! 5602: ! 5603: case GT_EXPR: ! 5604: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5605: == MODE_INT) ! 5606: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5607: do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label); ! 5608: else ! 5609: comparison = compare (exp, GT, GTU); ! 5610: break; ! 5611: ! 5612: case GE_EXPR: ! 5613: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))) ! 5614: == MODE_INT) ! 5615: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))) ! 5616: do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label); ! 5617: else ! 5618: comparison = compare (exp, GE, GEU); ! 5619: break; ! 5620: ! 5621: default: ! 5622: normal: ! 5623: temp = expand_expr (exp, 0, VOIDmode, 0); ! 5624: #if 0 ! 5625: /* This is not needed any more and causes poor code since it causes ! 5626: comparisons and tests from non-SI objects to have different code ! 5627: sequences. */ ! 5628: /* Copy to register to avoid generating bad insns by cse ! 5629: from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */ ! 5630: if (!cse_not_expected && GET_CODE (temp) == MEM) ! 5631: temp = copy_to_reg (temp); ! 5632: #endif ! 5633: do_pending_stack_adjust (); ! 5634: if (GET_CODE (temp) == CONST_INT) ! 5635: comparison = (temp == const0_rtx ? const0_rtx : const_true_rtx); ! 5636: else if (GET_CODE (temp) == LABEL_REF) ! 5637: comparison = const_true_rtx; ! 5638: else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT ! 5639: && !can_compare_p (GET_MODE (temp))) ! 5640: /* Note swapping the labels gives us not-equal. */ ! 5641: do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label); ! 5642: else if (GET_MODE (temp) != VOIDmode) ! 5643: comparison = compare_from_rtx (temp, CONST0_RTX (GET_MODE (temp)), ! 5644: NE, 1, GET_MODE (temp), 0, 0); ! 5645: else ! 5646: abort (); ! 5647: } ! 5648: ! 5649: /* Do any postincrements in the expression that was tested. */ ! 5650: emit_queue (); ! 5651: ! 5652: /* If COMPARISON is nonzero here, it is an rtx that can be substituted ! 5653: straight into a conditional jump instruction as the jump condition. ! 5654: Otherwise, all the work has been done already. */ ! 5655: ! 5656: if (comparison == const_true_rtx) ! 5657: { ! 5658: if (if_true_label) ! 5659: emit_jump (if_true_label); ! 5660: } ! 5661: else if (comparison == const0_rtx) ! 5662: { ! 5663: if (if_false_label) ! 5664: emit_jump (if_false_label); ! 5665: } ! 5666: else if (comparison) ! 5667: do_jump_for_compare (comparison, if_false_label, if_true_label); ! 5668: ! 5669: free_temp_slots (); ! 5670: ! 5671: if (drop_through_label) ! 5672: emit_label (drop_through_label); ! 5673: } ! 5674: ! 5675: /* Given a comparison expression EXP for values too wide to be compared ! 5676: with one insn, test the comparison and jump to the appropriate label. ! 5677: The code of EXP is ignored; we always test GT if SWAP is 0, ! 5678: and LT if SWAP is 1. */ ! 5679: ! 5680: static void ! 5681: do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label) ! 5682: tree exp; ! 5683: int swap; ! 5684: rtx if_false_label, if_true_label; ! 5685: { ! 5686: rtx op0 = expand_expr (TREE_OPERAND (exp, swap), 0, VOIDmode, 0); ! 5687: rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), 0, VOIDmode, 0); ! 5688: enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))); ! 5689: int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD); ! 5690: rtx drop_through_label = 0; ! 5691: int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))); ! 5692: int i; ! 5693: ! 5694: if (! if_true_label || ! if_false_label) ! 5695: drop_through_label = gen_label_rtx (); ! 5696: if (! if_true_label) ! 5697: if_true_label = drop_through_label; ! 5698: if (! if_false_label) ! 5699: if_false_label = drop_through_label; ! 5700: ! 5701: /* Compare a word at a time, high order first. */ ! 5702: for (i = 0; i < nwords; i++) ! 5703: { ! 5704: rtx comp; ! 5705: rtx op0_word, op1_word; ! 5706: ! 5707: if (WORDS_BIG_ENDIAN) ! 5708: { ! 5709: op0_word = operand_subword_force (op0, i, mode); ! 5710: op1_word = operand_subword_force (op1, i, mode); ! 5711: } ! 5712: else ! 5713: { ! 5714: op0_word = operand_subword_force (op0, nwords - 1 - i, mode); ! 5715: op1_word = operand_subword_force (op1, nwords - 1 - i, mode); ! 5716: } ! 5717: ! 5718: /* All but high-order word must be compared as unsigned. */ ! 5719: comp = compare_from_rtx (op0_word, op1_word, ! 5720: (unsignedp || i > 0) ? GTU : GT, ! 5721: unsignedp, word_mode, 0, 0); ! 5722: if (comp == const_true_rtx) ! 5723: emit_jump (if_true_label); ! 5724: else if (comp != const0_rtx) ! 5725: do_jump_for_compare (comp, 0, if_true_label); ! 5726: ! 5727: /* Consider lower words only if these are equal. */ ! 5728: comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode, ! 5729: 0, 0); ! 5730: if (comp == const_true_rtx) ! 5731: emit_jump (if_false_label); ! 5732: else if (comp != const0_rtx) ! 5733: do_jump_for_compare (comp, 0, if_false_label); ! 5734: } ! 5735: ! 5736: if (if_false_label) ! 5737: emit_jump (if_false_label); ! 5738: if (drop_through_label) ! 5739: emit_label (drop_through_label); ! 5740: } ! 5741: ! 5742: /* Given an EQ_EXPR expression EXP for values too wide to be compared ! 5743: with one insn, test the comparison and jump to the appropriate label. */ ! 5744: ! 5745: static void ! 5746: do_jump_by_parts_equality (exp, if_false_label, if_true_label) ! 5747: tree exp; ! 5748: rtx if_false_label, if_true_label; ! 5749: { ! 5750: rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0); ! 5751: rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 5752: enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))); ! 5753: int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD); ! 5754: int i; ! 5755: rtx drop_through_label = 0; ! 5756: ! 5757: if (! if_false_label) ! 5758: drop_through_label = if_false_label = gen_label_rtx (); ! 5759: ! 5760: for (i = 0; i < nwords; i++) ! 5761: { ! 5762: rtx comp = compare_from_rtx (operand_subword_force (op0, i, mode), ! 5763: operand_subword_force (op1, i, mode), ! 5764: EQ, 0, word_mode, 0, 0); ! 5765: if (comp == const_true_rtx) ! 5766: emit_jump (if_false_label); ! 5767: else if (comp != const0_rtx) ! 5768: do_jump_for_compare (comp, if_false_label, 0); ! 5769: } ! 5770: ! 5771: if (if_true_label) ! 5772: emit_jump (if_true_label); ! 5773: if (drop_through_label) ! 5774: emit_label (drop_through_label); ! 5775: } ! 5776: ! 5777: /* Jump according to whether OP0 is 0. ! 5778: We assume that OP0 has an integer mode that is too wide ! 5779: for the available compare insns. */ ! 5780: ! 5781: static void ! 5782: do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label) ! 5783: rtx op0; ! 5784: rtx if_false_label, if_true_label; ! 5785: { ! 5786: int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD; ! 5787: int i; ! 5788: rtx drop_through_label = 0; ! 5789: ! 5790: if (! if_false_label) ! 5791: drop_through_label = if_false_label = gen_label_rtx (); ! 5792: ! 5793: for (i = 0; i < nwords; i++) ! 5794: { ! 5795: rtx comp = compare_from_rtx (operand_subword_force (op0, i, ! 5796: GET_MODE (op0)), ! 5797: const0_rtx, EQ, 0, word_mode, 0, 0); ! 5798: if (comp == const_true_rtx) ! 5799: emit_jump (if_false_label); ! 5800: else if (comp != const0_rtx) ! 5801: do_jump_for_compare (comp, if_false_label, 0); ! 5802: } ! 5803: ! 5804: if (if_true_label) ! 5805: emit_jump (if_true_label); ! 5806: if (drop_through_label) ! 5807: emit_label (drop_through_label); ! 5808: } ! 5809: ! 5810: /* Given a comparison expression in rtl form, output conditional branches to ! 5811: IF_TRUE_LABEL, IF_FALSE_LABEL, or both. */ ! 5812: ! 5813: static void ! 5814: do_jump_for_compare (comparison, if_false_label, if_true_label) ! 5815: rtx comparison, if_false_label, if_true_label; ! 5816: { ! 5817: if (if_true_label) ! 5818: { ! 5819: if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0) ! 5820: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_true_label)); ! 5821: else ! 5822: abort (); ! 5823: ! 5824: if (if_false_label) ! 5825: emit_jump (if_false_label); ! 5826: } ! 5827: else if (if_false_label) ! 5828: { ! 5829: rtx insn; ! 5830: rtx prev = PREV_INSN (get_last_insn ()); ! 5831: rtx branch = 0; ! 5832: ! 5833: /* Output the branch with the opposite condition. Then try to invert ! 5834: what is generated. If more than one insn is a branch, or if the ! 5835: branch is not the last insn written, abort. If we can't invert ! 5836: the branch, emit make a true label, redirect this jump to that, ! 5837: emit a jump to the false label and define the true label. */ ! 5838: ! 5839: if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0) ! 5840: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_false_label)); ! 5841: else ! 5842: abort (); ! 5843: ! 5844: /* Here we get the insn before what was just emitted. ! 5845: On some machines, emitting the branch can discard ! 5846: the previous compare insn and emit a replacement. */ ! 5847: if (prev == 0) ! 5848: /* If there's only one preceding insn... */ ! 5849: insn = get_insns (); ! 5850: else ! 5851: insn = NEXT_INSN (prev); ! 5852: ! 5853: for (insn = NEXT_INSN (insn); insn; insn = NEXT_INSN (insn)) ! 5854: if (GET_CODE (insn) == JUMP_INSN) ! 5855: { ! 5856: if (branch) ! 5857: abort (); ! 5858: branch = insn; ! 5859: } ! 5860: ! 5861: if (branch != get_last_insn ()) ! 5862: abort (); ! 5863: ! 5864: if (! invert_jump (branch, if_false_label)) ! 5865: { ! 5866: if_true_label = gen_label_rtx (); ! 5867: redirect_jump (branch, if_true_label); ! 5868: emit_jump (if_false_label); ! 5869: emit_label (if_true_label); ! 5870: } ! 5871: } ! 5872: } ! 5873: ! 5874: /* Generate code for a comparison expression EXP ! 5875: (including code to compute the values to be compared) ! 5876: and set (CC0) according to the result. ! 5877: SIGNED_CODE should be the rtx operation for this comparison for ! 5878: signed data; UNSIGNED_CODE, likewise for use if data is unsigned. ! 5879: ! 5880: We force a stack adjustment unless there are currently ! 5881: things pushed on the stack that aren't yet used. */ ! 5882: ! 5883: static rtx ! 5884: compare (exp, signed_code, unsigned_code) ! 5885: register tree exp; ! 5886: enum rtx_code signed_code, unsigned_code; ! 5887: { ! 5888: register rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0); ! 5889: register rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0); ! 5890: register tree type = TREE_TYPE (TREE_OPERAND (exp, 0)); ! 5891: register enum machine_mode mode = TYPE_MODE (type); ! 5892: int unsignedp = TREE_UNSIGNED (type); ! 5893: enum rtx_code code = unsignedp ? unsigned_code : signed_code; ! 5894: ! 5895: return compare_from_rtx (op0, op1, code, unsignedp, mode, ! 5896: ((mode == BLKmode) ! 5897: ? expr_size (TREE_OPERAND (exp, 0)) : 0), ! 5898: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT); ! 5899: } ! 5900: ! 5901: /* Like compare but expects the values to compare as two rtx's. ! 5902: The decision as to signed or unsigned comparison must be made by the caller. ! 5903: ! 5904: If MODE is BLKmode, SIZE is an RTX giving the size of the objects being ! 5905: compared. ! 5906: ! 5907: If ALIGN is non-zero, it is the alignment of this type; if zero, the ! 5908: size of MODE should be used. */ ! 5909: ! 5910: rtx ! 5911: compare_from_rtx (op0, op1, code, unsignedp, mode, size, align) ! 5912: register rtx op0, op1; ! 5913: enum rtx_code code; ! 5914: int unsignedp; ! 5915: enum machine_mode mode; ! 5916: rtx size; ! 5917: int align; ! 5918: { ! 5919: /* If one operand is constant, make it the second one. */ ! 5920: ! 5921: if (GET_CODE (op0) == CONST_INT || GET_CODE (op0) == CONST_DOUBLE) ! 5922: { ! 5923: rtx tem = op0; ! 5924: op0 = op1; ! 5925: op1 = tem; ! 5926: code = swap_condition (code); ! 5927: } ! 5928: ! 5929: if (flag_force_mem) ! 5930: { ! 5931: op0 = force_not_mem (op0); ! 5932: op1 = force_not_mem (op1); ! 5933: } ! 5934: ! 5935: do_pending_stack_adjust (); ! 5936: ! 5937: if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT) ! 5938: return simplify_relational_operation (code, mode, op0, op1); ! 5939: ! 5940: /* If this is a signed equality comparison, we can do it as an ! 5941: unsigned comparison since zero-extension is cheaper than sign ! 5942: extension and comparisons with zero are done as unsigned. If we ! 5943: are comparing against a constant, we must convert it to what it ! 5944: would look like unsigned. */ ! 5945: if ((code == EQ || code == NE) && ! unsignedp ! 5946: && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT) ! 5947: { ! 5948: if (GET_CODE (op1) == CONST_INT ! 5949: && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1)) ! 5950: op1 = gen_rtx (CONST_INT, VOIDmode, ! 5951: INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))); ! 5952: unsignedp = 1; ! 5953: } ! 5954: ! 5955: emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align); ! 5956: ! 5957: return gen_rtx (code, VOIDmode, cc0_rtx, const0_rtx); ! 5958: } ! 5959: ! 5960: /* Generate code to calculate EXP using a store-flag instruction ! 5961: and return an rtx for the result. ! 5962: If TARGET is nonzero, store the result there if convenient. ! 5963: ! 5964: If ONLY_CHEAP is non-zero, only do this if it is likely to be very ! 5965: cheap. ! 5966: ! 5967: Return zero if there is no suitable set-flag instruction ! 5968: available on this machine. ! 5969: ! 5970: Once expand_expr has been called on the arguments of the comparison, ! 5971: we are committed to doing the store flag, since it is not safe to ! 5972: re-evaluate the expression. We emit the store-flag insn by calling ! 5973: emit_store_flag, but only expand the arguments if we have a reason ! 5974: to believe that emit_store_flag will be successful. If we think that ! 5975: it will, but it isn't, we have to simulate the store-flag with a ! 5976: set/jump/set sequence. */ ! 5977: ! 5978: static rtx ! 5979: do_store_flag (exp, target, mode, only_cheap) ! 5980: tree exp; ! 5981: rtx target; ! 5982: enum machine_mode mode; ! 5983: int only_cheap; ! 5984: { ! 5985: enum rtx_code code; ! 5986: tree arg0 = TREE_OPERAND (exp, 0); ! 5987: tree arg1 = TREE_OPERAND (exp, 1); ! 5988: tree tem; ! 5989: tree type = TREE_TYPE (arg0); ! 5990: enum machine_mode operand_mode = TYPE_MODE (type); ! 5991: int unsignedp = TREE_UNSIGNED (type); ! 5992: rtx op0, op1; ! 5993: enum insn_code icode; ! 5994: rtx subtarget = target; ! 5995: rtx result, label, pattern, jump_pat; ! 5996: ! 5997: /* We won't bother with BLKmode store-flag operations because it would mean ! 5998: passing a lot of information to emit_store_flag. */ ! 5999: if (operand_mode == BLKmode) ! 6000: return 0; ! 6001: ! 6002: while (TREE_CODE (arg0) == NON_LVALUE_EXPR) ! 6003: arg0 = TREE_OPERAND (arg0, 0); ! 6004: ! 6005: while (TREE_CODE (arg1) == NON_LVALUE_EXPR) ! 6006: arg1 = TREE_OPERAND (arg1, 0); ! 6007: ! 6008: /* Put a constant second. */ ! 6009: if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST) ! 6010: { ! 6011: tem = arg0; arg0 = arg1; arg1 = tem; ! 6012: } ! 6013: ! 6014: /* Get the rtx comparison code to use. We know that EXP is a comparison ! 6015: operation of some type. Some comparisons against 1 and -1 can be ! 6016: converted to comparisons with zero. Do so here so that the tests ! 6017: below will be aware that we have a comparison with zero. */ ! 6018: ! 6019: switch (TREE_CODE (exp)) ! 6020: { ! 6021: case EQ_EXPR: ! 6022: code = EQ; ! 6023: break; ! 6024: case NE_EXPR: ! 6025: code = NE; ! 6026: break; ! 6027: case LT_EXPR: ! 6028: if (integer_onep (arg1)) ! 6029: arg1 = integer_zero_node, code = unsignedp ? LEU : LE; ! 6030: else ! 6031: code = unsignedp ? LTU : LT; ! 6032: break; ! 6033: case LE_EXPR: ! 6034: if (integer_all_onesp (arg1)) ! 6035: arg1 = integer_zero_node, code = unsignedp ? LTU : LT; ! 6036: else ! 6037: code = unsignedp ? LEU : LE; ! 6038: break; ! 6039: case GT_EXPR: ! 6040: if (integer_all_onesp (arg1)) ! 6041: arg1 = integer_zero_node, code = unsignedp ? GEU : GE; ! 6042: else ! 6043: code = unsignedp ? GTU : GT; ! 6044: break; ! 6045: case GE_EXPR: ! 6046: if (integer_onep (arg1)) ! 6047: arg1 = integer_zero_node, code = unsignedp ? GTU : GT; ! 6048: else ! 6049: code = unsignedp ? GEU : GE; ! 6050: break; ! 6051: default: ! 6052: abort (); ! 6053: } ! 6054: ! 6055: /* If this is an equality or inequality test of a single bit, we can ! 6056: do this by shifting the bit being tested to the low-order bit and ! 6057: masking the result with the constant 1. If the condition was EQ, ! 6058: we xor it with 1. This does not require an scc insn and is faster ! 6059: than an scc insn even if we have it. */ ! 6060: ! 6061: if ((code == NE || code == EQ) ! 6062: && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1) ! 6063: && integer_pow2p (TREE_OPERAND (arg0, 1)) ! 6064: && TYPE_PRECISION (type) <= HOST_BITS_PER_INT) ! 6065: { ! 6066: int bitnum = exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0, 1), ! 6067: 0, VOIDmode, 0))); ! 6068: ! 6069: if (subtarget == 0 || GET_CODE (subtarget) != REG ! 6070: || GET_MODE (subtarget) != operand_mode ! 6071: || ! safe_from_p (subtarget, TREE_OPERAND (arg0, 0))) ! 6072: subtarget = 0; ! 6073: ! 6074: op0 = expand_expr (TREE_OPERAND (arg0, 0), subtarget, VOIDmode, 0); ! 6075: ! 6076: if (bitnum != 0) ! 6077: op0 = expand_shift (RSHIFT_EXPR, GET_MODE (op0), op0, ! 6078: size_int (bitnum), target, 1); ! 6079: ! 6080: if (GET_MODE (op0) != mode) ! 6081: op0 = convert_to_mode (mode, op0, 1); ! 6082: ! 6083: if (bitnum != TYPE_PRECISION (type) - 1) ! 6084: op0 = expand_and (op0, const1_rtx, target); ! 6085: ! 6086: if (code == EQ) ! 6087: op0 = expand_binop (mode, xor_optab, op0, const1_rtx, target, 0, ! 6088: OPTAB_LIB_WIDEN); ! 6089: ! 6090: return op0; ! 6091: } ! 6092: ! 6093: /* Now see if we are likely to be able to do this. Return if not. */ ! 6094: if (! can_compare_p (operand_mode)) ! 6095: return 0; ! 6096: icode = setcc_gen_code[(int) code]; ! 6097: if (icode == CODE_FOR_nothing ! 6098: || (only_cheap && insn_operand_mode[(int) icode][0] != mode)) ! 6099: { ! 6100: /* We can only do this if it is one of the special cases that ! 6101: can be handled without an scc insn. */ ! 6102: if ((code == LT && integer_zerop (arg1)) ! 6103: || (! only_cheap && code == GE && integer_zerop (arg1))) ! 6104: ; ! 6105: else if (BRANCH_COST >= 0 ! 6106: && ! only_cheap && (code == NE || code == EQ) ! 6107: && TREE_CODE (type) != REAL_TYPE ! 6108: && ((abs_optab->handlers[(int) operand_mode].insn_code ! 6109: != CODE_FOR_nothing) ! 6110: || (ffs_optab->handlers[(int) operand_mode].insn_code ! 6111: != CODE_FOR_nothing))) ! 6112: ; ! 6113: else ! 6114: return 0; ! 6115: } ! 6116: ! 6117: preexpand_calls (exp); ! 6118: if (subtarget == 0 || GET_CODE (subtarget) != REG ! 6119: || GET_MODE (subtarget) != operand_mode ! 6120: || ! safe_from_p (subtarget, arg1)) ! 6121: subtarget = 0; ! 6122: ! 6123: op0 = expand_expr (arg0, subtarget, VOIDmode, 0); ! 6124: op1 = expand_expr (arg1, 0, VOIDmode, 0); ! 6125: ! 6126: if (target == 0) ! 6127: target = gen_reg_rtx (mode); ! 6128: ! 6129: result = emit_store_flag (target, code, op0, op1, operand_mode, ! 6130: unsignedp, 1); ! 6131: ! 6132: if (result) ! 6133: return result; ! 6134: ! 6135: /* If this failed, we have to do this with set/compare/jump/set code. */ ! 6136: if (target == 0 || GET_CODE (target) != REG ! 6137: || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1)) ! 6138: target = gen_reg_rtx (GET_MODE (target)); ! 6139: ! 6140: emit_move_insn (target, const1_rtx); ! 6141: result = compare_from_rtx (op0, op1, code, unsignedp, operand_mode, 0, 0); ! 6142: if (GET_CODE (result) == CONST_INT) ! 6143: return result == const0_rtx ? const0_rtx : const1_rtx; ! 6144: ! 6145: label = gen_label_rtx (); ! 6146: if (bcc_gen_fctn[(int) code] == 0) ! 6147: abort (); ! 6148: ! 6149: emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label)); ! 6150: emit_move_insn (target, const0_rtx); ! 6151: emit_label (label); ! 6152: ! 6153: return target; ! 6154: } ! 6155: ! 6156: /* Generate a tablejump instruction (used for switch statements). */ ! 6157: ! 6158: #ifdef HAVE_tablejump ! 6159: ! 6160: /* INDEX is the value being switched on, with the lowest value ! 6161: in the table already subtracted. ! 6162: RANGE is the length of the jump table. ! 6163: TABLE_LABEL is a CODE_LABEL rtx for the table itself. ! 6164: ! 6165: DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the ! 6166: index value is out of range. */ ! 6167: ! 6168: void ! 6169: do_tablejump (index, range, table_label, default_label) ! 6170: rtx index, range, table_label, default_label; ! 6171: { ! 6172: register rtx temp, vector; ! 6173: ! 6174: emit_cmp_insn (range, index, LTU, 0, GET_MODE (index), 0, 0); ! 6175: emit_jump_insn (gen_bltu (default_label)); ! 6176: /* If flag_force_addr were to affect this address ! 6177: it could interfere with the tricky assumptions made ! 6178: about addresses that contain label-refs, ! 6179: which may be valid only very near the tablejump itself. */ ! 6180: /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the ! 6181: GET_MODE_SIZE, because this indicates how large insns are. The other ! 6182: uses should all be Pmode, because they are addresses. This code ! 6183: could fail if addresses and insns are not the same size. */ ! 6184: index = memory_address_noforce ! 6185: (CASE_VECTOR_MODE, ! 6186: gen_rtx (PLUS, Pmode, ! 6187: gen_rtx (MULT, Pmode, index, ! 6188: gen_rtx (CONST_INT, VOIDmode, ! 6189: GET_MODE_SIZE (CASE_VECTOR_MODE))), ! 6190: gen_rtx (LABEL_REF, Pmode, table_label))); ! 6191: temp = gen_reg_rtx (CASE_VECTOR_MODE); ! 6192: vector = gen_rtx (MEM, CASE_VECTOR_MODE, index); ! 6193: RTX_UNCHANGING_P (vector) = 1; ! 6194: convert_move (temp, vector, 0); ! 6195: ! 6196: emit_jump_insn (gen_tablejump (temp, table_label)); ! 6197: ! 6198: #ifndef CASE_VECTOR_PC_RELATIVE ! 6199: /* If we are generating PIC code or if the table is PC-relative, the ! 6200: table and JUMP_INSN must be adjacent, so don't output a BARRIER. */ ! 6201: if (! flag_pic) ! 6202: emit_barrier (); ! 6203: #endif ! 6204: } ! 6205: ! 6206: #endif /* HAVE_tablejump */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.