1/* Top level of GCC compilers (cc1, cc1plus, etc.) 2 Copyright (C) 1987-2015 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING3. If not see 18<http://www.gnu.org/licenses/>. */ 19 20/* This is the top level of cc1/c++. 21 It parses command args, opens files, invokes the various passes 22 in the proper order, and counts the time used by each. 23 Error messages and low-level interface to malloc also handled here. */ 24 25#include "config.h" 26#include "system.h" 27#include "coretypes.h" 28#include "tm.h" 29#include "line-map.h" 30#include "input.h" 31#include "hash-set.h" 32#include "machmode.h" 33#include "vec.h" 34#include "double-int.h" 35#include "alias.h" 36#include "symtab.h" 37#include "wide-int.h" 38#include "inchash.h" 39#include "tree.h" 40#include "fold-const.h" 41#include "varasm.h" 42#include "tree-inline.h" 43#include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */ 44#include "version.h" 45#include "rtl.h" 46#include "tm_p.h" 47#include "flags.h" 48#include "insn-attr.h" 49#include "insn-config.h" 50#include "insn-flags.h" 51#include "hard-reg-set.h" 52#include "recog.h" 53#include "output.h" 54#include "except.h" 55#include "function.h" 56#include "toplev.h" 57#include "hashtab.h" 58#include "statistics.h" 59#include "real.h" 60#include "fixed-value.h" 61#include "expmed.h" 62#include "dojump.h" 63#include "explow.h" 64#include "calls.h" 65#include "emit-rtl.h" 66#include "stmt.h" 67#include "expr.h" 68#include "intl.h" 69#include "regs.h" 70#include "timevar.h" 71#include "diagnostic.h" 72#include "tree-diagnostic.h" 73#include "tree-pretty-print.h" 74#include "params.h" 75#include "reload.h" 76#include "ira.h" 77#include "lra.h" 78#include "dwarf2asm.h" 79#include "debug.h" 80#include "target.h" 81#include "common/common-target.h" 82#include "langhooks.h" 83#include "cfgloop.h" /* for init_set_costs */ 84#include "hosthooks.h" 85#include "predict.h" 86#include "basic-block.h" 87#include "hash-map.h" 88#include "is-a.h" 89#include "plugin-api.h" 90#include "ipa-ref.h" 91#include "cgraph.h" 92#include "opts.h" 93#include "opts-diagnostic.h" 94#include "coverage.h" 95#include "value-prof.h" 96#include "alloc-pool.h" 97#include "asan.h" 98#include "tsan.h" 99#include "tree-ssa-alias.h" 100#include "internal-fn.h" 101#include "gimple-expr.h" 102#include "gimple.h" 103#include "plugin.h" 104#include "context.h" 105#include "pass_manager.h" 106#include "auto-profile.h" 107#include "dwarf2out.h" 108#include "bitmap.h" 109#include "ipa-reference.h" 110#include "symbol-summary.h" 111#include "ipa-prop.h" 112#include "gcse.h" 113#include "insn-codes.h" 114#include "optabs.h" 115#include "tree-chkp.h" 116#include "omp-low.h" 117 118#if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) 119#include "dbxout.h" 120#endif 121 122#ifdef SDB_DEBUGGING_INFO 123#include "sdbout.h" 124#endif 125 126#ifdef XCOFF_DEBUGGING_INFO 127#include "xcoffout.h" /* Needed for external data 128 declarations for e.g. AIX 4.x. */ 129#endif 130 131#ifndef HAVE_epilogue 132#define HAVE_epilogue 0 133#endif 134#ifndef HAVE_prologue 135#define HAVE_prologue 0 136#endif 137 138#include <new> 139 140static void general_init (const char *, bool); 141static void do_compile (); 142static void process_options (void); 143static void backend_init (void); 144static int lang_dependent_init (const char *); 145static void init_asm_output (const char *); 146static void finalize (bool); 147 148static void crash_signal (int) ATTRIBUTE_NORETURN; 149static void compile_file (void); 150 151/* True if we don't need a backend (e.g. preprocessing only). */ 152static bool no_backend; 153 154/* Length of line when printing switch values. */ 155#define MAX_LINE 75 156 157/* Decoded options, and number of such options. */ 158struct cl_decoded_option *save_decoded_options; 159unsigned int save_decoded_options_count; 160 161/* Used to enable -fvar-tracking, -fweb and -frename-registers according 162 to optimize in process_options (). */ 163#define AUTODETECT_VALUE 2 164 165/* Debug hooks - dependent upon command line options. */ 166 167const struct gcc_debug_hooks *debug_hooks; 168 169/* The FUNCTION_DECL for the function currently being compiled, 170 or 0 if between functions. */ 171tree current_function_decl; 172 173/* Set to the FUNC_BEGIN label of the current function, or NULL 174 if none. */ 175const char * current_function_func_begin_label; 176 177/* A random sequence of characters, unless overridden by user. */ 178static const char *flag_random_seed; 179 180/* A local time stamp derived from the time of compilation. It will be 181 zero if the system cannot provide a time. It will be -1u, if the 182 user has specified a particular random seed. */ 183unsigned local_tick; 184 185/* Random number for this compilation */ 186HOST_WIDE_INT random_seed; 187 188/* -f flags. */ 189 190/* When non-NULL, indicates that whenever space is allocated on the 191 stack, the resulting stack pointer must not pass this 192 address---that is, for stacks that grow downward, the stack pointer 193 must always be greater than or equal to this address; for stacks 194 that grow upward, the stack pointer must be less than this address. 195 At present, the rtx may be either a REG or a SYMBOL_REF, although 196 the support provided depends on the backend. */ 197rtx stack_limit_rtx; 198 199/* True if the user has tagged the function with the 'section' 200 attribute. */ 201 202bool user_defined_section_attribute = false; 203 204struct target_flag_state default_target_flag_state; 205#if SWITCHABLE_TARGET 206struct target_flag_state *this_target_flag_state = &default_target_flag_state; 207#else 208#define this_target_flag_state (&default_target_flag_state) 209#endif 210 211/* The user symbol prefix after having resolved same. */ 212const char *user_label_prefix; 213 214/* Output files for assembler code (real compiler output) 215 and debugging dumps. */ 216 217FILE *asm_out_file; 218FILE *aux_info_file; 219FILE *stack_usage_file = NULL; 220 221/* The current working directory of a translation. It's generally the 222 directory from which compilation was initiated, but a preprocessed 223 file may specify the original directory in which it was 224 created. */ 225 226static const char *src_pwd; 227 228/* Initialize src_pwd with the given string, and return true. If it 229 was already initialized, return false. As a special case, it may 230 be called with a NULL argument to test whether src_pwd has NOT been 231 initialized yet. */ 232 233bool 234set_src_pwd (const char *pwd) 235{ 236 if (src_pwd) 237 { 238 if (strcmp (src_pwd, pwd) == 0) 239 return true; 240 else 241 return false; 242 } 243 244 src_pwd = xstrdup (pwd); 245 return true; 246} 247 248/* Return the directory from which the translation unit was initiated, 249 in case set_src_pwd() was not called before to assign it a 250 different value. */ 251 252const char * 253get_src_pwd (void) 254{ 255 if (! src_pwd) 256 { 257 src_pwd = getpwd (); 258 if (!src_pwd) 259 src_pwd = "."; 260 } 261 262 return src_pwd; 263} 264 265/* Called when the start of a function definition is parsed, 266 this function prints on stderr the name of the function. */ 267void 268announce_function (tree decl) 269{ 270 if (!quiet_flag) 271 { 272 if (rtl_dump_and_exit) 273 fprintf (stderr, "%s ", 274 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))); 275 else 276 fprintf (stderr, " %s", 277 identifier_to_locale (lang_hooks.decl_printable_name (decl, 2))); 278 fflush (stderr); 279 pp_needs_newline (global_dc->printer) = true; 280 diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL); 281 } 282} 283 284/* Initialize local_tick with a random number or -1 if 285 flag_random_seed is set. */ 286 287static void 288init_local_tick (void) 289{ 290 if (!flag_random_seed) 291 { 292 /* Try urandom first. Time of day is too likely to collide. 293 In case of any error we just use the local tick. */ 294 295 int fd = open ("/dev/urandom", O_RDONLY); 296 if (fd >= 0) 297 { 298 if (read (fd, &random_seed, sizeof (random_seed)) 299 != sizeof (random_seed)) 300 random_seed = 0; 301 close (fd); 302 } 303 304 /* Now get the tick anyways */ 305#ifdef HAVE_GETTIMEOFDAY 306 { 307 struct timeval tv; 308 309 gettimeofday (&tv, NULL); 310 local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000; 311 } 312#else 313 { 314 time_t now = time (NULL); 315 316 if (now != (time_t)-1) 317 local_tick = (unsigned) now; 318 } 319#endif 320 } 321 else 322 local_tick = -1; 323} 324 325/* Set up a default flag_random_seed and local_tick, unless the user 326 already specified one. Must be called after init_local_tick. */ 327 328static void 329init_random_seed (void) 330{ 331 if (!random_seed) 332 random_seed = local_tick ^ getpid (); /* Old racey fallback method */ 333} 334 335/* Obtain the random_seed. Unless NOINIT, initialize it if 336 it's not provided in the command line. */ 337 338HOST_WIDE_INT 339get_random_seed (bool noinit) 340{ 341 if (!flag_random_seed && !noinit) 342 init_random_seed (); 343 return random_seed; 344} 345 346/* Modify the random_seed string to VAL. Return its previous 347 value. */ 348 349const char * 350set_random_seed (const char *val) 351{ 352 const char *old = flag_random_seed; 353 flag_random_seed = val; 354 if (flag_random_seed) 355 { 356 char *endp; 357 358 /* When the driver passed in a hex number don't crc it again */ 359 random_seed = strtoul (flag_random_seed, &endp, 0); 360 if (!(endp > flag_random_seed && *endp == 0)) 361 random_seed = crc32_string (0, flag_random_seed); 362 } 363 return old; 364} 365 366/* Handler for fatal signals, such as SIGSEGV. These are transformed 367 into ICE messages, which is much more user friendly. In case the 368 error printer crashes, reset the signal to prevent infinite recursion. */ 369 370static void 371crash_signal (int signo) 372{ 373 signal (signo, SIG_DFL); 374 375 /* If we crashed while processing an ASM statement, then be a little more 376 graceful. It's most likely the user's fault. */ 377 if (this_is_asm_operands) 378 { 379 output_operand_lossage ("unrecoverable error"); 380 exit (FATAL_EXIT_CODE); 381 } 382 383 internal_error ("%s", strsignal (signo)); 384} 385 386/* A subroutine of wrapup_global_declarations. We've come to the end of 387 the compilation unit. All deferred variables should be undeferred, 388 and all incomplete decls should be finalized. */ 389 390void 391wrapup_global_declaration_1 (tree decl) 392{ 393 /* We're not deferring this any longer. Assignment is conditional to 394 avoid needlessly dirtying PCH pages. */ 395 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS) 396 && DECL_DEFER_OUTPUT (decl) != 0) 397 DECL_DEFER_OUTPUT (decl) = 0; 398 399 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0) 400 lang_hooks.finish_incomplete_decl (decl); 401} 402 403/* A subroutine of wrapup_global_declarations. Decide whether or not DECL 404 needs to be output. Return true if it is output. */ 405 406bool 407wrapup_global_declaration_2 (tree decl) 408{ 409 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl) 410 || (TREE_CODE (decl) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (decl))) 411 return false; 412 413 /* Don't write out static consts, unless we still need them. 414 415 We also keep static consts if not optimizing (for debugging), 416 unless the user specified -fno-keep-static-consts. 417 ??? They might be better written into the debug information. 418 This is possible when using DWARF. 419 420 A language processor that wants static constants to be always 421 written out (even if it is not used) is responsible for 422 calling rest_of_decl_compilation itself. E.g. the C front-end 423 calls rest_of_decl_compilation from finish_decl. 424 One motivation for this is that is conventional in some 425 environments to write things like: 426 static const char rcsid[] = "... version string ..."; 427 intending to force the string to be in the executable. 428 429 A language processor that would prefer to have unneeded 430 static constants "optimized away" would just defer writing 431 them out until here. E.g. C++ does this, because static 432 constants are often defined in header files. 433 434 ??? A tempting alternative (for both C and C++) would be 435 to force a constant to be written if and only if it is 436 defined in a main file, as opposed to an include file. */ 437 438 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 439 { 440 varpool_node *node; 441 bool needed = true; 442 node = varpool_node::get (decl); 443 444 if (!node && flag_ltrans) 445 needed = false; 446 else if (node && node->definition) 447 needed = false; 448 else if (node && node->alias) 449 needed = false; 450 else if (!symtab->global_info_ready 451 && (TREE_USED (decl) 452 || TREE_USED (DECL_ASSEMBLER_NAME (decl)))) 453 /* needed */; 454 else if (node && node->analyzed) 455 /* needed */; 456 else if (DECL_COMDAT (decl)) 457 needed = false; 458 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl) 459 && (optimize || !flag_keep_static_consts 460 || DECL_ARTIFICIAL (decl))) 461 needed = false; 462 463 if (needed) 464 { 465 rest_of_decl_compilation (decl, 1, 1); 466 return true; 467 } 468 } 469 470 return false; 471} 472 473/* Do any final processing required for the declarations in VEC, of 474 which there are LEN. We write out inline functions and variables 475 that have been deferred until this point, but which are required. 476 Returns nonzero if anything was put out. */ 477 478bool 479wrapup_global_declarations (tree *vec, int len) 480{ 481 bool reconsider, output_something = false; 482 int i; 483 484 for (i = 0; i < len; i++) 485 wrapup_global_declaration_1 (vec[i]); 486 487 /* Now emit any global variables or functions that we have been 488 putting off. We need to loop in case one of the things emitted 489 here references another one which comes earlier in the list. */ 490 do 491 { 492 reconsider = false; 493 for (i = 0; i < len; i++) 494 reconsider |= wrapup_global_declaration_2 (vec[i]); 495 if (reconsider) 496 output_something = true; 497 } 498 while (reconsider); 499 500 return output_something; 501} 502 503/* A subroutine of check_global_declarations. Issue appropriate warnings 504 for the global declaration DECL. */ 505 506void 507check_global_declaration_1 (tree decl) 508{ 509 /* Warn about any function declared static but not defined. We don't 510 warn about variables, because many programs have static variables 511 that exist only to get some text into the object file. */ 512 if (TREE_CODE (decl) == FUNCTION_DECL 513 && DECL_INITIAL (decl) == 0 514 && DECL_EXTERNAL (decl) 515 && ! DECL_ARTIFICIAL (decl) 516 && ! TREE_NO_WARNING (decl) 517 && ! TREE_PUBLIC (decl) 518 && (warn_unused_function 519 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))) 520 { 521 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 522 pedwarn (input_location, 0, "%q+F used but never defined", decl); 523 else 524 warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl); 525 /* This symbol is effectively an "extern" declaration now. */ 526 TREE_PUBLIC (decl) = 1; 527 } 528 529 /* Warn about static fns or vars defined but not used. */ 530 if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL) 531 /* We don't warn about "static const" variables because the 532 "rcs_id" idiom uses that construction. */ 533 || (warn_unused_variable 534 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl))) 535 && ! DECL_IN_SYSTEM_HEADER (decl) 536 && ! TREE_USED (decl) 537 /* The TREE_USED bit for file-scope decls is kept in the identifier, 538 to handle multiple external decls in different scopes. */ 539 && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))) 540 && ! DECL_EXTERNAL (decl) 541 && ! TREE_PUBLIC (decl) 542 /* A volatile variable might be used in some non-obvious way. */ 543 && ! TREE_THIS_VOLATILE (decl) 544 /* Global register variables must be declared to reserve them. */ 545 && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) 546 /* Otherwise, ask the language. */ 547 && lang_hooks.decls.warn_unused_global (decl)) 548 warning ((TREE_CODE (decl) == FUNCTION_DECL) 549 ? OPT_Wunused_function 550 : OPT_Wunused_variable, 551 "%q+D defined but not used", decl); 552} 553 554/* Issue appropriate warnings for the global declarations in V (of 555 which there are LEN). */ 556 557void 558check_global_declarations (tree *v, int len) 559{ 560 int i; 561 562 for (i = 0; i < len; i++) 563 check_global_declaration_1 (v[i]); 564} 565 566/* Emit debugging information for all global declarations in VEC. */ 567 568void 569emit_debug_global_declarations (tree *vec, int len) 570{ 571 int i; 572 573 /* Avoid confusing the debug information machinery when there are errors. */ 574 if (seen_error ()) 575 return; 576 577 timevar_push (TV_SYMOUT); 578 for (i = 0; i < len; i++) 579 debug_hooks->global_decl (vec[i]); 580 timevar_pop (TV_SYMOUT); 581} 582 583/* Compile an entire translation unit. Write a file of assembly 584 output and various debugging dumps. */ 585 586static void 587compile_file (void) 588{ 589 timevar_start (TV_PHASE_PARSING); 590 timevar_push (TV_PARSE_GLOBAL); 591 592 /* Call the parser, which parses the entire file (calling 593 rest_of_compilation for each function). */ 594 lang_hooks.parse_file (); 595 596 timevar_pop (TV_PARSE_GLOBAL); 597 timevar_stop (TV_PHASE_PARSING); 598 599 /* Compilation is now finished except for writing 600 what's left of the symbol table output. */ 601 602 if (flag_syntax_only || flag_wpa) 603 return; 604 605 /* Reset maximum_field_alignment, it can be adjusted by #pragma pack 606 and this shouldn't influence any types built by the middle-end 607 from now on (like gcov_info_type). */ 608 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT; 609 610 ggc_protect_identifiers = false; 611 612 /* This must also call finalize_compilation_unit. */ 613 lang_hooks.decls.final_write_globals (); 614 615 if (seen_error ()) 616 return; 617 618 timevar_start (TV_PHASE_LATE_ASM); 619 620 /* Compilation unit is finalized. When producing non-fat LTO object, we are 621 basically finished. */ 622 if (in_lto_p || !flag_lto || flag_fat_lto_objects) 623 { 624 /* File-scope initialization for AddressSanitizer. */ 625 if (flag_sanitize & SANITIZE_ADDRESS) 626 asan_finish_file (); 627 628 if (flag_sanitize & SANITIZE_THREAD) 629 tsan_finish_file (); 630 631 if (flag_check_pointer_bounds) 632 chkp_finish_file (); 633 634 omp_finish_file (); 635 636 output_shared_constant_pool (); 637 output_object_blocks (); 638 finish_tm_clone_pairs (); 639 640 /* Write out any pending weak symbol declarations. */ 641 weak_finish (); 642 643 /* This must be at the end before unwind and debug info. 644 Some target ports emit PIC setup thunks here. */ 645 targetm.asm_out.code_end (); 646 647 /* Do dbx symbols. */ 648 timevar_push (TV_SYMOUT); 649 650 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO 651 if (dwarf2out_do_frame ()) 652 dwarf2out_frame_finish (); 653 #endif 654 655 (*debug_hooks->finish) (main_input_filename); 656 timevar_pop (TV_SYMOUT); 657 658 /* Output some stuff at end of file if nec. */ 659 660 dw2_output_indirect_constants (); 661 662 /* Flush any pending external directives. */ 663 process_pending_assemble_externals (); 664 } 665 666 /* Emit LTO marker if LTO info has been previously emitted. This is 667 used by collect2 to determine whether an object file contains IL. 668 We used to emit an undefined reference here, but this produces 669 link errors if an object file with IL is stored into a shared 670 library without invoking lto1. */ 671 if (flag_generate_lto || flag_generate_offload) 672 { 673#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON 674 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, 675 "__gnu_lto_v1", 676 (unsigned HOST_WIDE_INT) 1, 8); 677#elif defined ASM_OUTPUT_ALIGNED_COMMON 678 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1", 679 (unsigned HOST_WIDE_INT) 1, 8); 680#else 681 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1", 682 (unsigned HOST_WIDE_INT) 1, 683 (unsigned HOST_WIDE_INT) 1); 684#endif 685 } 686 687 /* Let linker plugin know that this is a slim object and must be LTOed 688 even when user did not ask for it. */ 689 if (flag_generate_lto && !flag_fat_lto_objects) 690 { 691#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON 692 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim", 693 (unsigned HOST_WIDE_INT) 1, 8); 694#elif defined ASM_OUTPUT_ALIGNED_COMMON 695 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim", 696 (unsigned HOST_WIDE_INT) 1, 8); 697#else 698 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim", 699 (unsigned HOST_WIDE_INT) 1, 700 (unsigned HOST_WIDE_INT) 1); 701#endif 702 } 703 704 /* Attach a special .ident directive to the end of the file to identify 705 the version of GCC which compiled this code. The format of the .ident 706 string is patterned after the ones produced by native SVR4 compilers. */ 707 if (!flag_no_ident) 708 { 709 const char *pkg_version = "(GNU) "; 710 char *ident_str; 711 712 if (strcmp ("(GCC) ", pkgversion_string)) 713 pkg_version = pkgversion_string; 714 715 ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL)); 716 targetm.asm_out.output_ident (ident_str); 717 } 718 719 /* Auto profile finalization. */ 720 if (flag_auto_profile) 721 end_auto_profile (); 722 723 /* Invoke registered plugin callbacks. */ 724 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL); 725 726 /* This must be at the end. Some target ports emit end of file directives 727 into the assembly file here, and hence we can not output anything to the 728 assembly file after this point. */ 729 targetm.asm_out.file_end (); 730 731 timevar_stop (TV_PHASE_LATE_ASM); 732} 733 734/* Print version information to FILE. 735 Each line begins with INDENT (for the case where FILE is the 736 assembler output file). 737 738 If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler 739 proper and can print pertinent state (e.g. params and plugins). 740 741 If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the 742 compiler, and we don't hold the mutex on the compiler's global state: 743 we can't print params and plugins, since they might not be initialized, 744 or might be being manipulated by a compile running in another 745 thread. */ 746 747void 748print_version (FILE *file, const char *indent, bool show_global_state) 749{ 750 static const char fmt1[] = 751#ifdef __GNUC__ 752 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ") 753#else 754 N_("%s%s%s %sversion %s (%s) compiled by CC, ") 755#endif 756 ; 757 static const char fmt2[] = 758 N_("GMP version %s, MPFR version %s, MPC version %s\n"); 759 static const char fmt3[] = 760 N_("%s%swarning: %s header version %s differs from library version %s.\n"); 761 static const char fmt4[] = 762 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"); 763#ifndef __VERSION__ 764#define __VERSION__ "[?]" 765#endif 766 fprintf (file, 767 file == stderr ? _(fmt1) : fmt1, 768 indent, *indent != 0 ? " " : "", 769 lang_hooks.name, pkgversion_string, version_string, TARGET_NAME, 770 indent, __VERSION__); 771 772 /* We need to stringify the GMP macro values. Ugh, gmp_version has 773 two string formats, "i.j.k" and "i.j" when k is zero. As of 774 gmp-4.3.0, GMP always uses the 3 number format. */ 775#define GCC_GMP_STRINGIFY_VERSION3(X) #X 776#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X) 777#define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z)) 778#define GCC_GMP_VERSION \ 779 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL) 780#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0 781#define GCC_GMP_STRINGIFY_VERSION \ 782 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ 783 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) 784#else 785#define GCC_GMP_STRINGIFY_VERSION \ 786 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ 787 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \ 788 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL) 789#endif 790 fprintf (file, 791 file == stderr ? _(fmt2) : fmt2, 792 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING); 793 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version)) 794 fprintf (file, 795 file == stderr ? _(fmt3) : fmt3, 796 indent, *indent != 0 ? " " : "", 797 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version); 798 if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ())) 799 fprintf (file, 800 file == stderr ? _(fmt3) : fmt3, 801 indent, *indent != 0 ? " " : "", 802 "MPFR", MPFR_VERSION_STRING, mpfr_get_version ()); 803 if (strcmp (MPC_VERSION_STRING, mpc_get_version ())) 804 fprintf (file, 805 file == stderr ? _(fmt3) : fmt3, 806 indent, *indent != 0 ? " " : "", 807 "MPC", MPC_VERSION_STRING, mpc_get_version ()); 808 809 if (show_global_state) 810 { 811 fprintf (file, 812 file == stderr ? _(fmt4) : fmt4, 813 indent, *indent != 0 ? " " : "", 814 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE)); 815 816 print_plugins_versions (file, indent); 817 } 818} 819 820static int 821print_to_asm_out_file (print_switch_type type, const char * text) 822{ 823 bool prepend_sep = true; 824 825 switch (type) 826 { 827 case SWITCH_TYPE_LINE_END: 828 putc ('\n', asm_out_file); 829 return 1; 830 831 case SWITCH_TYPE_LINE_START: 832 fputs (ASM_COMMENT_START, asm_out_file); 833 return strlen (ASM_COMMENT_START); 834 835 case SWITCH_TYPE_DESCRIPTIVE: 836 if (ASM_COMMENT_START[0] == 0) 837 prepend_sep = false; 838 /* Drop through. */ 839 case SWITCH_TYPE_PASSED: 840 case SWITCH_TYPE_ENABLED: 841 if (prepend_sep) 842 fputc (' ', asm_out_file); 843 fputs (text, asm_out_file); 844 /* No need to return the length here as 845 print_single_switch has already done it. */ 846 return 0; 847 848 default: 849 return -1; 850 } 851} 852 853static int 854print_to_stderr (print_switch_type type, const char * text) 855{ 856 switch (type) 857 { 858 case SWITCH_TYPE_LINE_END: 859 putc ('\n', stderr); 860 return 1; 861 862 case SWITCH_TYPE_LINE_START: 863 return 0; 864 865 case SWITCH_TYPE_PASSED: 866 case SWITCH_TYPE_ENABLED: 867 fputc (' ', stderr); 868 /* Drop through. */ 869 870 case SWITCH_TYPE_DESCRIPTIVE: 871 fputs (text, stderr); 872 /* No need to return the length here as 873 print_single_switch has already done it. */ 874 return 0; 875 876 default: 877 return -1; 878 } 879} 880 881/* Print an option value and return the adjusted position in the line. 882 ??? print_fn doesn't handle errors, eg disk full; presumably other 883 code will catch a disk full though. */ 884 885static int 886print_single_switch (print_switch_fn_type print_fn, 887 int pos, 888 print_switch_type type, 889 const char * text) 890{ 891 /* The ultrix fprintf returns 0 on success, so compute the result 892 we want here since we need it for the following test. The +1 893 is for the separator character that will probably be emitted. */ 894 int len = strlen (text) + 1; 895 896 if (pos != 0 897 && pos + len > MAX_LINE) 898 { 899 print_fn (SWITCH_TYPE_LINE_END, NULL); 900 pos = 0; 901 } 902 903 if (pos == 0) 904 pos += print_fn (SWITCH_TYPE_LINE_START, NULL); 905 906 print_fn (type, text); 907 return pos + len; 908} 909 910/* Print active target switches using PRINT_FN. 911 POS is the current cursor position and MAX is the size of a "line". 912 Each line begins with INDENT and ends with TERM. 913 Each switch is separated from the next by SEP. */ 914 915static void 916print_switch_values (print_switch_fn_type print_fn) 917{ 918 int pos = 0; 919 size_t j; 920 921 /* Fill in the -frandom-seed option, if the user didn't pass it, so 922 that it can be printed below. This helps reproducibility. */ 923 if (!flag_random_seed) 924 init_random_seed (); 925 926 /* Print the options as passed. */ 927 pos = print_single_switch (print_fn, pos, 928 SWITCH_TYPE_DESCRIPTIVE, _("options passed: ")); 929 930 for (j = 1; j < save_decoded_options_count; j++) 931 { 932 switch (save_decoded_options[j].opt_index) 933 { 934 case OPT_o: 935 case OPT_d: 936 case OPT_dumpbase: 937 case OPT_dumpdir: 938 case OPT_auxbase: 939 case OPT_quiet: 940 case OPT_version: 941 /* Ignore these. */ 942 continue; 943 } 944 945 pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, 946 save_decoded_options[j].orig_option_with_args_text); 947 } 948 949 if (pos > 0) 950 print_fn (SWITCH_TYPE_LINE_END, NULL); 951 952 /* Print the -f and -m options that have been enabled. 953 We don't handle language specific options but printing argv 954 should suffice. */ 955 pos = print_single_switch (print_fn, 0, 956 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: ")); 957 958 for (j = 0; j < cl_options_count; j++) 959 if (cl_options[j].cl_report 960 && option_enabled (j, &global_options) > 0) 961 pos = print_single_switch (print_fn, pos, 962 SWITCH_TYPE_ENABLED, cl_options[j].opt_text); 963 964 print_fn (SWITCH_TYPE_LINE_END, NULL); 965} 966 967/* Open assembly code output file. Do this even if -fsyntax-only is 968 on, because then the driver will have provided the name of a 969 temporary file or bit bucket for us. NAME is the file specified on 970 the command line, possibly NULL. */ 971static void 972init_asm_output (const char *name) 973{ 974 if (name == NULL && asm_file_name == 0) 975 asm_out_file = stdout; 976 else 977 { 978 if (asm_file_name == 0) 979 { 980 int len = strlen (dump_base_name); 981 char *dumpname = XNEWVEC (char, len + 6); 982 983 memcpy (dumpname, dump_base_name, len + 1); 984 strip_off_ending (dumpname, len); 985 strcat (dumpname, ".s"); 986 asm_file_name = dumpname; 987 } 988 if (!strcmp (asm_file_name, "-")) 989 asm_out_file = stdout; 990 else if (!canonical_filename_eq (asm_file_name, name) 991 || !strcmp (asm_file_name, HOST_BIT_BUCKET)) 992 asm_out_file = fopen (asm_file_name, "w"); 993 else 994 /* Use UNKOWN_LOCATION to prevent gcc from printing the first 995 line in the current file. */ 996 fatal_error (UNKNOWN_LOCATION, 997 "input file %qs is the same as output file", 998 asm_file_name); 999 if (asm_out_file == 0) 1000 fatal_error (UNKNOWN_LOCATION, 1001 "can%'t open %qs for writing: %m", asm_file_name); 1002 } 1003 1004 if (!flag_syntax_only) 1005 { 1006 targetm.asm_out.file_start (); 1007 1008 if (flag_record_gcc_switches) 1009 { 1010 if (targetm.asm_out.record_gcc_switches) 1011 { 1012 /* Let the target know that we are about to start recording. */ 1013 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE, 1014 NULL); 1015 /* Now record the switches. */ 1016 print_switch_values (targetm.asm_out.record_gcc_switches); 1017 /* Let the target know that the recording is over. */ 1018 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE, 1019 NULL); 1020 } 1021 else 1022 inform (input_location, "-frecord-gcc-switches is not supported by the current target"); 1023 } 1024 1025 if (flag_verbose_asm) 1026 { 1027 /* Print the list of switches in effect 1028 into the assembler file as comments. */ 1029 print_version (asm_out_file, ASM_COMMENT_START, true); 1030 print_switch_values (print_to_asm_out_file); 1031 putc ('\n', asm_out_file); 1032 } 1033 } 1034} 1035 1036/* A helper function; used as the reallocator function for cpp's line 1037 table. */ 1038static void * 1039realloc_for_line_map (void *ptr, size_t len) 1040{ 1041 return ggc_realloc (ptr, len); 1042} 1043 1044/* A helper function: used as the allocator function for 1045 identifier_to_locale. */ 1046static void * 1047alloc_for_identifier_to_locale (size_t len) 1048{ 1049 return ggc_alloc_atomic (len); 1050} 1051 1052/* Output stack usage information. */ 1053void 1054output_stack_usage (void) 1055{ 1056 static bool warning_issued = false; 1057 enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED }; 1058 const char *stack_usage_kind_str[] = { 1059 "static", 1060 "dynamic", 1061 "dynamic,bounded" 1062 }; 1063 HOST_WIDE_INT stack_usage = current_function_static_stack_size; 1064 enum stack_usage_kind_type stack_usage_kind; 1065 1066 if (stack_usage < 0) 1067 { 1068 if (!warning_issued) 1069 { 1070 warning (0, "stack usage computation not supported for this target"); 1071 warning_issued = true; 1072 } 1073 return; 1074 } 1075 1076 stack_usage_kind = STATIC; 1077 1078 /* Add the maximum amount of space pushed onto the stack. */ 1079 if (current_function_pushed_stack_size > 0) 1080 { 1081 stack_usage += current_function_pushed_stack_size; 1082 stack_usage_kind = DYNAMIC_BOUNDED; 1083 } 1084 1085 /* Now on to the tricky part: dynamic stack allocation. */ 1086 if (current_function_allocates_dynamic_stack_space) 1087 { 1088 if (current_function_has_unbounded_dynamic_stack_size) 1089 stack_usage_kind = DYNAMIC; 1090 else 1091 stack_usage_kind = DYNAMIC_BOUNDED; 1092 1093 /* Add the size even in the unbounded case, this can't hurt. */ 1094 stack_usage += current_function_dynamic_stack_size; 1095 } 1096 1097 if (flag_stack_usage) 1098 { 1099 expanded_location loc 1100 = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); 1101 /* We don't want to print the full qualified name because it can be long, 1102 so we strip the scope prefix, but we may need to deal with the suffix 1103 created by the compiler. */ 1104 const char *suffix 1105 = strchr (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), '.'); 1106 const char *name 1107 = lang_hooks.decl_printable_name (current_function_decl, 2); 1108 if (suffix) 1109 { 1110 const char *dot = strchr (name, '.'); 1111 while (dot && strcasecmp (dot, suffix) != 0) 1112 { 1113 name = dot + 1; 1114 dot = strchr (name, '.'); 1115 } 1116 } 1117 else 1118 { 1119 const char *dot = strrchr (name, '.'); 1120 if (dot) 1121 name = dot + 1; 1122 } 1123 1124 fprintf (stack_usage_file, 1125 "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC"\t%s\n", 1126 lbasename (loc.file), 1127 loc.line, 1128 loc.column, 1129 name, 1130 stack_usage, 1131 stack_usage_kind_str[stack_usage_kind]); 1132 } 1133 1134 if (warn_stack_usage >= 0) 1135 { 1136 const location_t loc = DECL_SOURCE_LOCATION (current_function_decl); 1137 1138 if (stack_usage_kind == DYNAMIC) 1139 warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded"); 1140 else if (stack_usage > warn_stack_usage) 1141 { 1142 if (stack_usage_kind == DYNAMIC_BOUNDED) 1143 warning_at (loc, 1144 OPT_Wstack_usage_, "stack usage might be %wd bytes", 1145 stack_usage); 1146 else 1147 warning_at (loc, OPT_Wstack_usage_, "stack usage is %wd bytes", 1148 stack_usage); 1149 } 1150 } 1151} 1152 1153/* Open an auxiliary output file. */ 1154static FILE * 1155open_auxiliary_file (const char *ext) 1156{ 1157 char *filename; 1158 FILE *file; 1159 1160 filename = concat (aux_base_name, ".", ext, NULL); 1161 file = fopen (filename, "w"); 1162 if (!file) 1163 fatal_error (input_location, "can%'t open %s for writing: %m", filename); 1164 free (filename); 1165 return file; 1166} 1167 1168/* Initialization of the front end environment, before command line 1169 options are parsed. Signal handlers, internationalization etc. 1170 ARGV0 is main's argv[0]. */ 1171static void 1172general_init (const char *argv0, bool init_signals) 1173{ 1174 const char *p; 1175 1176 p = argv0 + strlen (argv0); 1177 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1])) 1178 --p; 1179 progname = p; 1180 1181 xmalloc_set_program_name (progname); 1182 1183 hex_init (); 1184 1185 /* Unlock the stdio streams. */ 1186 unlock_std_streams (); 1187 1188 gcc_init_libintl (); 1189 1190 identifier_to_locale_alloc = alloc_for_identifier_to_locale; 1191 identifier_to_locale_free = ggc_free; 1192 1193 /* Initialize the diagnostics reporting machinery, so option parsing 1194 can give warnings and errors. */ 1195 diagnostic_initialize (global_dc, N_OPTS); 1196 /* Set a default printer. Language specific initializations will 1197 override it later. */ 1198 tree_diagnostics_defaults (global_dc); 1199 1200 global_dc->show_caret 1201 = global_options_init.x_flag_diagnostics_show_caret; 1202 global_dc->show_option_requested 1203 = global_options_init.x_flag_diagnostics_show_option; 1204 global_dc->show_column 1205 = global_options_init.x_flag_show_column; 1206 global_dc->internal_error = plugins_internal_error_function; 1207 global_dc->option_enabled = option_enabled; 1208 global_dc->option_state = &global_options; 1209 global_dc->option_name = option_name; 1210 1211 if (init_signals) 1212 { 1213 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */ 1214#ifdef SIGSEGV 1215 signal (SIGSEGV, crash_signal); 1216#endif 1217#ifdef SIGILL 1218 signal (SIGILL, crash_signal); 1219#endif 1220#ifdef SIGBUS 1221 signal (SIGBUS, crash_signal); 1222#endif 1223#ifdef SIGABRT 1224 signal (SIGABRT, crash_signal); 1225#endif 1226#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT) 1227 signal (SIGIOT, crash_signal); 1228#endif 1229#ifdef SIGFPE 1230 signal (SIGFPE, crash_signal); 1231#endif 1232 1233 /* Other host-specific signal setup. */ 1234 (*host_hooks.extra_signals)(); 1235 } 1236 1237 /* Initialize the garbage-collector, string pools and tree type hash 1238 table. */ 1239 init_ggc (); 1240 init_stringpool (); 1241 input_location = UNKNOWN_LOCATION; 1242 line_table = ggc_alloc<line_maps> (); 1243 linemap_init (line_table, BUILTINS_LOCATION); 1244 line_table->reallocator = realloc_for_line_map; 1245 line_table->round_alloc_size = ggc_round_alloc_size; 1246 init_ttree (); 1247 1248 /* Initialize register usage now so switches may override. */ 1249 init_reg_sets (); 1250 1251 /* Register the language-independent parameters. */ 1252 global_init_params (); 1253 1254 /* This must be done after global_init_params but before argument 1255 processing. */ 1256 init_ggc_heuristics (); 1257 1258 /* Create the singleton holder for global state. 1259 Doing so also creates the pass manager and with it the passes. */ 1260 g = new gcc::context (); 1261 symtab = new (ggc_cleared_alloc <symbol_table> ()) symbol_table (); 1262 1263 statistics_early_init (); 1264 finish_params (); 1265} 1266 1267/* Return true if the current target supports -fsection-anchors. */ 1268 1269static bool 1270target_supports_section_anchors_p (void) 1271{ 1272 if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0) 1273 return false; 1274 1275 if (targetm.asm_out.output_anchor == NULL) 1276 return false; 1277 1278 return true; 1279} 1280 1281/* Default the align_* variables to 1 if they're still unset, and 1282 set up the align_*_log variables. */ 1283static void 1284init_alignments (void) 1285{ 1286 if (align_loops <= 0) 1287 align_loops = 1; 1288 if (align_loops_max_skip > align_loops) 1289 align_loops_max_skip = align_loops - 1; 1290 align_loops_log = floor_log2 (align_loops * 2 - 1); 1291 if (align_jumps <= 0) 1292 align_jumps = 1; 1293 if (align_jumps_max_skip > align_jumps) 1294 align_jumps_max_skip = align_jumps - 1; 1295 align_jumps_log = floor_log2 (align_jumps * 2 - 1); 1296 if (align_labels <= 0) 1297 align_labels = 1; 1298 align_labels_log = floor_log2 (align_labels * 2 - 1); 1299 if (align_labels_max_skip > align_labels) 1300 align_labels_max_skip = align_labels - 1; 1301 if (align_functions <= 0) 1302 align_functions = 1; 1303 align_functions_log = floor_log2 (align_functions * 2 - 1); 1304} 1305 1306/* Process the options that have been parsed. */ 1307static void 1308process_options (void) 1309{ 1310 /* Just in case lang_hooks.post_options ends up calling a debug_hook. 1311 This can happen with incorrect pre-processed input. */ 1312 debug_hooks = &do_nothing_debug_hooks; 1313 1314 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT; 1315 1316 /* Allow the front end to perform consistency checks and do further 1317 initialization based on the command line options. This hook also 1318 sets the original filename if appropriate (e.g. foo.i -> foo.c) 1319 so we can correctly initialize debug output. */ 1320 no_backend = lang_hooks.post_options (&main_input_filename); 1321 1322 /* Some machines may reject certain combinations of options. */ 1323 targetm.target_option.override (); 1324 1325 /* Avoid any informative notes in the second run of -fcompare-debug. */ 1326 if (flag_compare_debug) 1327 diagnostic_inhibit_notes (global_dc); 1328 1329 if (flag_section_anchors && !target_supports_section_anchors_p ()) 1330 { 1331 warning (OPT_fsection_anchors, 1332 "this target does not support %qs", "-fsection-anchors"); 1333 flag_section_anchors = 0; 1334 } 1335 1336 if (flag_short_enums == 2) 1337 flag_short_enums = targetm.default_short_enums (); 1338 1339 /* Set aux_base_name if not already set. */ 1340 if (aux_base_name) 1341 ; 1342 else if (main_input_filename) 1343 { 1344 char *name = xstrdup (lbasename (main_input_filename)); 1345 1346 strip_off_ending (name, strlen (name)); 1347 aux_base_name = name; 1348 } 1349 else 1350 aux_base_name = "gccaux"; 1351 1352#ifndef HAVE_isl 1353 if (flag_graphite 1354 || flag_graphite_identity 1355 || flag_loop_block 1356 || flag_loop_interchange 1357 || flag_loop_strip_mine 1358 || flag_loop_parallelize_all 1359 || flag_loop_unroll_jam) 1360 sorry ("Graphite loop optimizations cannot be used (ISL is not available)" 1361 "(-fgraphite, -fgraphite-identity, -floop-block, " 1362 "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, " 1363 "-floop-unroll-and-jam, and -ftree-loop-linear)"); 1364#endif 1365 1366 if (flag_check_pointer_bounds) 1367 { 1368 if (targetm.chkp_bound_mode () == VOIDmode) 1369 { 1370 error ("-fcheck-pointer-bounds is not supported for this target"); 1371 flag_check_pointer_bounds = 0; 1372 } 1373 1374 if (flag_sanitize & SANITIZE_ADDRESS) 1375 { 1376 error ("-fcheck-pointer-bounds is not supported with " 1377 "Address Sanitizer"); 1378 flag_check_pointer_bounds = 0; 1379 } 1380 } 1381 1382 /* One region RA really helps to decrease the code size. */ 1383 if (flag_ira_region == IRA_REGION_AUTODETECT) 1384 flag_ira_region 1385 = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED; 1386 1387 if (!abi_version_at_least (2)) 1388 { 1389 /* -fabi-version=1 support was removed after GCC 4.9. */ 1390 error ("%<-fabi-version=1%> is no longer supported"); 1391 flag_abi_version = 2; 1392 } 1393 1394 /* Unrolling all loops implies that standard loop unrolling must also 1395 be done. */ 1396 if (flag_unroll_all_loops) 1397 flag_unroll_loops = 1; 1398 1399 /* web and rename-registers help when run after loop unrolling. */ 1400 if (flag_web == AUTODETECT_VALUE) 1401 flag_web = flag_unroll_loops || flag_peel_loops; 1402 1403 if (flag_rename_registers == AUTODETECT_VALUE) 1404 flag_rename_registers = flag_unroll_loops || flag_peel_loops; 1405 1406 if (flag_non_call_exceptions) 1407 flag_asynchronous_unwind_tables = 1; 1408 if (flag_asynchronous_unwind_tables) 1409 flag_unwind_tables = 1; 1410 1411 if (flag_value_profile_transformations) 1412 flag_profile_values = 1; 1413 1414 /* Warn about options that are not supported on this machine. */ 1415#ifndef INSN_SCHEDULING 1416 if (flag_schedule_insns || flag_schedule_insns_after_reload) 1417 warning (0, "instruction scheduling not supported on this target machine"); 1418#endif 1419#ifndef DELAY_SLOTS 1420 if (flag_delayed_branch) 1421 warning (0, "this target machine does not have delayed branches"); 1422#endif 1423 1424 user_label_prefix = USER_LABEL_PREFIX; 1425 if (flag_leading_underscore != -1) 1426 { 1427 /* If the default prefix is more complicated than "" or "_", 1428 issue a warning and ignore this option. */ 1429 if (user_label_prefix[0] == 0 || 1430 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0)) 1431 { 1432 user_label_prefix = flag_leading_underscore ? "_" : ""; 1433 } 1434 else 1435 warning (0, "-f%sleading-underscore not supported on this target machine", 1436 flag_leading_underscore ? "" : "no-"); 1437 } 1438 1439 /* If we are in verbose mode, write out the version and maybe all the 1440 option flags in use. */ 1441 if (version_flag) 1442 { 1443 print_version (stderr, "", true); 1444 if (! quiet_flag) 1445 print_switch_values (print_to_stderr); 1446 } 1447 1448 if (flag_syntax_only) 1449 { 1450 write_symbols = NO_DEBUG; 1451 profile_flag = 0; 1452 } 1453 1454 if (flag_gtoggle) 1455 { 1456 if (debug_info_level == DINFO_LEVEL_NONE) 1457 { 1458 debug_info_level = DINFO_LEVEL_NORMAL; 1459 1460 if (write_symbols == NO_DEBUG) 1461 write_symbols = PREFERRED_DEBUGGING_TYPE; 1462 } 1463 else 1464 debug_info_level = DINFO_LEVEL_NONE; 1465 } 1466 1467 if (flag_dump_final_insns && !flag_syntax_only && !no_backend) 1468 { 1469 FILE *final_output = fopen (flag_dump_final_insns, "w"); 1470 if (!final_output) 1471 { 1472 error ("could not open final insn dump file %qs: %m", 1473 flag_dump_final_insns); 1474 flag_dump_final_insns = NULL; 1475 } 1476 else if (fclose (final_output)) 1477 { 1478 error ("could not close zeroed insn dump file %qs: %m", 1479 flag_dump_final_insns); 1480 flag_dump_final_insns = NULL; 1481 } 1482 } 1483 1484 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging 1485 level is 0. */ 1486 if (debug_info_level == DINFO_LEVEL_NONE) 1487 write_symbols = NO_DEBUG; 1488 1489 if (write_symbols == NO_DEBUG) 1490 ; 1491#if defined(DBX_DEBUGGING_INFO) 1492 else if (write_symbols == DBX_DEBUG) 1493 debug_hooks = &dbx_debug_hooks; 1494#endif 1495#if defined(XCOFF_DEBUGGING_INFO) 1496 else if (write_symbols == XCOFF_DEBUG) 1497 debug_hooks = &xcoff_debug_hooks; 1498#endif 1499#ifdef SDB_DEBUGGING_INFO 1500 else if (write_symbols == SDB_DEBUG) 1501 debug_hooks = &sdb_debug_hooks; 1502#endif 1503#ifdef DWARF2_DEBUGGING_INFO 1504 else if (write_symbols == DWARF2_DEBUG) 1505 debug_hooks = &dwarf2_debug_hooks; 1506#endif 1507#ifdef VMS_DEBUGGING_INFO 1508 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 1509 debug_hooks = &vmsdbg_debug_hooks; 1510#endif 1511 else 1512 error ("target system does not support the %qs debug format", 1513 debug_type_names[write_symbols]); 1514 1515 /* We know which debug output will be used so we can set flag_var_tracking 1516 and flag_var_tracking_uninit if the user has not specified them. */ 1517 if (debug_info_level < DINFO_LEVEL_NORMAL 1518 || debug_hooks->var_location == do_nothing_debug_hooks.var_location) 1519 { 1520 if (flag_var_tracking == 1 1521 || flag_var_tracking_uninit == 1) 1522 { 1523 if (debug_info_level < DINFO_LEVEL_NORMAL) 1524 warning (0, "variable tracking requested, but useless unless " 1525 "producing debug info"); 1526 else 1527 warning (0, "variable tracking requested, but not supported " 1528 "by this debug format"); 1529 } 1530 flag_var_tracking = 0; 1531 flag_var_tracking_uninit = 0; 1532 } 1533 1534 /* The debug hooks are used to implement -fdump-go-spec because it 1535 gives a simple and stable API for all the information we need to 1536 dump. */ 1537 if (flag_dump_go_spec != NULL) 1538 debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks); 1539 1540 /* If the user specifically requested variable tracking with tagging 1541 uninitialized variables, we need to turn on variable tracking. 1542 (We already determined above that variable tracking is feasible.) */ 1543 if (flag_var_tracking_uninit == 1) 1544 flag_var_tracking = 1; 1545 1546 if (flag_var_tracking == AUTODETECT_VALUE) 1547 flag_var_tracking = optimize >= 1; 1548 1549 if (flag_var_tracking_uninit == AUTODETECT_VALUE) 1550 flag_var_tracking_uninit = flag_var_tracking; 1551 1552 if (flag_var_tracking_assignments == AUTODETECT_VALUE) 1553 flag_var_tracking_assignments = flag_var_tracking 1554 && !(flag_selective_scheduling || flag_selective_scheduling2); 1555 1556 if (flag_var_tracking_assignments_toggle) 1557 flag_var_tracking_assignments = !flag_var_tracking_assignments; 1558 1559 if (flag_var_tracking_assignments && !flag_var_tracking) 1560 flag_var_tracking = flag_var_tracking_assignments = -1; 1561 1562 if (flag_var_tracking_assignments 1563 && (flag_selective_scheduling || flag_selective_scheduling2)) 1564 warning (0, "var-tracking-assignments changes selective scheduling"); 1565 1566 if (flag_tree_cselim == AUTODETECT_VALUE) 1567#ifdef HAVE_conditional_move 1568 flag_tree_cselim = 1; 1569#else 1570 flag_tree_cselim = 0; 1571#endif 1572 1573 /* If auxiliary info generation is desired, open the output file. 1574 This goes in the same directory as the source file--unlike 1575 all the other output files. */ 1576 if (flag_gen_aux_info) 1577 { 1578 aux_info_file = fopen (aux_info_file_name, "w"); 1579 if (aux_info_file == 0) 1580 fatal_error (input_location, "can%'t open %s: %m", aux_info_file_name); 1581 } 1582 1583 if (!targetm_common.have_named_sections) 1584 { 1585 if (flag_function_sections) 1586 { 1587 warning (0, "-ffunction-sections not supported for this target"); 1588 flag_function_sections = 0; 1589 } 1590 if (flag_data_sections) 1591 { 1592 warning (0, "-fdata-sections not supported for this target"); 1593 flag_data_sections = 0; 1594 } 1595 } 1596 1597#ifndef HAVE_prefetch 1598 if (flag_prefetch_loop_arrays > 0) 1599 { 1600 warning (0, "-fprefetch-loop-arrays not supported for this target"); 1601 flag_prefetch_loop_arrays = 0; 1602 } 1603#else 1604 if (flag_prefetch_loop_arrays > 0 && !HAVE_prefetch) 1605 { 1606 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)"); 1607 flag_prefetch_loop_arrays = 0; 1608 } 1609#endif 1610 1611 /* This combination of options isn't handled for i386 targets and doesn't 1612 make much sense anyway, so don't allow it. */ 1613 if (flag_prefetch_loop_arrays > 0 && optimize_size) 1614 { 1615 warning (0, "-fprefetch-loop-arrays is not supported with -Os"); 1616 flag_prefetch_loop_arrays = 0; 1617 } 1618 1619 /* The presence of IEEE signaling NaNs, implies all math can trap. */ 1620 if (flag_signaling_nans) 1621 flag_trapping_math = 1; 1622 1623 /* We cannot reassociate if we want traps or signed zeros. */ 1624 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros)) 1625 { 1626 warning (0, "-fassociative-math disabled; other options take precedence"); 1627 flag_associative_math = 0; 1628 } 1629 1630 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */ 1631 if (flag_cx_limited_range) 1632 flag_complex_method = 0; 1633 1634 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */ 1635 if (flag_cx_fortran_rules) 1636 flag_complex_method = 1; 1637 1638 /* Targets must be able to place spill slots at lower addresses. If the 1639 target already uses a soft frame pointer, the transition is trivial. */ 1640 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect) 1641 { 1642 warning (0, "-fstack-protector not supported for this target"); 1643 flag_stack_protect = 0; 1644 } 1645 if (!flag_stack_protect) 1646 warn_stack_protect = 0; 1647 1648 /* Address Sanitizer needs porting to each target architecture. */ 1649 1650 if ((flag_sanitize & SANITIZE_ADDRESS) 1651 && !FRAME_GROWS_DOWNWARD) 1652 { 1653 warning (0, 1654 "-fsanitize=address and -fsanitize=kernel-address " 1655 "are not supported for this target"); 1656 flag_sanitize &= ~SANITIZE_ADDRESS; 1657 } 1658 1659 if ((flag_sanitize & SANITIZE_USER_ADDRESS) 1660 && targetm.asan_shadow_offset == NULL) 1661 { 1662 warning (0, "-fsanitize=address not supported for this target"); 1663 flag_sanitize &= ~SANITIZE_ADDRESS; 1664 } 1665 1666 /* Do not use IPA optimizations for register allocation if profiler is active 1667 or port does not emit prologue and epilogue as RTL. */ 1668 if (profile_flag || !HAVE_prologue || !HAVE_epilogue) 1669 flag_ipa_ra = 0; 1670 1671 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error 1672 have not been set. */ 1673 if (!global_options_set.x_warnings_are_errors 1674 && warn_coverage_mismatch 1675 && (global_dc->classify_diagnostic[OPT_Wcoverage_mismatch] == 1676 DK_UNSPECIFIED)) 1677 diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch, 1678 DK_ERROR, UNKNOWN_LOCATION); 1679 1680 /* Save the current optimization options. */ 1681 optimization_default_node = build_optimization_node (&global_options); 1682 optimization_current_node = optimization_default_node; 1683 1684 /* Please don't change global_options after this point, those changes won't 1685 be reflected in optimization_{default,current}_node. */ 1686} 1687 1688/* This function can be called multiple times to reinitialize the compiler 1689 back end when register classes or instruction sets have changed, 1690 before each function. */ 1691static void 1692backend_init_target (void) 1693{ 1694 /* Initialize alignment variables. */ 1695 init_alignments (); 1696 1697 /* This depends on stack_pointer_rtx. */ 1698 init_fake_stack_mems (); 1699 1700 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is 1701 mode-dependent. */ 1702 init_alias_target (); 1703 1704 /* Depends on HARD_FRAME_POINTER_REGNUM. */ 1705 init_reload (); 1706 1707 /* Depends on the enabled attribute. */ 1708 recog_init (); 1709 1710 /* The following initialization functions need to generate rtl, so 1711 provide a dummy function context for them. */ 1712 init_dummy_function_start (); 1713 1714 /* rtx_cost is mode-dependent, so cached values need to be recomputed 1715 on a mode change. */ 1716 init_expmed (); 1717 init_lower_subreg (); 1718 init_set_costs (); 1719 1720 init_expr_target (); 1721 ira_init (); 1722 1723 /* We may need to recompute regno_save_code[] and regno_restore_code[] 1724 after a mode change as well. */ 1725 caller_save_initialized_p = false; 1726 1727 expand_dummy_function_end (); 1728} 1729 1730/* Initialize the compiler back end. This function is called only once, 1731 when starting the compiler. */ 1732static void 1733backend_init (void) 1734{ 1735 init_emit_once (); 1736 1737 init_rtlanal (); 1738 init_inline_once (); 1739 init_varasm_once (); 1740 save_register_info (); 1741 1742 /* Middle end needs this initialization for default mem attributes 1743 used by early calls to make_decl_rtl. */ 1744 init_emit_regs (); 1745 1746 /* Middle end needs this initialization for mode tables used to assign 1747 modes to vector variables. */ 1748 init_regs (); 1749} 1750 1751/* Initialize excess precision settings. */ 1752static void 1753init_excess_precision (void) 1754{ 1755 /* Adjust excess precision handling based on the target options. If 1756 the front end cannot handle it, flag_excess_precision_cmdline 1757 will already have been set accordingly in the post_options 1758 hook. */ 1759 gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT); 1760 flag_excess_precision = flag_excess_precision_cmdline; 1761 if (flag_unsafe_math_optimizations) 1762 flag_excess_precision = EXCESS_PRECISION_FAST; 1763 if (flag_excess_precision == EXCESS_PRECISION_STANDARD) 1764 { 1765 int flt_eval_method = TARGET_FLT_EVAL_METHOD; 1766 switch (flt_eval_method) 1767 { 1768 case -1: 1769 case 0: 1770 /* Either the target acts unpredictably (-1) or has all the 1771 operations required not to have excess precision (0). */ 1772 flag_excess_precision = EXCESS_PRECISION_FAST; 1773 break; 1774 case 1: 1775 case 2: 1776 /* In these cases, predictable excess precision makes 1777 sense. */ 1778 break; 1779 default: 1780 /* Any other implementation-defined FLT_EVAL_METHOD values 1781 require the compiler to handle the associated excess 1782 precision rules in excess_precision_type. */ 1783 gcc_unreachable (); 1784 } 1785 } 1786} 1787 1788/* Initialize things that are both lang-dependent and target-dependent. 1789 This function can be called more than once if target parameters change. */ 1790static void 1791lang_dependent_init_target (void) 1792{ 1793 /* This determines excess precision settings. */ 1794 init_excess_precision (); 1795 1796 /* This creates various _DECL nodes, so needs to be called after the 1797 front end is initialized. It also depends on the HAVE_xxx macros 1798 generated from the target machine description. */ 1799 init_optabs (); 1800 1801 gcc_assert (!this_target_rtl->target_specific_initialized); 1802} 1803 1804/* Perform initializations that are lang-dependent or target-dependent. 1805 but matters only for late optimizations and RTL generation. */ 1806 1807static int rtl_initialized; 1808 1809void 1810initialize_rtl (void) 1811{ 1812 /* Initialization done just once per compilation, but delayed 1813 till code generation. */ 1814 if (!rtl_initialized) 1815 ira_init_once (); 1816 rtl_initialized = true; 1817 1818 /* Target specific RTL backend initialization. */ 1819 if (!this_target_rtl->target_specific_initialized) 1820 { 1821 backend_init_target (); 1822 this_target_rtl->target_specific_initialized = true; 1823 } 1824} 1825 1826/* Language-dependent initialization. Returns nonzero on success. */ 1827static int 1828lang_dependent_init (const char *name) 1829{ 1830 location_t save_loc = input_location; 1831 if (dump_base_name == 0) 1832 dump_base_name = name && name[0] ? name : "gccdump"; 1833 1834 /* Other front-end initialization. */ 1835 input_location = BUILTINS_LOCATION; 1836 if (lang_hooks.init () == 0) 1837 return 0; 1838 input_location = save_loc; 1839 1840 if (!flag_wpa) 1841 { 1842 init_asm_output (name); 1843 1844 /* If stack usage information is desired, open the output file. */ 1845 if (flag_stack_usage) 1846 stack_usage_file = open_auxiliary_file ("su"); 1847 } 1848 1849 /* This creates various _DECL nodes, so needs to be called after the 1850 front end is initialized. */ 1851 init_eh (); 1852 1853 /* Do the target-specific parts of the initialization. */ 1854 lang_dependent_init_target (); 1855 1856 if (!flag_wpa) 1857 { 1858 /* If dbx symbol table desired, initialize writing it and output the 1859 predefined types. */ 1860 timevar_push (TV_SYMOUT); 1861 1862 /* Now we have the correct original filename, we can initialize 1863 debug output. */ 1864 (*debug_hooks->init) (name); 1865 1866 timevar_pop (TV_SYMOUT); 1867 } 1868 1869 return 1; 1870} 1871 1872 1873/* Reinitialize everything when target parameters, such as register usage, 1874 have changed. */ 1875void 1876target_reinit (void) 1877{ 1878 struct rtl_data saved_x_rtl; 1879 rtx *saved_regno_reg_rtx; 1880 tree saved_optimization_current_node; 1881 struct target_optabs *saved_this_fn_optabs; 1882 1883 /* Temporarily switch to the default optimization node, so that 1884 *this_target_optabs is set to the default, not reflecting 1885 whatever a previous function used for the optimize 1886 attribute. */ 1887 saved_optimization_current_node = optimization_current_node; 1888 saved_this_fn_optabs = this_fn_optabs; 1889 if (saved_optimization_current_node != optimization_default_node) 1890 { 1891 optimization_current_node = optimization_default_node; 1892 cl_optimization_restore 1893 (&global_options, 1894 TREE_OPTIMIZATION (optimization_default_node)); 1895 } 1896 this_fn_optabs = this_target_optabs; 1897 1898 /* Save *crtl and regno_reg_rtx around the reinitialization 1899 to allow target_reinit being called even after prepare_function_start. */ 1900 saved_regno_reg_rtx = regno_reg_rtx; 1901 if (saved_regno_reg_rtx) 1902 { 1903 saved_x_rtl = *crtl; 1904 memset (crtl, '\0', sizeof (*crtl)); 1905 regno_reg_rtx = NULL; 1906 } 1907 1908 this_target_rtl->target_specific_initialized = false; 1909 1910 /* This initializes hard_frame_pointer, and calls init_reg_modes_target() 1911 to initialize reg_raw_mode[]. */ 1912 init_emit_regs (); 1913 1914 /* This invokes target hooks to set fixed_reg[] etc, which is 1915 mode-dependent. */ 1916 init_regs (); 1917 1918 /* Reinitialize lang-dependent parts. */ 1919 lang_dependent_init_target (); 1920 1921 /* Restore the original optimization node. */ 1922 if (saved_optimization_current_node != optimization_default_node) 1923 { 1924 optimization_current_node = saved_optimization_current_node; 1925 cl_optimization_restore (&global_options, 1926 TREE_OPTIMIZATION (optimization_current_node)); 1927 } 1928 this_fn_optabs = saved_this_fn_optabs; 1929 1930 /* Restore regno_reg_rtx at the end, as free_after_compilation from 1931 expand_dummy_function_end clears it. */ 1932 if (saved_regno_reg_rtx) 1933 { 1934 *crtl = saved_x_rtl; 1935 regno_reg_rtx = saved_regno_reg_rtx; 1936 saved_regno_reg_rtx = NULL; 1937 } 1938} 1939 1940void 1941dump_memory_report (bool final) 1942{ 1943 dump_line_table_statistics (); 1944 ggc_print_statistics (); 1945 stringpool_statistics (); 1946 dump_tree_statistics (); 1947 dump_gimple_statistics (); 1948 dump_rtx_statistics (); 1949 dump_alloc_pool_statistics (); 1950 dump_bitmap_statistics (); 1951 dump_vec_loc_statistics (); 1952 dump_ggc_loc_statistics (final); 1953 dump_alias_stats (stderr); 1954 dump_pta_stats (stderr); 1955} 1956 1957/* Clean up: close opened files, etc. */ 1958 1959static void 1960finalize (bool no_backend) 1961{ 1962 /* Close the dump files. */ 1963 if (flag_gen_aux_info) 1964 { 1965 fclose (aux_info_file); 1966 if (seen_error ()) 1967 unlink (aux_info_file_name); 1968 } 1969 1970 /* Close non-debugging input and output files. Take special care to note 1971 whether fclose returns an error, since the pages might still be on the 1972 buffer chain while the file is open. */ 1973 1974 if (asm_out_file) 1975 { 1976 if (ferror (asm_out_file) != 0) 1977 fatal_error (input_location, "error writing to %s: %m", asm_file_name); 1978 if (fclose (asm_out_file) != 0) 1979 fatal_error (input_location, "error closing %s: %m", asm_file_name); 1980 } 1981 1982 if (stack_usage_file) 1983 fclose (stack_usage_file); 1984 1985 if (!no_backend) 1986 { 1987 statistics_fini (); 1988 1989 g->get_passes ()->finish_optimization_passes (); 1990 1991 lra_finish_once (); 1992 } 1993 1994 if (mem_report) 1995 dump_memory_report (true); 1996 1997 if (profile_report) 1998 dump_profile_report (); 1999 2000 /* Language-specific end of compilation actions. */ 2001 lang_hooks.finish (); 2002} 2003 2004static bool 2005standard_type_bitsize (int bitsize) 2006{ 2007 /* As a special exception, we always want __int128 enabled if possible. */ 2008 if (bitsize == 128) 2009 return false; 2010 if (bitsize == CHAR_TYPE_SIZE 2011 || bitsize == SHORT_TYPE_SIZE 2012 || bitsize == INT_TYPE_SIZE 2013 || bitsize == LONG_TYPE_SIZE 2014 || bitsize == LONG_LONG_TYPE_SIZE) 2015 return true; 2016 return false; 2017} 2018 2019/* Initialize the compiler, and compile the input file. */ 2020static void 2021do_compile () 2022{ 2023 process_options (); 2024 2025 /* Don't do any more if an error has already occurred. */ 2026 if (!seen_error ()) 2027 { 2028 int i; 2029 2030 timevar_start (TV_PHASE_SETUP); 2031 2032 /* This must be run always, because it is needed to compute the FP 2033 predefined macros, such as __LDBL_MAX__, for targets using non 2034 default FP formats. */ 2035 init_adjust_machine_modes (); 2036 init_derived_machine_modes (); 2037 2038 /* This must happen after the backend has a chance to process 2039 command line options, but before the parsers are 2040 initialized. */ 2041 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2042 if (targetm.scalar_mode_supported_p (int_n_data[i].m) 2043 && ! standard_type_bitsize (int_n_data[i].bitsize)) 2044 int_n_enabled_p[i] = true; 2045 else 2046 int_n_enabled_p[i] = false; 2047 2048 /* Set up the back-end if requested. */ 2049 if (!no_backend) 2050 backend_init (); 2051 2052 /* Language-dependent initialization. Returns true on success. */ 2053 if (lang_dependent_init (main_input_filename)) 2054 { 2055 /* Initialize yet another pass. */ 2056 2057 ggc_protect_identifiers = true; 2058 2059 symtab->initialize (); 2060 init_final (main_input_filename); 2061 coverage_init (aux_base_name); 2062 statistics_init (); 2063 invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL); 2064 2065 timevar_stop (TV_PHASE_SETUP); 2066 2067 compile_file (); 2068 } 2069 else 2070 { 2071 timevar_stop (TV_PHASE_SETUP); 2072 } 2073 2074 timevar_start (TV_PHASE_FINALIZE); 2075 2076 finalize (no_backend); 2077 2078 timevar_stop (TV_PHASE_FINALIZE); 2079 } 2080} 2081 2082toplev::toplev (bool use_TV_TOTAL, bool init_signals) 2083 : m_use_TV_TOTAL (use_TV_TOTAL), 2084 m_init_signals (init_signals) 2085{ 2086 if (!m_use_TV_TOTAL) 2087 start_timevars (); 2088} 2089 2090toplev::~toplev () 2091{ 2092 timevar_stop (TV_TOTAL); 2093 timevar_print (stderr); 2094} 2095 2096void 2097toplev::start_timevars () 2098{ 2099 if (time_report || !quiet_flag || flag_detailed_statistics) 2100 timevar_init (); 2101 2102 timevar_start (TV_TOTAL); 2103} 2104 2105/* Entry point of cc1, cc1plus, jc1, f771, etc. 2106 Exit code is FATAL_EXIT_CODE if can't open files or if there were 2107 any errors, or SUCCESS_EXIT_CODE if compilation succeeded. 2108 2109 It is not safe to call this function more than once. */ 2110 2111int 2112toplev::main (int argc, char **argv) 2113{ 2114 /* Parsing and gimplification sometimes need quite large stack. 2115 Increase stack size limits if possible. */ 2116 stack_limit_increase (64 * 1024 * 1024); 2117 2118 expandargv (&argc, &argv); 2119 2120 /* Initialization of GCC's environment, and diagnostics. */ 2121 general_init (argv[0], m_init_signals); 2122 2123 /* One-off initialization of options that does not need to be 2124 repeated when options are added for particular functions. */ 2125 init_options_once (); 2126 2127 /* Initialize global options structures; this must be repeated for 2128 each structure used for parsing options. */ 2129 init_options_struct (&global_options, &global_options_set); 2130 lang_hooks.init_options_struct (&global_options); 2131 2132 /* Convert the options to an array. */ 2133 decode_cmdline_options_to_array_default_mask (argc, 2134 CONST_CAST2 (const char **, 2135 char **, argv), 2136 &save_decoded_options, 2137 &save_decoded_options_count); 2138 2139 /* Perform language-specific options initialization. */ 2140 lang_hooks.init_options (save_decoded_options_count, save_decoded_options); 2141 2142 /* Parse the options and do minimal processing; basically just 2143 enough to default flags appropriately. */ 2144 decode_options (&global_options, &global_options_set, 2145 save_decoded_options, save_decoded_options_count, 2146 UNKNOWN_LOCATION, global_dc); 2147 2148 handle_common_deferred_options (); 2149 2150 init_local_tick (); 2151 2152 initialize_plugins (); 2153 2154 if (version_flag) 2155 print_version (stderr, "", true); 2156 2157 if (help_flag) 2158 print_plugins_help (stderr, ""); 2159 2160 /* Exit early if we can (e.g. -help). */ 2161 if (!exit_after_options) 2162 { 2163 if (m_use_TV_TOTAL) 2164 start_timevars (); 2165 do_compile (); 2166 } 2167 2168 if (warningcount || errorcount || werrorcount) 2169 print_ignored_options (); 2170 2171 /* Invoke registered plugin callbacks if any. Some plugins could 2172 emit some diagnostics here. */ 2173 invoke_plugin_callbacks (PLUGIN_FINISH, NULL); 2174 2175 diagnostic_finish (global_dc); 2176 2177 finalize_plugins (); 2178 location_adhoc_data_fini (line_table); 2179 if (seen_error () || werrorcount) 2180 return (FATAL_EXIT_CODE); 2181 2182 return (SUCCESS_EXIT_CODE); 2183} 2184 2185/* For those that want to, this function aims to clean up enough state that 2186 you can call toplev::main again. */ 2187void 2188toplev::finalize (void) 2189{ 2190 rtl_initialized = false; 2191 this_target_rtl->target_specific_initialized = false; 2192 2193 /* Needs to be called before cgraph_c_finalize since it uses symtab. */ 2194 ipa_reference_c_finalize (); 2195 2196 cgraph_c_finalize (); 2197 cgraphunit_c_finalize (); 2198 dwarf2out_c_finalize (); 2199 gcse_c_finalize (); 2200 ipa_cp_c_finalize (); 2201 ira_costs_c_finalize (); 2202 params_c_finalize (); 2203 2204 finalize_options_struct (&global_options); 2205 finalize_options_struct (&global_options_set); 2206 2207 XDELETEVEC (save_decoded_options); 2208 2209 /* Clean up the context (and pass_manager etc). */ 2210 delete g; 2211 g = NULL; 2212 2213 obstack_free (&opts_obstack, NULL); 2214} 2215