final.c (117404) | final.c (132727) |
---|---|
1/* Convert RTL to assembler code and output it, for GNU compiler. 2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, | 1/* Convert RTL to assembler code and output it, for GNU compiler. 2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, |
3 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. | 3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 --- 29 unchanged lines hidden (view full) --- 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 in assembler by the target functions function_prologue and 45 function_epilogue. Those instructions never exist as rtl. */ 46 47#include "config.h" 48#include "system.h" | 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 --- 29 unchanged lines hidden (view full) --- 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 in assembler by the target functions function_prologue and 45 function_epilogue. Those instructions never exist as rtl. */ 46 47#include "config.h" 48#include "system.h" |
49#include "coretypes.h" 50#include "tm.h" |
|
49 50#include "tree.h" 51#include "rtl.h" 52#include "tm_p.h" 53#include "regs.h" 54#include "insn-config.h" 55#include "insn-attr.h" 56#include "recog.h" --- 6 unchanged lines hidden (view full) --- 63#include "function.h" 64#include "toplev.h" 65#include "reload.h" 66#include "intl.h" 67#include "basic-block.h" 68#include "target.h" 69#include "debug.h" 70#include "expr.h" | 51 52#include "tree.h" 53#include "rtl.h" 54#include "tm_p.h" 55#include "regs.h" 56#include "insn-config.h" 57#include "insn-attr.h" 58#include "recog.h" --- 6 unchanged lines hidden (view full) --- 65#include "function.h" 66#include "toplev.h" 67#include "reload.h" 68#include "intl.h" 69#include "basic-block.h" 70#include "target.h" 71#include "debug.h" 72#include "expr.h" |
71#include "profile.h" | |
72#include "cfglayout.h" 73 74#ifdef XCOFF_DEBUGGING_INFO 75#include "xcoffout.h" /* Needed for external data 76 declarations for e.g. AIX 4.x. */ 77#endif 78 79#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 80#include "dwarf2out.h" 81#endif 82 | 73#include "cfglayout.h" 74 75#ifdef XCOFF_DEBUGGING_INFO 76#include "xcoffout.h" /* Needed for external data 77 declarations for e.g. AIX 4.x. */ 78#endif 79 80#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 81#include "dwarf2out.h" 82#endif 83 |
84#ifdef DBX_DEBUGGING_INFO 85#include "dbxout.h" 86#endif 87 |
|
83/* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a 84 null default for it to save conditionalization later. */ 85#ifndef CC_STATUS_INIT 86#define CC_STATUS_INIT 87#endif 88 89/* How to start an assembler comment. */ 90#ifndef ASM_COMMENT_START --- 10 unchanged lines hidden (view full) --- 101#endif 102 103#if defined(READONLY_DATA_SECTION) || defined(READONLY_DATA_SECTION_ASM_OP) 104#define HAVE_READONLY_DATA_SECTION 1 105#else 106#define HAVE_READONLY_DATA_SECTION 0 107#endif 108 | 88/* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a 89 null default for it to save conditionalization later. */ 90#ifndef CC_STATUS_INIT 91#define CC_STATUS_INIT 92#endif 93 94/* How to start an assembler comment. */ 95#ifndef ASM_COMMENT_START --- 10 unchanged lines hidden (view full) --- 106#endif 107 108#if defined(READONLY_DATA_SECTION) || defined(READONLY_DATA_SECTION_ASM_OP) 109#define HAVE_READONLY_DATA_SECTION 1 110#else 111#define HAVE_READONLY_DATA_SECTION 0 112#endif 113 |
114/* Bitflags used by final_scan_insn. */ 115#define SEEN_BB 1 116#define SEEN_NOTE 2 117#define SEEN_EMITTED 4 118 |
|
109/* Last insn processed by final_scan_insn. */ 110static rtx debug_insn; 111rtx current_output_insn; 112 113/* Line number of last NOTE. */ 114static int last_linenum; 115 116/* Highest line number in current block. */ --- 14 unchanged lines hidden (view full) --- 131 132/* Number of operands of this insn, for an `asm' with operands. */ 133static unsigned int insn_noperands; 134 135/* Compare optimization flag. */ 136 137static rtx last_ignored_compare = 0; 138 | 119/* Last insn processed by final_scan_insn. */ 120static rtx debug_insn; 121rtx current_output_insn; 122 123/* Line number of last NOTE. */ 124static int last_linenum; 125 126/* Highest line number in current block. */ --- 14 unchanged lines hidden (view full) --- 141 142/* Number of operands of this insn, for an `asm' with operands. */ 143static unsigned int insn_noperands; 144 145/* Compare optimization flag. */ 146 147static rtx last_ignored_compare = 0; 148 |
139/* Flag indicating this insn is the start of a new basic block. */ 140 141static int new_block = 1; 142 | |
143/* Assign a unique number to each insn that is output. 144 This can be used to generate unique local labels. */ 145 146static int insn_counter = 0; 147 148#ifdef HAVE_cc0 149/* This variable contains machine-dependent flags (defined in tm.h) 150 set and examined by output routines --- 13 unchanged lines hidden (view full) --- 164 In life_analysis, or in stupid_life_analysis, this is set 165 up to record the hard regs used explicitly. Reload adds 166 in the hard regs used for holding pseudo regs. Final uses 167 it to generate the code in the function prologue and epilogue 168 to save and restore registers as needed. */ 169 170char regs_ever_live[FIRST_PSEUDO_REGISTER]; 171 | 149/* Assign a unique number to each insn that is output. 150 This can be used to generate unique local labels. */ 151 152static int insn_counter = 0; 153 154#ifdef HAVE_cc0 155/* This variable contains machine-dependent flags (defined in tm.h) 156 set and examined by output routines --- 13 unchanged lines hidden (view full) --- 170 In life_analysis, or in stupid_life_analysis, this is set 171 up to record the hard regs used explicitly. Reload adds 172 in the hard regs used for holding pseudo regs. Final uses 173 it to generate the code in the function prologue and epilogue 174 to save and restore registers as needed. */ 175 176char regs_ever_live[FIRST_PSEUDO_REGISTER]; 177 |
178/* Like regs_ever_live, but 1 if a reg is set or clobbered from an asm. 179 Unlike regs_ever_live, elements of this array corresponding to 180 eliminable regs like the frame pointer are set if an asm sets them. */ 181 182char regs_asm_clobbered[FIRST_PSEUDO_REGISTER]; 183 |
|
172/* Nonzero means current function must be given a frame pointer. | 184/* Nonzero means current function must be given a frame pointer. |
173 Set in stmt.c if anything is allocated on the stack there. 174 Set in reload1.c if anything is allocated on the stack there. */ | 185 Initialized in function.c to 0. Set only in reload1.c as per 186 the needs of the function. */ |
175 176int frame_pointer_needed; 177 178/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */ 179 180static int block_depth; 181 182/* Nonzero if have enabled APP processing of our assembler output. */ --- 6 unchanged lines hidden (view full) --- 189rtx final_sequence; 190 191#ifdef ASSEMBLER_DIALECT 192 193/* Number of the assembler dialect to use, starting at 0. */ 194static int dialect_number; 195#endif 196 | 187 188int frame_pointer_needed; 189 190/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */ 191 192static int block_depth; 193 194/* Nonzero if have enabled APP processing of our assembler output. */ --- 6 unchanged lines hidden (view full) --- 201rtx final_sequence; 202 203#ifdef ASSEMBLER_DIALECT 204 205/* Number of the assembler dialect to use, starting at 0. */ 206static int dialect_number; 207#endif 208 |
197/* Indexed by line number, nonzero if there is a note for that line. */ 198 199static char *line_note_exists; 200 | |
201#ifdef HAVE_conditional_execution 202/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */ 203rtx current_insn_predicate; 204#endif 205 | 209#ifdef HAVE_conditional_execution 210/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */ 211rtx current_insn_predicate; 212#endif 213 |
206struct function_list 207{ 208 struct function_list *next; /* next function */ 209 const char *name; /* function name */ 210 long cfg_checksum; /* function checksum */ 211 long count_edges; /* number of intrumented edges in this function */ 212}; 213 214static struct function_list *functions_head = 0; 215static struct function_list **functions_tail = &functions_head; 216 | |
217#ifdef HAVE_ATTR_length | 214#ifdef HAVE_ATTR_length |
218static int asm_insn_count PARAMS ((rtx)); | 215static int asm_insn_count (rtx); |
219#endif | 216#endif |
220static void profile_function PARAMS ((FILE *)); 221static void profile_after_prologue PARAMS ((FILE *)); 222static void notice_source_line PARAMS ((rtx)); 223static rtx walk_alter_subreg PARAMS ((rtx *)); 224static void output_asm_name PARAMS ((void)); 225static void output_alternate_entry_point PARAMS ((FILE *, rtx)); 226static tree get_mem_expr_from_op PARAMS ((rtx, int *)); 227static void output_asm_operand_names PARAMS ((rtx *, int *, int)); 228static void output_operand PARAMS ((rtx, int)); | 217static void profile_function (FILE *); 218static void profile_after_prologue (FILE *); 219static bool notice_source_line (rtx); 220static rtx walk_alter_subreg (rtx *); 221static void output_asm_name (void); 222static void output_alternate_entry_point (FILE *, rtx); 223static tree get_mem_expr_from_op (rtx, int *); 224static void output_asm_operand_names (rtx *, int *, int); 225static void output_operand (rtx, int); |
229#ifdef LEAF_REGISTERS | 226#ifdef LEAF_REGISTERS |
230static void leaf_renumber_regs PARAMS ((rtx)); | 227static void leaf_renumber_regs (rtx); |
231#endif 232#ifdef HAVE_cc0 | 228#endif 229#ifdef HAVE_cc0 |
233static int alter_cond PARAMS ((rtx)); | 230static int alter_cond (rtx); |
234#endif 235#ifndef ADDR_VEC_ALIGN | 231#endif 232#ifndef ADDR_VEC_ALIGN |
236static int final_addr_vec_align PARAMS ((rtx)); | 233static int final_addr_vec_align (rtx); |
237#endif 238#ifdef HAVE_ATTR_length | 234#endif 235#ifdef HAVE_ATTR_length |
239static int align_fuzz PARAMS ((rtx, rtx, int, unsigned)); | 236static int align_fuzz (rtx, rtx, int, unsigned); |
240#endif 241 242/* Initialize data in final at the beginning of a compilation. */ 243 244void | 237#endif 238 239/* Initialize data in final at the beginning of a compilation. */ 240 241void |
245init_final (filename) 246 const char *filename ATTRIBUTE_UNUSED; | 242init_final (const char *filename ATTRIBUTE_UNUSED) |
247{ 248 app_on = 0; 249 final_sequence = 0; 250 251#ifdef ASSEMBLER_DIALECT 252 dialect_number = ASSEMBLER_DIALECT; 253#endif 254} 255 | 243{ 244 app_on = 0; 245 final_sequence = 0; 246 247#ifdef ASSEMBLER_DIALECT 248 dialect_number = ASSEMBLER_DIALECT; 249#endif 250} 251 |
256/* Called at end of source file, 257 to output the arc-profiling table for this entire compilation. */ 258 259void 260end_final (filename) 261 const char *filename; 262{ 263 if (profile_arc_flag && profile_info.count_instrumented_edges) 264 { 265 char name[20]; 266 tree string_type, string_cst; 267 tree structure_decl, structure_value, structure_pointer_type; 268 tree field_decl, decl_chain, value_chain; 269 tree sizeof_field_value, domain_type; 270 271 /* Build types. */ 272 string_type = build_pointer_type (char_type_node); 273 274 /* Libgcc2 bb structure. */ 275 structure_decl = make_node (RECORD_TYPE); 276 structure_pointer_type = build_pointer_type (structure_decl); 277 278 /* Output the main header, of 7 words: 279 0: 1 if this file is initialized, else 0. 280 1: address of file name (LPBX1). 281 2: address of table of counts (LPBX2). 282 3: number of counts in the table. 283 4: always 0, libgcc2 uses this as a pointer to next ``struct bb'' 284 285 The following are GNU extensions: 286 287 5: Number of bytes in this header. 288 6: address of table of function checksums (LPBX7). */ 289 290 /* The zero word. */ 291 decl_chain = 292 build_decl (FIELD_DECL, get_identifier ("zero_word"), 293 long_integer_type_node); 294 value_chain = build_tree_list (decl_chain, 295 convert (long_integer_type_node, 296 integer_zero_node)); 297 298 /* Address of filename. */ 299 { 300 char *cwd, *da_filename; 301 int da_filename_len; 302 303 field_decl = 304 build_decl (FIELD_DECL, get_identifier ("filename"), string_type); 305 TREE_CHAIN (field_decl) = decl_chain; 306 decl_chain = field_decl; 307 308 cwd = getpwd (); 309 da_filename_len = strlen (filename) + strlen (cwd) + 4 + 1; 310 da_filename = (char *) alloca (da_filename_len); 311 strcpy (da_filename, cwd); 312 strcat (da_filename, "/"); 313 strcat (da_filename, filename); 314 strcat (da_filename, ".da"); 315 da_filename_len = strlen (da_filename); 316 string_cst = build_string (da_filename_len + 1, da_filename); 317 domain_type = build_index_type (build_int_2 (da_filename_len, 0)); 318 TREE_TYPE (string_cst) 319 = build_array_type (char_type_node, domain_type); 320 value_chain = tree_cons (field_decl, 321 build1 (ADDR_EXPR, string_type, string_cst), 322 value_chain); 323 } 324 325 /* Table of counts. */ 326 { 327 tree gcov_type_type = make_unsigned_type (GCOV_TYPE_SIZE); 328 tree gcov_type_pointer_type = build_pointer_type (gcov_type_type); 329 tree domain_tree 330 = build_index_type (build_int_2 (profile_info. 331 count_instrumented_edges - 1, 0)); 332 tree gcov_type_array_type 333 = build_array_type (gcov_type_type, domain_tree); 334 tree gcov_type_array_pointer_type 335 = build_pointer_type (gcov_type_array_type); 336 tree counts_table; 337 338 field_decl = 339 build_decl (FIELD_DECL, get_identifier ("counts"), 340 gcov_type_pointer_type); 341 TREE_CHAIN (field_decl) = decl_chain; 342 decl_chain = field_decl; 343 344 /* No values. */ 345 counts_table 346 = build (VAR_DECL, gcov_type_array_type, NULL_TREE, NULL_TREE); 347 TREE_STATIC (counts_table) = 1; 348 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2); 349 DECL_NAME (counts_table) = get_identifier (name); 350 assemble_variable (counts_table, 0, 0, 0); 351 352 value_chain = tree_cons (field_decl, 353 build1 (ADDR_EXPR, 354 gcov_type_array_pointer_type, 355 counts_table), value_chain); 356 } 357 358 /* Count of the # of instrumented arcs. */ 359 field_decl 360 = build_decl (FIELD_DECL, get_identifier ("ncounts"), 361 long_integer_type_node); 362 TREE_CHAIN (field_decl) = decl_chain; 363 decl_chain = field_decl; 364 365 value_chain = tree_cons (field_decl, 366 convert (long_integer_type_node, 367 build_int_2 (profile_info. 368 count_instrumented_edges, 369 0)), value_chain); 370 /* Pointer to the next bb. */ 371 field_decl 372 = build_decl (FIELD_DECL, get_identifier ("next"), 373 structure_pointer_type); 374 TREE_CHAIN (field_decl) = decl_chain; 375 decl_chain = field_decl; 376 377 value_chain = tree_cons (field_decl, null_pointer_node, value_chain); 378 379 /* sizeof(struct bb). We'll set this after entire structure 380 is laid out. */ 381 field_decl 382 = build_decl (FIELD_DECL, get_identifier ("sizeof_bb"), 383 long_integer_type_node); 384 TREE_CHAIN (field_decl) = decl_chain; 385 decl_chain = field_decl; 386 387 sizeof_field_value = tree_cons (field_decl, NULL, value_chain); 388 value_chain = sizeof_field_value; 389 390 /* struct bb_function []. */ 391 { 392 struct function_list *item; 393 int num_nodes; 394 tree checksum_field, arc_count_field, name_field; 395 tree domain; 396 tree array_value_chain = NULL_TREE; 397 tree bb_fn_struct_type; 398 tree bb_fn_struct_array_type; 399 tree bb_fn_struct_array_pointer_type; 400 tree bb_fn_struct_pointer_type; 401 tree field_value, field_value_chain; 402 403 bb_fn_struct_type = make_node (RECORD_TYPE); 404 405 checksum_field = build_decl (FIELD_DECL, get_identifier ("checksum"), 406 long_integer_type_node); 407 408 arc_count_field 409 = build_decl (FIELD_DECL, get_identifier ("arc_count"), 410 integer_type_node); 411 TREE_CHAIN (checksum_field) = arc_count_field; 412 413 name_field 414 = build_decl (FIELD_DECL, get_identifier ("name"), string_type); 415 TREE_CHAIN (arc_count_field) = name_field; 416 417 TYPE_FIELDS (bb_fn_struct_type) = checksum_field; 418 419 num_nodes = 0; 420 421 for (item = functions_head; item != 0; item = item->next) 422 num_nodes++; 423 424 /* Note that the array contains a terminator, hence no - 1. */ 425 domain = build_index_type (build_int_2 (num_nodes, 0)); 426 427 bb_fn_struct_pointer_type = build_pointer_type (bb_fn_struct_type); 428 bb_fn_struct_array_type 429 = build_array_type (bb_fn_struct_type, domain); 430 bb_fn_struct_array_pointer_type 431 = build_pointer_type (bb_fn_struct_array_type); 432 433 layout_type (bb_fn_struct_type); 434 layout_type (bb_fn_struct_pointer_type); 435 layout_type (bb_fn_struct_array_type); 436 layout_type (bb_fn_struct_array_pointer_type); 437 438 for (item = functions_head; item != 0; item = item->next) 439 { 440 size_t name_len; 441 442 /* create constructor for structure. */ 443 field_value_chain 444 = build_tree_list (checksum_field, 445 convert (long_integer_type_node, 446 build_int_2 (item->cfg_checksum, 0))); 447 field_value_chain 448 = tree_cons (arc_count_field, 449 convert (integer_type_node, 450 build_int_2 (item->count_edges, 0)), 451 field_value_chain); 452 453 name_len = strlen (item->name); 454 string_cst = build_string (name_len + 1, item->name); 455 domain_type = build_index_type (build_int_2 (name_len, 0)); 456 TREE_TYPE (string_cst) 457 = build_array_type (char_type_node, domain_type); 458 field_value_chain = tree_cons (name_field, 459 build1 (ADDR_EXPR, string_type, 460 string_cst), 461 field_value_chain); 462 463 /* Add to chain. */ 464 array_value_chain 465 = tree_cons (NULL_TREE, build (CONSTRUCTOR, 466 bb_fn_struct_type, NULL_TREE, 467 nreverse (field_value_chain)), 468 array_value_chain); 469 } 470 471 /* Add terminator. */ 472 field_value = build_tree_list (arc_count_field, 473 convert (integer_type_node, 474 build_int_2 (-1, 0))); 475 476 array_value_chain = tree_cons (NULL_TREE, 477 build (CONSTRUCTOR, bb_fn_struct_type, 478 NULL_TREE, field_value), 479 array_value_chain); 480 481 482 /* Create constructor for array. */ 483 field_decl 484 = build_decl (FIELD_DECL, get_identifier ("function_infos"), 485 bb_fn_struct_pointer_type); 486 value_chain = tree_cons (field_decl, 487 build1 (ADDR_EXPR, 488 bb_fn_struct_array_pointer_type, 489 build (CONSTRUCTOR, 490 bb_fn_struct_array_type, 491 NULL_TREE, 492 nreverse 493 (array_value_chain))), 494 value_chain); 495 TREE_CHAIN (field_decl) = decl_chain; 496 decl_chain = field_decl; 497 } 498 499 /* Finish structure. */ 500 TYPE_FIELDS (structure_decl) = nreverse (decl_chain); 501 layout_type (structure_decl); 502 503 structure_value 504 = build (VAR_DECL, structure_decl, NULL_TREE, NULL_TREE); 505 DECL_INITIAL (structure_value) 506 = build (CONSTRUCTOR, structure_decl, NULL_TREE, 507 nreverse (value_chain)); 508 TREE_STATIC (structure_value) = 1; 509 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0); 510 DECL_NAME (structure_value) = get_identifier (name); 511 512 /* Size of this structure. */ 513 TREE_VALUE (sizeof_field_value) 514 = convert (long_integer_type_node, 515 build_int_2 (int_size_in_bytes (structure_decl), 0)); 516 517 /* Build structure. */ 518 assemble_variable (structure_value, 0, 0, 0); 519 } 520} 521 | |
522/* Default target function prologue and epilogue assembler output. 523 524 If not overridden for epilogue code, then the function body itself 525 contains return instructions wherever needed. */ 526void | 252/* Default target function prologue and epilogue assembler output. 253 254 If not overridden for epilogue code, then the function body itself 255 contains return instructions wherever needed. */ 256void |
527default_function_pro_epilogue (file, size) 528 FILE *file ATTRIBUTE_UNUSED; 529 HOST_WIDE_INT size ATTRIBUTE_UNUSED; | 257default_function_pro_epilogue (FILE *file ATTRIBUTE_UNUSED, 258 HOST_WIDE_INT size ATTRIBUTE_UNUSED) |
530{ 531} 532 533/* Default target hook that outputs nothing to a stream. */ 534void | 259{ 260} 261 262/* Default target hook that outputs nothing to a stream. */ 263void |
535no_asm_to_stream (file) 536 FILE *file ATTRIBUTE_UNUSED; | 264no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED) |
537{ 538} 539 540/* Enable APP processing of subsequent output. 541 Used before the output from an `asm' statement. */ 542 543void | 265{ 266} 267 268/* Enable APP processing of subsequent output. 269 Used before the output from an `asm' statement. */ 270 271void |
544app_enable () | 272app_enable (void) |
545{ 546 if (! app_on) 547 { 548 fputs (ASM_APP_ON, asm_out_file); 549 app_on = 1; 550 } 551} 552 553/* Disable APP processing of subsequent output. 554 Called from varasm.c before most kinds of output. */ 555 556void | 273{ 274 if (! app_on) 275 { 276 fputs (ASM_APP_ON, asm_out_file); 277 app_on = 1; 278 } 279} 280 281/* Disable APP processing of subsequent output. 282 Called from varasm.c before most kinds of output. */ 283 284void |
557app_disable () | 285app_disable (void) |
558{ 559 if (app_on) 560 { 561 fputs (ASM_APP_OFF, asm_out_file); 562 app_on = 0; 563 } 564} 565 566/* Return the number of slots filled in the current 567 delayed branch sequence (we don't count the insn needing the 568 delay slot). Zero if not in a delayed branch sequence. */ 569 570#ifdef DELAY_SLOTS 571int | 286{ 287 if (app_on) 288 { 289 fputs (ASM_APP_OFF, asm_out_file); 290 app_on = 0; 291 } 292} 293 294/* Return the number of slots filled in the current 295 delayed branch sequence (we don't count the insn needing the 296 delay slot). Zero if not in a delayed branch sequence. */ 297 298#ifdef DELAY_SLOTS 299int |
572dbr_sequence_length () | 300dbr_sequence_length (void) |
573{ 574 if (final_sequence != 0) 575 return XVECLEN (final_sequence, 0) - 1; 576 else 577 return 0; 578} 579#endif 580 --- 36 unchanged lines hidden (view full) --- 617 618static rtx *uid_align; 619static int *uid_shuid; 620static struct label_alignment *label_align; 621 622/* Indicate that branch shortening hasn't yet been done. */ 623 624void | 301{ 302 if (final_sequence != 0) 303 return XVECLEN (final_sequence, 0) - 1; 304 else 305 return 0; 306} 307#endif 308 --- 36 unchanged lines hidden (view full) --- 345 346static rtx *uid_align; 347static int *uid_shuid; 348static struct label_alignment *label_align; 349 350/* Indicate that branch shortening hasn't yet been done. */ 351 352void |
625init_insn_lengths () | 353init_insn_lengths (void) |
626{ 627 if (uid_shuid) 628 { 629 free (uid_shuid); 630 uid_shuid = 0; 631 } 632 if (insn_lengths) 633 { --- 10 unchanged lines hidden (view full) --- 644 uid_align = 0; 645 } 646} 647 648/* Obtain the current length of an insn. If branch shortening has been done, 649 get its actual length. Otherwise, get its maximum length. */ 650 651int | 354{ 355 if (uid_shuid) 356 { 357 free (uid_shuid); 358 uid_shuid = 0; 359 } 360 if (insn_lengths) 361 { --- 10 unchanged lines hidden (view full) --- 372 uid_align = 0; 373 } 374} 375 376/* Obtain the current length of an insn. If branch shortening has been done, 377 get its actual length. Otherwise, get its maximum length. */ 378 379int |
652get_attr_length (insn) 653 rtx insn ATTRIBUTE_UNUSED; | 380get_attr_length (rtx insn ATTRIBUTE_UNUSED) |
654{ 655#ifdef HAVE_ATTR_length 656 rtx body; 657 int i; 658 int length = 0; 659 660 if (insn_lengths_max_uid > INSN_UID (insn)) 661 return insn_lengths[INSN_UID (insn)]; --- 117 unchanged lines hidden (view full) --- 779#endif 780 781#ifndef JUMP_ALIGN_MAX_SKIP 782#define JUMP_ALIGN_MAX_SKIP align_jumps_max_skip 783#endif 784 785#ifndef ADDR_VEC_ALIGN 786static int | 381{ 382#ifdef HAVE_ATTR_length 383 rtx body; 384 int i; 385 int length = 0; 386 387 if (insn_lengths_max_uid > INSN_UID (insn)) 388 return insn_lengths[INSN_UID (insn)]; --- 117 unchanged lines hidden (view full) --- 506#endif 507 508#ifndef JUMP_ALIGN_MAX_SKIP 509#define JUMP_ALIGN_MAX_SKIP align_jumps_max_skip 510#endif 511 512#ifndef ADDR_VEC_ALIGN 513static int |
787final_addr_vec_align (addr_vec) 788 rtx addr_vec; | 514final_addr_vec_align (rtx addr_vec) |
789{ 790 int align = GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec))); 791 792 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT) 793 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT; 794 return exact_log2 (align); 795 796} --- 13 unchanged lines hidden (view full) --- 810 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment) 811 812#define LABEL_TO_MAX_SKIP(LABEL) \ 813 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip) 814 815/* For the benefit of port specific code do this also as a function. */ 816 817int | 515{ 516 int align = GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec))); 517 518 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT) 519 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT; 520 return exact_log2 (align); 521 522} --- 13 unchanged lines hidden (view full) --- 536 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment) 537 538#define LABEL_TO_MAX_SKIP(LABEL) \ 539 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip) 540 541/* For the benefit of port specific code do this also as a function. */ 542 543int |
818label_to_alignment (label) 819 rtx label; | 544label_to_alignment (rtx label) |
820{ 821 return LABEL_TO_ALIGNMENT (label); 822} 823 824#ifdef HAVE_ATTR_length 825/* The differences in addresses 826 between a branch and its target might grow or shrink depending on 827 the alignment the start insn of the range (the branch for a forward --- 18 unchanged lines hidden (view full) --- 846 START and END might grow / shrink due to a different address for start 847 which changes the size of alignment insns between START and END. 848 KNOWN_ALIGN_LOG is the alignment known for START. 849 GROWTH should be ~0 if the objective is to compute potential code size 850 increase, and 0 if the objective is to compute potential shrink. 851 The return value is undefined for any other value of GROWTH. */ 852 853static int | 545{ 546 return LABEL_TO_ALIGNMENT (label); 547} 548 549#ifdef HAVE_ATTR_length 550/* The differences in addresses 551 between a branch and its target might grow or shrink depending on 552 the alignment the start insn of the range (the branch for a forward --- 18 unchanged lines hidden (view full) --- 571 START and END might grow / shrink due to a different address for start 572 which changes the size of alignment insns between START and END. 573 KNOWN_ALIGN_LOG is the alignment known for START. 574 GROWTH should be ~0 if the objective is to compute potential code size 575 increase, and 0 if the objective is to compute potential shrink. 576 The return value is undefined for any other value of GROWTH. */ 577 578static int |
854align_fuzz (start, end, known_align_log, growth) 855 rtx start, end; 856 int known_align_log; 857 unsigned growth; | 579align_fuzz (rtx start, rtx end, int known_align_log, unsigned int growth) |
858{ 859 int uid = INSN_UID (start); 860 rtx align_label; 861 int known_align = 1 << known_align_log; 862 int end_shuid = INSN_SHUID (end); 863 int fuzz = 0; 864 865 for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid]) --- 22 unchanged lines hidden (view full) --- 888 branch shortening pass, minus a value to account for possible size 889 increase due to alignment. For a backward branch, it is the start 890 address of the branch as known from the current pass, plus a value 891 to account for possible size increase due to alignment. 892 NB.: Therefore, the maximum offset allowed for backward branches needs 893 to exclude the branch size. */ 894 895int | 580{ 581 int uid = INSN_UID (start); 582 rtx align_label; 583 int known_align = 1 << known_align_log; 584 int end_shuid = INSN_SHUID (end); 585 int fuzz = 0; 586 587 for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid]) --- 22 unchanged lines hidden (view full) --- 610 branch shortening pass, minus a value to account for possible size 611 increase due to alignment. For a backward branch, it is the start 612 address of the branch as known from the current pass, plus a value 613 to account for possible size increase due to alignment. 614 NB.: Therefore, the maximum offset allowed for backward branches needs 615 to exclude the branch size. */ 616 617int |
896insn_current_reference_address (branch) 897 rtx branch; | 618insn_current_reference_address (rtx branch) |
898{ 899 rtx dest, seq; 900 int seq_uid; 901 902 if (! INSN_ADDRESSES_SET_P ()) 903 return 0; 904 905 seq = NEXT_INSN (PREV_INSN (branch)); --- 20 unchanged lines hidden (view full) --- 926 /* Backward branch. */ 927 return (insn_current_address 928 + align_fuzz (dest, seq, length_unit_log, ~0)); 929 } 930} 931#endif /* HAVE_ATTR_length */ 932 933void | 619{ 620 rtx dest, seq; 621 int seq_uid; 622 623 if (! INSN_ADDRESSES_SET_P ()) 624 return 0; 625 626 seq = NEXT_INSN (PREV_INSN (branch)); --- 20 unchanged lines hidden (view full) --- 647 /* Backward branch. */ 648 return (insn_current_address 649 + align_fuzz (dest, seq, length_unit_log, ~0)); 650 } 651} 652#endif /* HAVE_ATTR_length */ 653 654void |
934compute_alignments () | 655compute_alignments (void) |
935{ 936 int log, max_skip, max_log; 937 basic_block bb; 938 939 if (label_align) 940 { 941 free (label_align); 942 label_align = 0; 943 } 944 945 max_labelno = max_label_num (); 946 min_labelno = get_first_label_num (); | 656{ 657 int log, max_skip, max_log; 658 basic_block bb; 659 660 if (label_align) 661 { 662 free (label_align); 663 label_align = 0; 664 } 665 666 max_labelno = max_label_num (); 667 min_labelno = get_first_label_num (); |
947 label_align = (struct label_alignment *) 948 xcalloc (max_labelno - min_labelno + 1, sizeof (struct label_alignment)); | 668 label_align = xcalloc (max_labelno - min_labelno + 1, 669 sizeof (struct label_alignment)); |
949 950 /* If not optimizing or optimizing for size, don't assign any alignments. */ 951 if (! optimize || optimize_size) 952 return; 953 954 FOR_EACH_BB (bb) 955 { | 670 671 /* If not optimizing or optimizing for size, don't assign any alignments. */ 672 if (! optimize || optimize_size) 673 return; 674 675 FOR_EACH_BB (bb) 676 { |
956 rtx label = bb->head; | 677 rtx label = BB_HEAD (bb); |
957 int fallthru_frequency = 0, branch_frequency = 0, has_fallthru = 0; 958 edge e; 959 | 678 int fallthru_frequency = 0, branch_frequency = 0, has_fallthru = 0; 679 edge e; 680 |
960 if (GET_CODE (label) != CODE_LABEL) | 681 if (GET_CODE (label) != CODE_LABEL 682 || probably_never_executed_bb_p (bb)) |
961 continue; 962 max_log = LABEL_ALIGN (label); 963 max_skip = LABEL_ALIGN_MAX_SKIP; 964 965 for (e = bb->pred; e; e = e->pred_next) 966 { 967 if (e->flags & EDGE_FALLTHRU) 968 has_fallthru = 1, fallthru_frequency += EDGE_FREQUENCY (e); --- 22 unchanged lines hidden (view full) --- 991 { 992 max_log = log; 993 max_skip = JUMP_ALIGN_MAX_SKIP; 994 } 995 } 996 /* In case block is frequent and reached mostly by non-fallthru edge, 997 align it. It is most likely a first block of loop. */ 998 if (has_fallthru | 683 continue; 684 max_log = LABEL_ALIGN (label); 685 max_skip = LABEL_ALIGN_MAX_SKIP; 686 687 for (e = bb->pred; e; e = e->pred_next) 688 { 689 if (e->flags & EDGE_FALLTHRU) 690 has_fallthru = 1, fallthru_frequency += EDGE_FREQUENCY (e); --- 22 unchanged lines hidden (view full) --- 713 { 714 max_log = log; 715 max_skip = JUMP_ALIGN_MAX_SKIP; 716 } 717 } 718 /* In case block is frequent and reached mostly by non-fallthru edge, 719 align it. It is most likely a first block of loop. */ 720 if (has_fallthru |
721 && maybe_hot_bb_p (bb) |
|
999 && branch_frequency + fallthru_frequency > BB_FREQ_MAX / 10 1000 && branch_frequency > fallthru_frequency * 2) 1001 { 1002 log = LOOP_ALIGN (label); 1003 if (max_log < log) 1004 { 1005 max_log = log; 1006 max_skip = LOOP_ALIGN_MAX_SKIP; 1007 } 1008 } 1009 LABEL_TO_ALIGNMENT (label) = max_log; 1010 LABEL_TO_MAX_SKIP (label) = max_skip; 1011 } 1012} 1013 1014/* Make a pass over all insns and compute their actual lengths by shortening 1015 any branches of variable length if possible. */ 1016 | 722 && branch_frequency + fallthru_frequency > BB_FREQ_MAX / 10 723 && branch_frequency > fallthru_frequency * 2) 724 { 725 log = LOOP_ALIGN (label); 726 if (max_log < log) 727 { 728 max_log = log; 729 max_skip = LOOP_ALIGN_MAX_SKIP; 730 } 731 } 732 LABEL_TO_ALIGNMENT (label) = max_log; 733 LABEL_TO_MAX_SKIP (label) = max_skip; 734 } 735} 736 737/* Make a pass over all insns and compute their actual lengths by shortening 738 any branches of variable length if possible. */ 739 |
1017/* Give a default value for the lowest address in a function. */ 1018 1019#ifndef FIRST_INSN_ADDRESS 1020#define FIRST_INSN_ADDRESS 0 1021#endif 1022 | |
1023/* shorten_branches might be called multiple times: for example, the SH 1024 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG. 1025 In order to do this, it needs proper length information, which it obtains 1026 by calling shorten_branches. This cannot be collapsed with 1027 shorten_branches itself into a single pass unless we also want to integrate 1028 reorg.c, since the branch splitting exposes new instructions with delay 1029 slots. */ 1030 1031void | 740/* shorten_branches might be called multiple times: for example, the SH 741 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG. 742 In order to do this, it needs proper length information, which it obtains 743 by calling shorten_branches. This cannot be collapsed with 744 shorten_branches itself into a single pass unless we also want to integrate 745 reorg.c, since the branch splitting exposes new instructions with delay 746 slots. */ 747 748void |
1032shorten_branches (first) 1033 rtx first ATTRIBUTE_UNUSED; | 749shorten_branches (rtx first ATTRIBUTE_UNUSED) |
1034{ 1035 rtx insn; 1036 int max_uid; 1037 int i; 1038 int max_log; 1039 int max_skip; 1040#ifdef HAVE_ATTR_length 1041#define MAX_CODE_ALIGN 16 --- 4 unchanged lines hidden (view full) --- 1046 int uid; 1047 rtx align_tab[MAX_CODE_ALIGN]; 1048 1049#endif 1050 1051 /* Compute maximum UID and allocate label_align / uid_shuid. */ 1052 max_uid = get_max_uid (); 1053 | 750{ 751 rtx insn; 752 int max_uid; 753 int i; 754 int max_log; 755 int max_skip; 756#ifdef HAVE_ATTR_length 757#define MAX_CODE_ALIGN 16 --- 4 unchanged lines hidden (view full) --- 762 int uid; 763 rtx align_tab[MAX_CODE_ALIGN]; 764 765#endif 766 767 /* Compute maximum UID and allocate label_align / uid_shuid. */ 768 max_uid = get_max_uid (); 769 |
1054 uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid); | 770 uid_shuid = xmalloc (max_uid * sizeof *uid_shuid); |
1055 1056 if (max_labelno != max_label_num ()) 1057 { 1058 int old = max_labelno; 1059 int n_labels; 1060 int n_old_labels; 1061 1062 max_labelno = max_label_num (); 1063 1064 n_labels = max_labelno - min_labelno + 1; 1065 n_old_labels = old - min_labelno + 1; 1066 | 771 772 if (max_labelno != max_label_num ()) 773 { 774 int old = max_labelno; 775 int n_labels; 776 int n_old_labels; 777 778 max_labelno = max_label_num (); 779 780 n_labels = max_labelno - min_labelno + 1; 781 n_old_labels = old - min_labelno + 1; 782 |
1067 label_align = (struct label_alignment *) xrealloc 1068 (label_align, n_labels * sizeof (struct label_alignment)); | 783 label_align = xrealloc (label_align, 784 n_labels * sizeof (struct label_alignment)); |
1069 1070 /* Range of labels grows monotonically in the function. Abort here 1071 means that the initialization of array got lost. */ 1072 if (n_old_labels > n_labels) 1073 abort (); 1074 1075 memset (label_align + n_old_labels, 0, 1076 (n_labels - n_old_labels) * sizeof (struct label_alignment)); --- 78 unchanged lines hidden (view full) --- 1155 } 1156 break; 1157 } 1158 } 1159 } 1160#ifdef HAVE_ATTR_length 1161 1162 /* Allocate the rest of the arrays. */ | 785 786 /* Range of labels grows monotonically in the function. Abort here 787 means that the initialization of array got lost. */ 788 if (n_old_labels > n_labels) 789 abort (); 790 791 memset (label_align + n_old_labels, 0, 792 (n_labels - n_old_labels) * sizeof (struct label_alignment)); --- 78 unchanged lines hidden (view full) --- 871 } 872 break; 873 } 874 } 875 } 876#ifdef HAVE_ATTR_length 877 878 /* Allocate the rest of the arrays. */ |
1163 insn_lengths = (int *) xmalloc (max_uid * sizeof (*insn_lengths)); | 879 insn_lengths = xmalloc (max_uid * sizeof (*insn_lengths)); |
1164 insn_lengths_max_uid = max_uid; 1165 /* Syntax errors can lead to labels being outside of the main insn stream. 1166 Initialize insn_addresses, so that we get reproducible results. */ 1167 INSN_ADDRESSES_ALLOC (max_uid); 1168 | 880 insn_lengths_max_uid = max_uid; 881 /* Syntax errors can lead to labels being outside of the main insn stream. 882 Initialize insn_addresses, so that we get reproducible results. */ 883 INSN_ADDRESSES_ALLOC (max_uid); 884 |
1169 varying_length = (char *) xcalloc (max_uid, sizeof (char)); | 885 varying_length = xcalloc (max_uid, sizeof (char)); |
1170 1171 /* Initialize uid_align. We scan instructions 1172 from end to start, and keep in align_tab[n] the last seen insn 1173 that does an alignment of at least n+1, i.e. the successor 1174 in the alignment chain for an insn that does / has a known 1175 alignment of n. */ | 886 887 /* Initialize uid_align. We scan instructions 888 from end to start, and keep in align_tab[n] the last seen insn 889 that does an alignment of at least n+1, i.e. the successor 890 in the alignment chain for an insn that does / has a known 891 alignment of n. */ |
1176 uid_align = (rtx *) xcalloc (max_uid, sizeof *uid_align); | 892 uid_align = xcalloc (max_uid, sizeof *uid_align); |
1177 1178 for (i = MAX_CODE_ALIGN; --i >= 0;) 1179 align_tab[i] = NULL_RTX; 1180 seq = get_last_insn (); 1181 for (; seq; seq = PREV_INSN (seq)) 1182 { 1183 int uid = INSN_UID (seq); 1184 int log; --- 60 unchanged lines hidden (view full) --- 1245 flags.min_after_base = min > rel; 1246 flags.max_after_base = max > rel; 1247 ADDR_DIFF_VEC_FLAGS (pat) = flags; 1248 } 1249 } 1250#endif /* CASE_VECTOR_SHORTEN_MODE */ 1251 1252 /* Compute initial lengths, addresses, and varying flags for each insn. */ | 893 894 for (i = MAX_CODE_ALIGN; --i >= 0;) 895 align_tab[i] = NULL_RTX; 896 seq = get_last_insn (); 897 for (; seq; seq = PREV_INSN (seq)) 898 { 899 int uid = INSN_UID (seq); 900 int log; --- 60 unchanged lines hidden (view full) --- 961 flags.min_after_base = min > rel; 962 flags.max_after_base = max > rel; 963 ADDR_DIFF_VEC_FLAGS (pat) = flags; 964 } 965 } 966#endif /* CASE_VECTOR_SHORTEN_MODE */ 967 968 /* Compute initial lengths, addresses, and varying flags for each insn. */ |
1253 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; | 969 for (insn_current_address = 0, insn = first; |
1254 insn != 0; 1255 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn)) 1256 { 1257 uid = INSN_UID (insn); 1258 1259 insn_lengths[uid] = 0; 1260 1261 if (GET_CODE (insn) == CODE_LABEL) --- 84 unchanged lines hidden (view full) --- 1346 /* Now loop over all the insns finding varying length insns. For each, 1347 get the current insn length. If it has changed, reflect the change. 1348 When nothing changes for a full pass, we are done. */ 1349 1350 while (something_changed) 1351 { 1352 something_changed = 0; 1353 insn_current_align = MAX_CODE_ALIGN - 1; | 970 insn != 0; 971 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn)) 972 { 973 uid = INSN_UID (insn); 974 975 insn_lengths[uid] = 0; 976 977 if (GET_CODE (insn) == CODE_LABEL) --- 84 unchanged lines hidden (view full) --- 1062 /* Now loop over all the insns finding varying length insns. For each, 1063 get the current insn length. If it has changed, reflect the change. 1064 When nothing changes for a full pass, we are done. */ 1065 1066 while (something_changed) 1067 { 1068 something_changed = 0; 1069 insn_current_align = MAX_CODE_ALIGN - 1; |
1354 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; | 1070 for (insn_current_address = 0, insn = first; |
1355 insn != 0; 1356 insn = NEXT_INSN (insn)) 1357 { 1358 int new_length; 1359#ifdef ADJUST_INSN_LENGTH 1360 int tmp_length; 1361#endif 1362 int length_align; --- 217 unchanged lines hidden (view full) --- 1580} 1581 1582#ifdef HAVE_ATTR_length 1583/* Given the body of an INSN known to be generated by an ASM statement, return 1584 the number of machine instructions likely to be generated for this insn. 1585 This is used to compute its length. */ 1586 1587static int | 1071 insn != 0; 1072 insn = NEXT_INSN (insn)) 1073 { 1074 int new_length; 1075#ifdef ADJUST_INSN_LENGTH 1076 int tmp_length; 1077#endif 1078 int length_align; --- 217 unchanged lines hidden (view full) --- 1296} 1297 1298#ifdef HAVE_ATTR_length 1299/* Given the body of an INSN known to be generated by an ASM statement, return 1300 the number of machine instructions likely to be generated for this insn. 1301 This is used to compute its length. */ 1302 1303static int |
1588asm_insn_count (body) 1589 rtx body; | 1304asm_insn_count (rtx body) |
1590{ 1591 const char *template; 1592 int count = 1; 1593 1594 if (GET_CODE (body) == ASM_INPUT) 1595 template = XSTR (body, 0); 1596 else 1597 template = decode_asm_operands (body, NULL, NULL, NULL, NULL); --- 12 unchanged lines hidden (view full) --- 1610 assembler pseudo-ops have already been output in `assemble_start_function'. 1611 1612 FIRST is the first insn of the rtl for the function being compiled. 1613 FILE is the file to write assembler code to. 1614 OPTIMIZE is nonzero if we should eliminate redundant 1615 test and compare insns. */ 1616 1617void | 1305{ 1306 const char *template; 1307 int count = 1; 1308 1309 if (GET_CODE (body) == ASM_INPUT) 1310 template = XSTR (body, 0); 1311 else 1312 template = decode_asm_operands (body, NULL, NULL, NULL, NULL); --- 12 unchanged lines hidden (view full) --- 1325 assembler pseudo-ops have already been output in `assemble_start_function'. 1326 1327 FIRST is the first insn of the rtl for the function being compiled. 1328 FILE is the file to write assembler code to. 1329 OPTIMIZE is nonzero if we should eliminate redundant 1330 test and compare insns. */ 1331 1332void |
1618final_start_function (first, file, optimize) 1619 rtx first; 1620 FILE *file; 1621 int optimize ATTRIBUTE_UNUSED; | 1333final_start_function (rtx first ATTRIBUTE_UNUSED, FILE *file, 1334 int optimize ATTRIBUTE_UNUSED) |
1622{ 1623 block_depth = 0; 1624 1625 this_is_asm_operands = 0; 1626 | 1335{ 1336 block_depth = 0; 1337 1338 this_is_asm_operands = 0; 1339 |
1627#ifdef NON_SAVING_SETJMP 1628 /* A function that calls setjmp should save and restore all the 1629 call-saved registers on a system where longjmp clobbers them. */ 1630 if (NON_SAVING_SETJMP && current_function_calls_setjmp) 1631 { 1632 int i; | 1340 last_filename = locator_file (prologue_locator); 1341 last_linenum = locator_line (prologue_locator); |
1633 | 1342 |
1634 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 1635 if (!call_used_regs[i]) 1636 regs_ever_live[i] = 1; 1637 } 1638#endif 1639 1640 if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED) 1641 notice_source_line (first); | |
1642 high_block_linenum = high_function_linenum = last_linenum; 1643 1644 (*debug_hooks->begin_prologue) (last_linenum, last_filename); 1645 1646#if defined (DWARF2_UNWIND_INFO) || defined (IA64_UNWIND_INFO) 1647 if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG) 1648 dwarf2out_begin_prologue (0, NULL); 1649#endif --- 15 unchanged lines hidden (view full) --- 1665 dwarf2out_frame_debug (NULL_RTX); 1666#endif 1667 1668 /* If debugging, assign block numbers to all of the blocks in this 1669 function. */ 1670 if (write_symbols) 1671 { 1672 remove_unnecessary_notes (); | 1343 high_block_linenum = high_function_linenum = last_linenum; 1344 1345 (*debug_hooks->begin_prologue) (last_linenum, last_filename); 1346 1347#if defined (DWARF2_UNWIND_INFO) || defined (IA64_UNWIND_INFO) 1348 if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG) 1349 dwarf2out_begin_prologue (0, NULL); 1350#endif --- 15 unchanged lines hidden (view full) --- 1366 dwarf2out_frame_debug (NULL_RTX); 1367#endif 1368 1369 /* If debugging, assign block numbers to all of the blocks in this 1370 function. */ 1371 if (write_symbols) 1372 { 1373 remove_unnecessary_notes (); |
1673 scope_to_insns_finalize (); | 1374 reemit_insn_block_notes (); |
1674 number_blocks (current_function_decl); 1675 /* We never actually put out begin/end notes for the top-level 1676 block in the function. But, conceptually, that block is 1677 always needed. */ 1678 TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1; 1679 } 1680 1681 /* First output the function prologue: code to set up the stack frame. */ 1682 (*targetm.asm_out.function_prologue) (file, get_frame_size ()); 1683 1684 /* If the machine represents the prologue as RTL, the profiling code must 1685 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */ 1686#ifdef HAVE_prologue 1687 if (! HAVE_prologue) 1688#endif 1689 profile_after_prologue (file); 1690} 1691 1692static void | 1375 number_blocks (current_function_decl); 1376 /* We never actually put out begin/end notes for the top-level 1377 block in the function. But, conceptually, that block is 1378 always needed. */ 1379 TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1; 1380 } 1381 1382 /* First output the function prologue: code to set up the stack frame. */ 1383 (*targetm.asm_out.function_prologue) (file, get_frame_size ()); 1384 1385 /* If the machine represents the prologue as RTL, the profiling code must 1386 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */ 1387#ifdef HAVE_prologue 1388 if (! HAVE_prologue) 1389#endif 1390 profile_after_prologue (file); 1391} 1392 1393static void |
1693profile_after_prologue (file) 1694 FILE *file ATTRIBUTE_UNUSED; | 1394profile_after_prologue (FILE *file ATTRIBUTE_UNUSED) |
1695{ 1696#ifndef PROFILE_BEFORE_PROLOGUE 1697 if (current_function_profile) 1698 profile_function (file); 1699#endif /* not PROFILE_BEFORE_PROLOGUE */ 1700} 1701 1702static void | 1395{ 1396#ifndef PROFILE_BEFORE_PROLOGUE 1397 if (current_function_profile) 1398 profile_function (file); 1399#endif /* not PROFILE_BEFORE_PROLOGUE */ 1400} 1401 1402static void |
1703profile_function (file) 1704 FILE *file ATTRIBUTE_UNUSED; | 1403profile_function (FILE *file ATTRIBUTE_UNUSED) |
1705{ 1706#ifndef NO_PROFILE_COUNTERS | 1404{ 1405#ifndef NO_PROFILE_COUNTERS |
1707 int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE); | 1406# define NO_PROFILE_COUNTERS 0 |
1708#endif 1709#if defined(ASM_OUTPUT_REG_PUSH) | 1407#endif 1408#if defined(ASM_OUTPUT_REG_PUSH) |
1710#if defined(STRUCT_VALUE_INCOMING_REGNUM) || defined(STRUCT_VALUE_REGNUM) | |
1711 int sval = current_function_returns_struct; | 1409 int sval = current_function_returns_struct; |
1712#endif | 1410 rtx svrtx = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl), 1); |
1713#if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM) 1714 int cxt = current_function_needs_context; 1715#endif 1716#endif /* ASM_OUTPUT_REG_PUSH */ 1717 | 1411#if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM) 1412 int cxt = current_function_needs_context; 1413#endif 1414#endif /* ASM_OUTPUT_REG_PUSH */ 1415 |
1718#ifndef NO_PROFILE_COUNTERS 1719 data_section (); 1720 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); 1721 ASM_OUTPUT_INTERNAL_LABEL (file, "LP", current_function_funcdef_no); 1722 assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1); 1723#endif | 1416 if (! NO_PROFILE_COUNTERS) 1417 { 1418 int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE); 1419 data_section (); 1420 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); 1421 (*targetm.asm_out.internal_label) (file, "LP", current_function_funcdef_no); 1422 assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1); 1423 } |
1724 1725 function_section (current_function_decl); 1726 | 1424 1425 function_section (current_function_decl); 1426 |
1727#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1728 if (sval) 1729 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM); 1730#else 1731#if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1732 if (sval) 1733 { 1734 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM); 1735 } | 1427#if defined(ASM_OUTPUT_REG_PUSH) 1428 if (sval && svrtx != NULL_RTX && GET_CODE (svrtx) == REG) 1429 ASM_OUTPUT_REG_PUSH (file, REGNO (svrtx)); |
1736#endif | 1430#endif |
1737#endif | |
1738 1739#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1740 if (cxt) 1741 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM); 1742#else 1743#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1744 if (cxt) 1745 { --- 11 unchanged lines hidden (view full) --- 1757#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1758 if (cxt) 1759 { 1760 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM); 1761 } 1762#endif 1763#endif 1764 | 1431 1432#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1433 if (cxt) 1434 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM); 1435#else 1436#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1437 if (cxt) 1438 { --- 11 unchanged lines hidden (view full) --- 1450#if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1451 if (cxt) 1452 { 1453 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM); 1454 } 1455#endif 1456#endif 1457 |
1765#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1766 if (sval) 1767 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM); 1768#else 1769#if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) 1770 if (sval) 1771 { 1772 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM); 1773 } | 1458#if defined(ASM_OUTPUT_REG_PUSH) 1459 if (sval && svrtx != NULL_RTX && GET_CODE (svrtx) == REG) 1460 ASM_OUTPUT_REG_POP (file, REGNO (svrtx)); |
1774#endif | 1461#endif |
1775#endif | |
1776} 1777 1778/* Output assembler code for the end of a function. 1779 For clarity, args are same as those of `final_start_function' 1780 even though not all of them are needed. */ 1781 1782void | 1462} 1463 1464/* Output assembler code for the end of a function. 1465 For clarity, args are same as those of `final_start_function' 1466 even though not all of them are needed. */ 1467 1468void |
1783final_end_function () | 1469final_end_function (void) |
1784{ 1785 app_disable (); 1786 1787 (*debug_hooks->end_function) (high_function_linenum); 1788 1789 /* Finally, output the function epilogue: 1790 code to restore the stack frame and return to the caller. */ 1791 (*targetm.asm_out.function_epilogue) (asm_out_file, get_frame_size ()); --- 15 unchanged lines hidden (view full) --- 1807 just scanning as if we were outputting. 1808 Prescanning deletes and rearranges insns just like ordinary output. 1809 PRESCAN is -2 if we are outputting after having prescanned. 1810 In this case, don't try to delete or rearrange insns 1811 because that has already been done. 1812 Prescanning is done only on certain machines. */ 1813 1814void | 1470{ 1471 app_disable (); 1472 1473 (*debug_hooks->end_function) (high_function_linenum); 1474 1475 /* Finally, output the function epilogue: 1476 code to restore the stack frame and return to the caller. */ 1477 (*targetm.asm_out.function_epilogue) (asm_out_file, get_frame_size ()); --- 15 unchanged lines hidden (view full) --- 1493 just scanning as if we were outputting. 1494 Prescanning deletes and rearranges insns just like ordinary output. 1495 PRESCAN is -2 if we are outputting after having prescanned. 1496 In this case, don't try to delete or rearrange insns 1497 because that has already been done. 1498 Prescanning is done only on certain machines. */ 1499 1500void |
1815final (first, file, optimize, prescan) 1816 rtx first; 1817 FILE *file; 1818 int optimize; 1819 int prescan; | 1501final (rtx first, FILE *file, int optimize, int prescan) |
1820{ 1821 rtx insn; | 1502{ 1503 rtx insn; |
1822 int max_line = 0; | |
1823 int max_uid = 0; | 1504 int max_uid = 0; |
1505 int seen = 0; |
|
1824 1825 last_ignored_compare = 0; | 1506 1507 last_ignored_compare = 0; |
1826 new_block = 1; | |
1827 | 1508 |
1828 /* Make a map indicating which line numbers appear in this function. 1829 When producing SDB debugging info, delete troublesome line number | 1509#ifdef SDB_DEBUGGING_INFO 1510 /* When producing SDB debugging info, delete troublesome line number |
1830 notes from inlined functions in other files as well as duplicate 1831 line number notes. */ | 1511 notes from inlined functions in other files as well as duplicate 1512 line number notes. */ |
1832#ifdef SDB_DEBUGGING_INFO | |
1833 if (write_symbols == SDB_DEBUG) 1834 { 1835 rtx last = 0; 1836 for (insn = first; insn; insn = NEXT_INSN (insn)) 1837 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 1838 { 1839 if ((RTX_INTEGRATED_P (insn) 1840 && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0) | 1513 if (write_symbols == SDB_DEBUG) 1514 { 1515 rtx last = 0; 1516 for (insn = first; insn; insn = NEXT_INSN (insn)) 1517 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 1518 { 1519 if ((RTX_INTEGRATED_P (insn) 1520 && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0) |
1841 || (last != 0 1842 && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last) 1843 && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last))) | 1521 || (last != 0 1522 && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last) 1523 && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last))) |
1844 { 1845 delete_insn (insn); /* Use delete_note. */ 1846 continue; 1847 } 1848 last = insn; | 1524 { 1525 delete_insn (insn); /* Use delete_note. */ 1526 continue; 1527 } 1528 last = insn; |
1849 if (NOTE_LINE_NUMBER (insn) > max_line) 1850 max_line = NOTE_LINE_NUMBER (insn); | |
1851 } 1852 } | 1529 } 1530 } |
1853 else | |
1854#endif | 1531#endif |
1855 { 1856 for (insn = first; insn; insn = NEXT_INSN (insn)) 1857 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line) 1858 max_line = NOTE_LINE_NUMBER (insn); 1859 } | |
1860 | 1532 |
1861 line_note_exists = (char *) xcalloc (max_line + 1, sizeof (char)); 1862 | |
1863 for (insn = first; insn; insn = NEXT_INSN (insn)) 1864 { | 1533 for (insn = first; insn; insn = NEXT_INSN (insn)) 1534 { |
1865 if (INSN_UID (insn) > max_uid) /* find largest UID */ | 1535 if (INSN_UID (insn) > max_uid) /* Find largest UID. */ |
1866 max_uid = INSN_UID (insn); | 1536 max_uid = INSN_UID (insn); |
1867 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 1868 line_note_exists[NOTE_LINE_NUMBER (insn)] = 1; | |
1869#ifdef HAVE_cc0 1870 /* If CC tracking across branches is enabled, record the insn which 1871 jumps to each branch only reached from one place. */ 1872 if (optimize && GET_CODE (insn) == JUMP_INSN) 1873 { 1874 rtx lab = JUMP_LABEL (insn); 1875 if (lab && LABEL_NUSES (lab) == 1) 1876 { --- 19 unchanged lines hidden (view full) --- 1896 insn_current_address = -1; 1897 else 1898 abort (); 1899 } 1900 else 1901 insn_current_address = INSN_ADDRESSES (INSN_UID (insn)); 1902#endif /* HAVE_ATTR_length */ 1903 | 1537#ifdef HAVE_cc0 1538 /* If CC tracking across branches is enabled, record the insn which 1539 jumps to each branch only reached from one place. */ 1540 if (optimize && GET_CODE (insn) == JUMP_INSN) 1541 { 1542 rtx lab = JUMP_LABEL (insn); 1543 if (lab && LABEL_NUSES (lab) == 1) 1544 { --- 19 unchanged lines hidden (view full) --- 1564 insn_current_address = -1; 1565 else 1566 abort (); 1567 } 1568 else 1569 insn_current_address = INSN_ADDRESSES (INSN_UID (insn)); 1570#endif /* HAVE_ATTR_length */ 1571 |
1904 insn = final_scan_insn (insn, file, optimize, prescan, 0); | 1572 insn = final_scan_insn (insn, file, optimize, prescan, 0, &seen); |
1905 } | 1573 } |
1906 1907 /* Store function names for edge-profiling. */ 1908 /* ??? Probably should re-use the existing struct function. */ 1909 1910 if (cfun->arc_profile) 1911 { 1912 struct function_list *new_item = xmalloc (sizeof (struct function_list)); 1913 1914 *functions_tail = new_item; 1915 functions_tail = &new_item->next; 1916 1917 new_item->next = 0; 1918 new_item->name = xstrdup (IDENTIFIER_POINTER 1919 (DECL_ASSEMBLER_NAME (current_function_decl))); 1920 new_item->cfg_checksum = profile_info.current_function_cfg_checksum; 1921 new_item->count_edges = profile_info.count_edges_instrumented_now; 1922 } 1923 1924 free (line_note_exists); 1925 line_note_exists = NULL; | |
1926} 1927 1928const char * | 1574} 1575 1576const char * |
1929get_insn_template (code, insn) 1930 int code; 1931 rtx insn; | 1577get_insn_template (int code, rtx insn) |
1932{ | 1578{ |
1933 const void *output = insn_data[code].output; | |
1934 switch (insn_data[code].output_format) 1935 { 1936 case INSN_OUTPUT_FORMAT_SINGLE: | 1579 switch (insn_data[code].output_format) 1580 { 1581 case INSN_OUTPUT_FORMAT_SINGLE: |
1937 return (const char *) output; | 1582 return insn_data[code].output.single; |
1938 case INSN_OUTPUT_FORMAT_MULTI: | 1583 case INSN_OUTPUT_FORMAT_MULTI: |
1939 return ((const char *const *) output)[which_alternative]; | 1584 return insn_data[code].output.multi[which_alternative]; |
1940 case INSN_OUTPUT_FORMAT_FUNCTION: 1941 if (insn == NULL) 1942 abort (); | 1585 case INSN_OUTPUT_FORMAT_FUNCTION: 1586 if (insn == NULL) 1587 abort (); |
1943 return (*(insn_output_fn) output) (recog_data.operand, insn); | 1588 return (*insn_data[code].output.function) (recog_data.operand, insn); |
1944 1945 default: 1946 abort (); 1947 } 1948} 1949 1950/* Emit the appropriate declaration for an alternate-entry-point 1951 symbol represented by INSN, to FILE. INSN is a CODE_LABEL with 1952 LABEL_KIND != LABEL_NORMAL. 1953 1954 The case fall-through in this function is intentional. */ 1955static void | 1589 1590 default: 1591 abort (); 1592 } 1593} 1594 1595/* Emit the appropriate declaration for an alternate-entry-point 1596 symbol represented by INSN, to FILE. INSN is a CODE_LABEL with 1597 LABEL_KIND != LABEL_NORMAL. 1598 1599 The case fall-through in this function is intentional. */ 1600static void |
1956output_alternate_entry_point (file, insn) 1957 FILE *file; 1958 rtx insn; | 1601output_alternate_entry_point (FILE *file, rtx insn) |
1959{ 1960 const char *name = LABEL_NAME (insn); 1961 1962 switch (LABEL_KIND (insn)) 1963 { 1964 case LABEL_WEAK_ENTRY: 1965#ifdef ASM_WEAKEN_LABEL 1966 ASM_WEAKEN_LABEL (file, name); --- 14 unchanged lines hidden (view full) --- 1981} 1982 1983/* The final scan for one insn, INSN. 1984 Args are same as in `final', except that INSN 1985 is the insn being scanned. 1986 Value returned is the next insn to be scanned. 1987 1988 NOPEEPHOLES is the flag to disallow peephole processing (currently | 1602{ 1603 const char *name = LABEL_NAME (insn); 1604 1605 switch (LABEL_KIND (insn)) 1606 { 1607 case LABEL_WEAK_ENTRY: 1608#ifdef ASM_WEAKEN_LABEL 1609 ASM_WEAKEN_LABEL (file, name); --- 14 unchanged lines hidden (view full) --- 1624} 1625 1626/* The final scan for one insn, INSN. 1627 Args are same as in `final', except that INSN 1628 is the insn being scanned. 1629 Value returned is the next insn to be scanned. 1630 1631 NOPEEPHOLES is the flag to disallow peephole processing (currently |
1989 used for within delayed branch sequence output). */ | 1632 used for within delayed branch sequence output). |
1990 | 1633 |
1634 SEEN is used to track the end of the prologue, for emitting 1635 debug information. We force the emission of a line note after 1636 both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG, or 1637 at the beginning of the second basic block, whichever comes 1638 first. */ 1639 |
|
1991rtx | 1640rtx |
1992final_scan_insn (insn, file, optimize, prescan, nopeepholes) 1993 rtx insn; 1994 FILE *file; 1995 int optimize ATTRIBUTE_UNUSED; 1996 int prescan; 1997 int nopeepholes ATTRIBUTE_UNUSED; | 1641final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, 1642 int prescan, int nopeepholes ATTRIBUTE_UNUSED, 1643 int *seen) |
1998{ 1999#ifdef HAVE_cc0 2000 rtx set; 2001#endif 2002 2003 insn_counter++; 2004 2005 /* Ignore deleted insns. These can occur when we split insns (due to a --- 22 unchanged lines hidden (view full) --- 2028 2029 case NOTE_INSN_BASIC_BLOCK: 2030#ifdef IA64_UNWIND_INFO 2031 IA64_UNWIND_EMIT (asm_out_file, insn); 2032#endif 2033 if (flag_debug_asm) 2034 fprintf (asm_out_file, "\t%s basic block %d\n", 2035 ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index); | 1644{ 1645#ifdef HAVE_cc0 1646 rtx set; 1647#endif 1648 1649 insn_counter++; 1650 1651 /* Ignore deleted insns. These can occur when we split insns (due to a --- 22 unchanged lines hidden (view full) --- 1674 1675 case NOTE_INSN_BASIC_BLOCK: 1676#ifdef IA64_UNWIND_INFO 1677 IA64_UNWIND_EMIT (asm_out_file, insn); 1678#endif 1679 if (flag_debug_asm) 1680 fprintf (asm_out_file, "\t%s basic block %d\n", 1681 ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index); |
1682 1683 if ((*seen & (SEEN_EMITTED | SEEN_BB)) == SEEN_BB) 1684 { 1685 *seen |= SEEN_EMITTED; 1686 last_filename = NULL; 1687 } 1688 else 1689 *seen |= SEEN_BB; 1690 |
|
2036 break; 2037 2038 case NOTE_INSN_EH_REGION_BEG: 2039 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB", 2040 NOTE_EH_HANDLER (insn)); 2041 break; 2042 2043 case NOTE_INSN_EH_REGION_END: 2044 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE", 2045 NOTE_EH_HANDLER (insn)); 2046 break; 2047 2048 case NOTE_INSN_PROLOGUE_END: 2049 (*targetm.asm_out.function_end_prologue) (file); 2050 profile_after_prologue (file); | 1691 break; 1692 1693 case NOTE_INSN_EH_REGION_BEG: 1694 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB", 1695 NOTE_EH_HANDLER (insn)); 1696 break; 1697 1698 case NOTE_INSN_EH_REGION_END: 1699 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE", 1700 NOTE_EH_HANDLER (insn)); 1701 break; 1702 1703 case NOTE_INSN_PROLOGUE_END: 1704 (*targetm.asm_out.function_end_prologue) (file); 1705 profile_after_prologue (file); |
1706 1707 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE) 1708 { 1709 *seen |= SEEN_EMITTED; 1710 last_filename = NULL; 1711 } 1712 else 1713 *seen |= SEEN_NOTE; 1714 |
|
2051 break; 2052 2053 case NOTE_INSN_EPILOGUE_BEG: 2054 (*targetm.asm_out.function_begin_epilogue) (file); 2055 break; 2056 2057 case NOTE_INSN_FUNCTION_BEG: 2058 app_disable (); 2059 (*debug_hooks->end_prologue) (last_linenum, last_filename); | 1715 break; 1716 1717 case NOTE_INSN_EPILOGUE_BEG: 1718 (*targetm.asm_out.function_begin_epilogue) (file); 1719 break; 1720 1721 case NOTE_INSN_FUNCTION_BEG: 1722 app_disable (); 1723 (*debug_hooks->end_prologue) (last_linenum, last_filename); |
1724 1725 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE) 1726 { 1727 *seen |= SEEN_EMITTED; 1728 last_filename = NULL; 1729 } 1730 else 1731 *seen |= SEEN_NOTE; 1732 |
|
2060 break; 2061 2062 case NOTE_INSN_BLOCK_BEG: 2063 if (debug_info_level == DINFO_LEVEL_NORMAL 2064 || debug_info_level == DINFO_LEVEL_VERBOSE 2065 || write_symbols == DWARF_DEBUG 2066 || write_symbols == DWARF2_DEBUG 2067 || write_symbols == VMS_AND_DWARF2_DEBUG --- 42 unchanged lines hidden (view full) --- 2110 break; 2111 2112 case 0: 2113 break; 2114 2115 default: 2116 if (NOTE_LINE_NUMBER (insn) <= 0) 2117 abort (); | 1733 break; 1734 1735 case NOTE_INSN_BLOCK_BEG: 1736 if (debug_info_level == DINFO_LEVEL_NORMAL 1737 || debug_info_level == DINFO_LEVEL_VERBOSE 1738 || write_symbols == DWARF_DEBUG 1739 || write_symbols == DWARF2_DEBUG 1740 || write_symbols == VMS_AND_DWARF2_DEBUG --- 42 unchanged lines hidden (view full) --- 1783 break; 1784 1785 case 0: 1786 break; 1787 1788 default: 1789 if (NOTE_LINE_NUMBER (insn) <= 0) 1790 abort (); |
2118 2119 /* This note is a line-number. */ 2120 { 2121 rtx note; 2122 int note_after = 0; 2123 2124 /* If there is anything real after this note, output it. 2125 If another line note follows, omit this one. */ 2126 for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note)) 2127 { 2128 if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL) 2129 break; 2130 2131 /* These types of notes can be significant 2132 so make sure the preceding line number stays. */ 2133 else if (GET_CODE (note) == NOTE 2134 && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG 2135 || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END 2136 || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG)) 2137 break; 2138 else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0) 2139 { 2140 /* Another line note follows; we can delete this note 2141 if no intervening line numbers have notes elsewhere. */ 2142 int num; 2143 for (num = NOTE_LINE_NUMBER (insn) + 1; 2144 num < NOTE_LINE_NUMBER (note); 2145 num++) 2146 if (line_note_exists[num]) 2147 break; 2148 2149 if (num >= NOTE_LINE_NUMBER (note)) 2150 note_after = 1; 2151 break; 2152 } 2153 } 2154 2155 /* Output this line note if it is the first or the last line 2156 note in a row. */ 2157 if (!note_after) 2158 { 2159 notice_source_line (insn); 2160 (*debug_hooks->source_line) (last_linenum, last_filename); 2161 } 2162 } | |
2163 break; 2164 } 2165 break; 2166 2167 case BARRIER: 2168#if defined (DWARF2_UNWIND_INFO) 2169 if (dwarf2out_do_frame ()) 2170 dwarf2out_frame_debug (insn); --- 47 unchanged lines hidden (view full) --- 2218 { 2219 NOTICE_UPDATE_CC (PATTERN (prev), prev); 2220 NOTICE_UPDATE_CC (PATTERN (jump), jump); 2221 } 2222 } 2223#endif 2224 if (prescan > 0) 2225 break; | 1791 break; 1792 } 1793 break; 1794 1795 case BARRIER: 1796#if defined (DWARF2_UNWIND_INFO) 1797 if (dwarf2out_do_frame ()) 1798 dwarf2out_frame_debug (insn); --- 47 unchanged lines hidden (view full) --- 1846 { 1847 NOTICE_UPDATE_CC (PATTERN (prev), prev); 1848 NOTICE_UPDATE_CC (PATTERN (jump), jump); 1849 } 1850 } 1851#endif 1852 if (prescan > 0) 1853 break; |
2226 new_block = 1; | |
2227 | 1854 |
2228#ifdef FINAL_PRESCAN_LABEL 2229 FINAL_PRESCAN_INSN (insn, NULL, 0); 2230#endif 2231 | |
2232 if (LABEL_NAME (insn)) 2233 (*debug_hooks->label) (insn); 2234 2235 if (app_on) 2236 { 2237 fputs (ASM_APP_OFF, file); 2238 app_on = 0; 2239 } --- 29 unchanged lines hidden (view full) --- 2269 } 2270 else 2271 function_section (current_function_decl); 2272 2273#ifdef ASM_OUTPUT_CASE_LABEL 2274 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), 2275 NEXT_INSN (insn)); 2276#else | 1855 if (LABEL_NAME (insn)) 1856 (*debug_hooks->label) (insn); 1857 1858 if (app_on) 1859 { 1860 fputs (ASM_APP_OFF, file); 1861 app_on = 0; 1862 } --- 29 unchanged lines hidden (view full) --- 1892 } 1893 else 1894 function_section (current_function_decl); 1895 1896#ifdef ASM_OUTPUT_CASE_LABEL 1897 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), 1898 NEXT_INSN (insn)); 1899#else |
2277 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn)); | 1900 (*targetm.asm_out.internal_label) (file, "L", CODE_LABEL_NUMBER (insn)); |
2278#endif 2279#endif 2280 break; 2281 } 2282 } 2283 if (LABEL_ALT_ENTRY_P (insn)) 2284 output_alternate_entry_point (file, insn); 2285 else | 1901#endif 1902#endif 1903 break; 1904 } 1905 } 1906 if (LABEL_ALT_ENTRY_P (insn)) 1907 output_alternate_entry_point (file, insn); 1908 else |
2286 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn)); | 1909 (*targetm.asm_out.internal_label) (file, "L", CODE_LABEL_NUMBER (insn)); |
2287 break; 2288 2289 default: 2290 { 2291 rtx body = PATTERN (insn); 2292 int insn_code_number; 2293 const char *template; 2294 rtx note; 2295 2296 /* An INSN, JUMP_INSN or CALL_INSN. 2297 First check for special kinds that recog doesn't recognize. */ 2298 | 1910 break; 1911 1912 default: 1913 { 1914 rtx body = PATTERN (insn); 1915 int insn_code_number; 1916 const char *template; 1917 rtx note; 1918 1919 /* An INSN, JUMP_INSN or CALL_INSN. 1920 First check for special kinds that recog doesn't recognize. */ 1921 |
2299 if (GET_CODE (body) == USE /* These are just declarations */ | 1922 if (GET_CODE (body) == USE /* These are just declarations. */ |
2300 || GET_CODE (body) == CLOBBER) 2301 break; 2302 2303#ifdef HAVE_cc0 2304 /* If there is a REG_CC_SETTER note on this insn, it means that 2305 the setting of the condition code was done in the delay slot 2306 of the insn that branched here. So recover the cc status 2307 from the insn that set it. */ --- 73 unchanged lines hidden (view full) --- 2381 insn); 2382#endif 2383#endif 2384 2385 function_section (current_function_decl); 2386 2387 break; 2388 } | 1923 || GET_CODE (body) == CLOBBER) 1924 break; 1925 1926#ifdef HAVE_cc0 1927 /* If there is a REG_CC_SETTER note on this insn, it means that 1928 the setting of the condition code was done in the delay slot 1929 of the insn that branched here. So recover the cc status 1930 from the insn that set it. */ --- 73 unchanged lines hidden (view full) --- 2004 insn); 2005#endif 2006#endif 2007 2008 function_section (current_function_decl); 2009 2010 break; 2011 } |
2012 /* Output this line note if it is the first or the last line 2013 note in a row. */ 2014 if (notice_source_line (insn)) 2015 { 2016 (*debug_hooks->source_line) (last_linenum, last_filename); 2017 } |
|
2389 2390 if (GET_CODE (body) == ASM_INPUT) 2391 { 2392 const char *string = XSTR (body, 0); 2393 2394 /* There's no telling what that did to the condition codes. */ 2395 CC_STATUS_INIT; 2396 if (prescan > 0) --- 10 unchanged lines hidden (view full) --- 2407 } 2408 break; 2409 } 2410 2411 /* Detect `asm' construct with operands. */ 2412 if (asm_noperands (body) >= 0) 2413 { 2414 unsigned int noperands = asm_noperands (body); | 2018 2019 if (GET_CODE (body) == ASM_INPUT) 2020 { 2021 const char *string = XSTR (body, 0); 2022 2023 /* There's no telling what that did to the condition codes. */ 2024 CC_STATUS_INIT; 2025 if (prescan > 0) --- 10 unchanged lines hidden (view full) --- 2036 } 2037 break; 2038 } 2039 2040 /* Detect `asm' construct with operands. */ 2041 if (asm_noperands (body) >= 0) 2042 { 2043 unsigned int noperands = asm_noperands (body); |
2415 rtx *ops = (rtx *) alloca (noperands * sizeof (rtx)); | 2044 rtx *ops = alloca (noperands * sizeof (rtx)); |
2416 const char *string; 2417 2418 /* There's no telling what that did to the condition codes. */ 2419 CC_STATUS_INIT; 2420 if (prescan > 0) 2421 break; 2422 2423 /* Get out the operand values. */ 2424 string = decode_asm_operands (body, ops, NULL, NULL, NULL); 2425 /* Inhibit aborts on what would otherwise be compiler bugs. */ 2426 insn_noperands = noperands; 2427 this_is_asm_operands = insn; 2428 | 2045 const char *string; 2046 2047 /* There's no telling what that did to the condition codes. */ 2048 CC_STATUS_INIT; 2049 if (prescan > 0) 2050 break; 2051 2052 /* Get out the operand values. */ 2053 string = decode_asm_operands (body, ops, NULL, NULL, NULL); 2054 /* Inhibit aborts on what would otherwise be compiler bugs. */ 2055 insn_noperands = noperands; 2056 this_is_asm_operands = insn; 2057 |
2058#ifdef FINAL_PRESCAN_INSN 2059 FINAL_PRESCAN_INSN (insn, ops, insn_noperands); 2060#endif 2061 |
|
2429 /* Output the insn using them. */ 2430 if (string[0]) 2431 { 2432 if (! app_on) 2433 { 2434 fputs (ASM_APP_ON, file); 2435 app_on = 1; 2436 } --- 15 unchanged lines hidden (view full) --- 2452 /* A delayed-branch sequence */ 2453 int i; 2454 rtx next; 2455 2456 if (prescan > 0) 2457 break; 2458 final_sequence = body; 2459 | 2062 /* Output the insn using them. */ 2063 if (string[0]) 2064 { 2065 if (! app_on) 2066 { 2067 fputs (ASM_APP_ON, file); 2068 app_on = 1; 2069 } --- 15 unchanged lines hidden (view full) --- 2085 /* A delayed-branch sequence */ 2086 int i; 2087 rtx next; 2088 2089 if (prescan > 0) 2090 break; 2091 final_sequence = body; 2092 |
2093 /* Record the delay slots' frame information before the branch. 2094 This is needed for delayed calls: see execute_cfa_program(). */ 2095#if defined (DWARF2_UNWIND_INFO) 2096 if (dwarf2out_do_frame ()) 2097 for (i = 1; i < XVECLEN (body, 0); i++) 2098 dwarf2out_frame_debug (XVECEXP (body, 0, i)); 2099#endif 2100 |
|
2460 /* The first insn in this SEQUENCE might be a JUMP_INSN that will 2461 force the restoration of a comparison that was previously 2462 thought unnecessary. If that happens, cancel this sequence 2463 and cause that insn to be restored. */ 2464 | 2101 /* The first insn in this SEQUENCE might be a JUMP_INSN that will 2102 force the restoration of a comparison that was previously 2103 thought unnecessary. If that happens, cancel this sequence 2104 and cause that insn to be restored. */ 2105 |
2465 next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1); | 2106 next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1, seen); |
2466 if (next != XVECEXP (body, 0, 1)) 2467 { 2468 final_sequence = 0; 2469 return next; 2470 } 2471 2472 for (i = 1; i < XVECLEN (body, 0); i++) 2473 { 2474 rtx insn = XVECEXP (body, 0, i); 2475 rtx next = NEXT_INSN (insn); 2476 /* We loop in case any instruction in a delay slot gets 2477 split. */ 2478 do | 2107 if (next != XVECEXP (body, 0, 1)) 2108 { 2109 final_sequence = 0; 2110 return next; 2111 } 2112 2113 for (i = 1; i < XVECLEN (body, 0); i++) 2114 { 2115 rtx insn = XVECEXP (body, 0, i); 2116 rtx next = NEXT_INSN (insn); 2117 /* We loop in case any instruction in a delay slot gets 2118 split. */ 2119 do |
2479 insn = final_scan_insn (insn, file, 0, prescan, 1); | 2120 insn = final_scan_insn (insn, file, 0, prescan, 1, seen); |
2480 while (insn != next); 2481 } 2482#ifdef DBR_OUTPUT_SEQEND 2483 DBR_OUTPUT_SEQEND (file); 2484#endif 2485 final_sequence = 0; 2486 2487 /* If the insn requiring the delay slot was a CALL_INSN, the --- 20 unchanged lines hidden (view full) --- 2508 This is done only when optimizing; if not optimizing, 2509 it should be possible for the user to alter a variable 2510 with the debugger in between statements 2511 and the next statement should reexamine the variable 2512 to compute the condition codes. */ 2513 2514 if (optimize) 2515 { | 2121 while (insn != next); 2122 } 2123#ifdef DBR_OUTPUT_SEQEND 2124 DBR_OUTPUT_SEQEND (file); 2125#endif 2126 final_sequence = 0; 2127 2128 /* If the insn requiring the delay slot was a CALL_INSN, the --- 20 unchanged lines hidden (view full) --- 2149 This is done only when optimizing; if not optimizing, 2150 it should be possible for the user to alter a variable 2151 with the debugger in between statements 2152 and the next statement should reexamine the variable 2153 to compute the condition codes. */ 2154 2155 if (optimize) 2156 { |
2516#if 0 2517 rtx set = single_set (insn); 2518#endif 2519 | |
2520 if (set 2521 && GET_CODE (SET_DEST (set)) == CC0 2522 && insn != last_ignored_compare) 2523 { 2524 if (GET_CODE (SET_SRC (set)) == SUBREG) 2525 SET_SRC (set) = alter_subreg (&SET_SRC (set)); 2526 else if (GET_CODE (SET_SRC (set)) == COMPARE) 2527 { --- 151 unchanged lines hidden (view full) --- 2679 /* When peepholing, if there were notes within the peephole, 2680 emit them before the peephole. */ 2681 if (next != 0 && next != NEXT_INSN (insn)) 2682 { 2683 rtx prev = PREV_INSN (insn); 2684 2685 for (note = NEXT_INSN (insn); note != next; 2686 note = NEXT_INSN (note)) | 2157 if (set 2158 && GET_CODE (SET_DEST (set)) == CC0 2159 && insn != last_ignored_compare) 2160 { 2161 if (GET_CODE (SET_SRC (set)) == SUBREG) 2162 SET_SRC (set) = alter_subreg (&SET_SRC (set)); 2163 else if (GET_CODE (SET_SRC (set)) == COMPARE) 2164 { --- 151 unchanged lines hidden (view full) --- 2316 /* When peepholing, if there were notes within the peephole, 2317 emit them before the peephole. */ 2318 if (next != 0 && next != NEXT_INSN (insn)) 2319 { 2320 rtx prev = PREV_INSN (insn); 2321 2322 for (note = NEXT_INSN (insn); note != next; 2323 note = NEXT_INSN (note)) |
2687 final_scan_insn (note, file, optimize, prescan, nopeepholes); | 2324 final_scan_insn (note, file, optimize, prescan, nopeepholes, seen); |
2688 2689 /* In case this is prescan, put the notes 2690 in proper position for later rescan. */ 2691 note = NEXT_INSN (insn); 2692 PREV_INSN (note) = prev; 2693 NEXT_INSN (prev) = note; 2694 NEXT_INSN (PREV_INSN (next)) = insn; 2695 PREV_INSN (insn) = PREV_INSN (next); --- 64 unchanged lines hidden (view full) --- 2760 which follows a deleted test insn, and that test insn 2761 needs to be reinserted. */ 2762 if (template == 0) 2763 { 2764 rtx prev; 2765 2766 if (prev_nonnote_insn (insn) != last_ignored_compare) 2767 abort (); | 2325 2326 /* In case this is prescan, put the notes 2327 in proper position for later rescan. */ 2328 note = NEXT_INSN (insn); 2329 PREV_INSN (note) = prev; 2330 NEXT_INSN (prev) = note; 2331 NEXT_INSN (PREV_INSN (next)) = insn; 2332 PREV_INSN (insn) = PREV_INSN (next); --- 64 unchanged lines hidden (view full) --- 2397 which follows a deleted test insn, and that test insn 2398 needs to be reinserted. */ 2399 if (template == 0) 2400 { 2401 rtx prev; 2402 2403 if (prev_nonnote_insn (insn) != last_ignored_compare) 2404 abort (); |
2768 new_block = 0; | |
2769 2770 /* We have already processed the notes between the setter and 2771 the user. Make sure we don't process them again, this is 2772 particularly important if one of the notes is a block 2773 scope note or an EH note. */ 2774 for (prev = insn; 2775 prev != last_ignored_compare; 2776 prev = PREV_INSN (prev)) --- 17 unchanged lines hidden (view full) --- 2794 2795#ifdef HAVE_ATTR_length 2796 /* This instruction should have been split in shorten_branches, 2797 to ensure that we would have valid length info for the 2798 splitees. */ 2799 abort (); 2800#endif 2801 | 2405 2406 /* We have already processed the notes between the setter and 2407 the user. Make sure we don't process them again, this is 2408 particularly important if one of the notes is a block 2409 scope note or an EH note. */ 2410 for (prev = insn; 2411 prev != last_ignored_compare; 2412 prev = PREV_INSN (prev)) --- 17 unchanged lines hidden (view full) --- 2430 2431#ifdef HAVE_ATTR_length 2432 /* This instruction should have been split in shorten_branches, 2433 to ensure that we would have valid length info for the 2434 splitees. */ 2435 abort (); 2436#endif 2437 |
2802 new_block = 0; | |
2803 return new; 2804 } 2805 2806 if (prescan > 0) 2807 break; 2808 2809#ifdef IA64_UNWIND_INFO 2810 IA64_UNWIND_EMIT (asm_out_file, insn); 2811#endif 2812 /* Output assembler code from the template. */ 2813 2814 output_asm_insn (template, recog_data.operand); 2815 | 2438 return new; 2439 } 2440 2441 if (prescan > 0) 2442 break; 2443 2444#ifdef IA64_UNWIND_INFO 2445 IA64_UNWIND_EMIT (asm_out_file, insn); 2446#endif 2447 /* Output assembler code from the template. */ 2448 2449 output_asm_insn (template, recog_data.operand); 2450 |
2451 /* If necessary, report the effect that the instruction has on 2452 the unwind info. We've already done this for delay slots 2453 and call instructions. */ |
|
2816#if defined (DWARF2_UNWIND_INFO) | 2454#if defined (DWARF2_UNWIND_INFO) |
2817#if defined (HAVE_prologue) 2818 if (GET_CODE (insn) == INSN && dwarf2out_do_frame ()) 2819 dwarf2out_frame_debug (insn); 2820#else 2821 if (!ACCUMULATE_OUTGOING_ARGS 2822 && GET_CODE (insn) == INSN | 2455 if (GET_CODE (insn) == INSN 2456#if !defined (HAVE_prologue) 2457 && !ACCUMULATE_OUTGOING_ARGS 2458#endif 2459 && final_sequence == 0 |
2823 && dwarf2out_do_frame ()) 2824 dwarf2out_frame_debug (insn); 2825#endif | 2460 && dwarf2out_do_frame ()) 2461 dwarf2out_frame_debug (insn); 2462#endif |
2826#endif | |
2827 2828#if 0 | 2463 2464#if 0 |
2829 /* It's not at all clear why we did this and doing so interferes 2830 with tests we'd like to do to use REG_WAS_0 notes, so let's try 2831 with this out. */ | 2465 /* It's not at all clear why we did this and doing so used to 2466 interfere with tests that used REG_WAS_0 notes, which are 2467 now gone, so let's try with this out. */ |
2832 2833 /* Mark this insn as having been output. */ 2834 INSN_DELETED_P (insn) = 1; 2835#endif 2836 2837 /* Emit information for vtable gc. */ 2838 note = find_reg_note (insn, REG_VTABLE_REF, NULL_RTX); | 2468 2469 /* Mark this insn as having been output. */ 2470 INSN_DELETED_P (insn) = 1; 2471#endif 2472 2473 /* Emit information for vtable gc. */ 2474 note = find_reg_note (insn, REG_VTABLE_REF, NULL_RTX); |
2839 if (note) 2840 assemble_vtable_entry (XEXP (XEXP (note, 0), 0), 2841 INTVAL (XEXP (XEXP (note, 0), 1))); | |
2842 2843 current_output_insn = debug_insn = 0; 2844 } 2845 } 2846 return NEXT_INSN (insn); 2847} 2848 2849/* Output debugging info to the assembler file FILE 2850 based on the NOTE-insn INSN, assumed to be a line number. */ 2851 | 2475 2476 current_output_insn = debug_insn = 0; 2477 } 2478 } 2479 return NEXT_INSN (insn); 2480} 2481 2482/* Output debugging info to the assembler file FILE 2483 based on the NOTE-insn INSN, assumed to be a line number. */ 2484 |
2852static void 2853notice_source_line (insn) 2854 rtx insn; | 2485static bool 2486notice_source_line (rtx insn) |
2855{ | 2487{ |
2856 const char *filename = NOTE_SOURCE_FILE (insn); | 2488 const char *filename = insn_file (insn); 2489 int linenum = insn_line (insn); |
2857 | 2490 |
2858 last_filename = filename; 2859 last_linenum = NOTE_LINE_NUMBER (insn); 2860 high_block_linenum = MAX (last_linenum, high_block_linenum); 2861 high_function_linenum = MAX (last_linenum, high_function_linenum); | 2491 if (filename && (filename != last_filename || last_linenum != linenum)) 2492 { 2493 last_filename = filename; 2494 last_linenum = linenum; 2495 high_block_linenum = MAX (last_linenum, high_block_linenum); 2496 high_function_linenum = MAX (last_linenum, high_function_linenum); 2497 return true; 2498 } 2499 return false; |
2862} 2863 2864/* For each operand in INSN, simplify (subreg (reg)) so that it refers 2865 directly to the desired hard register. */ 2866 2867void | 2500} 2501 2502/* For each operand in INSN, simplify (subreg (reg)) so that it refers 2503 directly to the desired hard register. */ 2504 2505void |
2868cleanup_subreg_operands (insn) 2869 rtx insn; | 2506cleanup_subreg_operands (rtx insn) |
2870{ 2871 int i; 2872 extract_insn_cached (insn); 2873 for (i = 0; i < recog_data.n_operands; i++) 2874 { | 2507{ 2508 int i; 2509 extract_insn_cached (insn); 2510 for (i = 0; i < recog_data.n_operands; i++) 2511 { |
2875 /* The following test cannot use recog_data.operand when tesing | 2512 /* The following test cannot use recog_data.operand when testing |
2876 for a SUBREG: the underlying object might have been changed 2877 already if we are inside a match_operator expression that 2878 matches the else clause. Instead we test the underlying 2879 expression directly. */ 2880 if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG) 2881 recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i]); 2882 else if (GET_CODE (recog_data.operand[i]) == PLUS 2883 || GET_CODE (recog_data.operand[i]) == MULT --- 11 unchanged lines hidden (view full) --- 2895 *recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i]); 2896 } 2897} 2898 2899/* If X is a SUBREG, replace it with a REG or a MEM, 2900 based on the thing it is a subreg of. */ 2901 2902rtx | 2513 for a SUBREG: the underlying object might have been changed 2514 already if we are inside a match_operator expression that 2515 matches the else clause. Instead we test the underlying 2516 expression directly. */ 2517 if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG) 2518 recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i]); 2519 else if (GET_CODE (recog_data.operand[i]) == PLUS 2520 || GET_CODE (recog_data.operand[i]) == MULT --- 11 unchanged lines hidden (view full) --- 2532 *recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i]); 2533 } 2534} 2535 2536/* If X is a SUBREG, replace it with a REG or a MEM, 2537 based on the thing it is a subreg of. */ 2538 2539rtx |
2903alter_subreg (xp) 2904 rtx *xp; | 2540alter_subreg (rtx *xp) |
2905{ 2906 rtx x = *xp; 2907 rtx y = SUBREG_REG (x); 2908 2909 /* simplify_subreg does not remove subreg from volatile references. 2910 We are required to. */ 2911 if (GET_CODE (y) == MEM) 2912 *xp = adjust_address (y, GET_MODE (x), SUBREG_BYTE (x)); 2913 else 2914 { 2915 rtx new = simplify_subreg (GET_MODE (x), y, GET_MODE (y), 2916 SUBREG_BYTE (x)); 2917 2918 if (new != 0) 2919 *xp = new; 2920 /* Simplify_subreg can't handle some REG cases, but we have to. */ 2921 else if (GET_CODE (y) == REG) 2922 { 2923 unsigned int regno = subreg_hard_regno (x, 1); | 2541{ 2542 rtx x = *xp; 2543 rtx y = SUBREG_REG (x); 2544 2545 /* simplify_subreg does not remove subreg from volatile references. 2546 We are required to. */ 2547 if (GET_CODE (y) == MEM) 2548 *xp = adjust_address (y, GET_MODE (x), SUBREG_BYTE (x)); 2549 else 2550 { 2551 rtx new = simplify_subreg (GET_MODE (x), y, GET_MODE (y), 2552 SUBREG_BYTE (x)); 2553 2554 if (new != 0) 2555 *xp = new; 2556 /* Simplify_subreg can't handle some REG cases, but we have to. */ 2557 else if (GET_CODE (y) == REG) 2558 { 2559 unsigned int regno = subreg_hard_regno (x, 1); |
2924 PUT_CODE (x, REG); 2925 REGNO (x) = regno; 2926 ORIGINAL_REGNO (x) = ORIGINAL_REGNO (y); 2927 /* This field has a different meaning for REGs and SUBREGs. Make 2928 sure to clear it! */ 2929 RTX_FLAG (x, used) = 0; | 2560 *xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, SUBREG_BYTE (x)); |
2930 } 2931 else 2932 abort (); 2933 } 2934 2935 return *xp; 2936} 2937 2938/* Do alter_subreg on all the SUBREGs contained in X. */ 2939 2940static rtx | 2561 } 2562 else 2563 abort (); 2564 } 2565 2566 return *xp; 2567} 2568 2569/* Do alter_subreg on all the SUBREGs contained in X. */ 2570 2571static rtx |
2941walk_alter_subreg (xp) 2942 rtx *xp; | 2572walk_alter_subreg (rtx *xp) |
2943{ 2944 rtx x = *xp; 2945 switch (GET_CODE (x)) 2946 { 2947 case PLUS: 2948 case MULT: 2949 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0)); 2950 XEXP (x, 1) = walk_alter_subreg (&XEXP (x, 1)); --- 20 unchanged lines hidden (view full) --- 2971 Not all of the bits there can be handled at this level in all cases. 2972 2973 The value is normally 0. 2974 1 means that the condition has become always true. 2975 -1 means that the condition has become always false. 2976 2 means that COND has been altered. */ 2977 2978static int | 2573{ 2574 rtx x = *xp; 2575 switch (GET_CODE (x)) 2576 { 2577 case PLUS: 2578 case MULT: 2579 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0)); 2580 XEXP (x, 1) = walk_alter_subreg (&XEXP (x, 1)); --- 20 unchanged lines hidden (view full) --- 2601 Not all of the bits there can be handled at this level in all cases. 2602 2603 The value is normally 0. 2604 1 means that the condition has become always true. 2605 -1 means that the condition has become always false. 2606 2 means that COND has been altered. */ 2607 2608static int |
2979alter_cond (cond) 2980 rtx cond; | 2609alter_cond (rtx cond) |
2981{ 2982 int value = 0; 2983 2984 if (cc_status.flags & CC_REVERSED) 2985 { 2986 value = 2; 2987 PUT_CODE (cond, swap_condition (GET_CODE (cond))); 2988 } --- 136 unchanged lines hidden (view full) --- 3125 return value; 3126} 3127#endif 3128 3129/* Report inconsistency between the assembler template and the operands. 3130 In an `asm', it's the user's fault; otherwise, the compiler's fault. */ 3131 3132void | 2610{ 2611 int value = 0; 2612 2613 if (cc_status.flags & CC_REVERSED) 2614 { 2615 value = 2; 2616 PUT_CODE (cond, swap_condition (GET_CODE (cond))); 2617 } --- 136 unchanged lines hidden (view full) --- 2754 return value; 2755} 2756#endif 2757 2758/* Report inconsistency between the assembler template and the operands. 2759 In an `asm', it's the user's fault; otherwise, the compiler's fault. */ 2760 2761void |
3133output_operand_lossage VPARAMS ((const char *msgid, ...)) | 2762output_operand_lossage (const char *msgid, ...) |
3134{ 3135 char *fmt_string; 3136 char *new_message; 3137 const char *pfx_str; | 2763{ 2764 char *fmt_string; 2765 char *new_message; 2766 const char *pfx_str; |
3138 VA_OPEN (ap, msgid); 3139 VA_FIXEDARG (ap, const char *, msgid); | 2767 va_list ap; |
3140 | 2768 |
2769 va_start (ap, msgid); 2770 |
|
3141 pfx_str = this_is_asm_operands ? _("invalid `asm': ") : "output_operand: "; 3142 asprintf (&fmt_string, "%s%s", pfx_str, _(msgid)); 3143 vasprintf (&new_message, fmt_string, ap); 3144 3145 if (this_is_asm_operands) 3146 error_for_asm (this_is_asm_operands, "%s", new_message); 3147 else 3148 internal_error ("%s", new_message); 3149 3150 free (fmt_string); 3151 free (new_message); | 2771 pfx_str = this_is_asm_operands ? _("invalid `asm': ") : "output_operand: "; 2772 asprintf (&fmt_string, "%s%s", pfx_str, _(msgid)); 2773 vasprintf (&new_message, fmt_string, ap); 2774 2775 if (this_is_asm_operands) 2776 error_for_asm (this_is_asm_operands, "%s", new_message); 2777 else 2778 internal_error ("%s", new_message); 2779 2780 free (fmt_string); 2781 free (new_message); |
3152 VA_CLOSE (ap); | 2782 va_end (ap); |
3153} 3154 3155/* Output of assembler code from a template, and its subroutines. */ 3156 3157/* Annotate the assembly with a comment describing the pattern and 3158 alternative used. */ 3159 3160static void | 2783} 2784 2785/* Output of assembler code from a template, and its subroutines. */ 2786 2787/* Annotate the assembly with a comment describing the pattern and 2788 alternative used. */ 2789 2790static void |
3161output_asm_name () | 2791output_asm_name (void) |
3162{ 3163 if (debug_insn) 3164 { 3165 int num = INSN_CODE (debug_insn); 3166 fprintf (asm_out_file, "\t%s %d\t%s", 3167 ASM_COMMENT_START, INSN_UID (debug_insn), 3168 insn_data[num].name); 3169 if (insn_data[num].n_alternatives > 1) --- 8 unchanged lines hidden (view full) --- 3178 } 3179} 3180 3181/* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it 3182 or its address, return that expr . Set *PADDRESSP to 1 if the expr 3183 corresponds to the address of the object and 0 if to the object. */ 3184 3185static tree | 2792{ 2793 if (debug_insn) 2794 { 2795 int num = INSN_CODE (debug_insn); 2796 fprintf (asm_out_file, "\t%s %d\t%s", 2797 ASM_COMMENT_START, INSN_UID (debug_insn), 2798 insn_data[num].name); 2799 if (insn_data[num].n_alternatives > 1) --- 8 unchanged lines hidden (view full) --- 2808 } 2809} 2810 2811/* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it 2812 or its address, return that expr . Set *PADDRESSP to 1 if the expr 2813 corresponds to the address of the object and 0 if to the object. */ 2814 2815static tree |
3186get_mem_expr_from_op (op, paddressp) 3187 rtx op; 3188 int *paddressp; | 2816get_mem_expr_from_op (rtx op, int *paddressp) |
3189{ 3190 tree expr; 3191 int inner_addressp; 3192 3193 *paddressp = 0; 3194 | 2817{ 2818 tree expr; 2819 int inner_addressp; 2820 2821 *paddressp = 0; 2822 |
3195 if (op == NULL) 3196 return 0; 3197 3198 if (GET_CODE (op) == REG && ORIGINAL_REGNO (op) >= FIRST_PSEUDO_REGISTER) 3199 return REGNO_DECL (ORIGINAL_REGNO (op)); | 2823 if (GET_CODE (op) == REG) 2824 return REG_EXPR (op); |
3200 else if (GET_CODE (op) != MEM) 3201 return 0; 3202 3203 if (MEM_EXPR (op) != 0) 3204 return MEM_EXPR (op); 3205 3206 /* Otherwise we have an address, so indicate it and look at the address. */ 3207 *paddressp = 1; --- 16 unchanged lines hidden (view full) --- 3224 return inner_addressp ? 0 : expr; 3225} 3226 3227/* Output operand names for assembler instructions. OPERANDS is the 3228 operand vector, OPORDER is the order to write the operands, and NOPS 3229 is the number of operands to write. */ 3230 3231static void | 2825 else if (GET_CODE (op) != MEM) 2826 return 0; 2827 2828 if (MEM_EXPR (op) != 0) 2829 return MEM_EXPR (op); 2830 2831 /* Otherwise we have an address, so indicate it and look at the address. */ 2832 *paddressp = 1; --- 16 unchanged lines hidden (view full) --- 2849 return inner_addressp ? 0 : expr; 2850} 2851 2852/* Output operand names for assembler instructions. OPERANDS is the 2853 operand vector, OPORDER is the order to write the operands, and NOPS 2854 is the number of operands to write. */ 2855 2856static void |
3232output_asm_operand_names (operands, oporder, nops) 3233 rtx *operands; 3234 int *oporder; 3235 int nops; | 2857output_asm_operand_names (rtx *operands, int *oporder, int nops) |
3236{ 3237 int wrote = 0; 3238 int i; 3239 3240 for (i = 0; i < nops; i++) 3241 { 3242 int addressp; | 2858{ 2859 int wrote = 0; 2860 int i; 2861 2862 for (i = 0; i < nops; i++) 2863 { 2864 int addressp; |
3243 tree expr = get_mem_expr_from_op (operands[oporder[i]], &addressp); | 2865 rtx op = operands[oporder[i]]; 2866 tree expr = get_mem_expr_from_op (op, &addressp); |
3244 | 2867 |
2868 fprintf (asm_out_file, "%c%s", 2869 wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START); 2870 wrote = 1; |
|
3245 if (expr) 3246 { | 2871 if (expr) 2872 { |
3247 fprintf (asm_out_file, "%c%s %s", 3248 wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START, | 2873 fprintf (asm_out_file, "%s", |
3249 addressp ? "*" : ""); 3250 print_mem_expr (asm_out_file, expr); 3251 wrote = 1; 3252 } | 2874 addressp ? "*" : ""); 2875 print_mem_expr (asm_out_file, expr); 2876 wrote = 1; 2877 } |
2878 else if (REG_P (op) && ORIGINAL_REGNO (op) 2879 && ORIGINAL_REGNO (op) != REGNO (op)) 2880 fprintf (asm_out_file, " tmp%i", ORIGINAL_REGNO (op)); |
|
3253 } 3254} 3255 3256/* Output text from TEMPLATE to the assembler output file, 3257 obeying %-directions to substitute operands taken from 3258 the vector OPERANDS. 3259 3260 %N (for N a digit) means print operand N in usual manner. --- 4 unchanged lines hidden (view full) --- 3265 %aN means expect operand N to be a memory address 3266 (not a memory reference!) and print a reference 3267 to that address. 3268 %nN means expect operand N to be a constant 3269 and print a constant expression for minus the value 3270 of the operand, with no other punctuation. */ 3271 3272void | 2881 } 2882} 2883 2884/* Output text from TEMPLATE to the assembler output file, 2885 obeying %-directions to substitute operands taken from 2886 the vector OPERANDS. 2887 2888 %N (for N a digit) means print operand N in usual manner. --- 4 unchanged lines hidden (view full) --- 2893 %aN means expect operand N to be a memory address 2894 (not a memory reference!) and print a reference 2895 to that address. 2896 %nN means expect operand N to be a constant 2897 and print a constant expression for minus the value 2898 of the operand, with no other punctuation. */ 2899 2900void |
3273output_asm_insn (template, operands) 3274 const char *template; 3275 rtx *operands; | 2901output_asm_insn (const char *template, rtx *operands) |
3276{ 3277 const char *p; 3278 int c; 3279#ifdef ASSEMBLER_DIALECT 3280 int dialect = 0; 3281#endif 3282 int oporder[MAX_RECOG_OPERANDS]; 3283 char opoutput[MAX_RECOG_OPERANDS]; --- 189 unchanged lines hidden (view full) --- 3473 output_asm_name (); 3474 3475 putc ('\n', asm_out_file); 3476} 3477 3478/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */ 3479 3480void | 2902{ 2903 const char *p; 2904 int c; 2905#ifdef ASSEMBLER_DIALECT 2906 int dialect = 0; 2907#endif 2908 int oporder[MAX_RECOG_OPERANDS]; 2909 char opoutput[MAX_RECOG_OPERANDS]; --- 189 unchanged lines hidden (view full) --- 3099 output_asm_name (); 3100 3101 putc ('\n', asm_out_file); 3102} 3103 3104/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */ 3105 3106void |
3481output_asm_label (x) 3482 rtx x; | 3107output_asm_label (rtx x) |
3483{ 3484 char buf[256]; 3485 3486 if (GET_CODE (x) == LABEL_REF) 3487 x = XEXP (x, 0); 3488 if (GET_CODE (x) == CODE_LABEL 3489 || (GET_CODE (x) == NOTE 3490 && NOTE_LINE_NUMBER (x) == NOTE_INSN_DELETED_LABEL)) --- 10 unchanged lines hidden (view full) --- 3501 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char 3502 between the % and the digits. 3503 When CODE is a non-letter, X is 0. 3504 3505 The meanings of the letters are machine-dependent and controlled 3506 by PRINT_OPERAND. */ 3507 3508static void | 3108{ 3109 char buf[256]; 3110 3111 if (GET_CODE (x) == LABEL_REF) 3112 x = XEXP (x, 0); 3113 if (GET_CODE (x) == CODE_LABEL 3114 || (GET_CODE (x) == NOTE 3115 && NOTE_LINE_NUMBER (x) == NOTE_INSN_DELETED_LABEL)) --- 10 unchanged lines hidden (view full) --- 3126 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char 3127 between the % and the digits. 3128 When CODE is a non-letter, X is 0. 3129 3130 The meanings of the letters are machine-dependent and controlled 3131 by PRINT_OPERAND. */ 3132 3133static void |
3509output_operand (x, code) 3510 rtx x; 3511 int code ATTRIBUTE_UNUSED; | 3134output_operand (rtx x, int code ATTRIBUTE_UNUSED) |
3512{ 3513 if (x && GET_CODE (x) == SUBREG) 3514 x = alter_subreg (&x); 3515 3516 /* If X is a pseudo-register, abort now rather than writing trash to the 3517 assembler file. */ 3518 3519 if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER) 3520 abort (); 3521 3522 PRINT_OPERAND (asm_out_file, x, code); 3523} 3524 3525/* Print a memory reference operand for address X 3526 using machine-dependent assembler syntax. 3527 The macro PRINT_OPERAND_ADDRESS exists just to control this function. */ 3528 3529void | 3135{ 3136 if (x && GET_CODE (x) == SUBREG) 3137 x = alter_subreg (&x); 3138 3139 /* If X is a pseudo-register, abort now rather than writing trash to the 3140 assembler file. */ 3141 3142 if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER) 3143 abort (); 3144 3145 PRINT_OPERAND (asm_out_file, x, code); 3146} 3147 3148/* Print a memory reference operand for address X 3149 using machine-dependent assembler syntax. 3150 The macro PRINT_OPERAND_ADDRESS exists just to control this function. */ 3151 3152void |
3530output_address (x) 3531 rtx x; | 3153output_address (rtx x) |
3532{ 3533 walk_alter_subreg (&x); 3534 PRINT_OPERAND_ADDRESS (asm_out_file, x); 3535} 3536 3537/* Print an integer constant expression in assembler syntax. 3538 Addition and subtraction are the only arithmetic 3539 that may appear in these expressions. */ 3540 3541void | 3154{ 3155 walk_alter_subreg (&x); 3156 PRINT_OPERAND_ADDRESS (asm_out_file, x); 3157} 3158 3159/* Print an integer constant expression in assembler syntax. 3160 Addition and subtraction are the only arithmetic 3161 that may appear in these expressions. */ 3162 3163void |
3542output_addr_const (file, x) 3543 FILE *file; 3544 rtx x; | 3164output_addr_const (FILE *file, rtx x) |
3545{ 3546 char buf[256]; 3547 3548 restart: 3549 switch (GET_CODE (x)) 3550 { 3551 case PC: 3552 putc ('.', file); --- 105 unchanged lines hidden (view full) --- 3658} 3659 3660/* A poor man's fprintf, with the added features of %I, %R, %L, and %U. 3661 %R prints the value of REGISTER_PREFIX. 3662 %L prints the value of LOCAL_LABEL_PREFIX. 3663 %U prints the value of USER_LABEL_PREFIX. 3664 %I prints the value of IMMEDIATE_PREFIX. 3665 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string. | 3165{ 3166 char buf[256]; 3167 3168 restart: 3169 switch (GET_CODE (x)) 3170 { 3171 case PC: 3172 putc ('.', file); --- 105 unchanged lines hidden (view full) --- 3278} 3279 3280/* A poor man's fprintf, with the added features of %I, %R, %L, and %U. 3281 %R prints the value of REGISTER_PREFIX. 3282 %L prints the value of LOCAL_LABEL_PREFIX. 3283 %U prints the value of USER_LABEL_PREFIX. 3284 %I prints the value of IMMEDIATE_PREFIX. 3285 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string. |
3666 Also supported are %d, %x, %s, %e, %f, %g and %%. | 3286 Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%. |
3667 3668 We handle alternate assembler dialects here, just like output_asm_insn. */ 3669 3670void | 3287 3288 We handle alternate assembler dialects here, just like output_asm_insn. */ 3289 3290void |
3671asm_fprintf VPARAMS ((FILE *file, const char *p, ...)) | 3291asm_fprintf (FILE *file, const char *p, ...) |
3672{ 3673 char buf[10]; 3674 char *q, c; | 3292{ 3293 char buf[10]; 3294 char *q, c; |
3295 va_list argptr; |
|
3675 | 3296 |
3676 VA_OPEN (argptr, p); 3677 VA_FIXEDARG (argptr, FILE *, file); 3678 VA_FIXEDARG (argptr, const char *, p); | 3297 va_start (argptr, p); |
3679 3680 buf[0] = '%'; 3681 3682 while ((c = *p++)) 3683 switch (c) 3684 { 3685#ifdef ASSEMBLER_DIALECT 3686 case '{': --- 21 unchanged lines hidden (view full) --- 3708 3709 case '}': 3710 break; 3711#endif 3712 3713 case '%': 3714 c = *p++; 3715 q = &buf[1]; | 3298 3299 buf[0] = '%'; 3300 3301 while ((c = *p++)) 3302 switch (c) 3303 { 3304#ifdef ASSEMBLER_DIALECT 3305 case '{': --- 21 unchanged lines hidden (view full) --- 3327 3328 case '}': 3329 break; 3330#endif 3331 3332 case '%': 3333 c = *p++; 3334 q = &buf[1]; |
3335 while (strchr ("-+ #0", c)) 3336 { 3337 *q++ = c; 3338 c = *p++; 3339 } |
|
3716 while (ISDIGIT (c) || c == '.') 3717 { 3718 *q++ = c; 3719 c = *p++; 3720 } 3721 switch (c) 3722 { 3723 case '%': | 3340 while (ISDIGIT (c) || c == '.') 3341 { 3342 *q++ = c; 3343 c = *p++; 3344 } 3345 switch (c) 3346 { 3347 case '%': |
3724 fprintf (file, "%%"); | 3348 putc ('%', file); |
3725 break; 3726 3727 case 'd': case 'i': case 'u': | 3349 break; 3350 3351 case 'd': case 'i': case 'u': |
3728 case 'x': case 'p': case 'X': 3729 case 'o': | 3352 case 'x': case 'X': case 'o': 3353 case 'c': |
3730 *q++ = c; 3731 *q = 0; 3732 fprintf (file, buf, va_arg (argptr, int)); 3733 break; 3734 3735 case 'w': | 3354 *q++ = c; 3355 *q = 0; 3356 fprintf (file, buf, va_arg (argptr, int)); 3357 break; 3358 3359 case 'w': |
3736 /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases, 3737 but we do not check for those cases. It means that the value 3738 is a HOST_WIDE_INT, which may be either `int' or `long'. */ 3739 3740#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT 3741#else 3742#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG 3743 *q++ = 'l'; 3744#else 3745 *q++ = 'l'; 3746 *q++ = 'l'; 3747#endif 3748#endif 3749 | 3360 /* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and 3361 'o' cases, but we do not check for those cases. It 3362 means that the value is a HOST_WIDE_INT, which may be 3363 either `long' or `long long'. */ 3364 memcpy (q, HOST_WIDE_INT_PRINT, strlen (HOST_WIDE_INT_PRINT)); 3365 q += strlen (HOST_WIDE_INT_PRINT); |
3750 *q++ = *p++; 3751 *q = 0; 3752 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT)); 3753 break; 3754 3755 case 'l': 3756 *q++ = c; | 3366 *q++ = *p++; 3367 *q = 0; 3368 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT)); 3369 break; 3370 3371 case 'l': 3372 *q++ = c; |
3757 *q++ = *p++; 3758 *q = 0; 3759 fprintf (file, buf, va_arg (argptr, long)); 3760 break; | 3373#ifdef HAVE_LONG_LONG 3374 if (*p == 'l') 3375 { 3376 *q++ = *p++; 3377 *q++ = *p++; 3378 *q = 0; 3379 fprintf (file, buf, va_arg (argptr, long long)); 3380 } 3381 else 3382#endif 3383 { 3384 *q++ = *p++; 3385 *q = 0; 3386 fprintf (file, buf, va_arg (argptr, long)); 3387 } |
3761 | 3388 |
3762 case 'e': 3763 case 'f': 3764 case 'g': 3765 *q++ = c; 3766 *q = 0; 3767 fprintf (file, buf, va_arg (argptr, double)); | |
3768 break; 3769 3770 case 's': 3771 *q++ = c; 3772 *q = 0; 3773 fprintf (file, buf, va_arg (argptr, char *)); 3774 break; 3775 --- 21 unchanged lines hidden (view full) --- 3797#endif 3798 break; 3799 3800 case 'U': 3801 fputs (user_label_prefix, file); 3802 break; 3803 3804#ifdef ASM_FPRINTF_EXTENSIONS | 3389 break; 3390 3391 case 's': 3392 *q++ = c; 3393 *q = 0; 3394 fprintf (file, buf, va_arg (argptr, char *)); 3395 break; 3396 --- 21 unchanged lines hidden (view full) --- 3418#endif 3419 break; 3420 3421 case 'U': 3422 fputs (user_label_prefix, file); 3423 break; 3424 3425#ifdef ASM_FPRINTF_EXTENSIONS |
3805 /* Upper case letters are reserved for general use by asm_fprintf | 3426 /* Uppercase letters are reserved for general use by asm_fprintf |
3806 and so are not available to target specific code. In order to 3807 prevent the ASM_FPRINTF_EXTENSIONS macro from using them then, 3808 they are defined here. As they get turned into real extensions 3809 to asm_fprintf they should be removed from this list. */ 3810 case 'A': case 'B': case 'C': case 'D': case 'E': 3811 case 'F': case 'G': case 'H': case 'J': case 'K': 3812 case 'M': case 'N': case 'P': case 'Q': case 'S': 3813 case 'T': case 'V': case 'W': case 'Y': case 'Z': 3814 break; 3815 3816 ASM_FPRINTF_EXTENSIONS (file, argptr, p) 3817#endif 3818 default: 3819 abort (); 3820 } 3821 break; 3822 3823 default: | 3427 and so are not available to target specific code. In order to 3428 prevent the ASM_FPRINTF_EXTENSIONS macro from using them then, 3429 they are defined here. As they get turned into real extensions 3430 to asm_fprintf they should be removed from this list. */ 3431 case 'A': case 'B': case 'C': case 'D': case 'E': 3432 case 'F': case 'G': case 'H': case 'J': case 'K': 3433 case 'M': case 'N': case 'P': case 'Q': case 'S': 3434 case 'T': case 'V': case 'W': case 'Y': case 'Z': 3435 break; 3436 3437 ASM_FPRINTF_EXTENSIONS (file, argptr, p) 3438#endif 3439 default: 3440 abort (); 3441 } 3442 break; 3443 3444 default: |
3824 fputc (c, file); | 3445 putc (c, file); |
3825 } | 3446 } |
3826 VA_CLOSE (argptr); | 3447 va_end (argptr); |
3827} 3828 3829/* Split up a CONST_DOUBLE or integer constant rtx 3830 into two rtx's for single words, 3831 storing in *FIRST the word that comes first in memory in the target 3832 and in *SECOND the other. */ 3833 3834void | 3448} 3449 3450/* Split up a CONST_DOUBLE or integer constant rtx 3451 into two rtx's for single words, 3452 storing in *FIRST the word that comes first in memory in the target 3453 and in *SECOND the other. */ 3454 3455void |
3835split_double (value, first, second) 3836 rtx value; 3837 rtx *first, *second; | 3456split_double (rtx value, rtx *first, rtx *second) |
3838{ 3839 if (GET_CODE (value) == CONST_INT) 3840 { 3841 if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD)) 3842 { 3843 /* In this case the CONST_INT holds both target words. 3844 Extract the bits from it into two word-sized pieces. 3845 Sign extend each half to HOST_WIDE_INT. */ --- 122 unchanged lines hidden (view full) --- 3968 *first = GEN_INT ((HOST_WIDE_INT) l[0]); 3969 *second = GEN_INT ((HOST_WIDE_INT) l[1]); 3970 } 3971} 3972 3973/* Return nonzero if this function has no function calls. */ 3974 3975int | 3457{ 3458 if (GET_CODE (value) == CONST_INT) 3459 { 3460 if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD)) 3461 { 3462 /* In this case the CONST_INT holds both target words. 3463 Extract the bits from it into two word-sized pieces. 3464 Sign extend each half to HOST_WIDE_INT. */ --- 122 unchanged lines hidden (view full) --- 3587 *first = GEN_INT ((HOST_WIDE_INT) l[0]); 3588 *second = GEN_INT ((HOST_WIDE_INT) l[1]); 3589 } 3590} 3591 3592/* Return nonzero if this function has no function calls. */ 3593 3594int |
3976leaf_function_p () | 3595leaf_function_p (void) |
3977{ 3978 rtx insn; 3979 rtx link; 3980 3981 if (current_function_profile || profile_arc_flag) 3982 return 0; 3983 3984 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) --- 26 unchanged lines hidden (view full) --- 4011 return 1; 4012} 4013 4014/* Return 1 if branch is a forward branch. 4015 Uses insn_shuid array, so it works only in the final pass. May be used by 4016 output templates to customary add branch prediction hints. 4017 */ 4018int | 3596{ 3597 rtx insn; 3598 rtx link; 3599 3600 if (current_function_profile || profile_arc_flag) 3601 return 0; 3602 3603 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) --- 26 unchanged lines hidden (view full) --- 3630 return 1; 3631} 3632 3633/* Return 1 if branch is a forward branch. 3634 Uses insn_shuid array, so it works only in the final pass. May be used by 3635 output templates to customary add branch prediction hints. 3636 */ 3637int |
4019final_forward_branch_p (insn) 4020 rtx insn; | 3638final_forward_branch_p (rtx insn) |
4021{ 4022 int insn_id, label_id; 4023 if (!uid_shuid) 4024 abort (); 4025 insn_id = INSN_SHUID (insn); 4026 label_id = INSN_SHUID (JUMP_LABEL (insn)); 4027 /* We've hit some insns that does not have id information available. */ 4028 if (!insn_id || !label_id) --- 11 unchanged lines hidden (view full) --- 4040 uses the "output" registers instead. */ 4041 4042#ifdef LEAF_REGISTERS 4043 4044/* Return 1 if this function uses only the registers that can be 4045 safely renumbered. */ 4046 4047int | 3639{ 3640 int insn_id, label_id; 3641 if (!uid_shuid) 3642 abort (); 3643 insn_id = INSN_SHUID (insn); 3644 label_id = INSN_SHUID (JUMP_LABEL (insn)); 3645 /* We've hit some insns that does not have id information available. */ 3646 if (!insn_id || !label_id) --- 11 unchanged lines hidden (view full) --- 3658 uses the "output" registers instead. */ 3659 3660#ifdef LEAF_REGISTERS 3661 3662/* Return 1 if this function uses only the registers that can be 3663 safely renumbered. */ 3664 3665int |
4048only_leaf_regs_used () | 3666only_leaf_regs_used (void) |
4049{ 4050 int i; | 3667{ 3668 int i; |
4051 char *permitted_reg_in_leaf_functions = LEAF_REGISTERS; | 3669 const char *const permitted_reg_in_leaf_functions = LEAF_REGISTERS; |
4052 4053 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 4054 if ((regs_ever_live[i] || global_regs[i]) 4055 && ! permitted_reg_in_leaf_functions[i]) 4056 return 0; 4057 4058 if (current_function_uses_pic_offset_table 4059 && pic_offset_table_rtx != 0 4060 && GET_CODE (pic_offset_table_rtx) == REG 4061 && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)]) 4062 return 0; 4063 4064 return 1; 4065} 4066 4067/* Scan all instructions and renumber all registers into those 4068 available in leaf functions. */ 4069 4070static void | 3670 3671 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 3672 if ((regs_ever_live[i] || global_regs[i]) 3673 && ! permitted_reg_in_leaf_functions[i]) 3674 return 0; 3675 3676 if (current_function_uses_pic_offset_table 3677 && pic_offset_table_rtx != 0 3678 && GET_CODE (pic_offset_table_rtx) == REG 3679 && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)]) 3680 return 0; 3681 3682 return 1; 3683} 3684 3685/* Scan all instructions and renumber all registers into those 3686 available in leaf functions. */ 3687 3688static void |
4071leaf_renumber_regs (first) 4072 rtx first; | 3689leaf_renumber_regs (rtx first) |
4073{ 4074 rtx insn; 4075 4076 /* Renumber only the actual patterns. 4077 The reg-notes can contain frame pointer refs, 4078 and renumbering them could crash, and should not be needed. */ 4079 for (insn = first; insn; insn = NEXT_INSN (insn)) 4080 if (INSN_P (insn)) --- 4 unchanged lines hidden (view full) --- 4085 if (INSN_P (XEXP (insn, 0))) 4086 leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0))); 4087} 4088 4089/* Scan IN_RTX and its subexpressions, and renumber all regs into those 4090 available in leaf functions. */ 4091 4092void | 3690{ 3691 rtx insn; 3692 3693 /* Renumber only the actual patterns. 3694 The reg-notes can contain frame pointer refs, 3695 and renumbering them could crash, and should not be needed. */ 3696 for (insn = first; insn; insn = NEXT_INSN (insn)) 3697 if (INSN_P (insn)) --- 4 unchanged lines hidden (view full) --- 3702 if (INSN_P (XEXP (insn, 0))) 3703 leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0))); 3704} 3705 3706/* Scan IN_RTX and its subexpressions, and renumber all regs into those 3707 available in leaf functions. */ 3708 3709void |
4093leaf_renumber_regs_insn (in_rtx) 4094 rtx in_rtx; | 3710leaf_renumber_regs_insn (rtx in_rtx) |
4095{ 4096 int i, j; 4097 const char *format_ptr; 4098 4099 if (in_rtx == 0) 4100 return; 4101 4102 /* Renumber all input-registers into output-registers. --- 60 unchanged lines hidden (view full) --- 4163 case 'u': 4164 break; 4165 4166 default: 4167 abort (); 4168 } 4169} 4170#endif | 3711{ 3712 int i, j; 3713 const char *format_ptr; 3714 3715 if (in_rtx == 0) 3716 return; 3717 3718 /* Renumber all input-registers into output-registers. --- 60 unchanged lines hidden (view full) --- 3779 case 'u': 3780 break; 3781 3782 default: 3783 abort (); 3784 } 3785} 3786#endif |
3787 3788 3789/* When -gused is used, emit debug info for only used symbols. But in 3790 addition to the standard intercepted debug_hooks there are some direct 3791 calls into this file, i.e., dbxout_symbol, dbxout_parms, and dbxout_reg_params. 3792 Those routines may also be called from a higher level intercepted routine. So 3793 to prevent recording data for an inner call to one of these for an intercept, 3794 we maintain an intercept nesting counter (debug_nesting). We only save the 3795 intercepted arguments if the nesting is 1. */ 3796int debug_nesting = 0; 3797 3798static tree *symbol_queue; 3799int symbol_queue_index = 0; 3800static int symbol_queue_size = 0; 3801 3802/* Generate the symbols for any queued up type symbols we encountered 3803 while generating the type info for some originally used symbol. 3804 This might generate additional entries in the queue. Only when 3805 the nesting depth goes to 0 is this routine called. */ 3806 3807void 3808debug_flush_symbol_queue (void) 3809{ 3810 int i; 3811 3812 /* Make sure that additionally queued items are not flushed 3813 prematurely. */ 3814 3815 ++debug_nesting; 3816 3817 for (i = 0; i < symbol_queue_index; ++i) 3818 { 3819 /* If we pushed queued symbols then such symbols are must be 3820 output no matter what anyone else says. Specifically, 3821 we need to make sure dbxout_symbol() thinks the symbol was 3822 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG 3823 which may be set for outside reasons. */ 3824 int saved_tree_used = TREE_USED (symbol_queue[i]); 3825 int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]); 3826 TREE_USED (symbol_queue[i]) = 1; 3827 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0; 3828 3829#ifdef DBX_DEBUGGING_INFO 3830 dbxout_symbol (symbol_queue[i], 0); 3831#endif 3832 3833 TREE_USED (symbol_queue[i]) = saved_tree_used; 3834 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug; 3835 } 3836 3837 symbol_queue_index = 0; 3838 --debug_nesting; 3839} 3840 3841/* Queue a type symbol needed as part of the definition of a decl 3842 symbol. These symbols are generated when debug_flush_symbol_queue() 3843 is called. */ 3844 3845void 3846debug_queue_symbol (tree decl) 3847{ 3848 if (symbol_queue_index >= symbol_queue_size) 3849 { 3850 symbol_queue_size += 10; 3851 symbol_queue = xrealloc (symbol_queue, 3852 symbol_queue_size * sizeof (tree)); 3853 } 3854 3855 symbol_queue[symbol_queue_index++] = decl; 3856} 3857 3858/* Free symbol queue. */ 3859void 3860debug_free_queue (void) 3861{ 3862 if (symbol_queue) 3863 { 3864 free (symbol_queue); 3865 symbol_queue = NULL; 3866 symbol_queue_size = 0; 3867 } 3868} |
|