1/* Convert RTL to assembler code and output it, for GNU compiler. 2 Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc. 3 4This file is part of GNU CC. 5 6GNU CC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GNU CC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GNU CC; see the file COPYING. If not, write to 18the Free Software Foundation, 59 Temple Place - Suite 330, 19Boston, MA 02111-1307, USA. */ 20 21 22/* This is the final pass of the compiler. 23 It looks at the rtl code for a function and outputs assembler code. 24 25 Call `final_start_function' to output the assembler code for function entry, 26 `final' to output assembler code for some RTL code, 27 `final_end_function' to output assembler code for function exit. 28 If a function is compiled in several pieces, each piece is 29 output separately with `final'. 30 31 Some optimizations are also done at this level. 32 Move instructions that were made unnecessary by good register allocation 33 are detected and omitted from the output. (Though most of these 34 are removed by the last jump pass.) 35 36 Instructions to set the condition codes are omitted when it can be 37 seen that the condition codes already had the desired values. 38 39 In some cases it is sufficient if the inherited condition codes 40 have related values, but this may require the following insn 41 (the one that tests the condition codes) to be modified. 42 43 The code for the function prologue and epilogue are generated 44 directly as assembler code by the macros FUNCTION_PROLOGUE and 45 FUNCTION_EPILOGUE. Those instructions never exist as rtl. */ 46 47#include "config.h" 48#include "system.h" 49 50#include "tree.h" 51#include "rtl.h" 52#include "regs.h" 53#include "insn-config.h" 54#include "insn-flags.h" 55#include "insn-attr.h" 56#include "insn-codes.h" 57#include "recog.h" 58#include "conditions.h" 59#include "flags.h" 60#include "real.h" 61#include "hard-reg-set.h" 62#include "defaults.h" 63#include "output.h" 64#include "except.h" 65#include "toplev.h" 66#include "reload.h" 67#include "intl.h" 68 69/* Get N_SLINE and N_SOL from stab.h if we can expect the file to exist. */ 70#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 71#include "dbxout.h" 72#if defined (USG) || !defined (HAVE_STAB_H) 73#include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */ 74#else 75#include <stab.h> 76#endif 77 78#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ 79 80#ifdef XCOFF_DEBUGGING_INFO 81#include "xcoffout.h" 82#endif 83 84#ifdef DWARF_DEBUGGING_INFO 85#include "dwarfout.h" 86#endif 87 88#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 89#include "dwarf2out.h" 90#endif 91 92#ifdef SDB_DEBUGGING_INFO 93#include "sdbout.h" 94#endif 95 96/* .stabd code for line number. */ 97#ifndef N_SLINE 98#define N_SLINE 0x44 99#endif 100 101/* .stabs code for included file name. */ 102#ifndef N_SOL 103#define N_SOL 0x84 104#endif 105 106#ifndef INT_TYPE_SIZE 107#define INT_TYPE_SIZE BITS_PER_WORD 108#endif 109 110#ifndef LONG_TYPE_SIZE 111#define LONG_TYPE_SIZE BITS_PER_WORD 112#endif 113 114/* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a 115 null default for it to save conditionalization later. */ 116#ifndef CC_STATUS_INIT 117#define CC_STATUS_INIT 118#endif 119 120/* How to start an assembler comment. */ 121#ifndef ASM_COMMENT_START 122#define ASM_COMMENT_START ";#" 123#endif 124 125/* Is the given character a logical line separator for the assembler? */ 126#ifndef IS_ASM_LOGICAL_LINE_SEPARATOR 127#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == ';') 128#endif 129 130#ifndef JUMP_TABLES_IN_TEXT_SECTION 131#define JUMP_TABLES_IN_TEXT_SECTION 0 132#endif 133 134/* Last insn processed by final_scan_insn. */ 135static rtx debug_insn = 0; 136 137/* Line number of last NOTE. */ 138static int last_linenum; 139 140/* Highest line number in current block. */ 141static int high_block_linenum; 142 143/* Likewise for function. */ 144static int high_function_linenum; 145 146/* Filename of last NOTE. */ 147static char *last_filename; 148 149/* Number of basic blocks seen so far; 150 used if profile_block_flag is set. */ 151static int count_basic_blocks; 152 153/* Number of instrumented arcs when profile_arc_flag is set. */ 154extern int count_instrumented_arcs; 155 156extern int length_unit_log; /* This is defined in insn-attrtab.c. */ 157 158/* Nonzero while outputting an `asm' with operands. 159 This means that inconsistencies are the user's fault, so don't abort. 160 The precise value is the insn being output, to pass to error_for_asm. */ 161static rtx this_is_asm_operands; 162 163/* Number of operands of this insn, for an `asm' with operands. */ 164static unsigned int insn_noperands; 165 166/* Compare optimization flag. */ 167 168static rtx last_ignored_compare = 0; 169 170/* Flag indicating this insn is the start of a new basic block. */ 171 172static int new_block = 1; 173 174/* All the symbol-blocks (levels of scoping) in the compilation 175 are assigned sequence numbers in order of appearance of the 176 beginnings of the symbol-blocks. Both final and dbxout do this, 177 and assume that they will both give the same number to each block. 178 Final uses these sequence numbers to generate assembler label names 179 LBBnnn and LBEnnn for the beginning and end of the symbol-block. 180 Dbxout uses the sequence numbers to generate references to the same labels 181 from the dbx debugging information. 182 183 Sdb records this level at the beginning of each function, 184 in order to find the current level when recursing down declarations. 185 It outputs the block beginning and endings 186 at the point in the asm file where the blocks would begin and end. */ 187 188int next_block_index; 189 190/* Assign a unique number to each insn that is output. 191 This can be used to generate unique local labels. */ 192 193static int insn_counter = 0; 194 195#ifdef HAVE_cc0 196/* This variable contains machine-dependent flags (defined in tm.h) 197 set and examined by output routines 198 that describe how to interpret the condition codes properly. */ 199 200CC_STATUS cc_status; 201 202/* During output of an insn, this contains a copy of cc_status 203 from before the insn. */ 204 205CC_STATUS cc_prev_status; 206#endif 207 208/* Indexed by hardware reg number, is 1 if that register is ever 209 used in the current function. 210 211 In life_analysis, or in stupid_life_analysis, this is set 212 up to record the hard regs used explicitly. Reload adds 213 in the hard regs used for holding pseudo regs. Final uses 214 it to generate the code in the function prologue and epilogue 215 to save and restore registers as needed. */ 216 217char regs_ever_live[FIRST_PSEUDO_REGISTER]; 218 219/* Nonzero means current function must be given a frame pointer. 220 Set in stmt.c if anything is allocated on the stack there. 221 Set in reload1.c if anything is allocated on the stack there. */ 222 223int frame_pointer_needed; 224 225/* Assign unique numbers to labels generated for profiling. */ 226 227int profile_label_no; 228 229/* Length so far allocated in PENDING_BLOCKS. */ 230 231static int max_block_depth; 232 233/* Stack of sequence numbers of symbol-blocks of which we have seen the 234 beginning but not yet the end. Sequence numbers are assigned at 235 the beginning; this stack allows us to find the sequence number 236 of a block that is ending. */ 237 238static int *pending_blocks; 239 240/* Number of elements currently in use in PENDING_BLOCKS. */ 241 242static int block_depth; 243 244/* Nonzero if have enabled APP processing of our assembler output. */ 245 246static int app_on; 247 248/* If we are outputting an insn sequence, this contains the sequence rtx. 249 Zero otherwise. */ 250 251rtx final_sequence; 252 253#ifdef ASSEMBLER_DIALECT 254 255/* Number of the assembler dialect to use, starting at 0. */ 256static int dialect_number; 257#endif 258 259/* Indexed by line number, nonzero if there is a note for that line. */ 260 261static char *line_note_exists; 262 263/* Linked list to hold line numbers for each basic block. */ 264 265struct bb_list { 266 struct bb_list *next; /* pointer to next basic block */ 267 int line_num; /* line number */ 268 int file_label_num; /* LPBC<n> label # for stored filename */ 269 int func_label_num; /* LPBC<n> label # for stored function name */ 270}; 271 272static struct bb_list *bb_head = 0; /* Head of basic block list */ 273static struct bb_list **bb_tail = &bb_head; /* Ptr to store next bb ptr */ 274static int bb_file_label_num = -1; /* Current label # for file */ 275static int bb_func_label_num = -1; /* Current label # for func */ 276 277/* Linked list to hold the strings for each file and function name output. */ 278 279struct bb_str { 280 struct bb_str *next; /* pointer to next string */ 281 const char *string; /* string */ 282 int label_num; /* label number */ 283 int length; /* string length */ 284}; 285 286extern rtx peephole PROTO((rtx)); 287 288static struct bb_str *sbb_head = 0; /* Head of string list. */ 289static struct bb_str **sbb_tail = &sbb_head; /* Ptr to store next bb str */ 290static int sbb_label_num = 0; /* Last label used */ 291 292#ifdef HAVE_ATTR_length 293static int asm_insn_count PROTO((rtx)); 294#endif 295static void profile_function PROTO((FILE *)); 296static void profile_after_prologue PROTO((FILE *)); 297static void add_bb PROTO((FILE *)); 298static int add_bb_string PROTO((const char *, int)); 299static void output_source_line PROTO((FILE *, rtx)); 300static rtx walk_alter_subreg PROTO((rtx)); 301static void output_asm_name PROTO((void)); 302static void output_operand PROTO((rtx, int)); 303#ifdef LEAF_REGISTERS 304static void leaf_renumber_regs PROTO((rtx)); 305#endif 306#ifdef HAVE_cc0 307static int alter_cond PROTO((rtx)); 308#endif 309 310extern char *getpwd (); 311 312/* Initialize data in final at the beginning of a compilation. */ 313 314void 315init_final (filename) 316 char *filename; 317{ 318 next_block_index = 2; 319 app_on = 0; 320 max_block_depth = 20; 321 pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks); 322 final_sequence = 0; 323 324#ifdef ASSEMBLER_DIALECT 325 dialect_number = ASSEMBLER_DIALECT; 326#endif 327} 328 329/* Called at end of source file, 330 to output the block-profiling table for this entire compilation. */ 331 332void 333end_final (filename) 334 const char *filename; 335{ 336 int i; 337 338 if (profile_block_flag || profile_arc_flag) 339 { 340 char name[20]; 341 int align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT); 342 int size, rounded; 343 struct bb_list *ptr; 344 struct bb_str *sptr; 345 int long_bytes = LONG_TYPE_SIZE / BITS_PER_UNIT; 346 int pointer_bytes = POINTER_SIZE / BITS_PER_UNIT; 347 348 if (profile_block_flag) 349 size = long_bytes * count_basic_blocks; 350 else 351 size = long_bytes * count_instrumented_arcs; 352 rounded = size; 353 354 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1; 355 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 356 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 357 358 data_section (); 359 360 /* Output the main header, of 11 words: 361 0: 1 if this file is initialized, else 0. 362 1: address of file name (LPBX1). 363 2: address of table of counts (LPBX2). 364 3: number of counts in the table. 365 4: always 0, for compatibility with Sun. 366 367 The following are GNU extensions: 368 369 5: address of table of start addrs of basic blocks (LPBX3). 370 6: Number of bytes in this header. 371 7: address of table of function names (LPBX4). 372 8: address of table of line numbers (LPBX5) or 0. 373 9: address of table of file names (LPBX6) or 0. 374 10: space reserved for basic block profiling. */ 375 376 ASM_OUTPUT_ALIGN (asm_out_file, align); 377 378 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0); 379 /* zero word */ 380 assemble_integer (const0_rtx, long_bytes, 1); 381 382 /* address of filename */ 383 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1); 384 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); 385 386 /* address of count table */ 387 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2); 388 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); 389 390 /* count of the # of basic blocks or # of instrumented arcs */ 391 if (profile_block_flag) 392 assemble_integer (GEN_INT (count_basic_blocks), long_bytes, 1); 393 else 394 assemble_integer (GEN_INT (count_instrumented_arcs), long_bytes, 395 1); 396 397 /* zero word (link field) */ 398 assemble_integer (const0_rtx, pointer_bytes, 1); 399 400 /* address of basic block start address table */ 401 if (profile_block_flag) 402 { 403 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); 404 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 405 1); 406 } 407 else 408 assemble_integer (const0_rtx, pointer_bytes, 1); 409 410 /* byte count for extended structure. */ 411 assemble_integer (GEN_INT (11 * UNITS_PER_WORD), long_bytes, 1); 412 413 /* address of function name table */ 414 if (profile_block_flag) 415 { 416 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4); 417 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 418 1); 419 } 420 else 421 assemble_integer (const0_rtx, pointer_bytes, 1); 422 423 /* address of line number and filename tables if debugging. */ 424 if (write_symbols != NO_DEBUG && profile_block_flag) 425 { 426 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5); 427 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); 428 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6); 429 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); 430 } 431 else 432 { 433 assemble_integer (const0_rtx, pointer_bytes, 1); 434 assemble_integer (const0_rtx, pointer_bytes, 1); 435 } 436 437 /* space for extension ptr (link field) */ 438 assemble_integer (const0_rtx, UNITS_PER_WORD, 1); 439 440 /* Output the file name changing the suffix to .d for Sun tcov 441 compatibility. */ 442 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1); 443 { 444 char *cwd = getpwd (); 445 int len = strlen (filename) + strlen (cwd) + 1; 446 char *data_file = (char *) alloca (len + 4); 447 448 strcpy (data_file, cwd); 449 strcat (data_file, "/"); 450 strcat (data_file, filename); 451 strip_off_ending (data_file, len); 452 if (profile_block_flag) 453 strcat (data_file, ".d"); 454 else 455 strcat (data_file, ".da"); 456 assemble_string (data_file, strlen (data_file) + 1); 457 } 458 459 /* Make space for the table of counts. */ 460 if (size == 0) 461 { 462 /* Realign data section. */ 463 ASM_OUTPUT_ALIGN (asm_out_file, align); 464 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 2); 465 if (size != 0) 466 assemble_zeros (size); 467 } 468 else 469 { 470 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2); 471#ifdef ASM_OUTPUT_SHARED_LOCAL 472 if (flag_shared_data) 473 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded); 474 else 475#endif 476#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL 477 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size, 478 BIGGEST_ALIGNMENT); 479#else 480#ifdef ASM_OUTPUT_ALIGNED_LOCAL 481 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, 482 BIGGEST_ALIGNMENT); 483#else 484 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); 485#endif 486#endif 487 } 488 489 /* Output any basic block strings */ 490 if (profile_block_flag) 491 { 492 readonly_data_section (); 493 if (sbb_head) 494 { 495 ASM_OUTPUT_ALIGN (asm_out_file, align); 496 for (sptr = sbb_head; sptr != 0; sptr = sptr->next) 497 { 498 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC", 499 sptr->label_num); 500 assemble_string (sptr->string, sptr->length); 501 } 502 } 503 } 504 505 /* Output the table of addresses. */ 506 if (profile_block_flag) 507 { 508 /* Realign in new section */ 509 ASM_OUTPUT_ALIGN (asm_out_file, align); 510 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3); 511 for (i = 0; i < count_basic_blocks; i++) 512 { 513 ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i); 514 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), 515 pointer_bytes, 1); 516 } 517 } 518 519 /* Output the table of function names. */ 520 if (profile_block_flag) 521 { 522 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4); 523 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) 524 { 525 if (ptr->func_label_num >= 0) 526 { 527 ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", 528 ptr->func_label_num); 529 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), 530 pointer_bytes, 1); 531 } 532 else 533 assemble_integer (const0_rtx, pointer_bytes, 1); 534 } 535 536 for ( ; i < count_basic_blocks; i++) 537 assemble_integer (const0_rtx, pointer_bytes, 1); 538 } 539 540 if (write_symbols != NO_DEBUG && profile_block_flag) 541 { 542 /* Output the table of line numbers. */ 543 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5); 544 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) 545 assemble_integer (GEN_INT (ptr->line_num), long_bytes, 1); 546 547 for ( ; i < count_basic_blocks; i++) 548 assemble_integer (const0_rtx, long_bytes, 1); 549 550 /* Output the table of file names. */ 551 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6); 552 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) 553 { 554 if (ptr->file_label_num >= 0) 555 { 556 ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", 557 ptr->file_label_num); 558 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), 559 pointer_bytes, 1); 560 } 561 else 562 assemble_integer (const0_rtx, pointer_bytes, 1); 563 } 564 565 for ( ; i < count_basic_blocks; i++) 566 assemble_integer (const0_rtx, pointer_bytes, 1); 567 } 568 569 /* End with the address of the table of addresses, 570 so we can find it easily, as the last word in the file's text. */ 571 if (profile_block_flag) 572 { 573 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); 574 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 575 1); 576 } 577 } 578} 579 580/* Enable APP processing of subsequent output. 581 Used before the output from an `asm' statement. */ 582 583void 584app_enable () 585{ 586 if (! app_on) 587 { 588 fputs (ASM_APP_ON, asm_out_file); 589 app_on = 1; 590 } 591} 592 593/* Disable APP processing of subsequent output. 594 Called from varasm.c before most kinds of output. */ 595 596void 597app_disable () 598{ 599 if (app_on) 600 { 601 fputs (ASM_APP_OFF, asm_out_file); 602 app_on = 0; 603 } 604} 605 606/* Return the number of slots filled in the current 607 delayed branch sequence (we don't count the insn needing the 608 delay slot). Zero if not in a delayed branch sequence. */ 609 610#ifdef DELAY_SLOTS 611int 612dbr_sequence_length () 613{ 614 if (final_sequence != 0) 615 return XVECLEN (final_sequence, 0) - 1; 616 else 617 return 0; 618} 619#endif 620 621/* The next two pages contain routines used to compute the length of an insn 622 and to shorten branches. */ 623 624/* Arrays for insn lengths, and addresses. The latter is referenced by 625 `insn_current_length'. */ 626 627static short *insn_lengths; 628int *insn_addresses; 629 630/* Max uid for which the above arrays are valid. */ 631static int insn_lengths_max_uid; 632 633/* Address of insn being processed. Used by `insn_current_length'. */ 634int insn_current_address; 635 636/* Address of insn being processed in previous iteration. */ 637int insn_last_address; 638 639/* konwn invariant alignment of insn being processed. */ 640int insn_current_align; 641 642/* After shorten_branches, for any insn, uid_align[INSN_UID (insn)] 643 gives the next following alignment insn that increases the known 644 alignment, or NULL_RTX if there is no such insn. 645 For any alignment obtained this way, we can again index uid_align with 646 its uid to obtain the next following align that in turn increases the 647 alignment, till we reach NULL_RTX; the sequence obtained this way 648 for each insn we'll call the alignment chain of this insn in the following 649 comments. */ 650 651struct label_alignment { 652 short alignment; 653 short max_skip; 654}; 655 656static rtx *uid_align; 657static int *uid_shuid; 658static struct label_alignment *label_align; 659 660/* Indicate that branch shortening hasn't yet been done. */ 661 662void 663init_insn_lengths () 664{ 665 if (label_align) 666 { 667 free (label_align); 668 label_align = 0; 669 } 670 if (uid_shuid) 671 { 672 free (uid_shuid); 673 uid_shuid = 0; 674 } 675 if (insn_lengths) 676 { 677 free (insn_lengths); 678 insn_lengths = 0; 679 insn_lengths_max_uid = 0; 680 } 681 if (insn_addresses) 682 { 683 free (insn_addresses); 684 insn_addresses = 0; 685 } 686 if (uid_align) 687 { 688 free (uid_align); 689 uid_align = 0; 690 } 691} 692 693/* Obtain the current length of an insn. If branch shortening has been done, 694 get its actual length. Otherwise, get its maximum length. */ 695 696int 697get_attr_length (insn) 698 rtx insn; 699{ 700#ifdef HAVE_ATTR_length 701 rtx body; 702 int i; 703 int length = 0; 704 705 if (insn_lengths_max_uid > INSN_UID (insn)) 706 return insn_lengths[INSN_UID (insn)]; 707 else 708 switch (GET_CODE (insn)) 709 { 710 case NOTE: 711 case BARRIER: 712 case CODE_LABEL: 713 return 0; 714 715 case CALL_INSN: 716 length = insn_default_length (insn); 717 break; 718 719 case JUMP_INSN: 720 body = PATTERN (insn); 721 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC) 722 { 723 /* Alignment is machine-dependent and should be handled by 724 ADDR_VEC_ALIGN. */ 725 } 726 else 727 length = insn_default_length (insn); 728 break; 729 730 case INSN: 731 body = PATTERN (insn); 732 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER) 733 return 0; 734 735 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0) 736 length = asm_insn_count (body) * insn_default_length (insn); 737 else if (GET_CODE (body) == SEQUENCE) 738 for (i = 0; i < XVECLEN (body, 0); i++) 739 length += get_attr_length (XVECEXP (body, 0, i)); 740 else 741 length = insn_default_length (insn); 742 break; 743 744 default: 745 break; 746 } 747 748#ifdef ADJUST_INSN_LENGTH 749 ADJUST_INSN_LENGTH (insn, length); 750#endif 751 return length; 752#else /* not HAVE_ATTR_length */ 753 return 0; 754#endif /* not HAVE_ATTR_length */ 755} 756 757/* Code to handle alignment inside shorten_branches. */ 758 759/* Here is an explanation how the algorithm in align_fuzz can give 760 proper results: 761 762 Call a sequence of instructions beginning with alignment point X 763 and continuing until the next alignment point `block X'. When `X' 764 is used in an expression, it means the alignment value of the 765 alignment point. 766 767 Call the distance between the start of the first insn of block X, and 768 the end of the last insn of block X `IX', for the `inner size of X'. 769 This is clearly the sum of the instruction lengths. 770 771 Likewise with the next alignment-delimited block following X, which we 772 shall call block Y. 773 774 Call the distance between the start of the first insn of block X, and 775 the start of the first insn of block Y `OX', for the `outer size of X'. 776 777 The estimated padding is then OX - IX. 778 779 OX can be safely estimated as 780 781 if (X >= Y) 782 OX = round_up(IX, Y) 783 else 784 OX = round_up(IX, X) + Y - X 785 786 Clearly est(IX) >= real(IX), because that only depends on the 787 instruction lengths, and those being overestimated is a given. 788 789 Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so 790 we needn't worry about that when thinking about OX. 791 792 When X >= Y, the alignment provided by Y adds no uncertainty factor 793 for branch ranges starting before X, so we can just round what we have. 794 But when X < Y, we don't know anything about the, so to speak, 795 `middle bits', so we have to assume the worst when aligning up from an 796 address mod X to one mod Y, which is Y - X. */ 797 798#ifndef LABEL_ALIGN 799#define LABEL_ALIGN(LABEL) 0 800#endif 801 802#ifndef LABEL_ALIGN_MAX_SKIP 803#define LABEL_ALIGN_MAX_SKIP 0 804#endif 805 806#ifndef LOOP_ALIGN 807#define LOOP_ALIGN(LABEL) 0 808#endif 809 810#ifndef LOOP_ALIGN_MAX_SKIP 811#define LOOP_ALIGN_MAX_SKIP 0 812#endif 813 814#ifndef LABEL_ALIGN_AFTER_BARRIER 815#define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0 816#endif 817 818#ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 819#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 0 820#endif 821 822#ifndef ADDR_VEC_ALIGN 823int 824final_addr_vec_align (addr_vec) 825 rtx addr_vec; 826{ 827 int align = exact_log2 (GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec)))); 828 829 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT) 830 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT; 831 return align; 832 833} 834#define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC) 835#endif 836 837#ifndef INSN_LENGTH_ALIGNMENT 838#define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log 839#endif 840 841#define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)]) 842 843static int min_labelno, max_labelno; 844 845#define LABEL_TO_ALIGNMENT(LABEL) \ 846 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment) 847 848#define LABEL_TO_MAX_SKIP(LABEL) \ 849 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip) 850 851/* For the benefit of port specific code do this also as a function. */ 852int 853label_to_alignment (label) 854 rtx label; 855{ 856 return LABEL_TO_ALIGNMENT (label); 857} 858 859#ifdef HAVE_ATTR_length 860/* The differences in addresses 861 between a branch and its target might grow or shrink depending on 862 the alignment the start insn of the range (the branch for a forward 863 branch or the label for a backward branch) starts out on; if these 864 differences are used naively, they can even oscillate infinitely. 865 We therefore want to compute a 'worst case' address difference that 866 is independent of the alignment the start insn of the range end 867 up on, and that is at least as large as the actual difference. 868 The function align_fuzz calculates the amount we have to add to the 869 naively computed difference, by traversing the part of the alignment 870 chain of the start insn of the range that is in front of the end insn 871 of the range, and considering for each alignment the maximum amount 872 that it might contribute to a size increase. 873 874 For casesi tables, we also want to know worst case minimum amounts of 875 address difference, in case a machine description wants to introduce 876 some common offset that is added to all offsets in a table. 877 For this purpose, align_fuzz with a growth argument of 0 comuptes the 878 appropriate adjustment. */ 879 880 881/* Compute the maximum delta by which the difference of the addresses of 882 START and END might grow / shrink due to a different address for start 883 which changes the size of alignment insns between START and END. 884 KNOWN_ALIGN_LOG is the alignment known for START. 885 GROWTH should be ~0 if the objective is to compute potential code size 886 increase, and 0 if the objective is to compute potential shrink. 887 The return value is undefined for any other value of GROWTH. */ 888int 889align_fuzz (start, end, known_align_log, growth) 890 rtx start, end; 891 int known_align_log; 892 unsigned growth; 893{ 894 int uid = INSN_UID (start); 895 rtx align_label; 896 int known_align = 1 << known_align_log; 897 int end_shuid = INSN_SHUID (end); 898 int fuzz = 0; 899 900 for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid]) 901 { 902 int align_addr, new_align; 903 904 uid = INSN_UID (align_label); 905 align_addr = insn_addresses[uid] - insn_lengths[uid]; 906 if (uid_shuid[uid] > end_shuid) 907 break; 908 known_align_log = LABEL_TO_ALIGNMENT (align_label); 909 new_align = 1 << known_align_log; 910 if (new_align < known_align) 911 continue; 912 fuzz += (-align_addr ^ growth) & (new_align - known_align); 913 known_align = new_align; 914 } 915 return fuzz; 916} 917 918/* Compute a worst-case reference address of a branch so that it 919 can be safely used in the presence of aligned labels. Since the 920 size of the branch itself is unknown, the size of the branch is 921 not included in the range. I.e. for a forward branch, the reference 922 address is the end address of the branch as known from the previous 923 branch shortening pass, minus a value to account for possible size 924 increase due to alignment. For a backward branch, it is the start 925 address of the branch as known from the current pass, plus a value 926 to account for possible size increase due to alignment. 927 NB.: Therefore, the maximum offset allowed for backward branches needs 928 to exclude the branch size. */ 929int 930insn_current_reference_address (branch) 931 rtx branch; 932{ 933 rtx dest; 934 rtx seq = NEXT_INSN (PREV_INSN (branch)); 935 int seq_uid = INSN_UID (seq); 936 if (GET_CODE (branch) != JUMP_INSN) 937 /* This can happen for example on the PA; the objective is to know the 938 offset to address something in front of the start of the function. 939 Thus, we can treat it like a backward branch. 940 We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than 941 any alignment we'd encounter, so we skip the call to align_fuzz. */ 942 return insn_current_address; 943 dest = JUMP_LABEL (branch); 944 /* BRANCH has no proper alignment chain set, so use SEQ. */ 945 if (INSN_SHUID (branch) < INSN_SHUID (dest)) 946 { 947 /* Forward branch. */ 948 return (insn_last_address + insn_lengths[seq_uid] 949 - align_fuzz (seq, dest, length_unit_log, ~0)); 950 } 951 else 952 { 953 /* Backward branch. */ 954 return (insn_current_address 955 + align_fuzz (dest, seq, length_unit_log, ~0)); 956 } 957} 958#endif /* HAVE_ATTR_length */ 959 960/* Make a pass over all insns and compute their actual lengths by shortening 961 any branches of variable length if possible. */ 962 963/* Give a default value for the lowest address in a function. */ 964 965#ifndef FIRST_INSN_ADDRESS 966#define FIRST_INSN_ADDRESS 0 967#endif 968 969/* shorten_branches might be called multiple times: for example, the SH 970 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG. 971 In order to do this, it needs proper length information, which it obtains 972 by calling shorten_branches. This cannot be collapsed with 973 shorten_branches itself into a single pass unless we also want to intergate 974 reorg.c, since the branch splitting exposes new instructions with delay 975 slots. */ 976 977void 978shorten_branches (first) 979 rtx first; 980{ 981 rtx insn; 982 int max_uid; 983 int i; 984 int max_log; 985 int max_skip; 986#ifdef HAVE_ATTR_length 987#define MAX_CODE_ALIGN 16 988 rtx seq; 989 int something_changed = 1; 990 char *varying_length; 991 rtx body; 992 int uid; 993 rtx align_tab[MAX_CODE_ALIGN]; 994 995 /* In order to make sure that all instructions have valid length info, 996 we must split them before we compute the address/length info. */ 997 998 for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn)) 999 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') 1000 { 1001 rtx old = insn; 1002 /* Don't split the insn if it has been deleted. */ 1003 if (! INSN_DELETED_P (old)) 1004 insn = try_split (PATTERN (old), old, 1); 1005 /* When not optimizing, the old insn will be still left around 1006 with only the 'deleted' bit set. Transform it into a note 1007 to avoid confusion of subsequent processing. */ 1008 if (INSN_DELETED_P (old)) 1009 { 1010 PUT_CODE (old , NOTE); 1011 NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED; 1012 NOTE_SOURCE_FILE (old) = 0; 1013 } 1014 } 1015#endif 1016 1017 /* We must do some computations even when not actually shortening, in 1018 order to get the alignment information for the labels. */ 1019 1020 init_insn_lengths (); 1021 1022 /* Compute maximum UID and allocate label_align / uid_shuid. */ 1023 max_uid = get_max_uid (); 1024 1025 max_labelno = max_label_num (); 1026 min_labelno = get_first_label_num (); 1027 label_align = (struct label_alignment *) xmalloc ( 1028 (max_labelno - min_labelno + 1) * sizeof (struct label_alignment)); 1029 bzero ((char *) label_align, 1030 (max_labelno - min_labelno + 1) * sizeof (struct label_alignment)); 1031 1032 uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid); 1033 1034 /* Initialize label_align and set up uid_shuid to be strictly 1035 monotonically rising with insn order. */ 1036 /* We use max_log here to keep track of the maximum alignment we want to 1037 impose on the next CODE_LABEL (or the current one if we are processing 1038 the CODE_LABEL itself). */ 1039 1040 max_log = 0; 1041 max_skip = 0; 1042 1043 for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn)) 1044 { 1045 int log; 1046 1047 INSN_SHUID (insn) = i++; 1048 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') 1049 { 1050 /* reorg might make the first insn of a loop being run once only, 1051 and delete the label in front of it. Then we want to apply 1052 the loop alignment to the new label created by reorg, which 1053 is separated by the former loop start insn from the 1054 NOTE_INSN_LOOP_BEG. */ 1055 } 1056 else if (GET_CODE (insn) == CODE_LABEL) 1057 { 1058 rtx next; 1059 1060 log = LABEL_ALIGN (insn); 1061 if (max_log < log) 1062 { 1063 max_log = log; 1064 max_skip = LABEL_ALIGN_MAX_SKIP; 1065 } 1066 next = NEXT_INSN (insn); 1067 /* ADDR_VECs only take room if read-only data goes into the text 1068 section. */ 1069 if (JUMP_TABLES_IN_TEXT_SECTION 1070#if !defined(READONLY_DATA_SECTION) 1071 || 1 1072#endif 1073 ) 1074 if (next && GET_CODE (next) == JUMP_INSN) 1075 { 1076 rtx nextbody = PATTERN (next); 1077 if (GET_CODE (nextbody) == ADDR_VEC 1078 || GET_CODE (nextbody) == ADDR_DIFF_VEC) 1079 { 1080 log = ADDR_VEC_ALIGN (next); 1081 if (max_log < log) 1082 { 1083 max_log = log; 1084 max_skip = LABEL_ALIGN_MAX_SKIP; 1085 } 1086 } 1087 } 1088 LABEL_TO_ALIGNMENT (insn) = max_log; 1089 LABEL_TO_MAX_SKIP (insn) = max_skip; 1090 max_log = 0; 1091 max_skip = 0; 1092 } 1093 else if (GET_CODE (insn) == BARRIER) 1094 { 1095 rtx label; 1096 1097 for (label = insn; label && GET_RTX_CLASS (GET_CODE (label)) != 'i'; 1098 label = NEXT_INSN (label)) 1099 if (GET_CODE (label) == CODE_LABEL) 1100 { 1101 log = LABEL_ALIGN_AFTER_BARRIER (insn); 1102 if (max_log < log) 1103 { 1104 max_log = log; 1105 max_skip = LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP; 1106 } 1107 break; 1108 } 1109 } 1110 /* Again, we allow NOTE_INSN_LOOP_BEG - INSN - CODE_LABEL 1111 sequences in order to handle reorg output efficiently. */ 1112 else if (GET_CODE (insn) == NOTE 1113 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG) 1114 { 1115 rtx label; 1116 1117 for (label = insn; label; label = NEXT_INSN (label)) 1118 if (GET_CODE (label) == CODE_LABEL) 1119 { 1120 log = LOOP_ALIGN (insn); 1121 if (max_log < log) 1122 { 1123 max_log = log; 1124 max_skip = LOOP_ALIGN_MAX_SKIP; 1125 } 1126 break; 1127 } 1128 } 1129 else 1130 continue; 1131 } 1132#ifdef HAVE_ATTR_length 1133 1134 /* Allocate the rest of the arrays. */ 1135 insn_lengths = (short *) xmalloc (max_uid * sizeof (short)); 1136 insn_addresses = (int *) xmalloc (max_uid * sizeof (int)); 1137 insn_lengths_max_uid = max_uid; 1138 /* Syntax errors can lead to labels being outside of the main insn stream. 1139 Initialize insn_addresses, so that we get reproducible results. */ 1140 bzero ((char *)insn_addresses, max_uid * sizeof *insn_addresses); 1141 uid_align = (rtx *) xmalloc (max_uid * sizeof *uid_align); 1142 1143 varying_length = (char *) xmalloc (max_uid * sizeof (char)); 1144 1145 bzero (varying_length, max_uid); 1146 1147 /* Initialize uid_align. We scan instructions 1148 from end to start, and keep in align_tab[n] the last seen insn 1149 that does an alignment of at least n+1, i.e. the successor 1150 in the alignment chain for an insn that does / has a known 1151 alignment of n. */ 1152 1153 bzero ((char *) uid_align, max_uid * sizeof *uid_align); 1154 1155 for (i = MAX_CODE_ALIGN; --i >= 0; ) 1156 align_tab[i] = NULL_RTX; 1157 seq = get_last_insn (); 1158 for (; seq; seq = PREV_INSN (seq)) 1159 { 1160 int uid = INSN_UID (seq); 1161 int log; 1162 log = (GET_CODE (seq) == CODE_LABEL ? LABEL_TO_ALIGNMENT (seq) : 0); 1163 uid_align[uid] = align_tab[0]; 1164 if (log) 1165 { 1166 /* Found an alignment label. */ 1167 uid_align[uid] = align_tab[log]; 1168 for (i = log - 1; i >= 0; i--) 1169 align_tab[i] = seq; 1170 } 1171 } 1172#ifdef CASE_VECTOR_SHORTEN_MODE 1173 if (optimize) 1174 { 1175 /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum 1176 label fields. */ 1177 1178 int min_shuid = INSN_SHUID (get_insns ()) - 1; 1179 int max_shuid = INSN_SHUID (get_last_insn ()) + 1; 1180 int rel; 1181 1182 for (insn = first; insn != 0; insn = NEXT_INSN (insn)) 1183 { 1184 rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat; 1185 int len, i, min, max, insn_shuid; 1186 int min_align; 1187 addr_diff_vec_flags flags; 1188 1189 if (GET_CODE (insn) != JUMP_INSN 1190 || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC) 1191 continue; 1192 pat = PATTERN (insn); 1193 len = XVECLEN (pat, 1); 1194 if (len <= 0) 1195 abort (); 1196 min_align = MAX_CODE_ALIGN; 1197 for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--) 1198 { 1199 rtx lab = XEXP (XVECEXP (pat, 1, i), 0); 1200 int shuid = INSN_SHUID (lab); 1201 if (shuid < min) 1202 { 1203 min = shuid; 1204 min_lab = lab; 1205 } 1206 if (shuid > max) 1207 { 1208 max = shuid; 1209 max_lab = lab; 1210 } 1211 if (min_align > LABEL_TO_ALIGNMENT (lab)) 1212 min_align = LABEL_TO_ALIGNMENT (lab); 1213 } 1214 XEXP (pat, 2) = gen_rtx_LABEL_REF (VOIDmode, min_lab); 1215 XEXP (pat, 3) = gen_rtx_LABEL_REF (VOIDmode, max_lab); 1216 insn_shuid = INSN_SHUID (insn); 1217 rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0)); 1218 flags.min_align = min_align; 1219 flags.base_after_vec = rel > insn_shuid; 1220 flags.min_after_vec = min > insn_shuid; 1221 flags.max_after_vec = max > insn_shuid; 1222 flags.min_after_base = min > rel; 1223 flags.max_after_base = max > rel; 1224 ADDR_DIFF_VEC_FLAGS (pat) = flags; 1225 } 1226 } 1227#endif /* CASE_VECTOR_SHORTEN_MODE */ 1228 1229 1230 /* Compute initial lengths, addresses, and varying flags for each insn. */ 1231 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; 1232 insn != 0; 1233 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn)) 1234 { 1235 uid = INSN_UID (insn); 1236 1237 insn_lengths[uid] = 0; 1238 1239 if (GET_CODE (insn) == CODE_LABEL) 1240 { 1241 int log = LABEL_TO_ALIGNMENT (insn); 1242 if (log) 1243 { 1244 int align = 1 << log; 1245 int new_address = (insn_current_address + align - 1) & -align; 1246 insn_lengths[uid] = new_address - insn_current_address; 1247 insn_current_address = new_address; 1248 } 1249 } 1250 1251 insn_addresses[uid] = insn_current_address; 1252 1253 if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER 1254 || GET_CODE (insn) == CODE_LABEL) 1255 continue; 1256 if (INSN_DELETED_P (insn)) 1257 continue; 1258 1259 body = PATTERN (insn); 1260 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC) 1261 { 1262 /* This only takes room if read-only data goes into the text 1263 section. */ 1264 if (JUMP_TABLES_IN_TEXT_SECTION 1265#if !defined(READONLY_DATA_SECTION) 1266 || 1 1267#endif 1268 ) 1269 insn_lengths[uid] = (XVECLEN (body, 1270 GET_CODE (body) == ADDR_DIFF_VEC) 1271 * GET_MODE_SIZE (GET_MODE (body))); 1272 /* Alignment is handled by ADDR_VEC_ALIGN. */ 1273 } 1274 else if (asm_noperands (body) >= 0) 1275 insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn); 1276 else if (GET_CODE (body) == SEQUENCE) 1277 { 1278 int i; 1279 int const_delay_slots; 1280#ifdef DELAY_SLOTS 1281 const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0)); 1282#else 1283 const_delay_slots = 0; 1284#endif 1285 /* Inside a delay slot sequence, we do not do any branch shortening 1286 if the shortening could change the number of delay slots 1287 of the branch. */ 1288 for (i = 0; i < XVECLEN (body, 0); i++) 1289 { 1290 rtx inner_insn = XVECEXP (body, 0, i); 1291 int inner_uid = INSN_UID (inner_insn); 1292 int inner_length; 1293 1294 if (asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0) 1295 inner_length = (asm_insn_count (PATTERN (inner_insn)) 1296 * insn_default_length (inner_insn)); 1297 else 1298 inner_length = insn_default_length (inner_insn); 1299 1300 insn_lengths[inner_uid] = inner_length; 1301 if (const_delay_slots) 1302 { 1303 if ((varying_length[inner_uid] 1304 = insn_variable_length_p (inner_insn)) != 0) 1305 varying_length[uid] = 1; 1306 insn_addresses[inner_uid] = (insn_current_address + 1307 insn_lengths[uid]); 1308 } 1309 else 1310 varying_length[inner_uid] = 0; 1311 insn_lengths[uid] += inner_length; 1312 } 1313 } 1314 else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER) 1315 { 1316 insn_lengths[uid] = insn_default_length (insn); 1317 varying_length[uid] = insn_variable_length_p (insn); 1318 } 1319 1320 /* If needed, do any adjustment. */ 1321#ifdef ADJUST_INSN_LENGTH 1322 ADJUST_INSN_LENGTH (insn, insn_lengths[uid]); 1323 if (insn_lengths[uid] < 0) 1324 fatal_insn ("Negative insn length", insn); 1325#endif 1326 } 1327 1328 /* Now loop over all the insns finding varying length insns. For each, 1329 get the current insn length. If it has changed, reflect the change. 1330 When nothing changes for a full pass, we are done. */ 1331 1332 while (something_changed) 1333 { 1334 something_changed = 0; 1335 insn_current_align = MAX_CODE_ALIGN - 1; 1336 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; 1337 insn != 0; 1338 insn = NEXT_INSN (insn)) 1339 { 1340 int new_length; 1341#ifdef ADJUST_INSN_LENGTH 1342 int tmp_length; 1343#endif 1344 int length_align; 1345 1346 uid = INSN_UID (insn); 1347 1348 if (GET_CODE (insn) == CODE_LABEL) 1349 { 1350 int log = LABEL_TO_ALIGNMENT (insn); 1351 if (log > insn_current_align) 1352 { 1353 int align = 1 << log; 1354 int new_address= (insn_current_address + align - 1) & -align; 1355 insn_lengths[uid] = new_address - insn_current_address; 1356 insn_current_align = log; 1357 insn_current_address = new_address; 1358 } 1359 else 1360 insn_lengths[uid] = 0; 1361 insn_addresses[uid] = insn_current_address; 1362 continue; 1363 } 1364 1365 length_align = INSN_LENGTH_ALIGNMENT (insn); 1366 if (length_align < insn_current_align) 1367 insn_current_align = length_align; 1368 1369 insn_last_address = insn_addresses[uid]; 1370 insn_addresses[uid] = insn_current_address; 1371 1372#ifdef CASE_VECTOR_SHORTEN_MODE 1373 if (optimize && GET_CODE (insn) == JUMP_INSN 1374 && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC) 1375 { 1376 rtx body = PATTERN (insn); 1377 int old_length = insn_lengths[uid]; 1378 rtx rel_lab = XEXP (XEXP (body, 0), 0); 1379 rtx min_lab = XEXP (XEXP (body, 2), 0); 1380 rtx max_lab = XEXP (XEXP (body, 3), 0); 1381 addr_diff_vec_flags flags = ADDR_DIFF_VEC_FLAGS (body); 1382 int rel_addr = insn_addresses[INSN_UID (rel_lab)]; 1383 int min_addr = insn_addresses[INSN_UID (min_lab)]; 1384 int max_addr = insn_addresses[INSN_UID (max_lab)]; 1385 rtx prev; 1386 int rel_align = 0; 1387 1388 /* Try to find a known alignment for rel_lab. */ 1389 for (prev = rel_lab; 1390 prev 1391 && ! insn_lengths[INSN_UID (prev)] 1392 && ! (varying_length[INSN_UID (prev)] & 1); 1393 prev = PREV_INSN (prev)) 1394 if (varying_length[INSN_UID (prev)] & 2) 1395 { 1396 rel_align = LABEL_TO_ALIGNMENT (prev); 1397 break; 1398 } 1399 1400 /* See the comment on addr_diff_vec_flags in rtl.h for the 1401 meaning of the flags values. base: REL_LAB vec: INSN */ 1402 /* Anything after INSN has still addresses from the last 1403 pass; adjust these so that they reflect our current 1404 estimate for this pass. */ 1405 if (flags.base_after_vec) 1406 rel_addr += insn_current_address - insn_last_address; 1407 if (flags.min_after_vec) 1408 min_addr += insn_current_address - insn_last_address; 1409 if (flags.max_after_vec) 1410 max_addr += insn_current_address - insn_last_address; 1411 /* We want to know the worst case, i.e. lowest possible value 1412 for the offset of MIN_LAB. If MIN_LAB is after REL_LAB, 1413 its offset is positive, and we have to be wary of code shrink; 1414 otherwise, it is negative, and we have to be vary of code 1415 size increase. */ 1416 if (flags.min_after_base) 1417 { 1418 /* If INSN is between REL_LAB and MIN_LAB, the size 1419 changes we are about to make can change the alignment 1420 within the observed offset, therefore we have to break 1421 it up into two parts that are independent. */ 1422 if (! flags.base_after_vec && flags.min_after_vec) 1423 { 1424 min_addr -= align_fuzz (rel_lab, insn, rel_align, 0); 1425 min_addr -= align_fuzz (insn, min_lab, 0, 0); 1426 } 1427 else 1428 min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0); 1429 } 1430 else 1431 { 1432 if (flags.base_after_vec && ! flags.min_after_vec) 1433 { 1434 min_addr -= align_fuzz (min_lab, insn, 0, ~0); 1435 min_addr -= align_fuzz (insn, rel_lab, 0, ~0); 1436 } 1437 else 1438 min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0); 1439 } 1440 /* Likewise, determine the highest lowest possible value 1441 for the offset of MAX_LAB. */ 1442 if (flags.max_after_base) 1443 { 1444 if (! flags.base_after_vec && flags.max_after_vec) 1445 { 1446 max_addr += align_fuzz (rel_lab, insn, rel_align, ~0); 1447 max_addr += align_fuzz (insn, max_lab, 0, ~0); 1448 } 1449 else 1450 max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0); 1451 } 1452 else 1453 { 1454 if (flags.base_after_vec && ! flags.max_after_vec) 1455 { 1456 max_addr += align_fuzz (max_lab, insn, 0, 0); 1457 max_addr += align_fuzz (insn, rel_lab, 0, 0); 1458 } 1459 else 1460 max_addr += align_fuzz (max_lab, rel_lab, 0, 0); 1461 } 1462 PUT_MODE (body, CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr, 1463 max_addr - rel_addr, 1464 body)); 1465 if (JUMP_TABLES_IN_TEXT_SECTION 1466#if !defined(READONLY_DATA_SECTION) 1467 || 1 1468#endif 1469 ) 1470 { 1471 insn_lengths[uid] 1472 = (XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body))); 1473 insn_current_address += insn_lengths[uid]; 1474 if (insn_lengths[uid] != old_length) 1475 something_changed = 1; 1476 } 1477 1478 continue; 1479 } 1480#endif /* CASE_VECTOR_SHORTEN_MODE */ 1481 1482 if (! (varying_length[uid])) 1483 { 1484 insn_current_address += insn_lengths[uid]; 1485 continue; 1486 } 1487 if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE) 1488 { 1489 int i; 1490 1491 body = PATTERN (insn); 1492 new_length = 0; 1493 for (i = 0; i < XVECLEN (body, 0); i++) 1494 { 1495 rtx inner_insn = XVECEXP (body, 0, i); 1496 int inner_uid = INSN_UID (inner_insn); 1497 int inner_length; 1498 1499 insn_addresses[inner_uid] = insn_current_address; 1500 1501 /* insn_current_length returns 0 for insns with a 1502 non-varying length. */ 1503 if (! varying_length[inner_uid]) 1504 inner_length = insn_lengths[inner_uid]; 1505 else 1506 inner_length = insn_current_length (inner_insn); 1507 1508 if (inner_length != insn_lengths[inner_uid]) 1509 { 1510 insn_lengths[inner_uid] = inner_length; 1511 something_changed = 1; 1512 } 1513 insn_current_address += insn_lengths[inner_uid]; 1514 new_length += inner_length; 1515 } 1516 } 1517 else 1518 { 1519 new_length = insn_current_length (insn); 1520 insn_current_address += new_length; 1521 } 1522 1523#ifdef ADJUST_INSN_LENGTH 1524 /* If needed, do any adjustment. */ 1525 tmp_length = new_length; 1526 ADJUST_INSN_LENGTH (insn, new_length); 1527 insn_current_address += (new_length - tmp_length); 1528#endif 1529 1530 if (new_length != insn_lengths[uid]) 1531 { 1532 insn_lengths[uid] = new_length; 1533 something_changed = 1; 1534 } 1535 } 1536 /* For a non-optimizing compile, do only a single pass. */ 1537 if (!optimize) 1538 break; 1539 } 1540 1541 free (varying_length); 1542 1543#endif /* HAVE_ATTR_length */ 1544} 1545 1546#ifdef HAVE_ATTR_length 1547/* Given the body of an INSN known to be generated by an ASM statement, return 1548 the number of machine instructions likely to be generated for this insn. 1549 This is used to compute its length. */ 1550 1551static int 1552asm_insn_count (body) 1553 rtx body; 1554{ 1555 char *template; 1556 int count = 1; 1557 1558 if (GET_CODE (body) == ASM_INPUT) 1559 template = XSTR (body, 0); 1560 else 1561 template = decode_asm_operands (body, NULL_PTR, NULL_PTR, 1562 NULL_PTR, NULL_PTR); 1563 1564 for ( ; *template; template++) 1565 if (IS_ASM_LOGICAL_LINE_SEPARATOR(*template) || *template == '\n') 1566 count++; 1567 1568 return count; 1569} 1570#endif 1571 1572/* Output assembler code for the start of a function, 1573 and initialize some of the variables in this file 1574 for the new function. The label for the function and associated 1575 assembler pseudo-ops have already been output in `assemble_start_function'. 1576 1577 FIRST is the first insn of the rtl for the function being compiled. 1578 FILE is the file to write assembler code to. 1579 OPTIMIZE is nonzero if we should eliminate redundant 1580 test and compare insns. */ 1581 1582void 1583final_start_function (first, file, optimize) 1584 rtx first; 1585 FILE *file; 1586 int optimize; 1587{ 1588 rtx insn; 1589 block_depth = 0; 1590 1591 this_is_asm_operands = 0; 1592 1593 /* [zooey]: gcc-2.95.3 generates incorrect source-line labels when generating 1594 debug-info because this function is called with first pointing to an note-insn 1595 that has been deleted (whose NOTE_LINE_NUMBER == NOTE_INSN_DELETED). 1596 In order to generate correct source-line labels, we skip to the first insn 1597 which has a line-number (if any). 1598 The result of this is a much improved debugging experience... 1599 */ 1600 if (NOTE_LINE_NUMBER (first) == NOTE_INSN_DELETED) 1601 for (insn = first; insn; insn = NEXT_INSN (insn)) 1602 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 1603 { 1604 first = insn; 1605 break; 1606 } 1607 1608#ifdef NON_SAVING_SETJMP 1609 /* A function that calls setjmp should save and restore all the 1610 call-saved registers on a system where longjmp clobbers them. */ 1611 if (NON_SAVING_SETJMP && current_function_calls_setjmp) 1612 { 1613 int i; 1614 1615 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 1616 if (!call_used_regs[i]) 1617 regs_ever_live[i] = 1; 1618 } 1619#endif 1620 1621 /* Initial line number is supposed to be output 1622 before the function's prologue and label 1623 so that the function's address will not appear to be 1624 in the last statement of the preceding function. */ 1625 if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED) 1626 last_linenum = high_block_linenum = high_function_linenum 1627 = NOTE_LINE_NUMBER (first); 1628 1629#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 1630 /* Output DWARF definition of the function. */ 1631 if (dwarf2out_do_frame ()) 1632 dwarf2out_begin_prologue (); 1633#endif 1634 1635 /* For SDB and XCOFF, the function beginning must be marked between 1636 the function label and the prologue. We always need this, even when 1637 -g1 was used. Defer on MIPS systems so that parameter descriptions 1638 follow function entry. */ 1639#if defined(SDB_DEBUGGING_INFO) && !defined(MIPS_DEBUGGING_INFO) 1640 if (write_symbols == SDB_DEBUG) 1641 sdbout_begin_function (last_linenum); 1642 else 1643#endif 1644#ifdef XCOFF_DEBUGGING_INFO 1645 if (write_symbols == XCOFF_DEBUG) 1646 xcoffout_begin_function (file, last_linenum); 1647 else 1648#endif 1649 /* But only output line number for other debug info types if -g2 1650 or better. */ 1651 if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED) 1652 output_source_line (file, first); 1653 1654#ifdef LEAF_REG_REMAP 1655 if (current_function_uses_only_leaf_regs) 1656 leaf_renumber_regs (first); 1657#endif 1658 1659 /* The Sun386i and perhaps other machines don't work right 1660 if the profiling code comes after the prologue. */ 1661#ifdef PROFILE_BEFORE_PROLOGUE 1662 if (profile_flag) 1663 profile_function (file); 1664#endif /* PROFILE_BEFORE_PROLOGUE */ 1665 1666#if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue) 1667 if (dwarf2out_do_frame ()) 1668 dwarf2out_frame_debug (NULL_RTX); 1669#endif 1670 1671#ifdef FUNCTION_PROLOGUE 1672 /* First output the function prologue: code to set up the stack frame. */ 1673 FUNCTION_PROLOGUE (file, get_frame_size ()); 1674#endif 1675 1676#if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 1677 if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) 1678 next_block_index = 1; 1679#endif 1680 1681 /* If the machine represents the prologue as RTL, the profiling code must 1682 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */ 1683#ifdef HAVE_prologue 1684 if (! HAVE_prologue) 1685#endif 1686 profile_after_prologue (file); 1687 1688 profile_label_no++; 1689 1690 /* If we are doing basic block profiling, remember a printable version 1691 of the function name. */ 1692 if (profile_block_flag) 1693 { 1694 bb_func_label_num 1695 = add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE); 1696 } 1697} 1698 1699static void 1700profile_after_prologue (file) 1701 FILE *file; 1702{ 1703#ifdef FUNCTION_BLOCK_PROFILER 1704 if (profile_block_flag) 1705 { 1706 FUNCTION_BLOCK_PROFILER (file, count_basic_blocks); 1707 } 1708#endif /* FUNCTION_BLOCK_PROFILER */ 1709 1710#ifndef PROFILE_BEFORE_PROLOGUE 1711 if (profile_flag) 1712 profile_function (file); 1713#endif /* not PROFILE_BEFORE_PROLOGUE */ 1714} 1715 1716static void 1717profile_function (file) 1718 FILE *file; 1719{ 1720#ifndef NO_PROFILE_COUNTERS 1721 int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE); 1722#endif 1723#if defined(ASM_OUTPUT_REG_PUSH) 1724#if defined(STRUCT_VALUE_INCOMING_REGNUM) || defined(STRUCT_VALUE_REGNUM) 1725 int sval = current_function_returns_struct; 1726#endif 1727#if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM) 1728 int cxt = current_function_needs_context; 1729#endif 1730#endif /* ASM_OUTPUT_REG_PUSH */ 1731 1732#ifndef NO_PROFILE_COUNTERS 1733 data_section (); 1734 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); 1735 ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no); 1736 assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, 1); 1737#endif 1738 1739 function_section (current_function_decl); 1740 1741#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1742 if (sval) 1743 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM); 1744#else 1745#if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1746 if (sval) 1747 { 1748 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM); 1749 } 1750#endif 1751#endif 1752 1753#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1754 if (cxt) 1755 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM); 1756#else 1757#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1758 if (cxt) 1759 { 1760 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM); 1761 } 1762#endif 1763#endif 1764 1765 FUNCTION_PROFILER (file, profile_label_no); 1766 1767#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1768 if (cxt) 1769 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM); 1770#else 1771#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1772 if (cxt) 1773 { 1774 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM); 1775 } 1776#endif 1777#endif 1778 1779#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1780 if (sval) 1781 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM); 1782#else 1783#if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1784 if (sval) 1785 { 1786 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM); 1787 } 1788#endif 1789#endif 1790} 1791 1792/* Output assembler code for the end of a function. 1793 For clarity, args are same as those of `final_start_function' 1794 even though not all of them are needed. */ 1795 1796void 1797final_end_function (first, file, optimize) 1798 rtx first; 1799 FILE *file; 1800 int optimize; 1801{ 1802 if (app_on) 1803 { 1804 fputs (ASM_APP_OFF, file); 1805 app_on = 0; 1806 } 1807 1808#ifdef SDB_DEBUGGING_INFO 1809 if (write_symbols == SDB_DEBUG) 1810 sdbout_end_function (high_function_linenum); 1811#endif 1812 1813#ifdef DWARF_DEBUGGING_INFO 1814 if (write_symbols == DWARF_DEBUG) 1815 dwarfout_end_function (); 1816#endif 1817 1818#ifdef XCOFF_DEBUGGING_INFO 1819 if (write_symbols == XCOFF_DEBUG) 1820 xcoffout_end_function (file, high_function_linenum); 1821#endif 1822 1823#ifdef FUNCTION_EPILOGUE 1824 /* Finally, output the function epilogue: 1825 code to restore the stack frame and return to the caller. */ 1826 FUNCTION_EPILOGUE (file, get_frame_size ()); 1827#endif 1828 1829#ifdef SDB_DEBUGGING_INFO 1830 if (write_symbols == SDB_DEBUG) 1831 sdbout_end_epilogue (); 1832#endif 1833 1834#ifdef DWARF_DEBUGGING_INFO 1835 if (write_symbols == DWARF_DEBUG) 1836 dwarfout_end_epilogue (); 1837#endif 1838 1839#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 1840 if (dwarf2out_do_frame ()) 1841 dwarf2out_end_epilogue (); 1842#endif 1843 1844#ifdef XCOFF_DEBUGGING_INFO 1845 if (write_symbols == XCOFF_DEBUG) 1846 xcoffout_end_epilogue (file); 1847#endif 1848 1849 bb_func_label_num = -1; /* not in function, nuke label # */ 1850 1851 /* If FUNCTION_EPILOGUE is not defined, then the function body 1852 itself contains return instructions wherever needed. */ 1853} 1854 1855/* Add a block to the linked list that remembers the current line/file/function 1856 for basic block profiling. Emit the label in front of the basic block and 1857 the instructions that increment the count field. */ 1858 1859static void 1860add_bb (file) 1861 FILE *file; 1862{ 1863 struct bb_list *ptr = (struct bb_list *) permalloc (sizeof (struct bb_list)); 1864 1865 /* Add basic block to linked list. */ 1866 ptr->next = 0; 1867 ptr->line_num = last_linenum; 1868 ptr->file_label_num = bb_file_label_num; 1869 ptr->func_label_num = bb_func_label_num; 1870 *bb_tail = ptr; 1871 bb_tail = &ptr->next; 1872 1873 /* Enable the table of basic-block use counts 1874 to point at the code it applies to. */ 1875 ASM_OUTPUT_INTERNAL_LABEL (file, "LPB", count_basic_blocks); 1876 1877 /* Before first insn of this basic block, increment the 1878 count of times it was entered. */ 1879#ifdef BLOCK_PROFILER 1880 BLOCK_PROFILER (file, count_basic_blocks); 1881#endif 1882#ifdef HAVE_cc0 1883 CC_STATUS_INIT; 1884#endif 1885 1886 new_block = 0; 1887 count_basic_blocks++; 1888} 1889 1890/* Add a string to be used for basic block profiling. */ 1891 1892static int 1893add_bb_string (string, perm_p) 1894 const char *string; 1895 int perm_p; 1896{ 1897 int len; 1898 struct bb_str *ptr = 0; 1899 1900 if (!string) 1901 { 1902 string = "<unknown>"; 1903 perm_p = TRUE; 1904 } 1905 1906 /* Allocate a new string if the current string isn't permanent. If 1907 the string is permanent search for the same string in other 1908 allocations. */ 1909 1910 len = strlen (string) + 1; 1911 if (!perm_p) 1912 { 1913 char *p = (char *) permalloc (len); 1914 bcopy (string, p, len); 1915 string = p; 1916 } 1917 else 1918 for (ptr = sbb_head; ptr != (struct bb_str *) 0; ptr = ptr->next) 1919 if (ptr->string == string) 1920 break; 1921 1922 /* Allocate a new string block if we need to. */ 1923 if (!ptr) 1924 { 1925 ptr = (struct bb_str *) permalloc (sizeof (*ptr)); 1926 ptr->next = 0; 1927 ptr->length = len; 1928 ptr->label_num = sbb_label_num++; 1929 ptr->string = string; 1930 *sbb_tail = ptr; 1931 sbb_tail = &ptr->next; 1932 } 1933 1934 return ptr->label_num; 1935} 1936 1937 1938/* Output assembler code for some insns: all or part of a function. 1939 For description of args, see `final_start_function', above. 1940 1941 PRESCAN is 1 if we are not really outputting, 1942 just scanning as if we were outputting. 1943 Prescanning deletes and rearranges insns just like ordinary output. 1944 PRESCAN is -2 if we are outputting after having prescanned. 1945 In this case, don't try to delete or rearrange insns 1946 because that has already been done. 1947 Prescanning is done only on certain machines. */ 1948 1949void 1950final (first, file, optimize, prescan) 1951 rtx first; 1952 FILE *file; 1953 int optimize; 1954 int prescan; 1955{ 1956 register rtx insn; 1957 int max_line = 0; 1958 int max_uid = 0; 1959 1960 last_ignored_compare = 0; 1961 new_block = 1; 1962 1963 check_exception_handler_labels (); 1964 1965 /* Make a map indicating which line numbers appear in this function. 1966 When producing SDB debugging info, delete troublesome line number 1967 notes from inlined functions in other files as well as duplicate 1968 line number notes. */ 1969#ifdef SDB_DEBUGGING_INFO 1970 if (write_symbols == SDB_DEBUG) 1971 { 1972 rtx last = 0; 1973 for (insn = first; insn; insn = NEXT_INSN (insn)) 1974 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 1975 { 1976 if ((RTX_INTEGRATED_P (insn) 1977 && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0) 1978 || (last != 0 1979 && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last) 1980 && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last))) 1981 { 1982 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; 1983 NOTE_SOURCE_FILE (insn) = 0; 1984 continue; 1985 } 1986 last = insn; 1987 if (NOTE_LINE_NUMBER (insn) > max_line) 1988 max_line = NOTE_LINE_NUMBER (insn); 1989 } 1990 } 1991 else 1992#endif 1993 { 1994 for (insn = first; insn; insn = NEXT_INSN (insn)) 1995 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line) 1996 max_line = NOTE_LINE_NUMBER (insn); 1997 } 1998 1999 line_note_exists = (char *) oballoc (max_line + 1); 2000 bzero (line_note_exists, max_line + 1); 2001 2002 for (insn = first; insn; insn = NEXT_INSN (insn)) 2003 { 2004 if (INSN_UID (insn) > max_uid) /* find largest UID */ 2005 max_uid = INSN_UID (insn); 2006 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 2007 line_note_exists[NOTE_LINE_NUMBER (insn)] = 1; 2008#ifdef HAVE_cc0 2009 /* If CC tracking across branches is enabled, record the insn which 2010 jumps to each branch only reached from one place. */ 2011 if (optimize && GET_CODE (insn) == JUMP_INSN) 2012 { 2013 rtx lab = JUMP_LABEL (insn); 2014 if (lab && LABEL_NUSES (lab) == 1) 2015 { 2016 LABEL_REFS (lab) = insn; 2017 } 2018 } 2019#endif 2020 } 2021 2022 /* Initialize insn_eh_region table if eh is being used. */ 2023 2024 init_insn_eh_region (first, max_uid); 2025 2026 init_recog (); 2027 2028 CC_STATUS_INIT; 2029 2030 /* Output the insns. */ 2031 for (insn = NEXT_INSN (first); insn;) 2032 { 2033#ifdef HAVE_ATTR_length 2034 insn_current_address = insn_addresses[INSN_UID (insn)]; 2035#endif 2036 insn = final_scan_insn (insn, file, optimize, prescan, 0); 2037 } 2038 2039 /* Do basic-block profiling here 2040 if the last insn was a conditional branch. */ 2041 if (profile_block_flag && new_block) 2042 add_bb (file); 2043 2044 free_insn_eh_region (); 2045} 2046 2047/* The final scan for one insn, INSN. 2048 Args are same as in `final', except that INSN 2049 is the insn being scanned. 2050 Value returned is the next insn to be scanned. 2051 2052 NOPEEPHOLES is the flag to disallow peephole processing (currently 2053 used for within delayed branch sequence output). */ 2054 2055rtx 2056final_scan_insn (insn, file, optimize, prescan, nopeepholes) 2057 rtx insn; 2058 FILE *file; 2059 int optimize; 2060 int prescan; 2061 int nopeepholes; 2062{ 2063#ifdef HAVE_cc0 2064 rtx set; 2065#endif 2066 2067 insn_counter++; 2068 2069 /* Ignore deleted insns. These can occur when we split insns (due to a 2070 template of "#") while not optimizing. */ 2071 if (INSN_DELETED_P (insn)) 2072 return NEXT_INSN (insn); 2073 2074 switch (GET_CODE (insn)) 2075 { 2076 case NOTE: 2077 if (prescan > 0) 2078 break; 2079 2080 /* Align the beginning of a loop, for higher speed 2081 on certain machines. */ 2082 2083 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG) 2084 break; /* This used to depend on optimize, but that was bogus. */ 2085 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END) 2086 break; 2087 2088 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG 2089 && ! exceptions_via_longjmp) 2090 { 2091 ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_BLOCK_NUMBER (insn)); 2092 if (! flag_new_exceptions) 2093 add_eh_table_entry (NOTE_BLOCK_NUMBER (insn)); 2094#ifdef ASM_OUTPUT_EH_REGION_BEG 2095 ASM_OUTPUT_EH_REGION_BEG (file, NOTE_BLOCK_NUMBER (insn)); 2096#endif 2097 break; 2098 } 2099 2100 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END 2101 && ! exceptions_via_longjmp) 2102 { 2103 ASM_OUTPUT_INTERNAL_LABEL (file, "LEHE", NOTE_BLOCK_NUMBER (insn)); 2104 if (flag_new_exceptions) 2105 add_eh_table_entry (NOTE_BLOCK_NUMBER (insn)); 2106#ifdef ASM_OUTPUT_EH_REGION_END 2107 ASM_OUTPUT_EH_REGION_END (file, NOTE_BLOCK_NUMBER (insn)); 2108#endif 2109 break; 2110 } 2111 2112 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) 2113 { 2114#ifdef FUNCTION_END_PROLOGUE 2115 FUNCTION_END_PROLOGUE (file); 2116#endif 2117 profile_after_prologue (file); 2118 break; 2119 } 2120 2121#ifdef FUNCTION_BEGIN_EPILOGUE 2122 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG) 2123 { 2124 FUNCTION_BEGIN_EPILOGUE (file); 2125 break; 2126 } 2127#endif 2128 2129 if (write_symbols == NO_DEBUG) 2130 break; 2131 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG) 2132 { 2133#if defined(SDB_DEBUGGING_INFO) && defined(MIPS_DEBUGGING_INFO) 2134 /* MIPS stabs require the parameter descriptions to be after the 2135 function entry point rather than before. */ 2136 if (write_symbols == SDB_DEBUG) 2137 sdbout_begin_function (last_linenum); 2138 else 2139#endif 2140#ifdef DWARF_DEBUGGING_INFO 2141 /* This outputs a marker where the function body starts, so it 2142 must be after the prologue. */ 2143 if (write_symbols == DWARF_DEBUG) 2144 dwarfout_begin_function (); 2145#endif 2146 break; 2147 } 2148 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED) 2149 break; /* An insn that was "deleted" */ 2150 if (app_on) 2151 { 2152 fputs (ASM_APP_OFF, file); 2153 app_on = 0; 2154 } 2155 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG 2156 && (debug_info_level == DINFO_LEVEL_NORMAL 2157 || debug_info_level == DINFO_LEVEL_VERBOSE 2158 || write_symbols == DWARF_DEBUG 2159 || write_symbols == DWARF2_DEBUG)) 2160 { 2161 /* Beginning of a symbol-block. Assign it a sequence number 2162 and push the number onto the stack PENDING_BLOCKS. */ 2163 2164 if (block_depth == max_block_depth) 2165 { 2166 /* PENDING_BLOCKS is full; make it longer. */ 2167 max_block_depth *= 2; 2168 pending_blocks 2169 = (int *) xrealloc (pending_blocks, 2170 max_block_depth * sizeof (int)); 2171 } 2172 pending_blocks[block_depth++] = next_block_index; 2173 2174 high_block_linenum = last_linenum; 2175 2176 /* Output debugging info about the symbol-block beginning. */ 2177 2178#ifdef SDB_DEBUGGING_INFO 2179 if (write_symbols == SDB_DEBUG) 2180 sdbout_begin_block (file, last_linenum, next_block_index); 2181#endif 2182#ifdef XCOFF_DEBUGGING_INFO 2183 if (write_symbols == XCOFF_DEBUG) 2184 xcoffout_begin_block (file, last_linenum, next_block_index); 2185#endif 2186#ifdef DBX_DEBUGGING_INFO 2187 if (write_symbols == DBX_DEBUG) 2188 ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index); 2189#endif 2190#ifdef DWARF_DEBUGGING_INFO 2191 if (write_symbols == DWARF_DEBUG) 2192 dwarfout_begin_block (next_block_index); 2193#endif 2194#ifdef DWARF2_DEBUGGING_INFO 2195 if (write_symbols == DWARF2_DEBUG) 2196 dwarf2out_begin_block (next_block_index); 2197#endif 2198 2199 next_block_index++; 2200 } 2201 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END 2202 && (debug_info_level == DINFO_LEVEL_NORMAL 2203 || debug_info_level == DINFO_LEVEL_VERBOSE 2204 || write_symbols == DWARF_DEBUG 2205 || write_symbols == DWARF2_DEBUG)) 2206 { 2207 /* End of a symbol-block. Pop its sequence number off 2208 PENDING_BLOCKS and output debugging info based on that. */ 2209 2210 --block_depth; 2211 if (block_depth < 0) 2212 abort (); 2213 2214#ifdef XCOFF_DEBUGGING_INFO 2215 if (write_symbols == XCOFF_DEBUG) 2216 xcoffout_end_block (file, high_block_linenum, 2217 pending_blocks[block_depth]); 2218#endif 2219#ifdef DBX_DEBUGGING_INFO 2220 if (write_symbols == DBX_DEBUG) 2221 ASM_OUTPUT_INTERNAL_LABEL (file, "LBE", 2222 pending_blocks[block_depth]); 2223#endif 2224#ifdef SDB_DEBUGGING_INFO 2225 if (write_symbols == SDB_DEBUG) 2226 sdbout_end_block (file, high_block_linenum, 2227 pending_blocks[block_depth]); 2228#endif 2229#ifdef DWARF_DEBUGGING_INFO 2230 if (write_symbols == DWARF_DEBUG) 2231 dwarfout_end_block (pending_blocks[block_depth]); 2232#endif 2233#ifdef DWARF2_DEBUGGING_INFO 2234 if (write_symbols == DWARF2_DEBUG) 2235 dwarf2out_end_block (pending_blocks[block_depth]); 2236#endif 2237 } 2238 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL 2239 && (debug_info_level == DINFO_LEVEL_NORMAL 2240 || debug_info_level == DINFO_LEVEL_VERBOSE)) 2241 { 2242#ifdef DWARF_DEBUGGING_INFO 2243 if (write_symbols == DWARF_DEBUG) 2244 dwarfout_label (insn); 2245#endif 2246#ifdef DWARF2_DEBUGGING_INFO 2247 if (write_symbols == DWARF2_DEBUG) 2248 dwarf2out_label (insn); 2249#endif 2250 } 2251 else if (NOTE_LINE_NUMBER (insn) > 0) 2252 /* This note is a line-number. */ 2253 { 2254 register rtx note; 2255 2256#if 0 /* This is what we used to do. */ 2257 output_source_line (file, insn); 2258#endif 2259 int note_after = 0; 2260 2261 /* If there is anything real after this note, 2262 output it. If another line note follows, omit this one. */ 2263 for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note)) 2264 { 2265 if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL) 2266 break; 2267 /* These types of notes can be significant 2268 so make sure the preceding line number stays. */ 2269 else if (GET_CODE (note) == NOTE 2270 && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG 2271 || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END 2272 || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG)) 2273 break; 2274 else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0) 2275 { 2276 /* Another line note follows; we can delete this note 2277 if no intervening line numbers have notes elsewhere. */ 2278 int num; 2279 for (num = NOTE_LINE_NUMBER (insn) + 1; 2280 num < NOTE_LINE_NUMBER (note); 2281 num++) 2282 if (line_note_exists[num]) 2283 break; 2284 2285 if (num >= NOTE_LINE_NUMBER (note)) 2286 note_after = 1; 2287 break; 2288 } 2289 } 2290 2291 /* Output this line note 2292 if it is the first or the last line note in a row. */ 2293 if (!note_after) 2294 output_source_line (file, insn); 2295 } 2296 break; 2297 2298 case BARRIER: 2299#if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS) 2300 /* If we push arguments, we need to check all insns for stack 2301 adjustments. */ 2302 if (dwarf2out_do_frame ()) 2303 dwarf2out_frame_debug (insn); 2304#endif 2305 break; 2306 2307 case CODE_LABEL: 2308 /* The target port might emit labels in the output function for 2309 some insn, e.g. sh.c output_branchy_insn. */ 2310 if (CODE_LABEL_NUMBER (insn) <= max_labelno) 2311 { 2312 int align = LABEL_TO_ALIGNMENT (insn); 2313#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN 2314 int max_skip = LABEL_TO_MAX_SKIP (insn); 2315#endif 2316 2317 if (align && NEXT_INSN (insn)) 2318#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN 2319 ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip); 2320#else 2321 ASM_OUTPUT_ALIGN (file, align); 2322#endif 2323 } 2324#ifdef HAVE_cc0 2325 CC_STATUS_INIT; 2326 /* If this label is reached from only one place, set the condition 2327 codes from the instruction just before the branch. */ 2328 2329 /* Disabled because some insns set cc_status in the C output code 2330 and NOTICE_UPDATE_CC alone can set incorrect status. */ 2331 if (0 /* optimize && LABEL_NUSES (insn) == 1*/) 2332 { 2333 rtx jump = LABEL_REFS (insn); 2334 rtx barrier = prev_nonnote_insn (insn); 2335 rtx prev; 2336 /* If the LABEL_REFS field of this label has been set to point 2337 at a branch, the predecessor of the branch is a regular 2338 insn, and that branch is the only way to reach this label, 2339 set the condition codes based on the branch and its 2340 predecessor. */ 2341 if (barrier && GET_CODE (barrier) == BARRIER 2342 && jump && GET_CODE (jump) == JUMP_INSN 2343 && (prev = prev_nonnote_insn (jump)) 2344 && GET_CODE (prev) == INSN) 2345 { 2346 NOTICE_UPDATE_CC (PATTERN (prev), prev); 2347 NOTICE_UPDATE_CC (PATTERN (jump), jump); 2348 } 2349 } 2350#endif 2351 if (prescan > 0) 2352 break; 2353 new_block = 1; 2354 2355#ifdef FINAL_PRESCAN_LABEL 2356 FINAL_PRESCAN_INSN (insn, NULL_PTR, 0); 2357#endif 2358 2359#ifdef SDB_DEBUGGING_INFO 2360 if (write_symbols == SDB_DEBUG && LABEL_NAME (insn)) 2361 sdbout_label (insn); 2362#endif 2363#ifdef DWARF_DEBUGGING_INFO 2364 if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn)) 2365 dwarfout_label (insn); 2366#endif 2367#ifdef DWARF2_DEBUGGING_INFO 2368 if (write_symbols == DWARF2_DEBUG && LABEL_NAME (insn)) 2369 dwarf2out_label (insn); 2370#endif 2371 if (app_on) 2372 { 2373 fputs (ASM_APP_OFF, file); 2374 app_on = 0; 2375 } 2376 if (NEXT_INSN (insn) != 0 2377 && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN) 2378 { 2379 rtx nextbody = PATTERN (NEXT_INSN (insn)); 2380 2381 /* If this label is followed by a jump-table, 2382 make sure we put the label in the read-only section. Also 2383 possibly write the label and jump table together. */ 2384 2385 if (GET_CODE (nextbody) == ADDR_VEC 2386 || GET_CODE (nextbody) == ADDR_DIFF_VEC) 2387 { 2388#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC) 2389 /* In this case, the case vector is being moved by the 2390 target, so don't output the label at all. Leave that 2391 to the back end macros. */ 2392#else 2393 if (! JUMP_TABLES_IN_TEXT_SECTION) 2394 { 2395 readonly_data_section (); 2396#ifdef READONLY_DATA_SECTION 2397 ASM_OUTPUT_ALIGN (file, 2398 exact_log2 (BIGGEST_ALIGNMENT 2399 / BITS_PER_UNIT)); 2400#endif /* READONLY_DATA_SECTION */ 2401 } 2402 else 2403 function_section (current_function_decl); 2404 2405#ifdef ASM_OUTPUT_CASE_LABEL 2406 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), 2407 NEXT_INSN (insn)); 2408#else 2409 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn)); 2410#endif 2411#endif 2412 break; 2413 } 2414 } 2415 2416 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn)); 2417 break; 2418 2419 default: 2420 { 2421 register rtx body = PATTERN (insn); 2422 int insn_code_number; 2423 const char *template; 2424#ifdef HAVE_cc0 2425 rtx note; 2426#endif 2427 2428 /* An INSN, JUMP_INSN or CALL_INSN. 2429 First check for special kinds that recog doesn't recognize. */ 2430 2431 if (GET_CODE (body) == USE /* These are just declarations */ 2432 || GET_CODE (body) == CLOBBER) 2433 break; 2434 2435#ifdef HAVE_cc0 2436 /* If there is a REG_CC_SETTER note on this insn, it means that 2437 the setting of the condition code was done in the delay slot 2438 of the insn that branched here. So recover the cc status 2439 from the insn that set it. */ 2440 2441 note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX); 2442 if (note) 2443 { 2444 NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0)); 2445 cc_prev_status = cc_status; 2446 } 2447#endif 2448 2449 /* Detect insns that are really jump-tables 2450 and output them as such. */ 2451 2452 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC) 2453 { 2454#if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)) 2455 register int vlen, idx; 2456#endif 2457 2458 if (prescan > 0) 2459 break; 2460 2461 if (app_on) 2462 { 2463 fputs (ASM_APP_OFF, file); 2464 app_on = 0; 2465 } 2466 2467#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC) 2468 if (GET_CODE (body) == ADDR_VEC) 2469 { 2470#ifdef ASM_OUTPUT_ADDR_VEC 2471 ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body); 2472#else 2473 abort(); 2474#endif 2475 } 2476 else 2477 { 2478#ifdef ASM_OUTPUT_ADDR_DIFF_VEC 2479 ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body); 2480#else 2481 abort(); 2482#endif 2483 } 2484#else 2485 vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC); 2486 for (idx = 0; idx < vlen; idx++) 2487 { 2488 if (GET_CODE (body) == ADDR_VEC) 2489 { 2490#ifdef ASM_OUTPUT_ADDR_VEC_ELT 2491 ASM_OUTPUT_ADDR_VEC_ELT 2492 (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0))); 2493#else 2494 abort (); 2495#endif 2496 } 2497 else 2498 { 2499#ifdef ASM_OUTPUT_ADDR_DIFF_ELT 2500 ASM_OUTPUT_ADDR_DIFF_ELT 2501 (file, 2502 body, 2503 CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)), 2504 CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0))); 2505#else 2506 abort (); 2507#endif 2508 } 2509 } 2510#ifdef ASM_OUTPUT_CASE_END 2511 ASM_OUTPUT_CASE_END (file, 2512 CODE_LABEL_NUMBER (PREV_INSN (insn)), 2513 insn); 2514#endif 2515#endif 2516 2517 function_section (current_function_decl); 2518 2519 break; 2520 } 2521 2522 /* Do basic-block profiling when we reach a new block. 2523 Done here to avoid jump tables. */ 2524 if (profile_block_flag && new_block) 2525 add_bb (file); 2526 2527 if (GET_CODE (body) == ASM_INPUT) 2528 { 2529 /* There's no telling what that did to the condition codes. */ 2530 CC_STATUS_INIT; 2531 if (prescan > 0) 2532 break; 2533 if (! app_on) 2534 { 2535 fputs (ASM_APP_ON, file); 2536 app_on = 1; 2537 } 2538 fprintf (asm_out_file, "\t%s\n", XSTR (body, 0)); 2539 break; 2540 } 2541 2542 /* Detect `asm' construct with operands. */ 2543 if (asm_noperands (body) >= 0) 2544 { 2545 unsigned int noperands = asm_noperands (body); 2546 rtx *ops = (rtx *) alloca (noperands * sizeof (rtx)); 2547 char *string; 2548 2549 /* There's no telling what that did to the condition codes. */ 2550 CC_STATUS_INIT; 2551 if (prescan > 0) 2552 break; 2553 2554 if (! app_on) 2555 { 2556 fputs (ASM_APP_ON, file); 2557 app_on = 1; 2558 } 2559 2560 /* Get out the operand values. */ 2561 string = decode_asm_operands (body, ops, NULL_PTR, 2562 NULL_PTR, NULL_PTR); 2563 /* Inhibit aborts on what would otherwise be compiler bugs. */ 2564 insn_noperands = noperands; 2565 this_is_asm_operands = insn; 2566 2567 /* Output the insn using them. */ 2568 output_asm_insn (string, ops); 2569 this_is_asm_operands = 0; 2570 break; 2571 } 2572 2573 if (prescan <= 0 && app_on) 2574 { 2575 fputs (ASM_APP_OFF, file); 2576 app_on = 0; 2577 } 2578 2579 if (GET_CODE (body) == SEQUENCE) 2580 { 2581 /* A delayed-branch sequence */ 2582 register int i; 2583 rtx next; 2584 2585 if (prescan > 0) 2586 break; 2587 final_sequence = body; 2588 2589 /* The first insn in this SEQUENCE might be a JUMP_INSN that will 2590 force the restoration of a comparison that was previously 2591 thought unnecessary. If that happens, cancel this sequence 2592 and cause that insn to be restored. */ 2593 2594 next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1); 2595 if (next != XVECEXP (body, 0, 1)) 2596 { 2597 final_sequence = 0; 2598 return next; 2599 } 2600 2601 for (i = 1; i < XVECLEN (body, 0); i++) 2602 { 2603 rtx insn = XVECEXP (body, 0, i); 2604 rtx next = NEXT_INSN (insn); 2605 /* We loop in case any instruction in a delay slot gets 2606 split. */ 2607 do 2608 insn = final_scan_insn (insn, file, 0, prescan, 1); 2609 while (insn != next); 2610 } 2611#ifdef DBR_OUTPUT_SEQEND 2612 DBR_OUTPUT_SEQEND (file); 2613#endif 2614 final_sequence = 0; 2615 2616 /* If the insn requiring the delay slot was a CALL_INSN, the 2617 insns in the delay slot are actually executed before the 2618 called function. Hence we don't preserve any CC-setting 2619 actions in these insns and the CC must be marked as being 2620 clobbered by the function. */ 2621 if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN) 2622 { 2623 CC_STATUS_INIT; 2624 } 2625 2626 /* Following a conditional branch sequence, we have a new basic 2627 block. */ 2628 if (profile_block_flag) 2629 { 2630 rtx insn = XVECEXP (body, 0, 0); 2631 rtx body = PATTERN (insn); 2632 2633 if ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET 2634 && GET_CODE (SET_SRC (body)) != LABEL_REF) 2635 || (GET_CODE (insn) == JUMP_INSN 2636 && GET_CODE (body) == PARALLEL 2637 && GET_CODE (XVECEXP (body, 0, 0)) == SET 2638 && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF)) 2639 new_block = 1; 2640 } 2641 break; 2642 } 2643 2644 /* We have a real machine instruction as rtl. */ 2645 2646 body = PATTERN (insn); 2647 2648#ifdef HAVE_cc0 2649 set = single_set(insn); 2650 2651 /* Check for redundant test and compare instructions 2652 (when the condition codes are already set up as desired). 2653 This is done only when optimizing; if not optimizing, 2654 it should be possible for the user to alter a variable 2655 with the debugger in between statements 2656 and the next statement should reexamine the variable 2657 to compute the condition codes. */ 2658 2659 if (optimize) 2660 { 2661#if 0 2662 rtx set = single_set(insn); 2663#endif 2664 2665 if (set 2666 && GET_CODE (SET_DEST (set)) == CC0 2667 && insn != last_ignored_compare) 2668 { 2669 if (GET_CODE (SET_SRC (set)) == SUBREG) 2670 SET_SRC (set) = alter_subreg (SET_SRC (set)); 2671 else if (GET_CODE (SET_SRC (set)) == COMPARE) 2672 { 2673 if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG) 2674 XEXP (SET_SRC (set), 0) 2675 = alter_subreg (XEXP (SET_SRC (set), 0)); 2676 if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG) 2677 XEXP (SET_SRC (set), 1) 2678 = alter_subreg (XEXP (SET_SRC (set), 1)); 2679 } 2680 if ((cc_status.value1 != 0 2681 && rtx_equal_p (SET_SRC (set), cc_status.value1)) 2682 || (cc_status.value2 != 0 2683 && rtx_equal_p (SET_SRC (set), cc_status.value2))) 2684 { 2685 /* Don't delete insn if it has an addressing side-effect. */ 2686 if (! FIND_REG_INC_NOTE (insn, 0) 2687 /* or if anything in it is volatile. */ 2688 && ! volatile_refs_p (PATTERN (insn))) 2689 { 2690 /* We don't really delete the insn; just ignore it. */ 2691 last_ignored_compare = insn; 2692 break; 2693 } 2694 } 2695 } 2696 } 2697#endif 2698 2699 /* Following a conditional branch, we have a new basic block. 2700 But if we are inside a sequence, the new block starts after the 2701 last insn of the sequence. */ 2702 if (profile_block_flag && final_sequence == 0 2703 && ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET 2704 && GET_CODE (SET_SRC (body)) != LABEL_REF) 2705 || (GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == PARALLEL 2706 && GET_CODE (XVECEXP (body, 0, 0)) == SET 2707 && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF))) 2708 new_block = 1; 2709 2710#ifndef STACK_REGS 2711 /* Don't bother outputting obvious no-ops, even without -O. 2712 This optimization is fast and doesn't interfere with debugging. 2713 Don't do this if the insn is in a delay slot, since this 2714 will cause an improper number of delay insns to be written. */ 2715 if (final_sequence == 0 2716 && prescan >= 0 2717 && GET_CODE (insn) == INSN && GET_CODE (body) == SET 2718 && GET_CODE (SET_SRC (body)) == REG 2719 && GET_CODE (SET_DEST (body)) == REG 2720 && REGNO (SET_SRC (body)) == REGNO (SET_DEST (body))) 2721 break; 2722#endif 2723 2724#ifdef HAVE_cc0 2725 /* If this is a conditional branch, maybe modify it 2726 if the cc's are in a nonstandard state 2727 so that it accomplishes the same thing that it would 2728 do straightforwardly if the cc's were set up normally. */ 2729 2730 if (cc_status.flags != 0 2731 && GET_CODE (insn) == JUMP_INSN 2732 && GET_CODE (body) == SET 2733 && SET_DEST (body) == pc_rtx 2734 && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE 2735 && GET_RTX_CLASS (GET_CODE (XEXP (SET_SRC (body), 0))) == '<' 2736 && XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx 2737 /* This is done during prescan; it is not done again 2738 in final scan when prescan has been done. */ 2739 && prescan >= 0) 2740 { 2741 /* This function may alter the contents of its argument 2742 and clear some of the cc_status.flags bits. 2743 It may also return 1 meaning condition now always true 2744 or -1 meaning condition now always false 2745 or 2 meaning condition nontrivial but altered. */ 2746 register int result = alter_cond (XEXP (SET_SRC (body), 0)); 2747 /* If condition now has fixed value, replace the IF_THEN_ELSE 2748 with its then-operand or its else-operand. */ 2749 if (result == 1) 2750 SET_SRC (body) = XEXP (SET_SRC (body), 1); 2751 if (result == -1) 2752 SET_SRC (body) = XEXP (SET_SRC (body), 2); 2753 2754 /* The jump is now either unconditional or a no-op. 2755 If it has become a no-op, don't try to output it. 2756 (It would not be recognized.) */ 2757 if (SET_SRC (body) == pc_rtx) 2758 { 2759 PUT_CODE (insn, NOTE); 2760 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; 2761 NOTE_SOURCE_FILE (insn) = 0; 2762 break; 2763 } 2764 else if (GET_CODE (SET_SRC (body)) == RETURN) 2765 /* Replace (set (pc) (return)) with (return). */ 2766 PATTERN (insn) = body = SET_SRC (body); 2767 2768 /* Rerecognize the instruction if it has changed. */ 2769 if (result != 0) 2770 INSN_CODE (insn) = -1; 2771 } 2772 2773 /* Make same adjustments to instructions that examine the 2774 condition codes without jumping and instructions that 2775 handle conditional moves (if this machine has either one). */ 2776 2777 if (cc_status.flags != 0 2778 && set != 0) 2779 { 2780 rtx cond_rtx, then_rtx, else_rtx; 2781 2782 if (GET_CODE (insn) != JUMP_INSN 2783 && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE) 2784 { 2785 cond_rtx = XEXP (SET_SRC (set), 0); 2786 then_rtx = XEXP (SET_SRC (set), 1); 2787 else_rtx = XEXP (SET_SRC (set), 2); 2788 } 2789 else 2790 { 2791 cond_rtx = SET_SRC (set); 2792 then_rtx = const_true_rtx; 2793 else_rtx = const0_rtx; 2794 } 2795 2796 switch (GET_CODE (cond_rtx)) 2797 { 2798 case GTU: 2799 case GT: 2800 case LTU: 2801 case LT: 2802 case GEU: 2803 case GE: 2804 case LEU: 2805 case LE: 2806 case EQ: 2807 case NE: 2808 { 2809 register int result; 2810 if (XEXP (cond_rtx, 0) != cc0_rtx) 2811 break; 2812 result = alter_cond (cond_rtx); 2813 if (result == 1) 2814 validate_change (insn, &SET_SRC (set), then_rtx, 0); 2815 else if (result == -1) 2816 validate_change (insn, &SET_SRC (set), else_rtx, 0); 2817 else if (result == 2) 2818 INSN_CODE (insn) = -1; 2819 if (SET_DEST (set) == SET_SRC (set)) 2820 { 2821 PUT_CODE (insn, NOTE); 2822 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; 2823 NOTE_SOURCE_FILE (insn) = 0; 2824 } 2825 } 2826 break; 2827 2828 default: 2829 break; 2830 } 2831 } 2832 2833#endif 2834 2835 /* Do machine-specific peephole optimizations if desired. */ 2836 2837 if (optimize && !flag_no_peephole && !nopeepholes) 2838 { 2839 rtx next = peephole (insn); 2840 /* When peepholing, if there were notes within the peephole, 2841 emit them before the peephole. */ 2842 if (next != 0 && next != NEXT_INSN (insn)) 2843 { 2844 rtx prev = PREV_INSN (insn); 2845 rtx note; 2846 2847 for (note = NEXT_INSN (insn); note != next; 2848 note = NEXT_INSN (note)) 2849 final_scan_insn (note, file, optimize, prescan, nopeepholes); 2850 2851 /* In case this is prescan, put the notes 2852 in proper position for later rescan. */ 2853 note = NEXT_INSN (insn); 2854 PREV_INSN (note) = prev; 2855 NEXT_INSN (prev) = note; 2856 NEXT_INSN (PREV_INSN (next)) = insn; 2857 PREV_INSN (insn) = PREV_INSN (next); 2858 NEXT_INSN (insn) = next; 2859 PREV_INSN (next) = insn; 2860 } 2861 2862 /* PEEPHOLE might have changed this. */ 2863 body = PATTERN (insn); 2864 } 2865 2866 /* Try to recognize the instruction. 2867 If successful, verify that the operands satisfy the 2868 constraints for the instruction. Crash if they don't, 2869 since `reload' should have changed them so that they do. */ 2870 2871 insn_code_number = recog_memoized (insn); 2872 extract_insn (insn); 2873 cleanup_subreg_operands (insn); 2874 2875#ifdef REGISTER_CONSTRAINTS 2876 if (! constrain_operands (1)) 2877 fatal_insn_not_found (insn); 2878#endif 2879 2880 /* Some target machines need to prescan each insn before 2881 it is output. */ 2882 2883#ifdef FINAL_PRESCAN_INSN 2884 FINAL_PRESCAN_INSN (insn, recog_operand, recog_n_operands); 2885#endif 2886 2887#ifdef HAVE_cc0 2888 cc_prev_status = cc_status; 2889 2890 /* Update `cc_status' for this instruction. 2891 The instruction's output routine may change it further. 2892 If the output routine for a jump insn needs to depend 2893 on the cc status, it should look at cc_prev_status. */ 2894 2895 NOTICE_UPDATE_CC (body, insn); 2896#endif 2897 2898 debug_insn = insn; 2899 2900#if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS) 2901 /* If we push arguments, we want to know where the calls are. */ 2902 if (GET_CODE (insn) == CALL_INSN && dwarf2out_do_frame ()) 2903 dwarf2out_frame_debug (insn); 2904#endif 2905 2906 /* If the proper template needs to be chosen by some C code, 2907 run that code and get the real template. */ 2908 2909 template = insn_template[insn_code_number]; 2910 if (template == 0) 2911 { 2912 template = (*insn_outfun[insn_code_number]) (recog_operand, insn); 2913 2914 /* If the C code returns 0, it means that it is a jump insn 2915 which follows a deleted test insn, and that test insn 2916 needs to be reinserted. */ 2917 if (template == 0) 2918 { 2919 if (prev_nonnote_insn (insn) != last_ignored_compare) 2920 abort (); 2921 new_block = 0; 2922 return prev_nonnote_insn (insn); 2923 } 2924 } 2925 2926 /* If the template is the string "#", it means that this insn must 2927 be split. */ 2928 if (template[0] == '#' && template[1] == '\0') 2929 { 2930 rtx new = try_split (body, insn, 0); 2931 2932 /* If we didn't split the insn, go away. */ 2933 if (new == insn && PATTERN (new) == body) 2934 fatal_insn ("Could not split insn", insn); 2935 2936#ifdef HAVE_ATTR_length 2937 /* This instruction should have been split in shorten_branches, 2938 to ensure that we would have valid length info for the 2939 splitees. */ 2940 abort (); 2941#endif 2942 2943 new_block = 0; 2944 return new; 2945 } 2946 2947 if (prescan > 0) 2948 break; 2949 2950 /* Output assembler code from the template. */ 2951 2952 output_asm_insn (template, recog_operand); 2953 2954#if defined (DWARF2_UNWIND_INFO) 2955#if !defined (ACCUMULATE_OUTGOING_ARGS) 2956 /* If we push arguments, we need to check all insns for stack 2957 adjustments. */ 2958 if (GET_CODE (insn) == INSN && dwarf2out_do_frame ()) 2959 dwarf2out_frame_debug (insn); 2960#else 2961#if defined (HAVE_prologue) 2962 /* If this insn is part of the prologue, emit DWARF v2 2963 call frame info. */ 2964 if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ()) 2965 dwarf2out_frame_debug (insn); 2966#endif 2967#endif 2968#endif 2969 2970#if 0 2971 /* It's not at all clear why we did this and doing so interferes 2972 with tests we'd like to do to use REG_WAS_0 notes, so let's try 2973 with this out. */ 2974 2975 /* Mark this insn as having been output. */ 2976 INSN_DELETED_P (insn) = 1; 2977#endif 2978 2979 debug_insn = 0; 2980 } 2981 } 2982 return NEXT_INSN (insn); 2983} 2984 2985/* Output debugging info to the assembler file FILE 2986 based on the NOTE-insn INSN, assumed to be a line number. */ 2987 2988static void 2989output_source_line (file, insn) 2990 FILE *file; 2991 rtx insn; 2992{ 2993 register char *filename = NOTE_SOURCE_FILE (insn); 2994 2995 /* Remember filename for basic block profiling. 2996 Filenames are allocated on the permanent obstack 2997 or are passed in ARGV, so we don't have to save 2998 the string. */ 2999 3000 if (profile_block_flag && last_filename != filename) 3001 bb_file_label_num = add_bb_string (filename, TRUE); 3002 3003 last_filename = filename; 3004 last_linenum = NOTE_LINE_NUMBER (insn); 3005 high_block_linenum = MAX (last_linenum, high_block_linenum); 3006 high_function_linenum = MAX (last_linenum, high_function_linenum); 3007 3008 if (write_symbols != NO_DEBUG) 3009 { 3010#ifdef SDB_DEBUGGING_INFO 3011 if (write_symbols == SDB_DEBUG 3012#if 0 /* People like having line numbers even in wrong file! */ 3013 /* COFF can't handle multiple source files--lose, lose. */ 3014 && !strcmp (filename, main_input_filename) 3015#endif 3016 /* COFF relative line numbers must be positive. */ 3017 && last_linenum > sdb_begin_function_line) 3018 { 3019#ifdef ASM_OUTPUT_SOURCE_LINE 3020 ASM_OUTPUT_SOURCE_LINE (file, last_linenum); 3021#else 3022 fprintf (file, "\t.ln\t%d\n", 3023 ((sdb_begin_function_line > -1) 3024 ? last_linenum - sdb_begin_function_line : 1)); 3025#endif 3026 } 3027#endif 3028 3029#if defined (DBX_DEBUGGING_INFO) 3030 if (write_symbols == DBX_DEBUG) 3031 dbxout_source_line (file, filename, NOTE_LINE_NUMBER (insn)); 3032#endif 3033 3034#if defined (XCOFF_DEBUGGING_INFO) 3035 if (write_symbols == XCOFF_DEBUG) 3036 xcoffout_source_line (file, filename, insn); 3037#endif 3038 3039#ifdef DWARF_DEBUGGING_INFO 3040 if (write_symbols == DWARF_DEBUG) 3041 dwarfout_line (filename, NOTE_LINE_NUMBER (insn)); 3042#endif 3043 3044#ifdef DWARF2_DEBUGGING_INFO 3045 if (write_symbols == DWARF2_DEBUG) 3046 dwarf2out_line (filename, NOTE_LINE_NUMBER (insn)); 3047#endif 3048 } 3049} 3050 3051 3052/* For each operand in INSN, simplify (subreg (reg)) so that it refers 3053 directly to the desired hard register. */ 3054void 3055cleanup_subreg_operands (insn) 3056 rtx insn; 3057{ 3058 int i; 3059 3060 extract_insn (insn); 3061 for (i = 0; i < recog_n_operands; i++) 3062 { 3063 if (GET_CODE (recog_operand[i]) == SUBREG) 3064 recog_operand[i] = alter_subreg (recog_operand[i]); 3065 else if (GET_CODE (recog_operand[i]) == PLUS 3066 || GET_CODE (recog_operand[i]) == MULT 3067 || GET_CODE (recog_operand[i]) == MEM) 3068 recog_operand[i] = walk_alter_subreg (recog_operand[i]); 3069 } 3070 3071 for (i = 0; i < recog_n_dups; i++) 3072 { 3073 if (GET_CODE (*recog_dup_loc[i]) == SUBREG) 3074 *recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]); 3075 else if (GET_CODE (*recog_dup_loc[i]) == PLUS 3076 || GET_CODE (*recog_dup_loc[i]) == MULT 3077 || GET_CODE (*recog_dup_loc[i]) == MEM) 3078 *recog_dup_loc[i] = walk_alter_subreg (*recog_dup_loc[i]); 3079 } 3080} 3081 3082/* If X is a SUBREG, replace it with a REG or a MEM, 3083 based on the thing it is a subreg of. */ 3084 3085rtx 3086alter_subreg (x) 3087 register rtx x; 3088{ 3089 register rtx y = SUBREG_REG (x); 3090 3091 if (GET_CODE (y) == SUBREG) 3092 y = alter_subreg (y); 3093 3094 /* If reload is operating, we may be replacing inside this SUBREG. 3095 Check for that and make a new one if so. */ 3096 if (reload_in_progress && find_replacement (&SUBREG_REG (x)) != 0) 3097 x = copy_rtx (x); 3098 3099 if (GET_CODE (y) == REG) 3100 { 3101 /* If the word size is larger than the size of this register, 3102 adjust the register number to compensate. */ 3103 /* ??? Note that this just catches stragglers created by/for 3104 integrate. It would be better if we either caught these 3105 earlier, or kept _all_ subregs until now and eliminate 3106 gen_lowpart and friends. */ 3107 3108 PUT_CODE (x, REG); 3109#ifdef ALTER_HARD_SUBREG 3110 REGNO (x) = ALTER_HARD_SUBREG(GET_MODE (x), SUBREG_WORD (x), 3111 GET_MODE (y), REGNO (y)); 3112#else 3113 REGNO (x) = REGNO (y) + SUBREG_WORD (x); 3114#endif 3115 /* This field has a different meaning for REGs and SUBREGs. Make sure 3116 to clear it! */ 3117 x->used = 0; 3118 } 3119 else if (GET_CODE (y) == MEM) 3120 { 3121 register int offset = SUBREG_WORD (x) * UNITS_PER_WORD; 3122 if (BYTES_BIG_ENDIAN) 3123 offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))) 3124 - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y)))); 3125 PUT_CODE (x, MEM); 3126 MEM_COPY_ATTRIBUTES (x, y); 3127 MEM_ALIAS_SET (x) = MEM_ALIAS_SET (y); 3128 XEXP (x, 0) = plus_constant_for_output (XEXP (y, 0), offset); 3129 } 3130 3131 return x; 3132} 3133 3134/* Do alter_subreg on all the SUBREGs contained in X. */ 3135 3136static rtx 3137walk_alter_subreg (x) 3138 rtx x; 3139{ 3140 switch (GET_CODE (x)) 3141 { 3142 case PLUS: 3143 case MULT: 3144 XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0)); 3145 XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1)); 3146 break; 3147 3148 case MEM: 3149 XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0)); 3150 break; 3151 3152 case SUBREG: 3153 return alter_subreg (x); 3154 3155 default: 3156 break; 3157 } 3158 3159 return x; 3160} 3161 3162#ifdef HAVE_cc0 3163 3164/* Given BODY, the body of a jump instruction, alter the jump condition 3165 as required by the bits that are set in cc_status.flags. 3166 Not all of the bits there can be handled at this level in all cases. 3167 3168 The value is normally 0. 3169 1 means that the condition has become always true. 3170 -1 means that the condition has become always false. 3171 2 means that COND has been altered. */ 3172 3173static int 3174alter_cond (cond) 3175 register rtx cond; 3176{ 3177 int value = 0; 3178 3179 if (cc_status.flags & CC_REVERSED) 3180 { 3181 value = 2; 3182 PUT_CODE (cond, swap_condition (GET_CODE (cond))); 3183 } 3184 3185 if (cc_status.flags & CC_INVERTED) 3186 { 3187 value = 2; 3188 PUT_CODE (cond, reverse_condition (GET_CODE (cond))); 3189 } 3190 3191 if (cc_status.flags & CC_NOT_POSITIVE) 3192 switch (GET_CODE (cond)) 3193 { 3194 case LE: 3195 case LEU: 3196 case GEU: 3197 /* Jump becomes unconditional. */ 3198 return 1; 3199 3200 case GT: 3201 case GTU: 3202 case LTU: 3203 /* Jump becomes no-op. */ 3204 return -1; 3205 3206 case GE: 3207 PUT_CODE (cond, EQ); 3208 value = 2; 3209 break; 3210 3211 case LT: 3212 PUT_CODE (cond, NE); 3213 value = 2; 3214 break; 3215 3216 default: 3217 break; 3218 } 3219 3220 if (cc_status.flags & CC_NOT_NEGATIVE) 3221 switch (GET_CODE (cond)) 3222 { 3223 case GE: 3224 case GEU: 3225 /* Jump becomes unconditional. */ 3226 return 1; 3227 3228 case LT: 3229 case LTU: 3230 /* Jump becomes no-op. */ 3231 return -1; 3232 3233 case LE: 3234 case LEU: 3235 PUT_CODE (cond, EQ); 3236 value = 2; 3237 break; 3238 3239 case GT: 3240 case GTU: 3241 PUT_CODE (cond, NE); 3242 value = 2; 3243 break; 3244 3245 default: 3246 break; 3247 } 3248 3249 if (cc_status.flags & CC_NO_OVERFLOW) 3250 switch (GET_CODE (cond)) 3251 { 3252 case GEU: 3253 /* Jump becomes unconditional. */ 3254 return 1; 3255 3256 case LEU: 3257 PUT_CODE (cond, EQ); 3258 value = 2; 3259 break; 3260 3261 case GTU: 3262 PUT_CODE (cond, NE); 3263 value = 2; 3264 break; 3265 3266 case LTU: 3267 /* Jump becomes no-op. */ 3268 return -1; 3269 3270 default: 3271 break; 3272 } 3273 3274 if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N)) 3275 switch (GET_CODE (cond)) 3276 { 3277 default: 3278 abort (); 3279 3280 case NE: 3281 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT); 3282 value = 2; 3283 break; 3284 3285 case EQ: 3286 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE); 3287 value = 2; 3288 break; 3289 } 3290 3291 if (cc_status.flags & CC_NOT_SIGNED) 3292 /* The flags are valid if signed condition operators are converted 3293 to unsigned. */ 3294 switch (GET_CODE (cond)) 3295 { 3296 case LE: 3297 PUT_CODE (cond, LEU); 3298 value = 2; 3299 break; 3300 3301 case LT: 3302 PUT_CODE (cond, LTU); 3303 value = 2; 3304 break; 3305 3306 case GT: 3307 PUT_CODE (cond, GTU); 3308 value = 2; 3309 break; 3310 3311 case GE: 3312 PUT_CODE (cond, GEU); 3313 value = 2; 3314 break; 3315 3316 default: 3317 break; 3318 } 3319 3320 return value; 3321} 3322#endif 3323 3324/* Report inconsistency between the assembler template and the operands. 3325 In an `asm', it's the user's fault; otherwise, the compiler's fault. */ 3326 3327void 3328output_operand_lossage (msgid) 3329 const char *msgid; 3330{ 3331 if (this_is_asm_operands) 3332 error_for_asm (this_is_asm_operands, "invalid `asm': %s", _(msgid)); 3333 else 3334 fatal ("Internal compiler error, output_operand_lossage `%s'", _(msgid)); 3335} 3336 3337/* Output of assembler code from a template, and its subroutines. */ 3338 3339/* Output text from TEMPLATE to the assembler output file, 3340 obeying %-directions to substitute operands taken from 3341 the vector OPERANDS. 3342 3343 %N (for N a digit) means print operand N in usual manner. 3344 %lN means require operand N to be a CODE_LABEL or LABEL_REF 3345 and print the label name with no punctuation. 3346 %cN means require operand N to be a constant 3347 and print the constant expression with no punctuation. 3348 %aN means expect operand N to be a memory address 3349 (not a memory reference!) and print a reference 3350 to that address. 3351 %nN means expect operand N to be a constant 3352 and print a constant expression for minus the value 3353 of the operand, with no other punctuation. */ 3354 3355static void 3356output_asm_name () 3357{ 3358 if (flag_print_asm_name) 3359 { 3360 /* Annotate the assembly with a comment describing the pattern and 3361 alternative used. */ 3362 if (debug_insn) 3363 { 3364 register int num = INSN_CODE (debug_insn); 3365 fprintf (asm_out_file, "\t%s %d\t%s", 3366 ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]); 3367 if (insn_n_alternatives[num] > 1) 3368 fprintf (asm_out_file, "/%d", which_alternative + 1); 3369#ifdef HAVE_ATTR_length 3370 fprintf (asm_out_file, "\t[length = %d]", get_attr_length (debug_insn)); 3371#endif 3372 /* Clear this so only the first assembler insn 3373 of any rtl insn will get the special comment for -dp. */ 3374 debug_insn = 0; 3375 } 3376 } 3377} 3378 3379void 3380output_asm_insn (template, operands) 3381 const char *template; 3382 rtx *operands; 3383{ 3384 register const char *p; 3385 register int c; 3386 3387 /* An insn may return a null string template 3388 in a case where no assembler code is needed. */ 3389 if (*template == 0) 3390 return; 3391 3392 p = template; 3393 putc ('\t', asm_out_file); 3394 3395#ifdef ASM_OUTPUT_OPCODE 3396 ASM_OUTPUT_OPCODE (asm_out_file, p); 3397#endif 3398 3399 while ((c = *p++)) 3400 switch (c) 3401 { 3402 case '\n': 3403 output_asm_name (); 3404 putc (c, asm_out_file); 3405#ifdef ASM_OUTPUT_OPCODE 3406 while ((c = *p) == '\t') 3407 { 3408 putc (c, asm_out_file); 3409 p++; 3410 } 3411 ASM_OUTPUT_OPCODE (asm_out_file, p); 3412#endif 3413 break; 3414 3415#ifdef ASSEMBLER_DIALECT 3416 case '{': 3417 { 3418 register int i; 3419 3420 /* If we want the first dialect, do nothing. Otherwise, skip 3421 DIALECT_NUMBER of strings ending with '|'. */ 3422 for (i = 0; i < dialect_number; i++) 3423 { 3424 while (*p && *p++ != '|') 3425 ; 3426 3427 if (*p == '|') 3428 p++; 3429 } 3430 } 3431 break; 3432 3433 case '|': 3434 /* Skip to close brace. */ 3435 while (*p && *p++ != '}') 3436 ; 3437 break; 3438 3439 case '}': 3440 break; 3441#endif 3442 3443 case '%': 3444 /* %% outputs a single %. */ 3445 if (*p == '%') 3446 { 3447 p++; 3448 putc (c, asm_out_file); 3449 } 3450 /* %= outputs a number which is unique to each insn in the entire 3451 compilation. This is useful for making local labels that are 3452 referred to more than once in a given insn. */ 3453 else if (*p == '=') 3454 { 3455 p++; 3456 fprintf (asm_out_file, "%d", insn_counter); 3457 } 3458 /* % followed by a letter and some digits 3459 outputs an operand in a special way depending on the letter. 3460 Letters `acln' are implemented directly. 3461 Other letters are passed to `output_operand' so that 3462 the PRINT_OPERAND macro can define them. */ 3463 else if ((*p >= 'a' && *p <= 'z') 3464 || (*p >= 'A' && *p <= 'Z')) 3465 { 3466 int letter = *p++; 3467 c = atoi (p); 3468 3469 if (! (*p >= '0' && *p <= '9')) 3470 output_operand_lossage ("operand number missing after %-letter"); 3471 else if (this_is_asm_operands && (c < 0 || (unsigned int) c >= insn_noperands)) 3472 output_operand_lossage ("operand number out of range"); 3473 else if (letter == 'l') 3474 output_asm_label (operands[c]); 3475 else if (letter == 'a') 3476 output_address (operands[c]); 3477 else if (letter == 'c') 3478 { 3479 if (CONSTANT_ADDRESS_P (operands[c])) 3480 output_addr_const (asm_out_file, operands[c]); 3481 else 3482 output_operand (operands[c], 'c'); 3483 } 3484 else if (letter == 'n') 3485 { 3486 if (GET_CODE (operands[c]) == CONST_INT) 3487 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, 3488 - INTVAL (operands[c])); 3489 else 3490 { 3491 putc ('-', asm_out_file); 3492 output_addr_const (asm_out_file, operands[c]); 3493 } 3494 } 3495 else 3496 output_operand (operands[c], letter); 3497 3498 while ((c = *p) >= '0' && c <= '9') p++; 3499 } 3500 /* % followed by a digit outputs an operand the default way. */ 3501 else if (*p >= '0' && *p <= '9') 3502 { 3503 c = atoi (p); 3504 if (this_is_asm_operands && (c < 0 || (unsigned int) c >= insn_noperands)) 3505 output_operand_lossage ("operand number out of range"); 3506 else 3507 output_operand (operands[c], 0); 3508 while ((c = *p) >= '0' && c <= '9') p++; 3509 } 3510 /* % followed by punctuation: output something for that 3511 punctuation character alone, with no operand. 3512 The PRINT_OPERAND macro decides what is actually done. */ 3513#ifdef PRINT_OPERAND_PUNCT_VALID_P 3514 else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char)*p)) 3515 output_operand (NULL_RTX, *p++); 3516#endif 3517 else 3518 output_operand_lossage ("invalid %%-code"); 3519 break; 3520 3521 default: 3522 putc (c, asm_out_file); 3523 } 3524 3525 output_asm_name (); 3526 3527 putc ('\n', asm_out_file); 3528} 3529 3530/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */ 3531 3532void 3533output_asm_label (x) 3534 rtx x; 3535{ 3536 char buf[256]; 3537 3538 if (GET_CODE (x) == LABEL_REF) 3539 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0))); 3540 else if (GET_CODE (x) == CODE_LABEL) 3541 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x)); 3542 else 3543 output_operand_lossage ("`%l' operand isn't a label"); 3544 3545 assemble_name (asm_out_file, buf); 3546} 3547 3548/* Print operand X using machine-dependent assembler syntax. 3549 The macro PRINT_OPERAND is defined just to control this function. 3550 CODE is a non-digit that preceded the operand-number in the % spec, 3551 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char 3552 between the % and the digits. 3553 When CODE is a non-letter, X is 0. 3554 3555 The meanings of the letters are machine-dependent and controlled 3556 by PRINT_OPERAND. */ 3557 3558static void 3559output_operand (x, code) 3560 rtx x; 3561 int code; 3562{ 3563 if (x && GET_CODE (x) == SUBREG) 3564 x = alter_subreg (x); 3565 3566 /* If X is a pseudo-register, abort now rather than writing trash to the 3567 assembler file. */ 3568 3569 if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER) 3570 abort (); 3571 3572 PRINT_OPERAND (asm_out_file, x, code); 3573} 3574 3575/* Print a memory reference operand for address X 3576 using machine-dependent assembler syntax. 3577 The macro PRINT_OPERAND_ADDRESS exists just to control this function. */ 3578 3579void 3580output_address (x) 3581 rtx x; 3582{ 3583 walk_alter_subreg (x); 3584 PRINT_OPERAND_ADDRESS (asm_out_file, x); 3585} 3586 3587/* Print an integer constant expression in assembler syntax. 3588 Addition and subtraction are the only arithmetic 3589 that may appear in these expressions. */ 3590 3591void 3592output_addr_const (file, x) 3593 FILE *file; 3594 rtx x; 3595{ 3596 char buf[256]; 3597 3598 restart: 3599 switch (GET_CODE (x)) 3600 { 3601 case PC: 3602 if (flag_pic) 3603 putc ('.', file); 3604 else 3605 abort (); 3606 break; 3607 3608 case SYMBOL_REF: 3609 assemble_name (file, XSTR (x, 0)); 3610 break; 3611 3612 case LABEL_REF: 3613 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0))); 3614 assemble_name (file, buf); 3615 break; 3616 3617 case CODE_LABEL: 3618 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x)); 3619 assemble_name (file, buf); 3620 break; 3621 3622 case CONST_INT: 3623 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x)); 3624 break; 3625 3626 case CONST: 3627 /* This used to output parentheses around the expression, 3628 but that does not work on the 386 (either ATT or BSD assembler). */ 3629 output_addr_const (file, XEXP (x, 0)); 3630 break; 3631 3632 case CONST_DOUBLE: 3633 if (GET_MODE (x) == VOIDmode) 3634 { 3635 /* We can use %d if the number is one word and positive. */ 3636 if (CONST_DOUBLE_HIGH (x)) 3637 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, 3638 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x)); 3639 else if (CONST_DOUBLE_LOW (x) < 0) 3640 fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x)); 3641 else 3642 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x)); 3643 } 3644 else 3645 /* We can't handle floating point constants; 3646 PRINT_OPERAND must handle them. */ 3647 output_operand_lossage ("floating constant misused"); 3648 break; 3649 3650 case PLUS: 3651 /* Some assemblers need integer constants to appear last (eg masm). */ 3652 if (GET_CODE (XEXP (x, 0)) == CONST_INT) 3653 { 3654 output_addr_const (file, XEXP (x, 1)); 3655 if (INTVAL (XEXP (x, 0)) >= 0) 3656 fprintf (file, "+"); 3657 output_addr_const (file, XEXP (x, 0)); 3658 } 3659 else 3660 { 3661 output_addr_const (file, XEXP (x, 0)); 3662 if (INTVAL (XEXP (x, 1)) >= 0) 3663 fprintf (file, "+"); 3664 output_addr_const (file, XEXP (x, 1)); 3665 } 3666 break; 3667 3668 case MINUS: 3669 /* Avoid outputting things like x-x or x+5-x, 3670 since some assemblers can't handle that. */ 3671 x = simplify_subtraction (x); 3672 if (GET_CODE (x) != MINUS) 3673 goto restart; 3674 3675 output_addr_const (file, XEXP (x, 0)); 3676 fprintf (file, "-"); 3677 if (GET_CODE (XEXP (x, 1)) == CONST_INT 3678 && INTVAL (XEXP (x, 1)) < 0) 3679 { 3680 fprintf (file, ASM_OPEN_PAREN); 3681 output_addr_const (file, XEXP (x, 1)); 3682 fprintf (file, ASM_CLOSE_PAREN); 3683 } 3684 else 3685 output_addr_const (file, XEXP (x, 1)); 3686 break; 3687 3688 case ZERO_EXTEND: 3689 case SIGN_EXTEND: 3690 output_addr_const (file, XEXP (x, 0)); 3691 break; 3692 3693 default: 3694 output_operand_lossage ("invalid expression as operand"); 3695 } 3696} 3697 3698/* A poor man's fprintf, with the added features of %I, %R, %L, and %U. 3699 %R prints the value of REGISTER_PREFIX. 3700 %L prints the value of LOCAL_LABEL_PREFIX. 3701 %U prints the value of USER_LABEL_PREFIX. 3702 %I prints the value of IMMEDIATE_PREFIX. 3703 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string. 3704 Also supported are %d, %x, %s, %e, %f, %g and %%. 3705 3706 We handle alternate assembler dialects here, just like output_asm_insn. */ 3707 3708void 3709asm_fprintf VPROTO((FILE *file, const char *p, ...)) 3710{ 3711#ifndef ANSI_PROTOTYPES 3712 FILE *file; 3713 const char *p; 3714#endif 3715 va_list argptr; 3716 char buf[10]; 3717 char *q, c; 3718 3719 VA_START (argptr, p); 3720 3721#ifndef ANSI_PROTOTYPES 3722 file = va_arg (argptr, FILE *); 3723 p = va_arg (argptr, const char *); 3724#endif 3725 3726 buf[0] = '%'; 3727 3728 while ((c = *p++)) 3729 switch (c) 3730 { 3731#ifdef ASSEMBLER_DIALECT 3732 case '{': 3733 { 3734 int i; 3735 3736 /* If we want the first dialect, do nothing. Otherwise, skip 3737 DIALECT_NUMBER of strings ending with '|'. */ 3738 for (i = 0; i < dialect_number; i++) 3739 { 3740 while (*p && *p++ != '|') 3741 ; 3742 3743 if (*p == '|') 3744 p++; 3745 } 3746 } 3747 break; 3748 3749 case '|': 3750 /* Skip to close brace. */ 3751 while (*p && *p++ != '}') 3752 ; 3753 break; 3754 3755 case '}': 3756 break; 3757#endif 3758 3759 case '%': 3760 c = *p++; 3761 q = &buf[1]; 3762 while ((c >= '0' && c <= '9') || c == '.') 3763 { 3764 *q++ = c; 3765 c = *p++; 3766 } 3767 switch (c) 3768 { 3769 case '%': 3770 fprintf (file, "%%"); 3771 break; 3772 3773 case 'd': case 'i': case 'u': 3774 case 'x': case 'p': case 'X': 3775 case 'o': 3776 *q++ = c; 3777 *q = 0; 3778 fprintf (file, buf, va_arg (argptr, int)); 3779 break; 3780 3781 case 'w': 3782 /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases, 3783 but we do not check for those cases. It means that the value 3784 is a HOST_WIDE_INT, which may be either `int' or `long'. */ 3785 3786#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT 3787#else 3788#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG 3789 *q++ = 'l'; 3790#else 3791 *q++ = 'l'; 3792 *q++ = 'l'; 3793#endif 3794#endif 3795 3796 *q++ = *p++; 3797 *q = 0; 3798 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT)); 3799 break; 3800 3801 case 'l': 3802 *q++ = c; 3803 *q++ = *p++; 3804 *q = 0; 3805 fprintf (file, buf, va_arg (argptr, long)); 3806 break; 3807 3808 case 'e': 3809 case 'f': 3810 case 'g': 3811 *q++ = c; 3812 *q = 0; 3813 fprintf (file, buf, va_arg (argptr, double)); 3814 break; 3815 3816 case 's': 3817 *q++ = c; 3818 *q = 0; 3819 fprintf (file, buf, va_arg (argptr, char *)); 3820 break; 3821 3822 case 'O': 3823#ifdef ASM_OUTPUT_OPCODE 3824 ASM_OUTPUT_OPCODE (asm_out_file, p); 3825#endif 3826 break; 3827 3828 case 'R': 3829#ifdef REGISTER_PREFIX 3830 fprintf (file, "%s", REGISTER_PREFIX); 3831#endif 3832 break; 3833 3834 case 'I': 3835#ifdef IMMEDIATE_PREFIX 3836 fprintf (file, "%s", IMMEDIATE_PREFIX); 3837#endif 3838 break; 3839 3840 case 'L': 3841#ifdef LOCAL_LABEL_PREFIX 3842 fprintf (file, "%s", LOCAL_LABEL_PREFIX); 3843#endif 3844 break; 3845 3846 case 'U': 3847 fputs (user_label_prefix, file); 3848 break; 3849 3850 default: 3851 abort (); 3852 } 3853 break; 3854 3855 default: 3856 fputc (c, file); 3857 } 3858} 3859 3860/* Split up a CONST_DOUBLE or integer constant rtx 3861 into two rtx's for single words, 3862 storing in *FIRST the word that comes first in memory in the target 3863 and in *SECOND the other. */ 3864 3865void 3866split_double (value, first, second) 3867 rtx value; 3868 rtx *first, *second; 3869{ 3870 if (GET_CODE (value) == CONST_INT) 3871 { 3872 if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD)) 3873 { 3874 /* In this case the CONST_INT holds both target words. 3875 Extract the bits from it into two word-sized pieces. 3876 Sign extend each half to HOST_WIDE_INT. */ 3877 rtx low, high; 3878 /* On machines where HOST_BITS_PER_WIDE_INT == BITS_PER_WORD 3879 the shift below will cause a compiler warning, even though 3880 this code won't be executed. So put the shift amounts in 3881 variables to avoid the warning. */ 3882 int rshift = HOST_BITS_PER_WIDE_INT - BITS_PER_WORD; 3883 int lshift = HOST_BITS_PER_WIDE_INT - 2 * BITS_PER_WORD; 3884 3885 low = GEN_INT ((INTVAL (value) << rshift) >> rshift); 3886 high = GEN_INT ((INTVAL (value) << lshift) >> rshift); 3887 if (WORDS_BIG_ENDIAN) 3888 { 3889 *first = high; 3890 *second = low; 3891 } 3892 else 3893 { 3894 *first = low; 3895 *second = high; 3896 } 3897 } 3898 else 3899 { 3900 /* The rule for using CONST_INT for a wider mode 3901 is that we regard the value as signed. 3902 So sign-extend it. */ 3903 rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx); 3904 if (WORDS_BIG_ENDIAN) 3905 { 3906 *first = high; 3907 *second = value; 3908 } 3909 else 3910 { 3911 *first = value; 3912 *second = high; 3913 } 3914 } 3915 } 3916 else if (GET_CODE (value) != CONST_DOUBLE) 3917 { 3918 if (WORDS_BIG_ENDIAN) 3919 { 3920 *first = const0_rtx; 3921 *second = value; 3922 } 3923 else 3924 { 3925 *first = value; 3926 *second = const0_rtx; 3927 } 3928 } 3929 else if (GET_MODE (value) == VOIDmode 3930 /* This is the old way we did CONST_DOUBLE integers. */ 3931 || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT) 3932 { 3933 /* In an integer, the words are defined as most and least significant. 3934 So order them by the target's convention. */ 3935 if (WORDS_BIG_ENDIAN) 3936 { 3937 *first = GEN_INT (CONST_DOUBLE_HIGH (value)); 3938 *second = GEN_INT (CONST_DOUBLE_LOW (value)); 3939 } 3940 else 3941 { 3942 *first = GEN_INT (CONST_DOUBLE_LOW (value)); 3943 *second = GEN_INT (CONST_DOUBLE_HIGH (value)); 3944 } 3945 } 3946 else 3947 { 3948#ifdef REAL_ARITHMETIC 3949 REAL_VALUE_TYPE r; long l[2]; 3950 REAL_VALUE_FROM_CONST_DOUBLE (r, value); 3951 3952 /* Note, this converts the REAL_VALUE_TYPE to the target's 3953 format, splits up the floating point double and outputs 3954 exactly 32 bits of it into each of l[0] and l[1] -- 3955 not necessarily BITS_PER_WORD bits. */ 3956 REAL_VALUE_TO_TARGET_DOUBLE (r, l); 3957 3958 /* If 32 bits is an entire word for the target, but not for the host, 3959 then sign-extend on the host so that the number will look the same 3960 way on the host that it would on the target. See for instance 3961 simplify_unary_operation. The #if is needed to avoid compiler 3962 warnings. */ 3963 3964#if HOST_BITS_PER_LONG > 32 3965 if (BITS_PER_WORD < HOST_BITS_PER_LONG && BITS_PER_WORD == 32) 3966 { 3967 if (l[0] & ((long) 1 << 31)) 3968 l[0] |= ((long) (-1) << 32); 3969 if (l[1] & ((long) 1 << 31)) 3970 l[1] |= ((long) (-1) << 32); 3971 } 3972#endif 3973 3974 *first = GEN_INT ((HOST_WIDE_INT) l[0]); 3975 *second = GEN_INT ((HOST_WIDE_INT) l[1]); 3976#else 3977 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT 3978 || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD) 3979 && ! flag_pretend_float) 3980 abort (); 3981 3982 if ( 3983#ifdef HOST_WORDS_BIG_ENDIAN 3984 WORDS_BIG_ENDIAN 3985#else 3986 ! WORDS_BIG_ENDIAN 3987#endif 3988 ) 3989 { 3990 /* Host and target agree => no need to swap. */ 3991 *first = GEN_INT (CONST_DOUBLE_LOW (value)); 3992 *second = GEN_INT (CONST_DOUBLE_HIGH (value)); 3993 } 3994 else 3995 { 3996 *second = GEN_INT (CONST_DOUBLE_LOW (value)); 3997 *first = GEN_INT (CONST_DOUBLE_HIGH (value)); 3998 } 3999#endif /* no REAL_ARITHMETIC */ 4000 } 4001} 4002 4003/* Return nonzero if this function has no function calls. */ 4004 4005int 4006leaf_function_p () 4007{ 4008 rtx insn; 4009 4010 if (profile_flag || profile_block_flag || profile_arc_flag) 4011 return 0; 4012 4013 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 4014 { 4015 if (GET_CODE (insn) == CALL_INSN) 4016 return 0; 4017 if (GET_CODE (insn) == INSN 4018 && GET_CODE (PATTERN (insn)) == SEQUENCE 4019 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN) 4020 return 0; 4021 } 4022 for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1)) 4023 { 4024 if (GET_CODE (XEXP (insn, 0)) == CALL_INSN) 4025 return 0; 4026 if (GET_CODE (XEXP (insn, 0)) == INSN 4027 && GET_CODE (PATTERN (XEXP (insn, 0))) == SEQUENCE 4028 && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN) 4029 return 0; 4030 } 4031 4032 return 1; 4033} 4034 4035/* On some machines, a function with no call insns 4036 can run faster if it doesn't create its own register window. 4037 When output, the leaf function should use only the "output" 4038 registers. Ordinarily, the function would be compiled to use 4039 the "input" registers to find its arguments; it is a candidate 4040 for leaf treatment if it uses only the "input" registers. 4041 Leaf function treatment means renumbering so the function 4042 uses the "output" registers instead. */ 4043 4044#ifdef LEAF_REGISTERS 4045 4046static char permitted_reg_in_leaf_functions[] = LEAF_REGISTERS; 4047 4048/* Return 1 if this function uses only the registers that can be 4049 safely renumbered. */ 4050 4051int 4052only_leaf_regs_used () 4053{ 4054 int i; 4055 4056 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 4057 if ((regs_ever_live[i] || global_regs[i]) 4058 && ! permitted_reg_in_leaf_functions[i]) 4059 return 0; 4060 4061 if (current_function_uses_pic_offset_table 4062 && pic_offset_table_rtx != 0 4063 && GET_CODE (pic_offset_table_rtx) == REG 4064 && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)]) 4065 return 0; 4066 4067 return 1; 4068} 4069 4070/* Scan all instructions and renumber all registers into those 4071 available in leaf functions. */ 4072 4073static void 4074leaf_renumber_regs (first) 4075 rtx first; 4076{ 4077 rtx insn; 4078 4079 /* Renumber only the actual patterns. 4080 The reg-notes can contain frame pointer refs, 4081 and renumbering them could crash, and should not be needed. */ 4082 for (insn = first; insn; insn = NEXT_INSN (insn)) 4083 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') 4084 leaf_renumber_regs_insn (PATTERN (insn)); 4085 for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1)) 4086 if (GET_RTX_CLASS (GET_CODE (XEXP (insn, 0))) == 'i') 4087 leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0))); 4088} 4089 4090/* Scan IN_RTX and its subexpressions, and renumber all regs into those 4091 available in leaf functions. */ 4092 4093void 4094leaf_renumber_regs_insn (in_rtx) 4095 register rtx in_rtx; 4096{ 4097 register int i, j; 4098 register char *format_ptr; 4099 4100 if (in_rtx == 0) 4101 return; 4102 4103 /* Renumber all input-registers into output-registers. 4104 renumbered_regs would be 1 for an output-register; 4105 they */ 4106 4107 if (GET_CODE (in_rtx) == REG) 4108 { 4109 int newreg; 4110 4111 /* Don't renumber the same reg twice. */ 4112 if (in_rtx->used) 4113 return; 4114 4115 newreg = REGNO (in_rtx); 4116 /* Don't try to renumber pseudo regs. It is possible for a pseudo reg 4117 to reach here as part of a REG_NOTE. */ 4118 if (newreg >= FIRST_PSEUDO_REGISTER) 4119 { 4120 in_rtx->used = 1; 4121 return; 4122 } 4123 newreg = LEAF_REG_REMAP (newreg); 4124 if (newreg < 0) 4125 abort (); 4126 regs_ever_live[REGNO (in_rtx)] = 0; 4127 regs_ever_live[newreg] = 1; 4128 REGNO (in_rtx) = newreg; 4129 in_rtx->used = 1; 4130 } 4131 4132 if (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i') 4133 { 4134 /* Inside a SEQUENCE, we find insns. 4135 Renumber just the patterns of these insns, 4136 just as we do for the top-level insns. */ 4137 leaf_renumber_regs_insn (PATTERN (in_rtx)); 4138 return; 4139 } 4140 4141 format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)); 4142 4143 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++) 4144 switch (*format_ptr++) 4145 { 4146 case 'e': 4147 leaf_renumber_regs_insn (XEXP (in_rtx, i)); 4148 break; 4149 4150 case 'E': 4151 if (NULL != XVEC (in_rtx, i)) 4152 { 4153 for (j = 0; j < XVECLEN (in_rtx, i); j++) 4154 leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j)); 4155 } 4156 break; 4157 4158 case 'S': 4159 case 's': 4160 case '0': 4161 case 'i': 4162 case 'w': 4163 case 'n': 4164 case 'u': 4165 break; 4166 4167 default: 4168 abort (); 4169 } 4170} 4171#endif 4172