![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to stmt.c CVS log | Up to [GCC 1.x] / gcc |
1.1 ! root 1: /* Expands front end tree to back end RTL for GNU C-Compiler ! 2: Copyright (C) 1987 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* This file handles the generation of rtl code from tree structure ! 23: at the level of statements using subroutines in exp*.c and emit-rtl.c. ! 24: It also creates the rtl expressions for parameters and auto variables ! 25: and has full responsibility for allocating stack slots. ! 26: A few routines in this file are called during later passes ! 27: when stack frame management requires it. ! 28: ! 29: The main entry point is expand_function, which is at the end. */ ! 30: ! 31: #include "config.h" ! 32: ! 33: #include <stdio.h> ! 34: ! 35: #include "rtl.h" ! 36: #include "tree.h" ! 37: #include "insn-flags.h" ! 38: #include "stupid.h" ! 39: #include "expr.h" ! 40: ! 41: #define MAX(x,y) (((x) > (y)) ? (x) : (y)) ! 42: #define MIN(x,y) (((x) < (y)) ? (x) : (y)) ! 43: ! 44: /* Label that will go on function epilogue. ! 45: Jumping to this label serves as a "return" instruction ! 46: on machines which require execution of the epilogue on all returns. */ ! 47: ! 48: static rtx return_label; ! 49: ! 50: /* The FUNCTION_DECL node for the function being compiled. */ ! 51: ! 52: static tree this_function; ! 53: ! 54: /* Offset to end of allocated area of stack frame. ! 55: If stack grows down, this is the address of the last stack slot allocated. ! 56: If stack grows up, this is the address for the next slot. */ ! 57: static int frame_offset; ! 58: ! 59: /* Length in bytes of largest structure value returned by ! 60: any function called so far in this function. */ ! 61: static int max_structure_value_size; ! 62: ! 63: /* Label to jump back to for tail recursion, or 0 if we have ! 64: not yet needed one for this function. */ ! 65: static rtx tail_recursion_label; ! 66: ! 67: /* Place after which to insert the tail_recursion_label if we need one. */ ! 68: static rtx tail_recursion_reentry; ! 69: ! 70: static int tail_recursion_args (); ! 71: ! 72: /* Estimate the complexity of the compiled code for STMT. ! 73: This is a rough estimate and is used for purposes ! 74: of deciding which optimizations are worth applying. */ ! 75: ! 76: static int ! 77: stmt_complexity (stmt) ! 78: tree stmt; ! 79: { ! 80: register tree s; ! 81: register int c = 0; ! 82: for (s = stmt; s; s = TREE_CHAIN (s)) ! 83: switch (TREE_CODE (s)) ! 84: { ! 85: case LABEL_STMT: ! 86: break; ! 87: ! 88: case COMPOUND_STMT: ! 89: c += stmt_complexity (STMT_BODY (s)); ! 90: break; ! 91: ! 92: case LOOP_STMT: ! 93: c += 1 + stmt_complexity (STMT_BODY (s)); ! 94: break; ! 95: ! 96: case EXIT_STMT: ! 97: c += 2; ! 98: break; ! 99: ! 100: case GOTO_STMT: ! 101: case ASM_STMT: ! 102: c += 1; ! 103: break; ! 104: ! 105: case IF_STMT: ! 106: c += 2 + stmt_complexity (STMT_THEN (s)) ! 107: + stmt_complexity (STMT_ELSE (s)); ! 108: break; ! 109: ! 110: case EXPR_STMT: ! 111: case RETURN_STMT: ! 112: c += 3; ! 113: break; ! 114: ! 115: /* The body of the case statement is actually not included ! 116: in the CASE_STMT, so it will be counted separately. */ ! 117: case CASE_STMT: ! 118: c += 3; ! 119: break; ! 120: ! 121: case LET_STMT: ! 122: case WITH_STMT: ! 123: c += list_length (STMT_VARS (s)) + stmt_complexity (STMT_BODY (s)); ! 124: break; ! 125: ! 126: default: abort (); ! 127: } ! 128: return c; ! 129: } ! 130: ! 131: static void expand_stmt (); ! 132: static void expand_stmts (); ! 133: static void expand_case_stmt (); ! 134: ! 135: /* Set nonzero at beginning of function ! 136: to prevent output of the NOTE_INSN_BLOCK_BEG for the outermost block. ! 137: This is because `final' generates it specially, ! 138: before the function prologue. */ ! 139: ! 140: static int inhibit_block_beg; ! 141: ! 142: /* Return the rtx-label that corresponds to a LABEL_DECL, ! 143: creating it if necessary. */ ! 144: ! 145: static rtx ! 146: label_rtx (label) ! 147: tree label; ! 148: { ! 149: if (DECL_RTL (label)) ! 150: return DECL_RTL (label); ! 151: ! 152: return DECL_RTL (label) = gen_label_rtx (); ! 153: } ! 154: ! 155: /* Add an unconditional jump to LABEL as the next sequential instruction. */ ! 156: ! 157: void ! 158: emit_jump (label) ! 159: rtx label; ! 160: { ! 161: do_pending_stack_adjust (); ! 162: emit_jump_insn (gen_jump (label)); ! 163: emit_barrier (); ! 164: } ! 165: ! 166: /* Return nonzero if T is a "simple enough" expression ! 167: such that we prefer to duplicate it as a loop exit condition. ! 168: We accept only comparisons whose operands are constants or variables. */ ! 169: ! 170: static int ! 171: exit_simple_enough_p (t) ! 172: tree t; ! 173: { ! 174: register enum tree_code code = TREE_CODE (t); ! 175: register tree op; ! 176: if (!(code == EQ_EXPR || code == NE_EXPR ! 177: || code == LT_EXPR || code == LE_EXPR ! 178: || code == GT_EXPR || code == GE_EXPR)) ! 179: return 0; ! 180: op = TREE_OPERAND (t, 0); ! 181: if (TREE_CODE (op) != VAR_DECL ! 182: && TREE_CODE (op) != INTEGER_CST ! 183: && TREE_CODE (op) != REAL_CST) ! 184: return 0; ! 185: op = TREE_OPERAND (t, 1); ! 186: if (TREE_CODE (op) != VAR_DECL ! 187: && TREE_CODE (op) != INTEGER_CST ! 188: && TREE_CODE (op) != REAL_CST) ! 189: return 0; ! 190: return 1; ! 191: } ! 192: ! 193: /* Generate rtl code for a sequence of statements ! 194: chained through the TREE_CHAIN. ! 195: LOOP_EXIT says where an EXIT_STMT should jump to. */ ! 196: ! 197: static void ! 198: expand_stmts (stmts, loop_exit) ! 199: tree stmts; ! 200: rtx loop_exit; ! 201: { ! 202: register tree stmt; ! 203: for (stmt = stmts; stmt; stmt = TREE_CHAIN (stmt)) ! 204: expand_stmt (stmt, loop_exit); ! 205: } ! 206: ! 207: /* Generate rtl for one statement, STMT. ! 208: LOOP_EXIT is an rtl CODE_LABEL to jump to to exit a loop. */ ! 209: ! 210: /* Stack of LET_STMT blocks that we are currently within ! 211: during the rtl-generation tree walk. */ ! 212: ! 213: struct block_stack ! 214: { ! 215: tree block; /* the LET_STMT tree node */ ! 216: rtx stack_level; /* the saved-on-entry stack pointer */ ! 217: struct block_stack *next; /* data for the containing LET_STMT or 0 */ ! 218: }; ! 219: ! 220: struct block_stack *block_stack; ! 221: ! 222: static void ! 223: expand_stmt (stmt, loop_exit) ! 224: tree stmt; ! 225: rtx loop_exit; ! 226: { ! 227: struct block_stack thisblock; ! 228: ! 229: if (STMT_SOURCE_LINE (stmt) != 0) ! 230: emit_note (STMT_SOURCE_FILE (stmt), STMT_SOURCE_LINE (stmt)); ! 231: ! 232: switch (TREE_CODE (stmt)) ! 233: { ! 234: case LABEL_STMT: ! 235: do_pending_stack_adjust (); ! 236: emit_label (label_rtx (STMT_BODY (stmt))); ! 237: break; ! 238: ! 239: case GOTO_STMT: ! 240: if (GET_CODE (label_rtx (STMT_BODY (stmt))) != CODE_LABEL) ! 241: abort (); ! 242: /* Look at the binding contours (LET_STMTs) we are jumping out of ! 243: and if any of them allocates a variable size auto variable ! 244: reset the stack to the appropriate level. */ ! 245: { ! 246: tree context = DECL_CONTEXT (STMT_BODY (stmt)); ! 247: struct block_stack *block; ! 248: rtx stack_level = 0; ! 249: ! 250: /* Chase contexts up from the target label. */ ! 251: while (context) ! 252: { ! 253: /* Chase contexts up from where we are. ! 254: We want the innermost block containing both ! 255: the goto and the label. */ ! 256: for (block = block_stack; block; ! 257: block = block->next) ! 258: { ! 259: if (block->stack_level != 0) ! 260: stack_level = block->stack_level; ! 261: if (block->block == context) ! 262: { ! 263: if (stack_level != 0) ! 264: emit_move_insn (gen_rtx (REG, Pmode, ! 265: STACK_POINTER_REGNUM), ! 266: stack_level); ! 267: goto context_done; ! 268: } ! 269: } ! 270: context = STMT_SUPERCONTEXT (context); ! 271: } ! 272: context_done: ; ! 273: } ! 274: emit_jump (label_rtx (STMT_BODY (stmt))); ! 275: break; ! 276: ! 277: case EXPR_STMT: ! 278: expand_expr (STMT_BODY (stmt), 0, VOIDmode, 0); ! 279: break; ! 280: ! 281: case COMPOUND_STMT: ! 282: expand_stmts (STMT_BODY (stmt), loop_exit); ! 283: break; ! 284: ! 285: case ASM_STMT: ! 286: emit_insn (gen_rtx (ASM_INPUT, VOIDmode, ! 287: TREE_STRING_POINTER (STMT_BODY (stmt)))); ! 288: break; ! 289: ! 290: case IF_STMT: ! 291: { ! 292: register rtx afterlabel = gen_label_rtx (); ! 293: ! 294: /* Simpler handling if there is no else-part ! 295: or a null then-part. */ ! 296: if (STMT_THEN (stmt) == 0) ! 297: { ! 298: do_jump (STMT_COND (stmt), NULL, afterlabel); ! 299: expand_stmts (STMT_ELSE (stmt), loop_exit); ! 300: } ! 301: else if (STMT_ELSE (stmt) == 0) ! 302: { ! 303: do_jump (STMT_COND (stmt), afterlabel, NULL); ! 304: expand_stmts (STMT_THEN (stmt), loop_exit); ! 305: } ! 306: else ! 307: { ! 308: register rtx elselabel = gen_label_rtx (); ! 309: ! 310: do_jump (STMT_COND (stmt), elselabel, NULL); ! 311: expand_stmts (STMT_THEN (stmt), loop_exit); ! 312: emit_jump (afterlabel); ! 313: emit_label (elselabel); ! 314: expand_stmts (STMT_ELSE (stmt), loop_exit); ! 315: } ! 316: do_pending_stack_adjust (); ! 317: emit_label (afterlabel); ! 318: } ! 319: break; ! 320: ! 321: case EXIT_STMT: ! 322: /* Exit if the condition is false. */ ! 323: do_jump (STMT_BODY (stmt), loop_exit, NULL); ! 324: break; ! 325: ! 326: case RETURN_STMT: ! 327: if (STMT_BODY (stmt)) ! 328: { ! 329: register rtx val = 0; ! 330: register rtx op0; ! 331: /* For tail-recursive call to current function, ! 332: just jump back to the beginning. ! 333: It's unsafe if any auto variable in this function ! 334: has its address taken; for simplicity, ! 335: require stack frame to be empty. */ ! 336: if (! cse_not_expected ! 337: && frame_offset == 0 ! 338: && TREE_CODE (STMT_BODY (stmt)) == MODIFY_EXPR ! 339: && TREE_CODE (TREE_OPERAND (STMT_BODY (stmt), 1)) == CALL_EXPR ! 340: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (STMT_BODY (stmt), 1), 0)) == ADDR_EXPR ! 341: && TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (STMT_BODY (stmt), 1), 0), 0) == this_function ! 342: /* Finish checking validity, and if valid emit code ! 343: to set the argument variables for the new call. */ ! 344: && tail_recursion_args (TREE_OPERAND (TREE_OPERAND (STMT_BODY (stmt), 1), 1), ! 345: DECL_ARGUMENTS (this_function))) ! 346: { ! 347: ; ! 348: if (tail_recursion_label == 0) ! 349: { ! 350: tail_recursion_label = gen_label_rtx (); ! 351: emit_label_after (tail_recursion_label, ! 352: tail_recursion_reentry); ! 353: } ! 354: emit_jump (tail_recursion_label); ! 355: emit_barrier (); ! 356: break; ! 357: } ! 358: #ifndef FUNCTION_EPILOGUE ! 359: /* If this is return x == y; then generate ! 360: if (x == y) return 1; else return 0; ! 361: if we can do it with explicit return insns. */ ! 362: if (TREE_CODE (STMT_BODY (stmt)) == MODIFY_EXPR) ! 363: switch (TREE_CODE (TREE_OPERAND (STMT_BODY (stmt), 1))) ! 364: { ! 365: case EQ_EXPR: ! 366: case NE_EXPR: ! 367: case GT_EXPR: ! 368: case GE_EXPR: ! 369: case LT_EXPR: ! 370: case LE_EXPR: ! 371: case TRUTH_ANDIF_EXPR: ! 372: case TRUTH_ORIF_EXPR: ! 373: case TRUTH_NOT_EXPR: ! 374: op0 = gen_label_rtx (); ! 375: val = DECL_RTL (DECL_RESULT (this_function)); ! 376: jumpifnot (TREE_OPERAND (STMT_BODY (stmt), 1), op0); ! 377: emit_move_insn (val, const1_rtx); ! 378: emit_insn (gen_rtx (USE, VOIDmode, val)); ! 379: emit_jump_insn (gen_return ()); ! 380: emit_barrier (); ! 381: emit_label (op0); ! 382: emit_move_insn (val, const0_rtx); ! 383: emit_insn (gen_rtx (USE, VOIDmode, val)); ! 384: emit_jump_insn (gen_return ()); ! 385: emit_barrier (); ! 386: } ! 387: if (val != 0) ! 388: break; ! 389: #endif ! 390: val = expand_expr (STMT_BODY (stmt), 0, VOIDmode, 0); ! 391: if (GET_CODE (val) == REG) ! 392: emit_insn (gen_rtx (USE, VOIDmode, val)); ! 393: emit_queue (); ! 394: } ! 395: /* Return insn or function epilogue ignore the stack pointer. */ ! 396: clear_pending_stack_adjust (); ! 397: #ifdef FUNCTION_EPILOGUE ! 398: emit_jump (return_label); ! 399: #else ! 400: emit_jump_insn (gen_return ()); ! 401: #endif ! 402: emit_barrier (); ! 403: break; ! 404: ! 405: case LET_STMT: ! 406: { ! 407: rtx oldstack = 0; ! 408: register tree decl; ! 409: ! 410: /* Make an entry on BLOCK_STACK for the block we are entering. */ ! 411: ! 412: thisblock.block = stmt; ! 413: thisblock.next = block_stack; ! 414: thisblock.stack_level = 0; ! 415: block_stack = &thisblock; ! 416: ! 417: /* Output a NOTE to mark the beginning of the scope, ! 418: except when inhibited (for a function's outermost block). */ ! 419: ! 420: if (inhibit_block_beg) ! 421: inhibit_block_beg = 0; ! 422: else ! 423: emit_note (0, NOTE_INSN_BLOCK_BEG); ! 424: ! 425: if (reg_birth_insn) ! 426: { ! 427: /* If doing stupid register allocation, ! 428: mark all register variables of this block ! 429: as beginning life here. */ ! 430: ! 431: register rtx last_insn = get_last_insn (); ! 432: ! 433: for (decl = STMT_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 434: { ! 435: if (TREE_CODE (decl) == VAR_DECL ! 436: && DECL_RTL (decl) != 0 ! 437: && GET_CODE (DECL_RTL (decl)) == REG) ! 438: reg_birth_insn[REGNO (DECL_RTL (decl))] = last_insn; ! 439: } ! 440: } ! 441: ! 442: /* Allocate space for all variable-size variables, ! 443: and set OLDSTACK nonzero if there are any. */ ! 444: for (decl = STMT_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 445: if (TREE_CODE (decl) == VAR_DECL ! 446: && !TREE_LITERAL (DECL_SIZE (decl))) ! 447: { ! 448: rtx address, size; ! 449: ! 450: if (oldstack == 0) ! 451: { ! 452: do_pending_stack_adjust (); ! 453: oldstack = copy_to_reg (gen_rtx (REG, Pmode, ! 454: STACK_POINTER_REGNUM)); ! 455: thisblock.stack_level = oldstack; ! 456: } ! 457: size = expand_expr (DECL_SIZE (decl), 0, VOIDmode, 0); ! 458: #ifdef STACK_GROWS_DOWNWARD ! 459: anti_adjust_stack (size); ! 460: #endif ! 461: address = copy_to_reg (gen_rtx (REG, Pmode, ! 462: STACK_POINTER_REGNUM)); ! 463: #ifndef STACK_GROWS_DOWNWARD ! 464: anti_adjust_stack (size); ! 465: #endif ! 466: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), address); ! 467: } ! 468: ! 469: /* Compute and store the initial values ! 470: of all nonstatic variables bound here. */ ! 471: for (decl = STMT_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 472: if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl) ! 473: && ! TREE_STATIC (decl)) ! 474: { ! 475: if (DECL_VOFFSET (decl) ! 476: || !TREE_LITERAL (DECL_SIZE (decl))) ! 477: abort (); ! 478: emit_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); ! 479: expand_assignment (decl, DECL_INITIAL (decl)); ! 480: } ! 481: ! 482: /* Generate code for the body of the block. */ ! 483: ! 484: expand_stmts (STMT_BODY (stmt), 0); ! 485: ! 486: /* Mark the end of the scope. */ ! 487: ! 488: emit_note (0, NOTE_INSN_BLOCK_END); ! 489: ! 490: if (reg_death_insn) ! 491: { ! 492: /* If doing stupid register allocation, ! 493: mark all register variables of this block ! 494: as having just died. */ ! 495: register rtx last_insn = get_last_insn (); ! 496: ! 497: for (decl = STMT_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 498: { ! 499: if (TREE_CODE (decl) == VAR_DECL ! 500: && DECL_RTL (decl) != 0 ! 501: && GET_CODE (DECL_RTL (decl)) == REG) ! 502: reg_death_insn[REGNO (DECL_RTL (decl))] = last_insn; ! 503: } ! 504: } ! 505: ! 506: /* Restore stack level in effect before the block ! 507: (only if variable-size objects allocated). */ ! 508: ! 509: if (oldstack != 0) ! 510: emit_move_insn (gen_rtx (REG, Pmode, ! 511: STACK_POINTER_REGNUM), ! 512: oldstack); ! 513: ! 514: /* Restore block_stack level for containing block. */ ! 515: ! 516: block_stack = thisblock.next; ! 517: } ! 518: break; ! 519: ! 520: case LOOP_STMT: ! 521: { ! 522: register rtx lab1, lab2; ! 523: register tree x1 = tree_last (STMT_BODY (stmt)); ! 524: ! 525: /* There are several ways to arrange the compilation of a loop. ! 526: We choose one depending on where the exits are and what kinds ! 527: of conditions they test. */ ! 528: ! 529: lab1 = gen_label_rtx (); ! 530: lab2 = gen_label_rtx (); ! 531: ! 532: /* If the body ends with a conditional exit or goto, ! 533: just compile it straight through. The conditional at the end ! 534: will combine with the branch back. */ ! 535: if (TREE_CODE (x1) == EXIT_STMT ! 536: || (TREE_CODE (x1) == IF_STMT ! 537: && (TREE_CODE (STMT_THEN (x1)) == GOTO_STMT ! 538: || (STMT_ELSE (x1) ! 539: && TREE_CODE (STMT_ELSE (x1)) == GOTO_STMT)))) ! 540: { ! 541: do_pending_stack_adjust (); ! 542: emit_note (0, NOTE_INSN_LOOP_BEG); ! 543: emit_label (lab1); ! 544: expand_stmts (STMT_BODY (stmt), lab2); ! 545: emit_jump (lab1); ! 546: } ! 547: #if 0 ! 548: /* If the loop starts with a conditional exit that tests ! 549: a very simple condition, duplicate the test, jumping around ! 550: the loop if we don't want to execute it even once. ! 551: Then put the test at the end of the loop. */ ! 552: else if (! cse_not_expected ! 553: && TREE_CODE (STMT_BODY (stmt)) == EXIT_STMT ! 554: && stmt_complexity (stmt) < 15 ! 555: && exit_simple_enough_p (STMT_BODY (STMT_BODY (stmt)))) ! 556: { ! 557: do_jump (STMT_BODY (STMT_BODY (stmt)), lab2, 0); ! 558: emit_note (0, NOTE_INSN_LOOP_BEG); ! 559: emit_label (lab1); ! 560: expand_stmts (TREE_CHAIN (STMT_BODY (stmt)), lab2); ! 561: do_jump (STMT_BODY (STMT_BODY (stmt)), 0, lab1); ! 562: } ! 563: #endif ! 564: /* If the loop starts with a conditional exit that tests ! 565: a very simple condition, put that exit at the end of the loop ! 566: and enter by jumping to that test. */ ! 567: else if (! cse_not_expected ! 568: && TREE_CODE (STMT_BODY (stmt)) == EXIT_STMT) ! 569: { ! 570: register rtx lab3 = gen_label_rtx (); ! 571: do_pending_stack_adjust (); ! 572: emit_note (0, NOTE_INSN_LOOP_BEG); ! 573: emit_jump (lab3); ! 574: emit_label (lab1); ! 575: expand_stmts (TREE_CHAIN (STMT_BODY (stmt)), lab2); ! 576: do_pending_stack_adjust (); ! 577: emit_label (lab3); ! 578: do_jump (STMT_BODY (STMT_BODY (stmt)), 0, lab1); ! 579: } ! 580: /* Neither starts nor ends with a conditional exit. Strange. ! 581: Do it the simplest possible way. */ ! 582: else ! 583: { ! 584: do_pending_stack_adjust (); ! 585: emit_note (0, NOTE_INSN_LOOP_BEG); ! 586: emit_label (lab1); ! 587: expand_stmts (STMT_BODY (stmt), lab2); ! 588: emit_jump (lab1); ! 589: } ! 590: ! 591: emit_note (0, NOTE_INSN_LOOP_END); ! 592: emit_label (lab2); ! 593: } ! 594: break; ! 595: ! 596: case CASE_STMT: ! 597: expand_case_stmt (stmt); ! 598: break; ! 599: ! 600: default: ! 601: abort (); ! 602: } ! 603: ! 604: /* Perform any postincrements or postdecrements. */ ! 605: ! 606: emit_queue (); ! 607: } ! 608: ! 609: /* Emit code to alter this function's formal parms for a tail-recursive call. ! 610: ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs). ! 611: FORMALS is the chain of decls of formals. ! 612: Return 1 if this can be done; ! 613: otherwise return 0 and do not emit any code. */ ! 614: ! 615: static int ! 616: tail_recursion_args (actuals, formals) ! 617: tree actuals, formals; ! 618: { ! 619: register tree a = actuals, f = formals; ! 620: register int i; ! 621: register rtx *argvec; ! 622: ! 623: /* Check that number and types of actuals are compatible ! 624: with the formals. This is not always true in valid C code. ! 625: Also check that no formal needs to be addressable ! 626: and that all formals are scalars. */ ! 627: ! 628: /* Also count the args. */ ! 629: ! 630: for (a = actuals, f = formals, i = 0; a && f; a = TREE_CHAIN (a), f = TREE_CHAIN (f), i++) ! 631: { ! 632: if (TREE_TYPE (TREE_VALUE (a)) != TREE_TYPE (f)) ! 633: return 0; ! 634: if (GET_CODE (DECL_RTL (f)) != REG || DECL_MODE (f) == BLKmode) ! 635: return 0; ! 636: } ! 637: if (a != 0 || f != 0) ! 638: return 0; ! 639: ! 640: /* Compute all the actuals. */ ! 641: ! 642: argvec = (rtx *) alloca (i * sizeof (rtx)); ! 643: ! 644: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++) ! 645: argvec[i] = expand_expr (TREE_VALUE (a), 0, VOIDmode, 0); ! 646: ! 647: /* Find which actual values refer to current values of previous formals. ! 648: Copy each of them now, before any formal is changed. */ ! 649: ! 650: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++) ! 651: { ! 652: int copy = 0; ! 653: register int j; ! 654: for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++) ! 655: if (reg_mentioned_p (DECL_RTL (f), argvec[i])) ! 656: { copy = 1; break; } ! 657: if (copy) ! 658: argvec[i] = copy_to_reg (argvec[i]); ! 659: } ! 660: ! 661: /* Store the values of the actuals into the formals. */ ! 662: ! 663: for (f = formals, i = 0; f; f = TREE_CHAIN (f), i++) ! 664: { ! 665: if (DECL_MODE (f) == GET_MODE (argvec[i])) ! 666: emit_move_insn (DECL_RTL (f), argvec[i]); ! 667: else ! 668: convert_move (DECL_RTL (f), argvec[i]); ! 669: } ! 670: ! 671: return 1; ! 672: } ! 673: ! 674: /* Generate code for a CASE_STMT node, ! 675: which stands for a dispatch table. */ ! 676: ! 677: static void ! 678: expand_case_stmt (stmt) ! 679: tree stmt; ! 680: { ! 681: tree minval, maxval, range; ! 682: rtx default_label = 0; ! 683: register tree elt; ! 684: register tree c; ! 685: int count; ! 686: tree index_exp; ! 687: rtx index; ! 688: rtx table_label = gen_label_rtx (); ! 689: int ncases; ! 690: rtx *labelvec; ! 691: register int i; ! 692: ! 693: /* Get upper and lower bounds of case values. */ ! 694: count = 0; ! 695: for (c = STMT_CASE_LIST (stmt); c; c = TREE_CHAIN (c)) ! 696: if (elt = TREE_PURPOSE (c)) ! 697: { ! 698: /* Note that in Pascal it will be possible ! 699: to have a RANGE_EXPR here as long as both ! 700: ends of the range are constant. ! 701: It will be necessary to extend this function ! 702: to handle them. */ ! 703: if (TREE_CODE (elt) != INTEGER_CST) ! 704: abort (); ! 705: ! 706: if (count++ == 0) ! 707: { ! 708: minval = maxval = elt; ! 709: } ! 710: else ! 711: { ! 712: if (INT_CST_LT (elt, minval)) ! 713: minval = elt; ! 714: if (INT_CST_LT (maxval, elt)) ! 715: maxval = elt; ! 716: } ! 717: } ! 718: else ! 719: default_label = label_rtx (TREE_VALUE (c)); ! 720: ! 721: if (default_label == 0) ! 722: abort (); ! 723: ! 724: /* Compute span of values. */ ! 725: range = combine (MINUS_EXPR, maxval, minval); ! 726: ! 727: /* If range of values is much bigger than number of values, ! 728: make a sequence of conditional branches instead of a dispatch. */ ! 729: if (TREE_INT_CST_HIGH (range) != 0 ! 730: #ifdef HAVE_casesi ! 731: || count < 4 ! 732: #else ! 733: /* If machine does not have a case insn that compares the ! 734: bounds, this means extra overhead for dispatch tables ! 735: which raises the threshold for using them. */ ! 736: || count < 7 ! 737: #endif ! 738: || TREE_INT_CST_LOW (range) > 10 * count) ! 739: { ! 740: index_exp = get_unwidened (STMT_CASE_INDEX (stmt), 0); ! 741: index = expand_expr (index_exp, 0, VOIDmode, 0); ! 742: emit_queue (); ! 743: ! 744: index = protect_from_queue (index, 0); ! 745: if (GET_CODE (index) == MEM) ! 746: index = copy_to_reg (index); ! 747: do_pending_stack_adjust (); ! 748: ! 749: for (c = STMT_CASE_LIST (stmt); c; c = TREE_CHAIN (c)) ! 750: if ((elt = TREE_PURPOSE (c)) ! 751: && int_fits_type_p (elt, TREE_TYPE (index_exp))) ! 752: do_jump_if_equal (expand_expr (elt, 0, VOIDmode, 0), index, ! 753: label_rtx (TREE_VALUE (c))); ! 754: ! 755: emit_jump (default_label); ! 756: return; ! 757: } ! 758: ! 759: index_exp = STMT_CASE_INDEX (stmt); ! 760: ! 761: #ifdef HAVE_casesi ! 762: if (TYPE_MODE (TREE_TYPE (index_exp)) == DImode) ! 763: { ! 764: index_exp = build2 (MINUS_EXPR, index_exp, minval); ! 765: TREE_TYPE (index_exp) = TREE_TYPE (STMT_CASE_INDEX (stmt)); ! 766: index_exp = convert (integer_type_node, index_exp); ! 767: minval = integer_zero_node; ! 768: } ! 769: else if (TYPE_MODE (TREE_TYPE (index_exp)) != SImode) ! 770: index_exp = convert (integer_type_node, index_exp); ! 771: index = expand_expr (index_exp, 0, VOIDmode, 0); ! 772: emit_queue (); ! 773: index = protect_from_queue (index, 0); ! 774: do_pending_stack_adjust (); ! 775: ! 776: emit_jump_insn (gen_casesi (index, expand_expr (minval, 0, VOIDmode, 0), ! 777: expand_expr (range, 0, VOIDmode, 0), ! 778: table_label)); ! 779: #else ! 780: #ifdef HAVE_tablejump ! 781: index_exp = build2 (MINUS_EXPR, index_exp, minval); ! 782: TREE_TYPE (index_exp) = TREE_TYPE (STMT_CASE_INDEX (stmt)); ! 783: index_exp = convert (integer_type_node, index_exp); ! 784: index = expand_expr (index_exp, 0, VOIDmode, 0); ! 785: emit_queue (); ! 786: index = protect_from_queue (index, 0); ! 787: do_pending_stack_adjust (); ! 788: ! 789: do_tablejump (index, ! 790: gen_rtx (CONST_INT, VOIDmode, TREE_INT_CST_LOW (range)), ! 791: table_label, default_label); ! 792: #else ! 793: lossage; ! 794: #endif /* not HAVE_tablejump */ ! 795: #endif /* not HAVE_casesi */ ! 796: ! 797: /* Get table of labels to jump to, in order of case index. */ ! 798: ! 799: ncases = TREE_INT_CST_LOW (range) + 1; ! 800: labelvec = (rtx *) alloca (ncases * sizeof (rtx)); ! 801: bzero (labelvec, ncases * sizeof (rtx)); ! 802: ! 803: for (c = STMT_CASE_LIST (stmt); c; c = TREE_CHAIN (c)) ! 804: if (elt = TREE_PURPOSE (c)) ! 805: { ! 806: register int i = TREE_INT_CST_LOW (elt) - TREE_INT_CST_LOW (minval); ! 807: labelvec[i] = gen_rtx (LABEL_REF, Pmode, label_rtx (TREE_VALUE (c))); ! 808: } ! 809: ! 810: /* Fill in the gaps with the default. */ ! 811: for (i = 0; i < ncases; i++) ! 812: if (labelvec[i] == 0) ! 813: labelvec[i] = gen_rtx (LABEL_REF, Pmode, default_label); ! 814: ! 815: /* Output the table */ ! 816: emit_label (table_label); ! 817: ! 818: #ifdef CASE_VECTOR_PC_RELATIVE ! 819: emit_jump_insn (gen_rtx (ADDR_DIFF_VEC, CASE_VECTOR_MODE, ! 820: gen_rtx (LABEL_REF, Pmode, table_label), ! 821: gen_rtvec_v (ncases, labelvec))); ! 822: #else ! 823: emit_jump_insn (gen_rtx (ADDR_VEC, CASE_VECTOR_MODE, ! 824: gen_rtvec_v (ncases, labelvec))); ! 825: #endif ! 826: emit_jump (default_label); ! 827: } ! 828: ! 829: /* Find all the variables declared within a function ! 830: and give them rtl definitions. */ ! 831: ! 832: /* Return size needed for stack frame based on slots so far allocated. */ ! 833: ! 834: int ! 835: get_frame_size () ! 836: { ! 837: return frame_offset; ! 838: } ! 839: ! 840: /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it ! 841: with machine mode MODE. */ ! 842: ! 843: rtx ! 844: assign_stack_local (mode, size) ! 845: enum machine_mode mode; ! 846: int size; ! 847: { ! 848: register rtx value; ! 849: ! 850: /* This function may not be used during rtl generation ! 851: because at that time space is being allocated for ! 852: structure values returned by function calls, ! 853: but we don't know how big the space is until the end ! 854: of rtl generation. */ ! 855: if (max_structure_value_size > 0) ! 856: abort (); ! 857: ! 858: /* Make each stack slot a multiple of the main allocation unit. */ ! 859: size = (((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1) ! 860: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)) ! 861: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); ! 862: ! 863: #ifdef FRAME_GROWS_DOWNWARD ! 864: frame_offset -= size; ! 865: #endif ! 866: value = gen_rtx (MEM, mode, ! 867: gen_rtx (PLUS, Pmode, ! 868: gen_rtx (REG, SImode, FRAME_POINTER_REGNUM), ! 869: gen_rtx (CONST_INT, VOIDmode, frame_offset))); ! 870: #ifndef FRAME_GROWS_DOWNWARD ! 871: frame_offset += size; ! 872: #endif ! 873: ! 874: return value; ! 875: } ! 876: ! 877: /* 1 + last pseudo register number used for one of the user's variables ! 878: (as opposed to compiler-generated temporaries). */ ! 879: ! 880: int first_temp_reg_num; ! 881: ! 882: static void assign_vars_1 (); ! 883: ! 884: /* Assign stack slots or pseudo-registers to all the variables ! 885: local to the body of a function being compiled (STMT). */ ! 886: ! 887: static void ! 888: assign_all_vars (stmt) ! 889: tree stmt; ! 890: { ! 891: frame_offset = STARTING_FRAME_OFFSET; ! 892: assign_vars_1 (stmt); ! 893: first_temp_reg_num = max_reg_num (); ! 894: } ! 895: ! 896: /* Assign stack slots or pseudo-registers to all the identifiers ! 897: local within STMT, by recursive tree walk, except for variables ! 898: of varying size. */ ! 899: ! 900: static void ! 901: assign_vars_1 (stmt) ! 902: register tree stmt; ! 903: { ! 904: register tree decl; ! 905: ! 906: while (stmt) ! 907: { ! 908: switch (TREE_CODE (stmt)) ! 909: { ! 910: case COMPOUND_STMT: ! 911: case LOOP_STMT: ! 912: assign_vars_1 (STMT_BODY (stmt)); ! 913: break; ! 914: ! 915: case IF_STMT: ! 916: assign_vars_1 (STMT_THEN (stmt)); ! 917: assign_vars_1 (STMT_ELSE (stmt)); ! 918: break; ! 919: ! 920: case LET_STMT: ! 921: for (decl = STMT_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 922: { ! 923: if (TREE_TYPE (decl) == error_mark_node) ! 924: DECL_RTL (decl) = gen_rtx (MEM, BLKmode, const0_rtx); ! 925: else if (TREE_CODE (decl) == FUNCTION_DECL) ! 926: /* External function */ ! 927: DECL_RTL (decl) ! 928: = gen_rtx (MEM, FUNCTION_MODE, ! 929: gen_rtx (SYMBOL_REF, Pmode, ! 930: IDENTIFIER_POINTER (DECL_NAME (decl)))); ! 931: else if (TREE_CODE (decl) != VAR_DECL) ! 932: ; ! 933: else if (TREE_STATIC (decl) || TREE_EXTERNAL (decl)) ! 934: ; /* These were done by assemble_variable. */ ! 935: else if (DECL_MODE (decl) != BLKmode ! 936: && ! TREE_VOLATILE (decl) ! 937: && ! TREE_ADDRESSABLE (decl) ! 938: && (TREE_REGDECL (decl) || ! obey_regdecls)) ! 939: { ! 940: /* Variable that can go in a register. */ ! 941: DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl)); ! 942: if (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE) ! 943: mark_reg_pointer (DECL_RTL (decl)); ! 944: } ! 945: else if (TREE_LITERAL (DECL_SIZE (decl))) ! 946: /* Variable of fixed size that goes on the stack. */ ! 947: DECL_RTL (decl) ! 948: = assign_stack_local (DECL_MODE (decl), ! 949: (TREE_INT_CST_LOW (DECL_SIZE (decl)) ! 950: * DECL_SIZE_UNIT (decl) ! 951: + BITS_PER_UNIT - 1) ! 952: / BITS_PER_UNIT); ! 953: /* Rtl for a dynamic-size object is set up when ! 954: the storage for the object is pushed. */ ! 955: ! 956: } ! 957: assign_vars_1 (STMT_BODY (stmt)); ! 958: } ! 959: stmt = TREE_CHAIN (stmt); ! 960: } ! 961: } ! 962: ! 963: /* 1 + last pseudo register number used for loading a copy ! 964: of a parameter of this function. */ ! 965: ! 966: static int max_parm_reg; ! 967: ! 968: /* Assign RTL expressions to the function's parameters. ! 969: This may involve copying them into registers and using ! 970: those registers as the RTL for them. */ ! 971: ! 972: static void ! 973: assign_parms (fndecl) ! 974: tree fndecl; ! 975: { ! 976: register tree parm; ! 977: register rtx parmloc; ! 978: register int i; ! 979: ! 980: for (parm = DECL_ARGUMENTS (fndecl), i = 0; parm; parm = TREE_CHAIN (parm), i++) ! 981: { ! 982: if (DECL_VOFFSET (parm)) ! 983: abort (); ! 984: if (TREE_TYPE (parm) == error_mark_node) ! 985: parmloc = gen_rtx (MEM, BLKmode, const0_rtx); ! 986: else ! 987: parmloc ! 988: = gen_rtx (MEM, TYPE_MODE (DECL_ARG_TYPE (parm)), ! 989: gen_rtx (PLUS, SImode, ! 990: gen_rtx (REG, SImode, ARG_POINTER_REGNUM), ! 991: gen_rtx (CONST_INT, VOIDmode, ! 992: DECL_OFFSET (parm) / BITS_PER_UNIT))); ! 993: ! 994: /* PARMLOC now refers to the parameter in the arglist ! 995: in the form in which it is passed. ! 996: Now output code if necessary to convert it to ! 997: the type in which this function declares it, ! 998: and store a reference to that value in DECL_RTL. ! 999: This reference may be the same as PARMLOC ! 1000: if no conversion is required. */ ! 1001: ! 1002: if (GET_MODE (parmloc) == BLKmode) ! 1003: DECL_RTL (parm) = parmloc; ! 1004: else if (! (TREE_ADDRESSABLE (parm) ! 1005: || (obey_regdecls && ! TREE_REGDECL (parm)))) ! 1006: { ! 1007: /* Store the parm in a register during the function. */ ! 1008: register rtx parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); ! 1009: ! 1010: DECL_RTL (parm) = parmreg; ! 1011: ! 1012: /* Copy the value into the register. */ ! 1013: if (GET_MODE (parmreg) != GET_MODE (parmloc)) ! 1014: convert_move (parmreg, parmloc, 0); ! 1015: else ! 1016: emit_move_insn (parmreg, parmloc); ! 1017: ! 1018: /* Mark the register as eliminable if we did no conversion. */ ! 1019: if (GET_MODE (parmreg) == GET_MODE (parmloc)) ! 1020: REG_NOTES (get_last_insn ()) = gen_rtx (EXPR_LIST, REG_CONST, ! 1021: parmreg, 0); ! 1022: ! 1023: /* For pointer data type, suggest pointer register. */ ! 1024: if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE) ! 1025: mark_reg_pointer (parmreg); ! 1026: } ! 1027: else if (GET_MODE (parmloc) != TYPE_MODE (TREE_TYPE (parm))) ! 1028: { ! 1029: /* Don't store in a register, but conversion is required. ! 1030: Convert it via a register and store back in the parm list ! 1031: in the new format. The debugger will expect this anyway. */ ! 1032: ! 1033: register rtx parmlcl ! 1034: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (parm)), ! 1035: copy_rtx (XEXP (parmloc, 0))); ! 1036: register rtx parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); ! 1037: ! 1038: convert_move (parmreg, parmloc, 0); ! 1039: emit_move_insn (parmlcl, parmreg); ! 1040: DECL_RTL (parm) = parmlcl; ! 1041: } ! 1042: else ! 1043: DECL_RTL (parm) = parmloc; ! 1044: } ! 1045: max_parm_reg = max_reg_num (); ! 1046: } ! 1047: ! 1048: /* Allocation of space for returned structure values. ! 1049: During the rtl generation pass, `get_structure_value_addr' ! 1050: is called from time to time to request the address of a block in our ! 1051: stack frame in which called functions will store the structures ! 1052: they are returning. The same space is used for all of these blocks. ! 1053: ! 1054: `get_structure_value_addr' records the maximum block size needed. ! 1055: ! 1056: At the end of generation `allocate_structure_value_space' is ! 1057: called to adjust `frame_offset' so that the needed space is allocated. */ ! 1058: ! 1059: rtx ! 1060: get_structure_value_addr (sizex) ! 1061: rtx sizex; ! 1062: { ! 1063: register int size; ! 1064: if (GET_CODE (sizex) != CONST_INT) ! 1065: abort (); ! 1066: size = INTVAL (sizex); ! 1067: ! 1068: /* Round up to a multiple of the main allocation unit. */ ! 1069: size = (((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1) ! 1070: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)) ! 1071: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); ! 1072: ! 1073: if (size > max_structure_value_size) ! 1074: { ! 1075: max_structure_value_size = size; ! 1076: } ! 1077: #ifdef FRAME_GROWS_DOWNWARD ! 1078: return gen_rtx (PLUS, Pmode, ! 1079: gen_rtx (REG, SImode, FRAME_POINTER_REGNUM), ! 1080: gen_rtx (CONST_INT, VOIDmode, frame_offset - size)); ! 1081: #else ! 1082: return gen_rtx (PLUS, Pmode, ! 1083: gen_rtx (REG, SImode, FRAME_POINTER_REGNUM), ! 1084: gen_rtx (CONST_INT, VOIDmode, frame_offset)); ! 1085: #endif ! 1086: } ! 1087: ! 1088: static void ! 1089: allocate_structure_value_space () ! 1090: { ! 1091: #ifdef FRAME_GROWS_DOWNWARD ! 1092: frame_offset -= max_structure_value_size; ! 1093: #else ! 1094: frame_offset += max_structure_value_size; ! 1095: #endif ! 1096: /* Allow `assign_stack_local' to be used once again. */ ! 1097: max_structure_value_size = 0; ! 1098: } ! 1099: ! 1100: /* Main entry point: generate the rtl code for a function SUBR ! 1101: represented as a tree. Returns the first insn. ! 1102: ! 1103: NO_CSE is 1 if cse is not going to be done; ! 1104: this is passed because when cse is to be done it is sometimes ! 1105: desirable to generate excess temporaries at this stage to give ! 1106: cse an opportunity to go to work. */ ! 1107: ! 1108: rtx ! 1109: expand_function (subr, no_cse) ! 1110: tree subr; ! 1111: int no_cse; ! 1112: { ! 1113: register int i; ! 1114: ! 1115: this_function = subr; ! 1116: cse_not_expected = no_cse; ! 1117: ! 1118: init_queue (); ! 1119: ! 1120: #ifdef FUNCTION_EPILOGUE ! 1121: return_label = gen_label_rtx (); ! 1122: #endif ! 1123: ! 1124: max_structure_value_size = 0; ! 1125: ! 1126: /* We are not currently within any block. */ ! 1127: block_stack = 0; ! 1128: tail_recursion_label = 0; ! 1129: ! 1130: clear_pending_stack_adjust (); ! 1131: clear_current_args_size (); ! 1132: ! 1133: /* Prevent ever trying to delete the first instruction of a function. ! 1134: Also tell final how to output a linenum before the function prologue. */ ! 1135: emit_note (DECL_SOURCE_FILE (subr), DECL_SOURCE_LINE (subr)); ! 1136: /* Make sure first insn is a note even if we don't want linenums. ! 1137: This makes sure the first insn will never be deleted. ! 1138: Also, final expects a note to appear there. */ ! 1139: emit_note (0, NOTE_INSN_DELETED); ! 1140: ! 1141: /* Initialize rtx for parameters and local variables. ! 1142: In some cases this requires emitting insns. */ ! 1143: ! 1144: assign_parms (subr); ! 1145: /* After the parm initializations is where the tail-recursion label ! 1146: should go, if we end up needing one. */ ! 1147: tail_recursion_reentry = get_last_insn (); ! 1148: ! 1149: assign_all_vars (DECL_INITIAL (subr)); ! 1150: ! 1151: /* Initialize rtx used to return the value. */ ! 1152: ! 1153: if (DECL_MODE (DECL_RESULT (subr)) == BLKmode) ! 1154: { ! 1155: /* Returning something that won't go in a register. */ ! 1156: register rtx value_address; ! 1157: ! 1158: /* Expect to be passed the address of a place to store the value, ! 1159: in the same register that is normally used to return values. */ ! 1160: value_address = gen_reg_rtx (Pmode); ! 1161: emit_move_insn (value_address, ! 1162: gen_rtx (REG, Pmode, STRUCT_VALUE_REGNUM)); ! 1163: DECL_RTL (DECL_RESULT (subr)) ! 1164: = gen_rtx (MEM, DECL_MODE (DECL_RESULT (subr)), ! 1165: value_address); ! 1166: } ! 1167: else ! 1168: DECL_RTL (DECL_RESULT (subr)) ! 1169: = gen_rtx (REG, DECL_MODE (DECL_RESULT (subr)), ! 1170: FUNCTION_VALUE_REGNUM); ! 1171: ! 1172: /* If doing stupid allocation, mark parms as born here. */ ! 1173: ! 1174: if (obey_regdecls) ! 1175: { ! 1176: rtx insn = get_last_insn (); ! 1177: ! 1178: reg_birth_insn = (rtx *) oballoc (first_temp_reg_num * sizeof (rtx)); ! 1179: reg_death_insn = (rtx *) oballoc (first_temp_reg_num * sizeof (rtx)); ! 1180: bzero (reg_birth_insn, first_temp_reg_num * sizeof (rtx)); ! 1181: bzero (reg_death_insn, first_temp_reg_num * sizeof (rtx)); ! 1182: ! 1183: for (i = 0; i < max_parm_reg; i++) ! 1184: reg_birth_insn[i] = insn; ! 1185: } ! 1186: ! 1187: /* Don't generate a NOTE_INSN_BLOCK_BEG for the function's topmost block. ! 1188: final will do it specially, in order to make it come before ! 1189: the function prologue, and we don't want to have two of them. */ ! 1190: inhibit_block_beg = 1; ! 1191: ! 1192: /* Generate the actual code for the function. ! 1193: `assign_stack_local' may not be called again ! 1194: until after `allocate_structure_value_space'. */ ! 1195: ! 1196: expand_stmt (DECL_INITIAL (subr), 0); ! 1197: ! 1198: /* If doing stupid register allocation, ! 1199: mark any argument variables as dying here in the last insn generated ! 1200: (which is always an end-of-block comment, so it is never deleted). */ ! 1201: if (obey_regdecls) ! 1202: { ! 1203: rtx insn = get_last_insn (); ! 1204: for (i = 0; i < max_parm_reg; i++) ! 1205: reg_death_insn[i] = insn; ! 1206: } ! 1207: ! 1208: /* Return insn or function epilogue ignore the stack pointer. */ ! 1209: clear_pending_stack_adjust (); ! 1210: ! 1211: /* If we require a true epilogue, ! 1212: put here the label that return statements jump to. ! 1213: If there will be no epilogue, write a return instruction. */ ! 1214: #ifdef FUNCTION_EPILOGUE ! 1215: emit_label (return_label); ! 1216: #else ! 1217: emit_jump_insn (gen_return ()); ! 1218: #endif ! 1219: ! 1220: allocate_structure_value_space (); ! 1221: ! 1222: return get_insns (); ! 1223: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.