toplev.c revision 18334
11573Srgrimes/* Top level of GNU C compiler 21573Srgrimes Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc. 31573Srgrimes 41573SrgrimesThis file is part of GNU CC. 51573Srgrimes 61573SrgrimesGNU CC is free software; you can redistribute it and/or modify 71573Srgrimesit under the terms of the GNU General Public License as published by 81573Srgrimesthe Free Software Foundation; either version 2, or (at your option) 91573Srgrimesany later version. 101573Srgrimes 111573SrgrimesGNU CC is distributed in the hope that it will be useful, 121573Srgrimesbut WITHOUT ANY WARRANTY; without even the implied warranty of 131573SrgrimesMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 141573SrgrimesGNU General Public License for more details. 151573Srgrimes 161573SrgrimesYou should have received a copy of the GNU General Public License 171573Srgrimesalong with GNU CC; see the file COPYING. If not, write to 181573Srgrimesthe Free Software Foundation, 59 Temple Place - Suite 330, 191573SrgrimesBoston, MA 02111-1307, USA. */ 201573Srgrimes 211573Srgrimes/* This is the top level of cc1/c++. 221573Srgrimes It parses command args, opens files, invokes the various passes 231573Srgrimes in the proper order, and counts the time used by each. 241573Srgrimes Error messages and low-level interface to malloc also handled here. */ 251573Srgrimes 261573Srgrimes#include "config.h" 271573Srgrimes#ifdef __STDC__ 281573Srgrimes#include <stdarg.h> 291573Srgrimes#else 301573Srgrimes#include <varargs.h> 311573Srgrimes#endif 321573Srgrimes#include <stdio.h> 331573Srgrimes#include <signal.h> 341573Srgrimes#include <setjmp.h> 351573Srgrimes#include <sys/types.h> 361573Srgrimes#include <ctype.h> 371573Srgrimes#include <sys/stat.h> 381573Srgrimes 391573Srgrimes#ifndef _WIN32 401573Srgrimes#ifdef USG 4134925Sdufault#undef FLOAT 421573Srgrimes#include <sys/param.h> 4312674Sdg/* This is for hpux. It is a real screw. They should change hpux. */ 441573Srgrimes#undef FLOAT 451573Srgrimes#include <sys/times.h> 461573Srgrimes#include <time.h> /* Correct for hpux at least. Is it good on other USG? */ 471573Srgrimes#undef FFS /* Some systems define this in param.h. */ 486171Sbde#else 491573Srgrimes#ifndef VMS 501573Srgrimes#include <sys/time.h> 511573Srgrimes#include <sys/resource.h> 521573Srgrimes#endif 531573Srgrimes#endif 541573Srgrimes#endif 551573Srgrimes 561573Srgrimes#include "input.h" 571573Srgrimes#include "tree.h" 581573Srgrimes#include "rtl.h" 591573Srgrimes#include "flags.h" 601573Srgrimes#include "insn-attr.h" 611573Srgrimes#include "defaults.h" 621573Srgrimes#include "output.h" 631573Srgrimes#include "bytecode.h" 641573Srgrimes#include "bc-emit.h" 651573Srgrimes 661573Srgrimes#ifdef XCOFF_DEBUGGING_INFO 671573Srgrimes#include "xcoffout.h" 681573Srgrimes#endif 691573Srgrimes 7036577Smsmith#ifdef VMS 711573Srgrimes/* The extra parameters substantially improve the I/O performance. */ 721573Srgrimesstatic FILE * 7336577Smsmithvms_fopen (fname, type) 741573Srgrimes char * fname; 751573Srgrimes char * type; 761573Srgrimes{ 771573Srgrimes /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two 781573Srgrimes fixed arguments, which matches ANSI's specification but not VAXCRTL's 791573Srgrimes pre-ANSI implementation. This hack circumvents the mismatch problem. */ 801573Srgrimes FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen; 811573Srgrimes 821573Srgrimes if (*type == 'w') 831573Srgrimes return (*vmslib_fopen) (fname, type, "mbc=32", 841573Srgrimes "deq=64", "fop=tef", "shr=nil"); 851573Srgrimes else 861573Srgrimes return (*vmslib_fopen) (fname, type, "mbc=32"); 871573Srgrimes} 881573Srgrimes#define fopen vms_fopen 891573Srgrimes#endif /* VMS */ 901573Srgrimes 911573Srgrimes#ifndef DEFAULT_GDB_EXTENSIONS 921573Srgrimes#define DEFAULT_GDB_EXTENSIONS 1 931573Srgrimes#endif 941573Srgrimes 951573Srgrimesextern int rtx_equal_function_value_matters; 961573Srgrimes 971573Srgrimes#if ! (defined (VMS) || defined (OS2)) 981573Srgrimesextern char **environ; 991573Srgrimes#endif 1001573Srgrimesextern char *version_string, *language_string; 1011573Srgrimes 1021573Srgrimes/* Carry information from ASM_DECLARE_OBJECT_NAME 1031573Srgrimes to ASM_FINISH_DECLARE_OBJECT. */ 1041573Srgrimes 1051573Srgrimesextern int size_directive_output; 1061573Srgrimesextern tree last_assemble_variable_decl; 1071573Srgrimes 1081573Srgrimesextern void init_lex (); 1091573Srgrimesextern void init_decl_processing (); 1101573Srgrimesextern void init_obstacks (); 1111573Srgrimesextern void init_tree_codes (); 1121573Srgrimesextern void init_rtl (); 1131573Srgrimesextern void init_regs (); 1141573Srgrimesextern void init_optabs (); 1151573Srgrimesextern void init_stmt (); 1161573Srgrimesextern void init_reg_sets (); 1171573Srgrimesextern void dump_flow_info (); 1181573Srgrimesextern void dump_sched_info (); 1191573Srgrimesextern void dump_local_alloc (); 1201573Srgrimes 1211573Srgrimesvoid rest_of_decl_compilation (); 1221573Srgrimesvoid error_with_file_and_line PVPROTO((char *file, int line, char *s, ...)); 1231573Srgrimesvoid error_with_decl PVPROTO((tree decl, char *s, ...)); 1241573Srgrimesvoid error_for_asm PVPROTO((rtx insn, char *s, ...)); 1251573Srgrimesvoid error PVPROTO((char *s, ...)); 1261573Srgrimesvoid fatal PVPROTO((char *s, ...)); 1271573Srgrimesvoid warning_with_file_and_line PVPROTO((char *file, int line, char *s, ...)); 1281573Srgrimesvoid warning_with_decl PVPROTO((tree decl, char *s, ...)); 1291573Srgrimesvoid warning_for_asm PVPROTO((rtx insn, char *s, ...)); 1301573Srgrimesvoid warning PVPROTO((char *s, ...)); 1311573Srgrimesvoid pedwarn PVPROTO((char *s, ...)); 1321573Srgrimesvoid pedwarn_with_decl PVPROTO((tree decl, char *s, ...)); 1331573Srgrimesvoid pedwarn_with_file_and_line PVPROTO((char *file, int line, char *s, ...)); 1341573Srgrimesvoid sorry PVPROTO((char *s, ...)); 1351573Srgrimesvoid really_sorry PVPROTO((char *s, ...)); 1361573Srgrimesvoid fancy_abort (); 1371573Srgrimes#ifndef abort 1381573Srgrimesvoid abort (); 1391573Srgrimes#endif 1401573Srgrimesvoid set_target_switch (); 1411573Srgrimesstatic void print_switch_values (); 1421573Srgrimesstatic char *decl_name (); 1431573Srgrimes 1441573Srgrimes#ifdef __alpha 1451573Srgrimesextern char *sbrk (); 1461573Srgrimes#endif 1471573Srgrimes 1481573Srgrimes/* Name of program invoked, sans directories. */ 1491573Srgrimes 1501573Srgrimeschar *progname; 1511573Srgrimes 1521573Srgrimes/* Copy of arguments to main. */ 1531573Srgrimesint save_argc; 1541573Srgrimeschar **save_argv; 1551573Srgrimes 1561573Srgrimes/* Name of current original source file (what was input to cpp). 1571573Srgrimes This comes from each #-command in the actual input. */ 1581573Srgrimes 1591573Srgrimeschar *input_filename; 1601573Srgrimes 1611573Srgrimes/* Name of top-level original source file (what was input to cpp). 1621573Srgrimes This comes from the #-command at the beginning of the actual input. 1631573Srgrimes If there isn't any there, then this is the cc1 input file name. */ 1641573Srgrimes 1651573Srgrimeschar *main_input_filename; 1661573Srgrimes 1671573Srgrimes/* Stream for reading from the input file. */ 1681573Srgrimes 1691573SrgrimesFILE *finput; 1701573Srgrimes 1711573Srgrimes/* Current line number in real source file. */ 1721573Srgrimes 1731573Srgrimesint lineno; 1741573Srgrimes 1751573Srgrimes/* Stack of currently pending input files. */ 1761573Srgrimes 1771573Srgrimesstruct file_stack *input_file_stack; 1781573Srgrimes 1791573Srgrimes/* Incremented on each change to input_file_stack. */ 18034030Sdufaultint input_file_stack_tick; 18134030Sdufault 18234925Sdufault/* FUNCTION_DECL for function now being parsed or compiled. */ 18334925Sdufault 18434030Sdufaultextern tree current_function_decl; 18534030Sdufault 18634925Sdufault/* Name to use as base of names for dump output files. */ 18734925Sdufault 18834030Sdufaultchar *dump_base_name; 18934030Sdufault 19034925Sdufault/* Bit flags that specify the machine subtype we are compiling for. 19134925Sdufault Bits are tested using macros TARGET_... defined in the tm.h file 19234030Sdufault and set by `-m...' switches. Must be defined in rtlanal.c. */ 19334030Sdufault 19434925Sdufaultextern int target_flags; 19534925Sdufault 19634030Sdufault/* Flags saying which kinds of debugging dump have been requested. */ 19734030Sdufault 19834925Sdufaultint rtl_dump = 0; 19934925Sdufaultint rtl_dump_and_exit = 0; 20034030Sdufaultint jump_opt_dump = 0; 20134030Sdufaultint cse_dump = 0; 20234925Sdufaultint loop_dump = 0; 20334925Sdufaultint cse2_dump = 0; 20434030Sdufaultint flow_dump = 0; 20534030Sdufaultint combine_dump = 0; 20634925Sdufaultint sched_dump = 0; 20734925Sdufaultint local_reg_dump = 0; 20834030Sdufaultint global_reg_dump = 0; 20934030Sdufaultint sched2_dump = 0; 21034925Sdufaultint jump2_opt_dump = 0; 21134925Sdufaultint dbr_sched_dump = 0; 21234030Sdufaultint flag_print_asm_name = 0; 21334030Sdufaultint stack_reg_dump = 0; 21434925Sdufault 21534925Sdufault/* Name for output file of assembly code, specified with -o. */ 21634030Sdufault 21734030Sdufaultchar *asm_file_name; 21834925Sdufault 21934925Sdufault/* Value of the -G xx switch, and whether it was passed or not. */ 22034030Sdufaultint g_switch_value; 22134030Sdufaultint g_switch_set; 22234925Sdufault 22334925Sdufault/* Type(s) of debugging information we are producing (if any). 22434030Sdufault See flags.h for the definitions of the different possible 22534030Sdufault types of debugging information. */ 22634925Sdufaultenum debug_info_type write_symbols = NO_DEBUG; 22734925Sdufault 22834030Sdufault/* Level of debugging information we are producing. See flags.h 22934030Sdufault for the definitions of the different possible levels. */ 23034925Sdufaultenum debug_info_level debug_info_level = DINFO_LEVEL_NONE; 23134925Sdufault 23234030Sdufault/* Nonzero means use GNU-only extensions in the generated symbolic 23334030Sdufault debugging information. */ 23434925Sdufault/* Currently, this only has an effect when write_symbols is set to 23534925Sdufault DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */ 23634030Sdufaultint use_gnu_debug_info_extensions = 0; 23734030Sdufault 23834925Sdufault/* Nonzero means do optimizations. -O. 23934925Sdufault Particular numeric values stand for particular amounts of optimization; 24034030Sdufault thus, -O2 stores 2 here. However, the optimizations beyond the basic 24134030Sdufault ones are not controlled directly by this variable. Instead, they are 24234925Sdufault controlled by individual `flag_...' variables that are defaulted 24334925Sdufault based on this variable. */ 24434030Sdufault 24534030Sdufaultint optimize = 0; 24634925Sdufault 24734925Sdufault/* Number of error messages and warning messages so far. */ 24834030Sdufault 24934030Sdufaultint errorcount = 0; 25034925Sdufaultint warningcount = 0; 25134925Sdufaultint sorrycount = 0; 25234030Sdufault 25334030Sdufault/* Flag to output bytecode instead of native assembler */ 25434925Sdufaultint output_bytecode = 0; 25534925Sdufault 25634030Sdufault/* Pointer to function to compute the name to use to print a declaration. */ 25734030Sdufault 25834925Sdufaultchar *(*decl_printable_name) (); 25934925Sdufault 26034030Sdufault/* Pointer to function to compute rtl for a language-specific tree code. */ 26134030Sdufault 26236577Smsmithstruct rtx_def *(*lang_expand_expr) (); 26334925Sdufault 26434925Sdufault/* Pointer to function to finish handling an incomplete decl at the 26534030Sdufault end of compilation. */ 26634030Sdufault 26734925Sdufaultvoid (*incomplete_decl_finalize_hook) () = 0; 26834925Sdufault 26934030Sdufault/* Pointer to function for interim exception handling implementation. 27034030Sdufault This interface will change, and it is only here until a better interface 27134925Sdufault replaces it. */ 27234925Sdufault 27334030Sdufaultvoid (*interim_eh_hook) PROTO((tree)); 27434030Sdufault 27534925Sdufault/* Nonzero if generating code to do profiling. */ 27634925Sdufault 27734030Sdufaultint profile_flag = 0; 27834030Sdufault 27934925Sdufault/* Nonzero if generating code to do profiling on a line-by-line basis. */ 28034925Sdufault 28134030Sdufaultint profile_block_flag; 28234030Sdufault 28334925Sdufault/* Nonzero for -pedantic switch: warn about anything 28434925Sdufault that standard spec forbids. */ 28534030Sdufault 28634925Sdufaultint pedantic = 0; 28734030Sdufault 2881573Srgrimes/* Temporarily suppress certain warnings. 2891573Srgrimes This is set while reading code from a system header file. */ 2901573Srgrimes 29136577Smsmithint in_system_header = 0; 2921573Srgrimes 2931573Srgrimes/* Nonzero means do stupid register allocation. 2941573Srgrimes Currently, this is 1 if `optimize' is 0. */ 2951573Srgrimes 2961573Srgrimesint obey_regdecls = 0; 2971573Srgrimes 2988870Srgrimes/* Don't print functions as they are compiled and don't print 2991573Srgrimes times taken by the various passes. -quiet. */ 300 301int quiet_flag = 0; 302 303/* -f flags. */ 304 305/* Nonzero means `char' should be signed. */ 306 307int flag_signed_char; 308 309/* Nonzero means give an enum type only as many bytes as it needs. */ 310 311int flag_short_enums; 312 313/* Nonzero for -fcaller-saves: allocate values in regs that need to 314 be saved across function calls, if that produces overall better code. 315 Optional now, so people can test it. */ 316 317#ifdef DEFAULT_CALLER_SAVES 318int flag_caller_saves = 1; 319#else 320int flag_caller_saves = 0; 321#endif 322 323/* Nonzero if structures and unions should be returned in memory. 324 325 This should only be defined if compatibility with another compiler or 326 with an ABI is needed, because it results in slower code. */ 327 328#ifndef DEFAULT_PCC_STRUCT_RETURN 329#define DEFAULT_PCC_STRUCT_RETURN 1 330#endif 331 332/* Nonzero for -fpcc-struct-return: return values the same way PCC does. */ 333 334int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN; 335 336/* Nonzero for -fforce-mem: load memory value into a register 337 before arithmetic on it. This makes better cse but slower compilation. */ 338 339int flag_force_mem = 0; 340 341/* Nonzero for -fforce-addr: load memory address into a register before 342 reference to memory. This makes better cse but slower compilation. */ 343 344int flag_force_addr = 0; 345 346/* Nonzero for -fdefer-pop: don't pop args after each function call; 347 instead save them up to pop many calls' args with one insns. */ 348 349int flag_defer_pop = 0; 350 351/* Nonzero for -ffloat-store: don't allocate floats and doubles 352 in extended-precision registers. */ 353 354int flag_float_store = 0; 355 356/* Nonzero for -fcse-follow-jumps: 357 have cse follow jumps to do a more extensive job. */ 358 359int flag_cse_follow_jumps; 360 361/* Nonzero for -fcse-skip-blocks: 362 have cse follow a branch around a block. */ 363int flag_cse_skip_blocks; 364 365/* Nonzero for -fexpensive-optimizations: 366 perform miscellaneous relatively-expensive optimizations. */ 367int flag_expensive_optimizations; 368 369/* Nonzero for -fthread-jumps: 370 have jump optimize output of loop. */ 371 372int flag_thread_jumps; 373 374/* Nonzero enables strength-reduction in loop.c. */ 375 376int flag_strength_reduce = 0; 377 378/* Nonzero enables loop unrolling in unroll.c. Only loops for which the 379 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY, 380 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are 381 unrolled. */ 382 383int flag_unroll_loops; 384 385/* Nonzero enables loop unrolling in unroll.c. All loops are unrolled. 386 This is generally not a win. */ 387 388int flag_unroll_all_loops; 389 390/* Nonzero for -fwritable-strings: 391 store string constants in data segment and don't uniquize them. */ 392 393int flag_writable_strings = 0; 394 395/* Nonzero means don't put addresses of constant functions in registers. 396 Used for compiling the Unix kernel, where strange substitutions are 397 done on the assembly output. */ 398 399int flag_no_function_cse = 0; 400 401/* Nonzero for -fomit-frame-pointer: 402 don't make a frame pointer in simple functions that don't require one. */ 403 404int flag_omit_frame_pointer = 0; 405 406/* Nonzero to inhibit use of define_optimization peephole opts. */ 407 408int flag_no_peephole = 0; 409 410/* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math 411 operations in the interest of optimization. For example it allows 412 GCC to assume arguments to sqrt are nonnegative numbers, allowing 413 faster code for sqrt to be generated. */ 414 415int flag_fast_math = 0; 416 417/* Nonzero means all references through pointers are volatile. */ 418 419int flag_volatile; 420 421/* Nonzero means treat all global and extern variables as global. */ 422 423int flag_volatile_global; 424 425/* Nonzero means just do syntax checking; don't output anything. */ 426 427int flag_syntax_only = 0; 428 429/* Nonzero means to rerun cse after loop optimization. This increases 430 compilation time about 20% and picks up a few more common expressions. */ 431 432static int flag_rerun_cse_after_loop; 433 434/* Nonzero for -finline-functions: ok to inline functions that look like 435 good inline candidates. */ 436 437int flag_inline_functions; 438 439/* Nonzero for -fkeep-inline-functions: even if we make a function 440 go inline everywhere, keep its definition around for debugging 441 purposes. */ 442 443int flag_keep_inline_functions; 444 445/* Nonzero means that functions will not be inlined. */ 446 447int flag_no_inline; 448 449/* Nonzero means we should be saving declaration info into a .X file. */ 450 451int flag_gen_aux_info = 0; 452 453/* Specified name of aux-info file. */ 454 455static char *aux_info_file_name; 456 457/* Nonzero means make the text shared if supported. */ 458 459int flag_shared_data; 460 461/* Nonzero means schedule into delayed branch slots if supported. */ 462 463int flag_delayed_branch; 464 465/* Nonzero means to run cleanups after CALL_EXPRs. */ 466 467int flag_short_temps; 468 469/* Nonzero if we are compiling pure (sharable) code. 470 Value is 1 if we are doing reasonable (i.e. simple 471 offset into offset table) pic. Value is 2 if we can 472 only perform register offsets. */ 473 474int flag_pic; 475 476/* Nonzero means place uninitialized global data in the bss section. */ 477 478int flag_no_common; 479 480/* Nonzero means pretend it is OK to examine bits of target floats, 481 even if that isn't true. The resulting code will have incorrect constants, 482 but the same series of instructions that the native compiler would make. */ 483 484int flag_pretend_float; 485 486/* Nonzero means change certain warnings into errors. 487 Usually these are warnings about failure to conform to some standard. */ 488 489int flag_pedantic_errors = 0; 490 491/* flag_schedule_insns means schedule insns within basic blocks (before 492 local_alloc). 493 flag_schedule_insns_after_reload means schedule insns after 494 global_alloc. */ 495 496int flag_schedule_insns = 0; 497int flag_schedule_insns_after_reload = 0; 498 499/* -finhibit-size-directive inhibits output of .size for ELF. 500 This is used only for compiling crtstuff.c, 501 and it may be extended to other effects 502 needed for crtstuff.c on other systems. */ 503int flag_inhibit_size_directive = 0; 504 505/* -fverbose-asm causes extra commentary information to be produced in 506 the generated assembly code (to make it more readable). This option 507 is generally only of use to those who actually need to read the 508 generated assembly code (perhaps while debugging the compiler itself). */ 509 510int flag_verbose_asm = 0; 511 512/* -fgnu-linker specifies use of the GNU linker for initializations. 513 (Or, more generally, a linker that handles initializations.) 514 -fno-gnu-linker says that collect2 will be used. */ 515#ifdef USE_COLLECT2 516int flag_gnu_linker = 0; 517#else 518int flag_gnu_linker = 1; 519#endif 520 521/* Tag all structures with __attribute__(packed) */ 522int flag_pack_struct = 0; 523 524/* Table of language-independent -f options. 525 STRING is the option name. VARIABLE is the address of the variable. 526 ON_VALUE is the value to store in VARIABLE 527 if `-fSTRING' is seen as an option. 528 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */ 529 530struct { char *string; int *variable; int on_value;} f_options[] = 531{ 532 {"float-store", &flag_float_store, 1}, 533 {"volatile", &flag_volatile, 1}, 534 {"volatile-global", &flag_volatile_global, 1}, 535 {"defer-pop", &flag_defer_pop, 1}, 536 {"omit-frame-pointer", &flag_omit_frame_pointer, 1}, 537 {"cse-follow-jumps", &flag_cse_follow_jumps, 1}, 538 {"cse-skip-blocks", &flag_cse_skip_blocks, 1}, 539 {"expensive-optimizations", &flag_expensive_optimizations, 1}, 540 {"thread-jumps", &flag_thread_jumps, 1}, 541 {"strength-reduce", &flag_strength_reduce, 1}, 542 {"unroll-loops", &flag_unroll_loops, 1}, 543 {"unroll-all-loops", &flag_unroll_all_loops, 1}, 544 {"writable-strings", &flag_writable_strings, 1}, 545 {"peephole", &flag_no_peephole, 0}, 546 {"force-mem", &flag_force_mem, 1}, 547 {"force-addr", &flag_force_addr, 1}, 548 {"function-cse", &flag_no_function_cse, 0}, 549 {"inline-functions", &flag_inline_functions, 1}, 550 {"keep-inline-functions", &flag_keep_inline_functions, 1}, 551 {"inline", &flag_no_inline, 0}, 552 {"syntax-only", &flag_syntax_only, 1}, 553 {"shared-data", &flag_shared_data, 1}, 554 {"caller-saves", &flag_caller_saves, 1}, 555 {"pcc-struct-return", &flag_pcc_struct_return, 1}, 556 {"reg-struct-return", &flag_pcc_struct_return, 0}, 557 {"delayed-branch", &flag_delayed_branch, 1}, 558 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1}, 559 {"pretend-float", &flag_pretend_float, 1}, 560 {"schedule-insns", &flag_schedule_insns, 1}, 561 {"schedule-insns2", &flag_schedule_insns_after_reload, 1}, 562 {"pic", &flag_pic, 1}, 563 {"PIC", &flag_pic, 2}, 564 {"fast-math", &flag_fast_math, 1}, 565 {"common", &flag_no_common, 0}, 566 {"inhibit-size-directive", &flag_inhibit_size_directive, 1}, 567 {"verbose-asm", &flag_verbose_asm, 1}, 568 {"gnu-linker", &flag_gnu_linker, 1}, 569 {"pack-struct", &flag_pack_struct, 1}, 570 {"bytecode", &output_bytecode, 1} 571}; 572 573/* Table of language-specific options. */ 574 575char *lang_options[] = 576{ 577 "-ansi", 578 "-fallow-single-precision", 579 580 "-fsigned-bitfields", 581 "-funsigned-bitfields", 582 "-fno-signed-bitfields", 583 "-fno-unsigned-bitfields", 584 "-fsigned-char", 585 "-funsigned-char", 586 "-fno-signed-char", 587 "-fno-unsigned-char", 588 589 "-ftraditional", 590 "-traditional", 591 "-fnotraditional", 592 "-fno-traditional", 593 594 "-fasm", 595 "-fno-asm", 596 "-fbuiltin", 597 "-fno-builtin", 598 "-fcond-mismatch", 599 "-fno-cond-mismatch", 600 "-fdollars-in-identifiers", 601 "-fno-dollars-in-identifiers", 602 "-fident", 603 "-fno-ident", 604 "-fshort-double", 605 "-fno-short-double", 606 "-fshort-enums", 607 "-fno-short-enums", 608 609 "-Wall", 610 "-Wbad-function-cast", 611 "-Wno-bad-function-cast", 612 "-Wcast-qual", 613 "-Wno-cast-qual", 614 "-Wchar-subscripts", 615 "-Wno-char-subscripts", 616 "-Wcomment", 617 "-Wno-comment", 618 "-Wcomments", 619 "-Wno-comments", 620 "-Wconversion", 621 "-Wno-conversion", 622 "-Wformat", 623 "-Wno-format", 624 "-Wimport", 625 "-Wno-import", 626 "-Wimplicit", 627 "-Wno-implicit", 628 "-Wmissing-braces", 629 "-Wno-missing-braces", 630 "-Wmissing-declarations", 631 "-Wno-missing-declarations", 632 "-Wmissing-prototypes", 633 "-Wno-missing-prototypes", 634 "-Wnested-externs", 635 "-Wno-nested-externs", 636 "-Wparentheses", 637 "-Wno-parentheses", 638 "-Wpointer-arith", 639 "-Wno-pointer-arith", 640 "-Wredundant-decls", 641 "-Wno-redundant-decls", 642 "-Wstrict-prototypes", 643 "-Wno-strict-prototypes", 644 "-Wtraditional", 645 "-Wno-traditional", 646 "-Wtrigraphs", 647 "-Wno-trigraphs", 648 "-Wwrite-strings", 649 "-Wno-write-strings", 650 651 /* these are for obj c */ 652 "-lang-objc", 653 "-gen-decls", 654 "-fgnu-runtime", 655 "-fno-gnu-runtime", 656 "-fnext-runtime", 657 "-fno-next-runtime", 658 "-Wselector", 659 "-Wno-selector", 660 "-Wprotocol", 661 "-Wno-protocol", 662 663#include "options.h" 664 0 665}; 666 667/* Options controlling warnings */ 668 669/* Don't print warning messages. -w. */ 670 671int inhibit_warnings = 0; 672 673/* Print various extra warnings. -W. */ 674 675int extra_warnings = 0; 676 677/* Treat warnings as errors. -Werror. */ 678 679int warnings_are_errors = 0; 680 681/* Nonzero to warn about unused local variables. */ 682 683int warn_unused; 684 685/* Nonzero to warn about variables used before they are initialized. */ 686 687int warn_uninitialized; 688 689/* Nonzero means warn about all declarations which shadow others. */ 690 691int warn_shadow; 692 693/* Warn if a switch on an enum fails to have a case for every enum value. */ 694 695int warn_switch; 696 697/* Nonzero means warn about function definitions that default the return type 698 or that use a null return and have a return-type other than void. */ 699 700int warn_return_type; 701 702/* Nonzero means warn about pointer casts that increase the required 703 alignment of the target type (and might therefore lead to a crash 704 due to a misaligned access). */ 705 706int warn_cast_align; 707 708/* Nonzero means warn about any identifiers that match in the first N 709 characters. The value N is in `id_clash_len'. */ 710 711int warn_id_clash; 712unsigned id_clash_len; 713 714/* Nonzero means warn about any objects definitions whose size is larger 715 than N bytes. Also want about function definitions whose returned 716 values are larger than N bytes. The value N is in `larger_than_size'. */ 717 718int warn_larger_than; 719unsigned larger_than_size; 720 721/* Nonzero means warn if inline function is too large. */ 722 723int warn_inline; 724 725/* Warn if a function returns an aggregate, 726 since there are often incompatible calling conventions for doing this. */ 727 728int warn_aggregate_return; 729 730/* Likewise for -W. */ 731 732struct { char *string; int *variable; int on_value;} W_options[] = 733{ 734 {"unused", &warn_unused, 1}, 735 {"error", &warnings_are_errors, 1}, 736 {"shadow", &warn_shadow, 1}, 737 {"switch", &warn_switch, 1}, 738 {"aggregate-return", &warn_aggregate_return, 1}, 739 {"cast-align", &warn_cast_align, 1}, 740 {"uninitialized", &warn_uninitialized, 1}, 741 {"inline", &warn_inline, 1} 742}; 743 744/* Output files for assembler code (real compiler output) 745 and debugging dumps. */ 746 747FILE *asm_out_file; 748FILE *aux_info_file; 749FILE *rtl_dump_file; 750FILE *jump_opt_dump_file; 751FILE *cse_dump_file; 752FILE *loop_dump_file; 753FILE *cse2_dump_file; 754FILE *flow_dump_file; 755FILE *combine_dump_file; 756FILE *sched_dump_file; 757FILE *local_reg_dump_file; 758FILE *global_reg_dump_file; 759FILE *sched2_dump_file; 760FILE *jump2_opt_dump_file; 761FILE *dbr_sched_dump_file; 762FILE *stack_reg_dump_file; 763 764/* Time accumulators, to count the total time spent in various passes. */ 765 766int parse_time; 767int varconst_time; 768int integration_time; 769int jump_time; 770int cse_time; 771int loop_time; 772int cse2_time; 773int flow_time; 774int combine_time; 775int sched_time; 776int local_alloc_time; 777int global_alloc_time; 778int sched2_time; 779int dbr_sched_time; 780int shorten_branch_time; 781int stack_reg_time; 782int final_time; 783int symout_time; 784int dump_time; 785 786/* Return time used so far, in microseconds. */ 787 788int 789get_run_time () 790{ 791#ifndef _WIN32 792#ifdef USG 793 struct tms tms; 794#else 795#ifndef VMS 796 struct rusage rusage; 797#else 798 struct 799 { 800 int proc_user_time; 801 int proc_system_time; 802 int child_user_time; 803 int child_system_time; 804 } vms_times; 805#endif 806#endif 807#endif 808 809 if (quiet_flag) 810 return 0; 811#ifdef _WIN32 812 if (clock() < 0) 813 return 0; 814 else 815 return (clock() * 1000); 816#else /* not _WIN32 */ 817#ifdef USG 818 times (&tms); 819 return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ); 820#else 821#ifndef VMS 822 getrusage (0, &rusage); 823 return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec 824 + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec); 825#else /* VMS */ 826 times (&vms_times); 827 return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000; 828#endif 829#endif 830#endif 831} 832 833#define TIMEVAR(VAR, BODY) \ 834do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0) 835 836void 837print_time (str, total) 838 char *str; 839 int total; 840{ 841 fprintf (stderr, 842 "time in %s: %d.%06d\n", 843 str, total / 1000000, total % 1000000); 844} 845 846/* Count an error or warning. Return 1 if the message should be printed. */ 847 848int 849count_error (warningp) 850 int warningp; 851{ 852 if (warningp && inhibit_warnings) 853 return 0; 854 855 if (warningp && !warnings_are_errors) 856 warningcount++; 857 else 858 { 859 static int warning_message = 0; 860 861 if (warningp && !warning_message) 862 { 863 fprintf (stderr, "%s: warnings being treated as errors\n", progname); 864 warning_message = 1; 865 } 866 errorcount++; 867 } 868 869 return 1; 870} 871 872/* Print a fatal error message. NAME is the text. 873 Also include a system error message based on `errno'. */ 874 875void 876pfatal_with_name (name) 877 char *name; 878{ 879 fprintf (stderr, "%s: ", progname); 880 perror (name); 881 exit (FATAL_EXIT_CODE); 882} 883 884void 885fatal_io_error (name) 886 char *name; 887{ 888 fprintf (stderr, "%s: %s: I/O error\n", progname, name); 889 exit (FATAL_EXIT_CODE); 890} 891 892/* Called to give a better error message for a bad insn rather than 893 just calling abort(). */ 894 895void 896fatal_insn (message, insn) 897 char *message; 898 rtx insn; 899{ 900 if (!output_bytecode) 901 { 902 error (message); 903 debug_rtx (insn); 904 } 905 if (asm_out_file) 906 fflush (asm_out_file); 907 if (aux_info_file) 908 fflush (aux_info_file); 909 if (rtl_dump_file) 910 fflush (rtl_dump_file); 911 if (jump_opt_dump_file) 912 fflush (jump_opt_dump_file); 913 if (cse_dump_file) 914 fflush (cse_dump_file); 915 if (loop_dump_file) 916 fflush (loop_dump_file); 917 if (cse2_dump_file) 918 fflush (cse2_dump_file); 919 if (flow_dump_file) 920 fflush (flow_dump_file); 921 if (combine_dump_file) 922 fflush (combine_dump_file); 923 if (sched_dump_file) 924 fflush (sched_dump_file); 925 if (local_reg_dump_file) 926 fflush (local_reg_dump_file); 927 if (global_reg_dump_file) 928 fflush (global_reg_dump_file); 929 if (sched2_dump_file) 930 fflush (sched2_dump_file); 931 if (jump2_opt_dump_file) 932 fflush (jump2_opt_dump_file); 933 if (dbr_sched_dump_file) 934 fflush (dbr_sched_dump_file); 935 if (stack_reg_dump_file) 936 fflush (stack_reg_dump_file); 937 abort (); 938} 939 940/* Called to give a better error message when we don't have an insn to match 941 what we are looking for or if the insn's constraints aren't satisfied, 942 rather than just calling abort(). */ 943 944void 945fatal_insn_not_found (insn) 946 rtx insn; 947{ 948 if (INSN_CODE (insn) < 0) 949 fatal_insn ("internal error--unrecognizable insn:", insn); 950 else 951 fatal_insn ("internal error--insn does not satisfy its constraints:", insn); 952} 953 954/* This is the default decl_printable_name function. */ 955 956static char * 957decl_name (decl, kind) 958 tree decl; 959 char **kind; 960{ 961 return IDENTIFIER_POINTER (DECL_NAME (decl)); 962} 963 964/* This is the default interim_eh_hook function. */ 965 966void 967interim_eh (finalization) 968 tree finalization; 969{ 970 /* Don't do anything by default. */ 971} 972 973static int need_error_newline; 974 975/* Function of last error message; 976 more generally, function such that if next error message is in it 977 then we don't have to mention the function name. */ 978static tree last_error_function = NULL; 979 980/* Used to detect when input_file_stack has changed since last described. */ 981static int last_error_tick; 982 983/* Called when the start of a function definition is parsed, 984 this function prints on stderr the name of the function. */ 985 986void 987announce_function (decl) 988 tree decl; 989{ 990 if (! quiet_flag) 991 { 992 char *junk; 993 if (rtl_dump_and_exit) 994 fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl))); 995 else 996 fprintf (stderr, " %s", (*decl_printable_name) (decl, &junk)); 997 fflush (stderr); 998 need_error_newline = 1; 999 last_error_function = current_function_decl; 1000 } 1001} 1002 1003/* The default function to print out name of current function that caused 1004 an error. */ 1005 1006void 1007default_print_error_function (file) 1008 char *file; 1009{ 1010 if (last_error_function != current_function_decl) 1011 { 1012 char *kind = "function"; 1013 if (current_function_decl != 0 1014 && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) 1015 kind = "method"; 1016 1017 if (file) 1018 fprintf (stderr, "%s: ", file); 1019 1020 if (current_function_decl == NULL) 1021 fprintf (stderr, "At top level:\n"); 1022 else 1023 { 1024 char *name = (*decl_printable_name) (current_function_decl, &kind); 1025 fprintf (stderr, "In %s `%s':\n", kind, name); 1026 } 1027 1028 last_error_function = current_function_decl; 1029 } 1030} 1031 1032/* Called by report_error_function to print out function name. 1033 * Default may be overridden by language front-ends. */ 1034 1035void (*print_error_function) PROTO((char*)) = default_print_error_function; 1036 1037/* Prints out, if necessary, the name of the current function 1038 that caused an error. Called from all error and warning functions. */ 1039 1040void 1041report_error_function (file) 1042 char *file; 1043{ 1044 struct file_stack *p; 1045 1046 if (need_error_newline) 1047 { 1048 fprintf (stderr, "\n"); 1049 need_error_newline = 0; 1050 } 1051 1052 (*print_error_function) (file); 1053 1054 if (input_file_stack && input_file_stack->next != 0 1055 && input_file_stack_tick != last_error_tick 1056 && file == input_filename) 1057 { 1058 fprintf (stderr, "In file included"); 1059 for (p = input_file_stack->next; p; p = p->next) 1060 { 1061 fprintf (stderr, " from %s:%d", p->name, p->line); 1062 if (p->next) 1063 fprintf (stderr, ",\n "); 1064 } 1065 fprintf (stderr, ":\n"); 1066 last_error_tick = input_file_stack_tick; 1067 } 1068} 1069 1070/* Print a message. */ 1071 1072static void 1073vmessage (prefix, s, ap) 1074 char *prefix; 1075 char *s; 1076 va_list ap; 1077{ 1078 if (prefix) 1079 fprintf (stderr, "%s: ", prefix); 1080 1081#ifdef HAVE_VPRINTF 1082 vfprintf (stderr, s, ap); 1083#else 1084 { 1085 HOST_WIDE_INT v1 = va_arg(ap, HOST_WIDE_INT); 1086 HOST_WIDE_INT v2 = va_arg(ap, HOST_WIDE_INT); 1087 HOST_WIDE_INT v3 = va_arg(ap, HOST_WIDE_INT); 1088 HOST_WIDE_INT v4 = va_arg(ap, HOST_WIDE_INT); 1089 fprintf (stderr, s, v1, v2, v3, v4); 1090 } 1091#endif 1092} 1093 1094/* Print a message relevant to line LINE of file FILE. */ 1095 1096static void 1097v_message_with_file_and_line (file, line, prefix, s, ap) 1098 char *file; 1099 int line; 1100 char *prefix; 1101 char *s; 1102 va_list ap; 1103{ 1104 if (file) 1105 fprintf (stderr, "%s:%d: ", file, line); 1106 else 1107 fprintf (stderr, "%s: ", progname); 1108 1109 vmessage (prefix, s, ap); 1110 fputc ('\n', stderr); 1111} 1112 1113/* Print a message relevant to the given DECL. */ 1114 1115static void 1116v_message_with_decl (decl, prefix, s, ap) 1117 tree decl; 1118 char *prefix; 1119 char *s; 1120 va_list ap; 1121{ 1122 char *n, *p, *junk; 1123 1124 fprintf (stderr, "%s:%d: ", 1125 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); 1126 1127 if (prefix) 1128 fprintf (stderr, "%s: ", prefix); 1129 1130 /* Do magic to get around lack of varargs support for insertion 1131 of arguments into existing list. We know that the decl is first; 1132 we ass_u_me that it will be printed with "%s". */ 1133 1134 for (p = s; *p; ++p) 1135 { 1136 if (*p == '%') 1137 { 1138 if (*(p + 1) == '%') 1139 ++p; 1140 else 1141 break; 1142 } 1143 } 1144 1145 if (p > s) /* Print the left-hand substring. */ 1146 { 1147 char fmt[sizeof "%.255s"]; 1148 long width = p - s; 1149 1150 if (width > 255L) width = 255L; /* arbitrary */ 1151 sprintf (fmt, "%%.%lds", width); 1152 fprintf (stderr, fmt, s); 1153 } 1154 1155 if (*p == '%') /* Print the name. */ 1156 { 1157 char *n = (DECL_NAME (decl) 1158 ? (*decl_printable_name) (decl, &junk) 1159 : "((anonymous))"); 1160 fputs (n, stderr); 1161 while (*p) 1162 { 1163 ++p; 1164 if (isalpha (*(p - 1) & 0xFF)) 1165 break; 1166 } 1167 } 1168 1169 if (*p) /* Print the rest of the message. */ 1170 vmessage ((char *)NULL, p, ap); 1171 1172 fputc ('\n', stderr); 1173} 1174 1175/* Figure file and line of the given INSN. */ 1176 1177static void 1178file_and_line_for_asm (insn, pfile, pline) 1179 rtx insn; 1180 char **pfile; 1181 int *pline; 1182{ 1183 rtx body = PATTERN (insn); 1184 rtx asmop; 1185 1186 /* Find the (or one of the) ASM_OPERANDS in the insn. */ 1187 if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS) 1188 asmop = SET_SRC (body); 1189 else if (GET_CODE (body) == ASM_OPERANDS) 1190 asmop = body; 1191 else if (GET_CODE (body) == PARALLEL 1192 && GET_CODE (XVECEXP (body, 0, 0)) == SET) 1193 asmop = SET_SRC (XVECEXP (body, 0, 0)); 1194 else if (GET_CODE (body) == PARALLEL 1195 && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS) 1196 asmop = XVECEXP (body, 0, 0); 1197 else 1198 asmop = NULL; 1199 1200 if (asmop) 1201 { 1202 *pfile = ASM_OPERANDS_SOURCE_FILE (asmop); 1203 *pline = ASM_OPERANDS_SOURCE_LINE (asmop); 1204 } 1205 else 1206 { 1207 *pfile = input_filename; 1208 *pline = lineno; 1209 } 1210} 1211 1212/* Report an error at line LINE of file FILE. */ 1213 1214static void 1215v_error_with_file_and_line (file, line, s, ap) 1216 char *file; 1217 int line; 1218 char *s; 1219 va_list ap; 1220{ 1221 count_error (0); 1222 report_error_function (file); 1223 v_message_with_file_and_line (file, line, (char *)NULL, s, ap); 1224} 1225 1226void 1227error_with_file_and_line VPROTO((char *file, int line, char *s, ...)) 1228{ 1229#ifndef __STDC__ 1230 char *file; 1231 int line; 1232 char *s; 1233#endif 1234 va_list ap; 1235 1236 VA_START (ap, s); 1237 1238#ifndef __STDC__ 1239 file = va_arg (ap, char *); 1240 line = va_arg (ap, int); 1241 s = va_arg (ap, char *); 1242#endif 1243 1244 v_error_with_file_and_line (file, line, s, ap); 1245 va_end (ap); 1246} 1247 1248/* Report an error at the declaration DECL. 1249 S is a format string which uses %s to substitute the declaration 1250 name; subsequent substitutions are a la printf. */ 1251 1252static void 1253v_error_with_decl (decl, s, ap) 1254 tree decl; 1255 char *s; 1256 va_list ap; 1257{ 1258 count_error (0); 1259 report_error_function (DECL_SOURCE_FILE (decl)); 1260 v_message_with_decl (decl, (char *)NULL, s, ap); 1261} 1262 1263void 1264error_with_decl VPROTO((tree decl, char *s, ...)) 1265{ 1266#ifndef __STDC__ 1267 tree decl; 1268 char *s; 1269#endif 1270 va_list ap; 1271 1272 VA_START (ap, s); 1273 1274#ifndef __STDC__ 1275 decl = va_arg (ap, tree); 1276 s = va_arg (ap, char *); 1277#endif 1278 1279 v_error_with_decl (decl, s, ap); 1280 va_end (ap); 1281} 1282 1283/* Report an error at the line number of the insn INSN. 1284 This is used only when INSN is an `asm' with operands, 1285 and each ASM_OPERANDS records its own source file and line. */ 1286 1287static void 1288v_error_for_asm (insn, s, ap) 1289 rtx insn; 1290 char *s; 1291 va_list ap; 1292{ 1293 char *file; 1294 int line; 1295 1296 count_error (0); 1297 file_and_line_for_asm (insn, &file, &line); 1298 report_error_function (file); 1299 v_message_with_file_and_line (file, line, (char *)NULL, s, ap); 1300} 1301 1302void 1303error_for_asm VPROTO((rtx insn, char *s, ...)) 1304{ 1305#ifndef __STDC__ 1306 rtx insn; 1307 char *s; 1308#endif 1309 va_list ap; 1310 1311 VA_START (ap, s); 1312 1313#ifndef __STDC__ 1314 insn = va_arg (ap, rtx); 1315 s = va_arg (ap, char *); 1316#endif 1317 1318 v_error_for_asm (insn, s, ap); 1319 va_end (ap); 1320} 1321 1322/* Report an error at the current line number. */ 1323 1324static void 1325verror (s, ap) 1326 char *s; 1327 va_list ap; 1328{ 1329 v_error_with_file_and_line (input_filename, lineno, s, ap); 1330} 1331 1332void 1333error VPROTO((char *s, ...)) 1334{ 1335#ifndef __STDC__ 1336 char *s; 1337#endif 1338 va_list ap; 1339 1340 VA_START (ap, s); 1341 1342#ifndef __STDC__ 1343 s = va_arg (ap, char *); 1344#endif 1345 1346 verror (s, ap); 1347 va_end (ap); 1348} 1349 1350/* Report a fatal error at the current line number. */ 1351 1352static void 1353vfatal (s, ap) 1354 char *s; 1355 va_list ap; 1356{ 1357 verror (s, ap); 1358 exit (FATAL_EXIT_CODE); 1359} 1360 1361void 1362fatal VPROTO((char *s, ...)) 1363{ 1364#ifndef __STDC__ 1365 char *s; 1366#endif 1367 va_list ap; 1368 1369 VA_START (ap, s); 1370 1371#ifndef __STDC__ 1372 s = va_arg (ap, char *); 1373#endif 1374 1375 vfatal (s, ap); 1376 va_end (ap); 1377} 1378 1379/* Report a warning at line LINE of file FILE. */ 1380 1381static void 1382v_warning_with_file_and_line (file, line, s, ap) 1383 char *file; 1384 int line; 1385 char *s; 1386 va_list ap; 1387{ 1388 if (count_error (1)) 1389 { 1390 report_error_function (file); 1391 v_message_with_file_and_line (file, line, "warning", s, ap); 1392 } 1393} 1394 1395void 1396warning_with_file_and_line VPROTO((char *file, int line, char *s, ...)) 1397{ 1398#ifndef __STDC__ 1399 char *file; 1400 int line; 1401 char *s; 1402#endif 1403 va_list ap; 1404 1405 VA_START (ap, s); 1406 1407#ifndef __STDC__ 1408 file = va_arg (ap, char *); 1409 line = va_arg (ap, int); 1410 s = va_arg (ap, char *); 1411#endif 1412 1413 v_warning_with_file_and_line (file, line, s, ap); 1414 va_end (ap); 1415} 1416 1417/* Report a warning at the declaration DECL. 1418 S is a format string which uses %s to substitute the declaration 1419 name; subsequent substitutions are a la printf. */ 1420 1421static void 1422v_warning_with_decl (decl, s, ap) 1423 tree decl; 1424 char *s; 1425 va_list ap; 1426{ 1427 if (count_error (1)) 1428 { 1429 report_error_function (DECL_SOURCE_FILE (decl)); 1430 v_message_with_decl (decl, "warning", s, ap); 1431 } 1432} 1433 1434void 1435warning_with_decl VPROTO((tree decl, char *s, ...)) 1436{ 1437#ifndef __STDC__ 1438 tree decl; 1439 char *s; 1440#endif 1441 va_list ap; 1442 1443 VA_START (ap, s); 1444 1445#ifndef __STDC__ 1446 decl = va_arg (ap, tree); 1447 s = va_arg (ap, char *); 1448#endif 1449 1450 v_warning_with_decl (decl, s, ap); 1451 va_end (ap); 1452} 1453 1454/* Report a warning at the line number of the insn INSN. 1455 This is used only when INSN is an `asm' with operands, 1456 and each ASM_OPERANDS records its own source file and line. */ 1457 1458static void 1459v_warning_for_asm (insn, s, ap) 1460 rtx insn; 1461 char *s; 1462 va_list ap; 1463{ 1464 if (count_error (1)) 1465 { 1466 char *file; 1467 int line; 1468 1469 file_and_line_for_asm (insn, &file, &line); 1470 report_error_function (file); 1471 v_message_with_file_and_line (file, line, "warning", s, ap); 1472 } 1473} 1474 1475void 1476warning_for_asm VPROTO((rtx insn, char *s, ...)) 1477{ 1478#ifndef __STDC__ 1479 rtx insn; 1480 char *s; 1481#endif 1482 va_list ap; 1483 1484 VA_START (ap, s); 1485 1486#ifndef __STDC__ 1487 insn = va_arg (ap, rtx); 1488 s = va_arg (ap, char *); 1489#endif 1490 1491 v_warning_for_asm (insn, s, ap); 1492 va_end (ap); 1493} 1494 1495/* Report a warning at the current line number. */ 1496 1497static void 1498vwarning (s, ap) 1499 char *s; 1500 va_list ap; 1501{ 1502 v_warning_with_file_and_line (input_filename, lineno, s, ap); 1503} 1504 1505void 1506warning VPROTO((char *s, ...)) 1507{ 1508#ifndef __STDC__ 1509 char *s; 1510#endif 1511 va_list ap; 1512 1513 VA_START (ap, s); 1514 1515#ifndef __STDC__ 1516 s = va_arg (ap, char *); 1517#endif 1518 1519 vwarning (s, ap); 1520 va_end (ap); 1521} 1522 1523/* These functions issue either warnings or errors depending on 1524 -pedantic-errors. */ 1525 1526static void 1527vpedwarn (s, ap) 1528 char *s; 1529 va_list ap; 1530{ 1531 if (flag_pedantic_errors) 1532 verror (s, ap); 1533 else 1534 vwarning (s, ap); 1535} 1536 1537void 1538pedwarn VPROTO((char *s, ...)) 1539{ 1540#ifndef __STDC__ 1541 char *s; 1542#endif 1543 va_list ap; 1544 1545 VA_START (ap, s); 1546 1547#ifndef __STDC__ 1548 s = va_arg (ap, char *); 1549#endif 1550 1551 vpedwarn (s, ap); 1552 va_end (ap); 1553} 1554 1555static void 1556v_pedwarn_with_decl (decl, s, ap) 1557 tree decl; 1558 char *s; 1559 va_list ap; 1560{ 1561 /* We don't want -pedantic-errors to cause the compilation to fail from 1562 "errors" in system header files. Sometimes fixincludes can't fix what's 1563 broken (eg: unsigned char bitfields - fixing it may change the alignment 1564 which will cause programs to mysteriously fail because the C library 1565 or kernel uses the original layout). There's no point in issuing a 1566 warning either, it's just unnecessary noise. */ 1567 1568 if (! DECL_IN_SYSTEM_HEADER (decl)) 1569 { 1570 if (flag_pedantic_errors) 1571 v_error_with_decl (decl, s, ap); 1572 else 1573 v_warning_with_decl (decl, s, ap); 1574 } 1575} 1576 1577void 1578pedwarn_with_decl VPROTO((tree decl, char *s, ...)) 1579{ 1580#ifndef __STDC__ 1581 tree decl; 1582 char *s; 1583#endif 1584 va_list ap; 1585 1586 VA_START (ap, s); 1587 1588#ifndef __STDC__ 1589 decl = va_arg (ap, tree); 1590 s = va_arg (ap, char *); 1591#endif 1592 1593 v_pedwarn_with_decl (decl, s, ap); 1594 va_end (ap); 1595} 1596 1597static void 1598v_pedwarn_with_file_and_line (file, line, s, ap) 1599 char *file; 1600 int line; 1601 char *s; 1602 va_list ap; 1603{ 1604 if (flag_pedantic_errors) 1605 v_error_with_file_and_line (file, line, s, ap); 1606 else 1607 v_warning_with_file_and_line (file, line, s, ap); 1608} 1609 1610void 1611pedwarn_with_file_and_line VPROTO((char *file, int line, char *s, ...)) 1612{ 1613#ifndef __STDC__ 1614 char *file; 1615 int line; 1616 char *s; 1617#endif 1618 va_list ap; 1619 1620 VA_START (ap, s); 1621 1622#ifndef __STDC__ 1623 file = va_arg (ap, char *); 1624 line = va_arg (ap, int); 1625 s = va_arg (ap, char *); 1626#endif 1627 1628 v_pedwarn_with_file_and_line (file, line, s, ap); 1629 va_end (ap); 1630} 1631 1632/* Apologize for not implementing some feature. */ 1633 1634static void 1635vsorry (s, ap) 1636 char *s; 1637 va_list ap; 1638{ 1639 sorrycount++; 1640 if (input_filename) 1641 fprintf (stderr, "%s:%d: ", input_filename, lineno); 1642 else 1643 fprintf (stderr, "%s: ", progname); 1644 vmessage ("sorry, not implemented", s, ap); 1645 fputc ('\n', stderr); 1646} 1647 1648void 1649sorry VPROTO((char *s, ...)) 1650{ 1651#ifndef __STDC__ 1652 char *s; 1653#endif 1654 va_list ap; 1655 1656 VA_START (ap, s); 1657 1658#ifndef __STDC__ 1659 s = va_arg (ap, char *); 1660#endif 1661 1662 vsorry (s, ap); 1663 va_end (ap); 1664} 1665 1666/* Apologize for not implementing some feature, then quit. */ 1667 1668static void 1669v_really_sorry (s, ap) 1670 char *s; 1671 va_list ap; 1672{ 1673 sorrycount++; 1674 if (input_filename) 1675 fprintf (stderr, "%s:%d: ", input_filename, lineno); 1676 else 1677 fprintf (stderr, "%s: ", progname); 1678 vmessage ("sorry, not implemented", s, ap); 1679 fatal (" (fatal)\n"); 1680} 1681 1682void 1683really_sorry VPROTO((char *s, ...)) 1684{ 1685#ifndef __STDC__ 1686 char *s; 1687#endif 1688 va_list ap; 1689 1690 VA_START (ap, s); 1691 1692#ifndef __STDC__ 1693 s = va_arg (ap, char *); 1694#endif 1695 1696 v_really_sorry (s, ap); 1697 va_end (ap); 1698} 1699 1700/* More 'friendly' abort that prints the line and file. 1701 config.h can #define abort fancy_abort if you like that sort of thing. 1702 1703 I don't think this is actually a good idea. 1704 Other sorts of crashes will look a certain way. 1705 It is a good thing if crashes from calling abort look the same way. 1706 -- RMS */ 1707 1708void 1709fancy_abort () 1710{ 1711 fatal ("internal gcc abort"); 1712} 1713 1714/* This calls abort and is used to avoid problems when abort if a macro. 1715 It is used when we need to pass the address of abort. */ 1716 1717void 1718do_abort () 1719{ 1720 abort (); 1721} 1722 1723/* When `malloc.c' is compiled with `rcheck' defined, 1724 it calls this function to report clobberage. */ 1725 1726void 1727botch (s) 1728{ 1729 abort (); 1730} 1731 1732/* Same as `malloc' but report error if no memory available. */ 1733 1734char * 1735xmalloc (size) 1736 unsigned size; 1737{ 1738 register char *value = (char *) malloc (size); 1739 if (value == 0) 1740 fatal ("virtual memory exhausted"); 1741 return value; 1742} 1743 1744/* Same as `realloc' but report error if no memory available. */ 1745 1746char * 1747xrealloc (ptr, size) 1748 char *ptr; 1749 int size; 1750{ 1751 char *result = (char *) realloc (ptr, size); 1752 if (!result) 1753 fatal ("virtual memory exhausted"); 1754 return result; 1755} 1756 1757/* Return the logarithm of X, base 2, considering X unsigned, 1758 if X is a power of 2. Otherwise, returns -1. 1759 1760 This should be used via the `exact_log2' macro. */ 1761 1762int 1763exact_log2_wide (x) 1764 register unsigned HOST_WIDE_INT x; 1765{ 1766 register int log = 0; 1767 /* Test for 0 or a power of 2. */ 1768 if (x == 0 || x != (x & -x)) 1769 return -1; 1770 while ((x >>= 1) != 0) 1771 log++; 1772 return log; 1773} 1774 1775/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X. 1776 If X is 0, return -1. 1777 1778 This should be used via the floor_log2 macro. */ 1779 1780int 1781floor_log2_wide (x) 1782 register unsigned HOST_WIDE_INT x; 1783{ 1784 register int log = -1; 1785 while (x != 0) 1786 log++, 1787 x >>= 1; 1788 return log; 1789} 1790 1791int float_handled; 1792jmp_buf float_handler; 1793 1794/* Specify where to longjmp to when a floating arithmetic error happens. 1795 If HANDLER is 0, it means don't handle the errors any more. */ 1796 1797void 1798set_float_handler (handler) 1799 jmp_buf handler; 1800{ 1801 float_handled = (handler != 0); 1802 if (handler) 1803 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler)); 1804} 1805 1806/* Specify, in HANDLER, where to longjmp to when a floating arithmetic 1807 error happens, pushing the previous specification into OLD_HANDLER. 1808 Return an indication of whether there was a previous handler in effect. */ 1809 1810int 1811push_float_handler (handler, old_handler) 1812 jmp_buf handler, old_handler; 1813{ 1814 int was_handled = float_handled; 1815 1816 float_handled = 1; 1817 if (was_handled) 1818 bcopy ((char *) float_handler, (char *) old_handler, 1819 sizeof (float_handler)); 1820 1821 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler)); 1822 return was_handled; 1823} 1824 1825/* Restore the previous specification of whether and where to longjmp to 1826 when a floating arithmetic error happens. */ 1827 1828void 1829pop_float_handler (handled, handler) 1830 int handled; 1831 jmp_buf handler; 1832{ 1833 float_handled = handled; 1834 if (handled) 1835 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler)); 1836} 1837 1838/* Signals actually come here. */ 1839 1840static void 1841float_signal (signo) 1842 /* If this is missing, some compilers complain. */ 1843 int signo; 1844{ 1845 if (float_handled == 0) 1846 abort (); 1847#if defined (USG) || defined (hpux) 1848 signal (SIGFPE, float_signal); /* re-enable the signal catcher */ 1849#endif 1850 float_handled = 0; 1851 signal (SIGFPE, float_signal); 1852 longjmp (float_handler, 1); 1853} 1854 1855/* Handler for SIGPIPE. */ 1856 1857static void 1858pipe_closed (signo) 1859 /* If this is missing, some compilers complain. */ 1860 int signo; 1861{ 1862 fatal ("output pipe has been closed"); 1863} 1864 1865/* Strip off a legitimate source ending from the input string NAME of 1866 length LEN. Rather than having to know the names used by all of 1867 our front ends, we strip off an ending of a period followed by one, 1868 two, or three characters. */ 1869 1870void 1871strip_off_ending (name, len) 1872 char *name; 1873 int len; 1874{ 1875 if (len > 2 && name[len - 2] == '.') 1876 name[len - 2] = '\0'; 1877 else if (len > 3 && name[len - 3] == '.') 1878 name[len - 3] = '\0'; 1879 else if (len > 4 && name[len - 4] == '.') 1880 name[len - 4] = '\0'; 1881} 1882 1883/* Output a quoted string. */ 1884void 1885output_quoted_string (asm_file, string) 1886 FILE *asm_file; 1887 char *string; 1888{ 1889 char c; 1890 1891 putc ('\"', asm_file); 1892 while ((c = *string++) != 0) 1893 { 1894 if (c == '\"' || c == '\\') 1895 putc ('\\', asm_file); 1896 putc (c, asm_file); 1897 } 1898 putc ('\"', asm_file); 1899} 1900 1901/* Output a file name in the form wanted by System V. */ 1902 1903void 1904output_file_directive (asm_file, input_name) 1905 FILE *asm_file; 1906 char *input_name; 1907{ 1908 int len = strlen (input_name); 1909 char *na = input_name + len; 1910 1911 /* NA gets INPUT_NAME sans directory names. */ 1912 while (na > input_name) 1913 { 1914 if (na[-1] == '/') 1915 break; 1916 na--; 1917 } 1918 1919#ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME 1920 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na); 1921#else 1922#ifdef ASM_OUTPUT_SOURCE_FILENAME 1923 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na); 1924#else 1925 fprintf (asm_file, "\t.file\t"); 1926 output_quoted_string (asm_file, na); 1927 fputc ('\n', asm_file); 1928#endif 1929#endif 1930} 1931 1932/* Routine to build language identifier for object file. */ 1933static void 1934output_lang_identify (asm_out_file) 1935 FILE *asm_out_file; 1936{ 1937 int len = strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1; 1938 char *s = (char *) alloca (len); 1939 sprintf (s, "__gnu_compiled_%s", lang_identify ()); 1940 ASM_OUTPUT_LABEL (asm_out_file, s); 1941} 1942 1943/* Routine to open a dump file. */ 1944static FILE * 1945open_dump_file (base_name, suffix) 1946 char *base_name; 1947 char *suffix; 1948{ 1949 FILE *f; 1950 char *dumpname = (char *) alloca (strlen (base_name) + strlen (suffix) + 1); 1951 1952 strcpy (dumpname, base_name); 1953 strcat (dumpname, suffix); 1954 f = fopen (dumpname, "w"); 1955 if (f == 0) 1956 pfatal_with_name (dumpname); 1957 return f; 1958} 1959 1960/* Compile an entire file of output from cpp, named NAME. 1961 Write a file of assembly output and various debugging dumps. */ 1962 1963static void 1964compile_file (name) 1965 char *name; 1966{ 1967 tree globals; 1968 int start_time; 1969 1970 int name_specified = name != 0; 1971 1972 if (dump_base_name == 0) 1973 dump_base_name = name ? name : "gccdump"; 1974 1975 parse_time = 0; 1976 varconst_time = 0; 1977 integration_time = 0; 1978 jump_time = 0; 1979 cse_time = 0; 1980 loop_time = 0; 1981 cse2_time = 0; 1982 flow_time = 0; 1983 combine_time = 0; 1984 sched_time = 0; 1985 local_alloc_time = 0; 1986 global_alloc_time = 0; 1987 sched2_time = 0; 1988 dbr_sched_time = 0; 1989 shorten_branch_time = 0; 1990 stack_reg_time = 0; 1991 final_time = 0; 1992 symout_time = 0; 1993 dump_time = 0; 1994 1995 /* Open input file. */ 1996 1997 if (name == 0 || !strcmp (name, "-")) 1998 { 1999 finput = stdin; 2000 name = "stdin"; 2001 } 2002 else 2003 finput = fopen (name, "r"); 2004 if (finput == 0) 2005 pfatal_with_name (name); 2006 2007#ifdef IO_BUFFER_SIZE 2008 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE); 2009#endif 2010 2011 /* Initialize data in various passes. */ 2012 2013 init_obstacks (); 2014 init_tree_codes (); 2015 init_lex (); 2016 /* Some of these really don't need to be called when generating bytecode, 2017 but the options would have to be parsed first to know that. -bson */ 2018 init_rtl (); 2019 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL 2020 || debug_info_level == DINFO_LEVEL_VERBOSE); 2021 init_regs (); 2022 init_decl_processing (); 2023 init_optabs (); 2024 init_stmt (); 2025 init_expmed (); 2026 init_expr_once (); 2027 init_loop (); 2028 init_reload (); 2029 2030 if (flag_caller_saves) 2031 init_caller_save (); 2032 2033 /* If auxiliary info generation is desired, open the output file. 2034 This goes in the same directory as the source file--unlike 2035 all the other output files. */ 2036 if (flag_gen_aux_info) 2037 { 2038 aux_info_file = fopen (aux_info_file_name, "w"); 2039 if (aux_info_file == 0) 2040 pfatal_with_name (aux_info_file_name); 2041 } 2042 2043 /* If rtl dump desired, open the output file. */ 2044 if (rtl_dump) 2045 rtl_dump_file = open_dump_file (dump_base_name, ".rtl"); 2046 2047 /* If jump_opt dump desired, open the output file. */ 2048 if (jump_opt_dump) 2049 jump_opt_dump_file = open_dump_file (dump_base_name, ".jump"); 2050 2051 /* If cse dump desired, open the output file. */ 2052 if (cse_dump) 2053 cse_dump_file = open_dump_file (dump_base_name, ".cse"); 2054 2055 /* If loop dump desired, open the output file. */ 2056 if (loop_dump) 2057 loop_dump_file = open_dump_file (dump_base_name, ".loop"); 2058 2059 /* If cse2 dump desired, open the output file. */ 2060 if (cse2_dump) 2061 cse2_dump_file = open_dump_file (dump_base_name, ".cse2"); 2062 2063 /* If flow dump desired, open the output file. */ 2064 if (flow_dump) 2065 flow_dump_file = open_dump_file (dump_base_name, ".flow"); 2066 2067 /* If combine dump desired, open the output file. */ 2068 if (combine_dump) 2069 combine_dump_file = open_dump_file (dump_base_name, ".combine"); 2070 2071 /* If scheduling dump desired, open the output file. */ 2072 if (sched_dump) 2073 sched_dump_file = open_dump_file (dump_base_name, ".sched"); 2074 2075 /* If local_reg dump desired, open the output file. */ 2076 if (local_reg_dump) 2077 local_reg_dump_file = open_dump_file (dump_base_name, ".lreg"); 2078 2079 /* If global_reg dump desired, open the output file. */ 2080 if (global_reg_dump) 2081 global_reg_dump_file = open_dump_file (dump_base_name, ".greg"); 2082 2083 /* If 2nd scheduling dump desired, open the output file. */ 2084 if (sched2_dump) 2085 sched2_dump_file = open_dump_file (dump_base_name, ".sched2"); 2086 2087 /* If jump2_opt dump desired, open the output file. */ 2088 if (jump2_opt_dump) 2089 jump2_opt_dump_file = open_dump_file (dump_base_name, ".jump2"); 2090 2091 /* If dbr_sched dump desired, open the output file. */ 2092 if (dbr_sched_dump) 2093 dbr_sched_dump_file = open_dump_file (dump_base_name, ".dbr"); 2094 2095#ifdef STACK_REGS 2096 2097 /* If stack_reg dump desired, open the output file. */ 2098 if (stack_reg_dump) 2099 stack_reg_dump_file = open_dump_file (dump_base_name, ".stack"); 2100 2101#endif 2102 2103 /* Open assembler code output file. */ 2104 2105 if (! name_specified && asm_file_name == 0) 2106 asm_out_file = stdout; 2107 else 2108 { 2109 int len = strlen (dump_base_name); 2110 register char *dumpname = (char *) xmalloc (len + 6); 2111 strcpy (dumpname, dump_base_name); 2112 strip_off_ending (dumpname, len); 2113 strcat (dumpname, ".s"); 2114 if (asm_file_name == 0) 2115 { 2116 asm_file_name = (char *) xmalloc (strlen (dumpname) + 1); 2117 strcpy (asm_file_name, dumpname); 2118 } 2119 if (!strcmp (asm_file_name, "-")) 2120 asm_out_file = stdout; 2121 else 2122 asm_out_file = fopen (asm_file_name, "w"); 2123 if (asm_out_file == 0) 2124 pfatal_with_name (asm_file_name); 2125 } 2126 2127#ifdef IO_BUFFER_SIZE 2128 setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE), 2129 _IOFBF, IO_BUFFER_SIZE); 2130#endif 2131 2132 input_filename = name; 2133 2134 /* Put an entry on the input file stack for the main input file. */ 2135 input_file_stack 2136 = (struct file_stack *) xmalloc (sizeof (struct file_stack)); 2137 input_file_stack->next = 0; 2138 input_file_stack->name = input_filename; 2139 2140 /* Perform language-specific initialization. 2141 This may set main_input_filename. */ 2142 lang_init (); 2143 2144 /* If the input doesn't start with a #line, use the input name 2145 as the official input file name. */ 2146 if (main_input_filename == 0) 2147 main_input_filename = name; 2148 2149 if (!output_bytecode) 2150 { 2151 ASM_FILE_START (asm_out_file); 2152 } 2153 2154 /* Output something to inform GDB that this compilation was by GCC. Also 2155 serves to tell GDB file consists of bytecodes. */ 2156 if (output_bytecode) 2157 fprintf (asm_out_file, "bc_gcc2_compiled.:\n"); 2158 else 2159 { 2160#ifndef ASM_IDENTIFY_GCC 2161 fprintf (asm_out_file, "gcc2_compiled.:\n"); 2162#else 2163 ASM_IDENTIFY_GCC (asm_out_file); 2164#endif 2165 } 2166 2167 /* Output something to identify which front-end produced this file. */ 2168#ifdef ASM_IDENTIFY_LANGUAGE 2169 ASM_IDENTIFY_LANGUAGE (asm_out_file); 2170#endif 2171 2172 if (output_bytecode) 2173 { 2174 if (profile_flag || profile_block_flag) 2175 error ("profiling not supported in bytecode compilation"); 2176 } 2177 else 2178 { 2179 /* ??? Note: There used to be a conditional here 2180 to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined. 2181 This was to guarantee separation between gcc_compiled. and 2182 the first function, for the sake of dbx on Suns. 2183 However, having the extra zero here confused the Emacs 2184 code for unexec, and might confuse other programs too. 2185 Therefore, I took out that change. 2186 In future versions we should find another way to solve 2187 that dbx problem. -- rms, 23 May 93. */ 2188 2189 /* Don't let the first function fall at the same address 2190 as gcc_compiled., if profiling. */ 2191 if (profile_flag || profile_block_flag) 2192 assemble_zeros (UNITS_PER_WORD); 2193 } 2194 2195 /* If dbx symbol table desired, initialize writing it 2196 and output the predefined types. */ 2197#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 2198 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG) 2199 TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename, 2200 getdecls ())); 2201#endif 2202#ifdef SDB_DEBUGGING_INFO 2203 if (write_symbols == SDB_DEBUG) 2204 TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename, 2205 getdecls ())); 2206#endif 2207#ifdef DWARF_DEBUGGING_INFO 2208 if (write_symbols == DWARF_DEBUG) 2209 TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename)); 2210#endif 2211 2212 /* Initialize yet another pass. */ 2213 2214 if (!output_bytecode) 2215 init_final (main_input_filename); 2216 2217 start_time = get_run_time (); 2218 2219 /* Call the parser, which parses the entire file 2220 (calling rest_of_compilation for each function). */ 2221 2222 if (yyparse () != 0) 2223 { 2224 if (errorcount == 0) 2225 fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)"); 2226 2227 /* In case there were missing closebraces, 2228 get us back to the global binding level. */ 2229 while (! global_bindings_p ()) 2230 poplevel (0, 0, 0); 2231 } 2232 2233 /* Compilation is now finished except for writing 2234 what's left of the symbol table output. */ 2235 2236 parse_time += get_run_time () - start_time; 2237 2238 parse_time -= integration_time; 2239 parse_time -= varconst_time; 2240 2241 globals = getdecls (); 2242 2243 /* Really define vars that have had only a tentative definition. 2244 Really output inline functions that must actually be callable 2245 and have not been output so far. */ 2246 2247 { 2248 int len = list_length (globals); 2249 tree *vec = (tree *) alloca (sizeof (tree) * len); 2250 int i; 2251 tree decl; 2252 int reconsider = 1; 2253 2254 /* Process the decls in reverse order--earliest first. 2255 Put them into VEC from back to front, then take out from front. */ 2256 2257 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl)) 2258 vec[len - i - 1] = decl; 2259 2260 for (i = 0; i < len; i++) 2261 { 2262 decl = vec[i]; 2263 2264 /* We're not deferring this any longer. */ 2265 DECL_DEFER_OUTPUT (decl) = 0; 2266 2267 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0 2268 && incomplete_decl_finalize_hook != 0) 2269 (*incomplete_decl_finalize_hook) (decl); 2270 } 2271 2272 /* Now emit any global variables or functions that we have been putting 2273 off. We need to loop in case one of the things emitted here 2274 references another one which comes earlier in the list. */ 2275 while (reconsider) 2276 { 2277 reconsider = 0; 2278 for (i = 0; i < len; i++) 2279 { 2280 decl = vec[i]; 2281 2282 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)) 2283 continue; 2284 2285 /* Don't write out static consts, unless we still need them. 2286 2287 We also keep static consts if not optimizing (for debugging). 2288 ??? They might be better written into the debug information. 2289 This is possible when using DWARF. 2290 2291 A language processor that wants static constants to be always 2292 written out (even if it is not used) is responsible for 2293 calling rest_of_decl_compilation itself. E.g. the C front-end 2294 calls rest_of_decl_compilation from finish_decl. 2295 One motivation for this is that is conventional in some 2296 environments to write things like: 2297 static const char rcsid[] = "... version string ..."; 2298 intending to force the string to be in the executable. 2299 2300 A language processor that would prefer to have unneeded 2301 static constants "optimized away" would just defer writing 2302 them out until here. E.g. C++ does this, because static 2303 constants are often defined in header files. 2304 2305 ??? A tempting alternative (for both C and C++) would be 2306 to force a constant to be written if and only if it is 2307 defined in a main file, as opposed to an include file. */ 2308 2309 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl) 2310 && (! TREE_READONLY (decl) 2311 || TREE_PUBLIC (decl) 2312 || !optimize 2313 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))) 2314 { 2315 reconsider = 1; 2316 rest_of_decl_compilation (decl, NULL_PTR, 1, 1); 2317 } 2318 2319 if (TREE_CODE (decl) == FUNCTION_DECL 2320 && DECL_INITIAL (decl) != 0 2321 && DECL_SAVED_INSNS (decl) != 0 2322 && (flag_keep_inline_functions 2323 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))) 2324 { 2325 reconsider = 1; 2326 temporary_allocation (); 2327 output_inline_function (decl); 2328 permanent_allocation (1); 2329 } 2330 } 2331 } 2332 2333 for (i = 0; i < len; i++) 2334 { 2335 decl = vec[i]; 2336 2337 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl) 2338 && ! TREE_ASM_WRITTEN (decl)) 2339 /* Cancel the RTL for this decl so that, if debugging info 2340 output for global variables is still to come, 2341 this one will be omitted. */ 2342 DECL_RTL (decl) = NULL; 2343 2344 /* Warn about any function 2345 declared static but not defined. 2346 We don't warn about variables, 2347 because many programs have static variables 2348 that exist only to get some text into the object file. */ 2349 if (TREE_CODE (decl) == FUNCTION_DECL 2350 && (warn_unused 2351 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 2352 && DECL_INITIAL (decl) == 0 2353 && DECL_EXTERNAL (decl) 2354 && ! TREE_PUBLIC (decl)) 2355 { 2356 pedwarn_with_decl (decl, 2357 "`%s' declared `static' but never defined"); 2358 /* This symbol is effectively an "extern" declaration now. */ 2359 TREE_PUBLIC (decl) = 1; 2360 assemble_external (decl); 2361 } 2362 2363 /* Warn about static fns or vars defined but not used, 2364 but not about inline functions or static consts 2365 since defining those in header files is normal practice. */ 2366 if (warn_unused 2367 && ((TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl)) 2368 || (TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl))) 2369 && ! DECL_IN_SYSTEM_HEADER (decl) 2370 && ! DECL_EXTERNAL (decl) 2371 && ! TREE_PUBLIC (decl) 2372 && ! TREE_USED (decl) 2373 && ! DECL_REGISTER (decl) 2374 /* The TREE_USED bit for file-scope decls 2375 is kept in the identifier, to handle multiple 2376 external decls in different scopes. */ 2377 && ! TREE_USED (DECL_NAME (decl))) 2378 warning_with_decl (decl, "`%s' defined but not used"); 2379 2380#ifdef SDB_DEBUGGING_INFO 2381 /* The COFF linker can move initialized global vars to the end. 2382 And that can screw up the symbol ordering. 2383 By putting the symbols in that order to begin with, 2384 we avoid a problem. mcsun!unido!fauern!tumuc!pes@uunet.uu.net. */ 2385 if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL 2386 && TREE_PUBLIC (decl) && DECL_INITIAL (decl) 2387 && ! DECL_EXTERNAL (decl) 2388 && DECL_RTL (decl) != 0) 2389 TIMEVAR (symout_time, sdbout_symbol (decl, 0)); 2390 2391 /* Output COFF information for non-global 2392 file-scope initialized variables. */ 2393 if (write_symbols == SDB_DEBUG 2394 && TREE_CODE (decl) == VAR_DECL 2395 && DECL_INITIAL (decl) 2396 && ! DECL_EXTERNAL (decl) 2397 && DECL_RTL (decl) != 0 2398 && GET_CODE (DECL_RTL (decl)) == MEM) 2399 TIMEVAR (symout_time, sdbout_toplevel_data (decl)); 2400#endif /* SDB_DEBUGGING_INFO */ 2401#ifdef DWARF_DEBUGGING_INFO 2402 /* Output DWARF information for file-scope tentative data object 2403 declarations, file-scope (extern) function declarations (which 2404 had no corresponding body) and file-scope tagged type declarations 2405 and definitions which have not yet been forced out. */ 2406 2407 if (write_symbols == DWARF_DEBUG 2408 && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))) 2409 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1)); 2410#endif 2411 } 2412 } 2413 2414 /* Write out any pending weak symbol declarations. */ 2415 2416 weak_finish (); 2417 2418 /* Do dbx symbols */ 2419#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 2420 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG) 2421 TIMEVAR (symout_time, 2422 { 2423 dbxout_finish (asm_out_file, main_input_filename); 2424 }); 2425#endif 2426 2427#ifdef DWARF_DEBUGGING_INFO 2428 if (write_symbols == DWARF_DEBUG) 2429 TIMEVAR (symout_time, 2430 { 2431 dwarfout_finish (); 2432 }); 2433#endif 2434 2435 /* Output some stuff at end of file if nec. */ 2436 2437 if (!output_bytecode) 2438 { 2439 end_final (main_input_filename); 2440 2441#ifdef ASM_FILE_END 2442 ASM_FILE_END (asm_out_file); 2443#endif 2444 } 2445 2446 /* Language-specific end of compilation actions. */ 2447 2448 lang_finish (); 2449 2450 if (output_bytecode) 2451 bc_write_file (asm_out_file); 2452 2453 /* Close the dump files. */ 2454 2455 if (flag_gen_aux_info) 2456 { 2457 fclose (aux_info_file); 2458 if (errorcount) 2459 unlink (aux_info_file_name); 2460 } 2461 2462 if (rtl_dump) 2463 fclose (rtl_dump_file); 2464 2465 if (jump_opt_dump) 2466 fclose (jump_opt_dump_file); 2467 2468 if (cse_dump) 2469 fclose (cse_dump_file); 2470 2471 if (loop_dump) 2472 fclose (loop_dump_file); 2473 2474 if (cse2_dump) 2475 fclose (cse2_dump_file); 2476 2477 if (flow_dump) 2478 fclose (flow_dump_file); 2479 2480 if (combine_dump) 2481 { 2482 dump_combine_total_stats (combine_dump_file); 2483 fclose (combine_dump_file); 2484 } 2485 2486 if (sched_dump) 2487 fclose (sched_dump_file); 2488 2489 if (local_reg_dump) 2490 fclose (local_reg_dump_file); 2491 2492 if (global_reg_dump) 2493 fclose (global_reg_dump_file); 2494 2495 if (sched2_dump) 2496 fclose (sched2_dump_file); 2497 2498 if (jump2_opt_dump) 2499 fclose (jump2_opt_dump_file); 2500 2501 if (dbr_sched_dump) 2502 fclose (dbr_sched_dump_file); 2503 2504#ifdef STACK_REGS 2505 if (stack_reg_dump) 2506 fclose (stack_reg_dump_file); 2507#endif 2508 2509 /* Close non-debugging input and output files. Take special care to note 2510 whether fclose returns an error, since the pages might still be on the 2511 buffer chain while the file is open. */ 2512 2513 fclose (finput); 2514 if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0) 2515 fatal_io_error (asm_file_name); 2516 2517 /* Print the times. */ 2518 2519 if (! quiet_flag) 2520 { 2521 fprintf (stderr,"\n"); 2522 print_time ("parse", parse_time); 2523 2524 if (!output_bytecode) 2525 { 2526 print_time ("integration", integration_time); 2527 print_time ("jump", jump_time); 2528 print_time ("cse", cse_time); 2529 print_time ("loop", loop_time); 2530 print_time ("cse2", cse2_time); 2531 print_time ("flow", flow_time); 2532 print_time ("combine", combine_time); 2533 print_time ("sched", sched_time); 2534 print_time ("local-alloc", local_alloc_time); 2535 print_time ("global-alloc", global_alloc_time); 2536 print_time ("sched2", sched2_time); 2537 print_time ("dbranch", dbr_sched_time); 2538 print_time ("shorten-branch", shorten_branch_time); 2539 print_time ("stack-reg", stack_reg_time); 2540 print_time ("final", final_time); 2541 print_time ("varconst", varconst_time); 2542 print_time ("symout", symout_time); 2543 print_time ("dump", dump_time); 2544 } 2545 } 2546} 2547 2548/* This is called from various places for FUNCTION_DECL, VAR_DECL, 2549 and TYPE_DECL nodes. 2550 2551 This does nothing for local (non-static) variables. 2552 Otherwise, it sets up the RTL and outputs any assembler code 2553 (label definition, storage allocation and initialization). 2554 2555 DECL is the declaration. If ASMSPEC is nonzero, it specifies 2556 the assembler symbol name to be used. TOP_LEVEL is nonzero 2557 if this declaration is not within a function. */ 2558 2559void 2560rest_of_decl_compilation (decl, asmspec, top_level, at_end) 2561 tree decl; 2562 char *asmspec; 2563 int top_level; 2564 int at_end; 2565{ 2566 /* Declarations of variables, and of functions defined elsewhere. */ 2567 2568/* The most obvious approach, to put an #ifndef around where 2569 this macro is used, doesn't work since it's inside a macro call. */ 2570#ifndef ASM_FINISH_DECLARE_OBJECT 2571#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END) 2572#endif 2573 2574 /* Forward declarations for nested functions are not "external", 2575 but we need to treat them as if they were. */ 2576 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl) 2577 || TREE_CODE (decl) == FUNCTION_DECL) 2578 TIMEVAR (varconst_time, 2579 { 2580 make_decl_rtl (decl, asmspec, top_level); 2581 /* Initialized extern variable exists to be replaced 2582 with its value, or represents something that will be 2583 output in another file. */ 2584 if (! (TREE_CODE (decl) == VAR_DECL 2585 && DECL_EXTERNAL (decl) && TREE_READONLY (decl) 2586 && DECL_INITIAL (decl) != 0 2587 && DECL_INITIAL (decl) != error_mark_node)) 2588 /* Don't output anything 2589 when a tentative file-scope definition is seen. 2590 But at end of compilation, do output code for them. */ 2591 if (! (! at_end && top_level 2592 && (DECL_INITIAL (decl) == 0 2593 || DECL_INITIAL (decl) == error_mark_node))) 2594 assemble_variable (decl, top_level, at_end, 0); 2595 if (decl == last_assemble_variable_decl) 2596 { 2597 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl, 2598 top_level, at_end); 2599 } 2600 }); 2601 else if (DECL_REGISTER (decl) && asmspec != 0) 2602 { 2603 if (decode_reg_name (asmspec) >= 0) 2604 { 2605 DECL_RTL (decl) = 0; 2606 make_decl_rtl (decl, asmspec, top_level); 2607 } 2608 else 2609 error ("invalid register name `%s' for register variable", asmspec); 2610 } 2611#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 2612 else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG) 2613 && TREE_CODE (decl) == TYPE_DECL) 2614 TIMEVAR (symout_time, dbxout_symbol (decl, 0)); 2615#endif 2616#ifdef SDB_DEBUGGING_INFO 2617 else if (write_symbols == SDB_DEBUG && top_level 2618 && TREE_CODE (decl) == TYPE_DECL) 2619 TIMEVAR (symout_time, sdbout_symbol (decl, 0)); 2620#endif 2621} 2622 2623/* Called after finishing a record, union or enumeral type. */ 2624 2625void 2626rest_of_type_compilation (type, toplev) 2627 tree type; 2628 int toplev; 2629{ 2630#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 2631 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG) 2632 TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev)); 2633#endif 2634#ifdef SDB_DEBUGGING_INFO 2635 if (write_symbols == SDB_DEBUG) 2636 TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev)); 2637#endif 2638} 2639 2640/* This is called from finish_function (within yyparse) 2641 after each top-level definition is parsed. 2642 It is supposed to compile that function or variable 2643 and output the assembler code for it. 2644 After we return, the tree storage is freed. */ 2645 2646void 2647rest_of_compilation (decl) 2648 tree decl; 2649{ 2650 register rtx insns; 2651 int start_time = get_run_time (); 2652 int tem; 2653 /* Nonzero if we have saved the original DECL_INITIAL of the function, 2654 to be restored after we finish compiling the function 2655 (for use when compiling inline calls to this function). */ 2656 tree saved_block_tree = 0; 2657 /* Likewise, for DECL_ARGUMENTS. */ 2658 tree saved_arguments = 0; 2659 int failure = 0; 2660 2661 if (output_bytecode) 2662 return; 2663 2664 /* If we are reconsidering an inline function 2665 at the end of compilation, skip the stuff for making it inline. */ 2666 2667 if (DECL_SAVED_INSNS (decl) == 0) 2668 { 2669 int specd = DECL_INLINE (decl); 2670 char *lose; 2671 2672 /* If requested, consider whether to make this function inline. */ 2673 if (specd || flag_inline_functions) 2674 TIMEVAR (integration_time, 2675 { 2676 lose = function_cannot_inline_p (decl); 2677 /* If not optimizing, then make sure the DECL_INLINE 2678 bit is off. */ 2679 if (lose || ! optimize) 2680 { 2681 if (warn_inline && specd) 2682 warning_with_decl (decl, lose); 2683 DECL_INLINE (decl) = 0; 2684 DECL_ABSTRACT_ORIGIN (decl) = 0; 2685 /* Don't really compile an extern inline function. 2686 If we can't make it inline, pretend 2687 it was only declared. */ 2688 if (DECL_EXTERNAL (decl)) 2689 { 2690 DECL_INITIAL (decl) = 0; 2691 goto exit_rest_of_compilation; 2692 } 2693 } 2694 else 2695 DECL_INLINE (decl) = 1; 2696 }); 2697 2698 insns = get_insns (); 2699 2700 /* Dump the rtl code if we are dumping rtl. */ 2701 2702 if (rtl_dump) 2703 TIMEVAR (dump_time, 2704 { 2705 fprintf (rtl_dump_file, "\n;; Function %s\n\n", 2706 IDENTIFIER_POINTER (DECL_NAME (decl))); 2707 if (DECL_SAVED_INSNS (decl)) 2708 fprintf (rtl_dump_file, ";; (integrable)\n\n"); 2709 print_rtl (rtl_dump_file, insns); 2710 fflush (rtl_dump_file); 2711 }); 2712 2713 /* If function is inline, and we don't yet know whether to 2714 compile it by itself, defer decision till end of compilation. 2715 finish_compilation will call rest_of_compilation again 2716 for those functions that need to be output. Also defer those 2717 functions that we are supposed to defer. */ 2718 2719 if (DECL_DEFER_OUTPUT (decl) 2720 || ((specd || DECL_INLINE (decl)) 2721 && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl) 2722 && ! flag_keep_inline_functions) 2723 || DECL_EXTERNAL (decl)))) 2724 { 2725 DECL_DEFER_OUTPUT (decl) = 1; 2726 2727 /* If -Wreturn-type, we have to do a bit of compilation. */ 2728 if (! warn_return_type) 2729 { 2730#ifdef DWARF_DEBUGGING_INFO 2731 /* Generate the DWARF info for the "abstract" instance 2732 of a function which we may later generate inlined and/or 2733 out-of-line instances of. */ 2734 if (write_symbols == DWARF_DEBUG) 2735 { 2736 set_decl_abstract_flags (decl, 1); 2737 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0)); 2738 set_decl_abstract_flags (decl, 0); 2739 } 2740#endif 2741 TIMEVAR (integration_time, save_for_inline_nocopy (decl)); 2742 goto exit_rest_of_compilation; 2743 } 2744 } 2745 2746 /* If we have to compile the function now, save its rtl and subdecls 2747 so that its compilation will not affect what others get. */ 2748 if (DECL_INLINE (decl) || DECL_DEFER_OUTPUT (decl)) 2749 { 2750#ifdef DWARF_DEBUGGING_INFO 2751 /* Generate the DWARF info for the "abstract" instance of 2752 a function which we will generate an out-of-line instance 2753 of almost immediately (and which we may also later generate 2754 various inlined instances of). */ 2755 if (write_symbols == DWARF_DEBUG) 2756 { 2757 set_decl_abstract_flags (decl, 1); 2758 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0)); 2759 set_decl_abstract_flags (decl, 0); 2760 } 2761#endif 2762 saved_block_tree = DECL_INITIAL (decl); 2763 saved_arguments = DECL_ARGUMENTS (decl); 2764 TIMEVAR (integration_time, save_for_inline_copying (decl)); 2765 } 2766 2767 /* If specified extern inline but we aren't inlining it, we are 2768 done. */ 2769 if (specd && DECL_EXTERNAL (decl)) 2770 goto exit_rest_of_compilation; 2771 } 2772 2773 if (! DECL_DEFER_OUTPUT (decl)) 2774 TREE_ASM_WRITTEN (decl) = 1; 2775 2776 /* Now that integrate will no longer see our rtl, we need not distinguish 2777 between the return value of this function and the return value of called 2778 functions. */ 2779 rtx_equal_function_value_matters = 0; 2780 2781 /* Don't return yet if -Wreturn-type; we need to do jump_optimize. */ 2782 if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type) 2783 { 2784 goto exit_rest_of_compilation; 2785 } 2786 2787 /* From now on, allocate rtl in current_obstack, not in saveable_obstack. 2788 Note that that may have been done above, in save_for_inline_copying. 2789 The call to resume_temporary_allocation near the end of this function 2790 goes back to the usual state of affairs. */ 2791 2792 rtl_in_current_obstack (); 2793 2794#ifdef FINALIZE_PIC 2795 /* If we are doing position-independent code generation, now 2796 is the time to output special prologues and epilogues. 2797 We do not want to do this earlier, because it just clutters 2798 up inline functions with meaningless insns. */ 2799 if (flag_pic) 2800 FINALIZE_PIC; 2801#endif 2802 2803 insns = get_insns (); 2804 2805 /* Copy any shared structure that should not be shared. */ 2806 2807 unshare_all_rtl (insns); 2808 2809 /* Instantiate all virtual registers. */ 2810 2811 instantiate_virtual_regs (current_function_decl, get_insns ()); 2812 2813 /* See if we have allocated stack slots that are not directly addressable. 2814 If so, scan all the insns and create explicit address computation 2815 for all references to such slots. */ 2816/* fixup_stack_slots (); */ 2817 2818 /* Do jump optimization the first time, if -opt. 2819 Also do it if -W, but in that case it doesn't change the rtl code, 2820 it only computes whether control can drop off the end of the function. */ 2821 2822 if (optimize > 0 || extra_warnings || warn_return_type 2823 /* If function is `noreturn', we should warn if it tries to return. */ 2824 || TREE_THIS_VOLATILE (decl)) 2825 { 2826 TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); 2827 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1)); 2828 } 2829 2830 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */ 2831 if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl)) 2832 goto exit_rest_of_compilation; 2833 2834 /* Dump rtl code after jump, if we are doing that. */ 2835 2836 if (jump_opt_dump) 2837 TIMEVAR (dump_time, 2838 { 2839 fprintf (jump_opt_dump_file, "\n;; Function %s\n\n", 2840 IDENTIFIER_POINTER (DECL_NAME (decl))); 2841 print_rtl (jump_opt_dump_file, insns); 2842 fflush (jump_opt_dump_file); 2843 }); 2844 2845 /* Perform common subexpression elimination. 2846 Nonzero value from `cse_main' means that jumps were simplified 2847 and some code may now be unreachable, so do 2848 jump optimization again. */ 2849 2850 if (cse_dump) 2851 TIMEVAR (dump_time, 2852 { 2853 fprintf (cse_dump_file, "\n;; Function %s\n\n", 2854 IDENTIFIER_POINTER (DECL_NAME (decl))); 2855 }); 2856 2857 if (optimize > 0) 2858 { 2859 TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1)); 2860 2861 if (flag_thread_jumps) 2862 /* Hacks by tiemann & kenner. */ 2863 TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1)); 2864 2865 TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (), 2866 0, cse_dump_file)); 2867 TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ())); 2868 2869 if (tem || optimize > 1) 2870 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0)); 2871 } 2872 2873 /* Dump rtl code after cse, if we are doing that. */ 2874 2875 if (cse_dump) 2876 TIMEVAR (dump_time, 2877 { 2878 print_rtl (cse_dump_file, insns); 2879 fflush (cse_dump_file); 2880 }); 2881 2882 if (loop_dump) 2883 TIMEVAR (dump_time, 2884 { 2885 fprintf (loop_dump_file, "\n;; Function %s\n\n", 2886 IDENTIFIER_POINTER (DECL_NAME (decl))); 2887 }); 2888 2889 /* Move constant computations out of loops. */ 2890 2891 if (optimize > 0) 2892 { 2893 TIMEVAR (loop_time, 2894 { 2895 loop_optimize (insns, loop_dump_file); 2896 }); 2897 } 2898 2899 /* Dump rtl code after loop opt, if we are doing that. */ 2900 2901 if (loop_dump) 2902 TIMEVAR (dump_time, 2903 { 2904 print_rtl (loop_dump_file, insns); 2905 fflush (loop_dump_file); 2906 }); 2907 2908 if (cse2_dump) 2909 TIMEVAR (dump_time, 2910 { 2911 fprintf (cse2_dump_file, "\n;; Function %s\n\n", 2912 IDENTIFIER_POINTER (DECL_NAME (decl))); 2913 }); 2914 2915 if (optimize > 0 && flag_rerun_cse_after_loop) 2916 { 2917 /* Running another jump optimization pass before the second 2918 cse pass sometimes simplifies the RTL enough to allow 2919 the second CSE pass to do a better job. Jump_optimize can change 2920 max_reg_num so we must rerun reg_scan afterwards. 2921 ??? Rework to not call reg_scan so often. */ 2922 TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); 2923 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1)); 2924 2925 TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0)); 2926 TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (), 2927 1, cse2_dump_file)); 2928 if (tem) 2929 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0)); 2930 } 2931 2932 if (optimize > 0 && flag_thread_jumps) 2933 /* This pass of jump threading straightens out code 2934 that was kinked by loop optimization. */ 2935 TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0)); 2936 2937 /* Dump rtl code after cse, if we are doing that. */ 2938 2939 if (cse2_dump) 2940 TIMEVAR (dump_time, 2941 { 2942 print_rtl (cse2_dump_file, insns); 2943 fflush (cse2_dump_file); 2944 }); 2945 2946 /* We are no longer anticipating cse in this function, at least. */ 2947 2948 cse_not_expected = 1; 2949 2950 /* Now we choose between stupid (pcc-like) register allocation 2951 (if we got the -noreg switch and not -opt) 2952 and smart register allocation. */ 2953 2954 if (optimize > 0) /* Stupid allocation probably won't work */ 2955 obey_regdecls = 0; /* if optimizations being done. */ 2956 2957 regclass_init (); 2958 2959 /* Print function header into flow dump now 2960 because doing the flow analysis makes some of the dump. */ 2961 2962 if (flow_dump) 2963 TIMEVAR (dump_time, 2964 { 2965 fprintf (flow_dump_file, "\n;; Function %s\n\n", 2966 IDENTIFIER_POINTER (DECL_NAME (decl))); 2967 }); 2968 2969 if (obey_regdecls) 2970 { 2971 TIMEVAR (flow_time, 2972 { 2973 regclass (insns, max_reg_num ()); 2974 stupid_life_analysis (insns, max_reg_num (), 2975 flow_dump_file); 2976 }); 2977 } 2978 else 2979 { 2980 /* Do control and data flow analysis, 2981 and write some of the results to dump file. */ 2982 2983 TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (), 2984 flow_dump_file)); 2985 if (warn_uninitialized) 2986 { 2987 uninitialized_vars_warning (DECL_INITIAL (decl)); 2988 setjmp_args_warning (); 2989 } 2990 } 2991 2992 /* Dump rtl after flow analysis. */ 2993 2994 if (flow_dump) 2995 TIMEVAR (dump_time, 2996 { 2997 print_rtl (flow_dump_file, insns); 2998 fflush (flow_dump_file); 2999 }); 3000 3001 /* If -opt, try combining insns through substitution. */ 3002 3003 if (optimize > 0) 3004 TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ())); 3005 3006 /* Dump rtl code after insn combination. */ 3007 3008 if (combine_dump) 3009 TIMEVAR (dump_time, 3010 { 3011 fprintf (combine_dump_file, "\n;; Function %s\n\n", 3012 IDENTIFIER_POINTER (DECL_NAME (decl))); 3013 dump_combine_stats (combine_dump_file); 3014 print_rtl (combine_dump_file, insns); 3015 fflush (combine_dump_file); 3016 }); 3017 3018 /* Print function header into sched dump now 3019 because doing the sched analysis makes some of the dump. */ 3020 3021 if (sched_dump) 3022 TIMEVAR (dump_time, 3023 { 3024 fprintf (sched_dump_file, "\n;; Function %s\n\n", 3025 IDENTIFIER_POINTER (DECL_NAME (decl))); 3026 }); 3027 3028 if (optimize > 0 && flag_schedule_insns) 3029 { 3030 /* Do control and data sched analysis, 3031 and write some of the results to dump file. */ 3032 3033 TIMEVAR (sched_time, schedule_insns (sched_dump_file)); 3034 } 3035 3036 /* Dump rtl after instruction scheduling. */ 3037 3038 if (sched_dump) 3039 TIMEVAR (dump_time, 3040 { 3041 print_rtl (sched_dump_file, insns); 3042 fflush (sched_dump_file); 3043 }); 3044 3045 /* Unless we did stupid register allocation, 3046 allocate pseudo-regs that are used only within 1 basic block. */ 3047 3048 if (!obey_regdecls) 3049 TIMEVAR (local_alloc_time, 3050 { 3051 regclass (insns, max_reg_num ()); 3052 local_alloc (); 3053 }); 3054 3055 /* Dump rtl code after allocating regs within basic blocks. */ 3056 3057 if (local_reg_dump) 3058 TIMEVAR (dump_time, 3059 { 3060 fprintf (local_reg_dump_file, "\n;; Function %s\n\n", 3061 IDENTIFIER_POINTER (DECL_NAME (decl))); 3062 dump_flow_info (local_reg_dump_file); 3063 dump_local_alloc (local_reg_dump_file); 3064 print_rtl (local_reg_dump_file, insns); 3065 fflush (local_reg_dump_file); 3066 }); 3067 3068 if (global_reg_dump) 3069 TIMEVAR (dump_time, 3070 fprintf (global_reg_dump_file, "\n;; Function %s\n\n", 3071 IDENTIFIER_POINTER (DECL_NAME (decl)))); 3072 3073 /* Unless we did stupid register allocation, 3074 allocate remaining pseudo-regs, then do the reload pass 3075 fixing up any insns that are invalid. */ 3076 3077 TIMEVAR (global_alloc_time, 3078 { 3079 if (!obey_regdecls) 3080 failure = global_alloc (global_reg_dump_file); 3081 else 3082 failure = reload (insns, 0, global_reg_dump_file); 3083 }); 3084 3085 if (global_reg_dump) 3086 TIMEVAR (dump_time, 3087 { 3088 dump_global_regs (global_reg_dump_file); 3089 print_rtl (global_reg_dump_file, insns); 3090 fflush (global_reg_dump_file); 3091 }); 3092 3093 if (failure) 3094 goto exit_rest_of_compilation; 3095 3096 reload_completed = 1; 3097 3098 /* On some machines, the prologue and epilogue code, or parts thereof, 3099 can be represented as RTL. Doing so lets us schedule insns between 3100 it and the rest of the code and also allows delayed branch 3101 scheduling to operate in the epilogue. */ 3102 3103 thread_prologue_and_epilogue_insns (insns); 3104 3105 if (optimize > 0 && flag_schedule_insns_after_reload) 3106 { 3107 if (sched2_dump) 3108 TIMEVAR (dump_time, 3109 { 3110 fprintf (sched2_dump_file, "\n;; Function %s\n\n", 3111 IDENTIFIER_POINTER (DECL_NAME (decl))); 3112 }); 3113 3114 /* Do control and data sched analysis again, 3115 and write some more of the results to dump file. */ 3116 3117 TIMEVAR (sched2_time, schedule_insns (sched2_dump_file)); 3118 3119 /* Dump rtl after post-reorder instruction scheduling. */ 3120 3121 if (sched2_dump) 3122 TIMEVAR (dump_time, 3123 { 3124 print_rtl (sched2_dump_file, insns); 3125 fflush (sched2_dump_file); 3126 }); 3127 } 3128 3129#ifdef LEAF_REGISTERS 3130 leaf_function = 0; 3131 if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ()) 3132 leaf_function = 1; 3133#endif 3134 3135 /* One more attempt to remove jumps to .+1 3136 left by dead-store-elimination. 3137 Also do cross-jumping this time 3138 and delete no-op move insns. */ 3139 3140 if (optimize > 0) 3141 { 3142 TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0)); 3143 } 3144 3145 /* Dump rtl code after jump, if we are doing that. */ 3146 3147 if (jump2_opt_dump) 3148 TIMEVAR (dump_time, 3149 { 3150 fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n", 3151 IDENTIFIER_POINTER (DECL_NAME (decl))); 3152 print_rtl (jump2_opt_dump_file, insns); 3153 fflush (jump2_opt_dump_file); 3154 }); 3155 3156 /* If a machine dependent reorganization is needed, call it. */ 3157#ifdef MACHINE_DEPENDENT_REORG 3158 MACHINE_DEPENDENT_REORG (insns); 3159#endif 3160 3161 /* If a scheduling pass for delayed branches is to be done, 3162 call the scheduling code. */ 3163 3164#ifdef DELAY_SLOTS 3165 if (optimize > 0 && flag_delayed_branch) 3166 { 3167 TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file)); 3168 if (dbr_sched_dump) 3169 { 3170 TIMEVAR (dump_time, 3171 { 3172 fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n", 3173 IDENTIFIER_POINTER (DECL_NAME (decl))); 3174 print_rtl (dbr_sched_dump_file, insns); 3175 fflush (dbr_sched_dump_file); 3176 }); 3177 } 3178 } 3179#endif 3180 3181 /* Shorten branches. */ 3182 TIMEVAR (shorten_branch_time, 3183 { 3184 shorten_branches (get_insns ()); 3185 }); 3186 3187#ifdef STACK_REGS 3188 TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file)); 3189 if (stack_reg_dump) 3190 { 3191 TIMEVAR (dump_time, 3192 { 3193 fprintf (stack_reg_dump_file, "\n;; Function %s\n\n", 3194 IDENTIFIER_POINTER (DECL_NAME (decl))); 3195 print_rtl (stack_reg_dump_file, insns); 3196 fflush (stack_reg_dump_file); 3197 }); 3198 } 3199#endif 3200 3201 /* Now turn the rtl into assembler code. */ 3202 3203 TIMEVAR (final_time, 3204 { 3205 rtx x; 3206 char *fnname; 3207 3208 /* Get the function's name, as described by its RTL. 3209 This may be different from the DECL_NAME name used 3210 in the source file. */ 3211 3212 x = DECL_RTL (decl); 3213 if (GET_CODE (x) != MEM) 3214 abort (); 3215 x = XEXP (x, 0); 3216 if (GET_CODE (x) != SYMBOL_REF) 3217 abort (); 3218 fnname = XSTR (x, 0); 3219 3220 assemble_start_function (decl, fnname); 3221 final_start_function (insns, asm_out_file, optimize); 3222 final (insns, asm_out_file, optimize, 0); 3223 final_end_function (insns, asm_out_file, optimize); 3224 assemble_end_function (decl, fnname); 3225 fflush (asm_out_file); 3226 }); 3227 3228 /* Write DBX symbols if requested */ 3229 3230 /* Note that for those inline functions where we don't initially 3231 know for certain that we will be generating an out-of-line copy, 3232 the first invocation of this routine (rest_of_compilation) will 3233 skip over this code by doing a `goto exit_rest_of_compilation;'. 3234 Later on, finish_compilation will call rest_of_compilation again 3235 for those inline functions that need to have out-of-line copies 3236 generated. During that call, we *will* be routed past here. */ 3237 3238#ifdef DBX_DEBUGGING_INFO 3239 if (write_symbols == DBX_DEBUG) 3240 TIMEVAR (symout_time, dbxout_function (decl)); 3241#endif 3242 3243#ifdef DWARF_DEBUGGING_INFO 3244 if (write_symbols == DWARF_DEBUG) 3245 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0)); 3246#endif 3247 3248 exit_rest_of_compilation: 3249 3250 /* In case the function was not output, 3251 don't leave any temporary anonymous types 3252 queued up for sdb output. */ 3253#ifdef SDB_DEBUGGING_INFO 3254 if (write_symbols == SDB_DEBUG) 3255 sdbout_types (NULL_TREE); 3256#endif 3257 3258 /* Put back the tree of subblocks and list of arguments 3259 from before we copied them. 3260 Code generation and the output of debugging info may have modified 3261 the copy, but the original is unchanged. */ 3262 3263 if (saved_block_tree != 0) 3264 DECL_INITIAL (decl) = saved_block_tree; 3265 if (saved_arguments != 0) 3266 DECL_ARGUMENTS (decl) = saved_arguments; 3267 3268 reload_completed = 0; 3269 3270 /* Clear out the insn_length contents now that they are no longer valid. */ 3271 init_insn_lengths (); 3272 3273 /* Clear out the real_constant_chain before some of the rtx's 3274 it runs through become garbage. */ 3275 3276 clear_const_double_mem (); 3277 3278 /* Cancel the effect of rtl_in_current_obstack. */ 3279 3280 resume_temporary_allocation (); 3281 3282 /* The parsing time is all the time spent in yyparse 3283 *except* what is spent in this function. */ 3284 3285 parse_time -= get_run_time () - start_time; 3286} 3287 3288/* Entry point of cc1/c++. Decode command args, then call compile_file. 3289 Exit code is 35 if can't open files, 34 if fatal error, 3290 33 if had nonfatal errors, else success. */ 3291 3292int 3293main (argc, argv, envp) 3294 int argc; 3295 char **argv; 3296 char **envp; 3297{ 3298 register int i; 3299 char *filename = 0; 3300 int flag_print_mem = 0; 3301 int version_flag = 0; 3302 char *p; 3303 3304 /* save in case md file wants to emit args as a comment. */ 3305 save_argc = argc; 3306 save_argv = argv; 3307 3308 p = argv[0] + strlen (argv[0]); 3309 while (p != argv[0] && p[-1] != '/' 3310#ifdef DIR_SEPARATOR 3311 && p[-1] != DIR_SEPARATOR 3312#endif 3313 ) 3314 --p; 3315 progname = p; 3316 3317#ifdef RLIMIT_STACK 3318 /* Get rid of any avoidable limit on stack size. */ 3319 { 3320 struct rlimit rlim; 3321 3322 /* Set the stack limit huge so that alloca does not fail. */ 3323 getrlimit (RLIMIT_STACK, &rlim); 3324 rlim.rlim_cur = rlim.rlim_max; 3325 setrlimit (RLIMIT_STACK, &rlim); 3326 } 3327#endif /* RLIMIT_STACK */ 3328 3329 signal (SIGFPE, float_signal); 3330 3331#ifdef SIGPIPE 3332 signal (SIGPIPE, pipe_closed); 3333#endif 3334 3335 decl_printable_name = decl_name; 3336 lang_expand_expr = (struct rtx_def *(*)()) do_abort; 3337 interim_eh_hook = interim_eh; 3338 3339 /* Initialize whether `char' is signed. */ 3340 flag_signed_char = DEFAULT_SIGNED_CHAR; 3341#ifdef DEFAULT_SHORT_ENUMS 3342 /* Initialize how much space enums occupy, by default. */ 3343 flag_short_enums = DEFAULT_SHORT_ENUMS; 3344#endif 3345 3346 /* Scan to see what optimization level has been specified. That will 3347 determine the default value of many flags. */ 3348 for (i = 1; i < argc; i++) 3349 { 3350 if (!strcmp (argv[i], "-O")) 3351 { 3352 optimize = 1; 3353 } 3354 else if (argv[i][0] == '-' && argv[i][1] == 'O') 3355 { 3356 /* Handle -O2, -O3, -O69, ... */ 3357 char *p = &argv[i][2]; 3358 int c; 3359 3360 while (c = *p++) 3361 if (! (c >= '0' && c <= '9')) 3362 break; 3363 if (c == 0) 3364 optimize = atoi (&argv[i][2]); 3365 } 3366 } 3367 3368 obey_regdecls = (optimize == 0); 3369 if (optimize == 0) 3370 { 3371 flag_no_inline = 1; 3372 warn_inline = 0; 3373 } 3374 3375 if (optimize >= 1) 3376 { 3377 flag_defer_pop = 1; 3378 flag_thread_jumps = 1; 3379#ifdef DELAY_SLOTS 3380 flag_delayed_branch = 1; 3381#endif 3382#ifdef CAN_DEBUG_WITHOUT_FP 3383 flag_omit_frame_pointer = 1; 3384#endif 3385 } 3386 3387 if (optimize >= 2) 3388 { 3389 flag_cse_follow_jumps = 1; 3390 flag_cse_skip_blocks = 1; 3391 flag_expensive_optimizations = 1; 3392 flag_strength_reduce = 1; 3393 flag_rerun_cse_after_loop = 1; 3394 flag_caller_saves = 1; 3395 flag_force_mem = 1; 3396#ifdef INSN_SCHEDULING 3397 flag_schedule_insns = 1; 3398 flag_schedule_insns_after_reload = 1; 3399#endif 3400 } 3401 3402 if (optimize >= 3) 3403 { 3404 flag_inline_functions = 1; 3405 } 3406 3407#ifdef OPTIMIZATION_OPTIONS 3408 /* Allow default optimizations to be specified on a per-machine basis. */ 3409 OPTIMIZATION_OPTIONS (optimize); 3410#endif 3411 3412 /* Initialize register usage now so switches may override. */ 3413 init_reg_sets (); 3414 3415 target_flags = 0; 3416 set_target_switch (""); 3417 3418 for (i = 1; i < argc; i++) 3419 { 3420 int j; 3421 /* If this is a language-specific option, 3422 decode it in a language-specific way. */ 3423 for (j = 0; lang_options[j] != 0; j++) 3424 if (!strncmp (argv[i], lang_options[j], 3425 strlen (lang_options[j]))) 3426 break; 3427 if (lang_options[j] != 0) 3428 /* If the option is valid for *some* language, 3429 treat it as valid even if this language doesn't understand it. */ 3430 lang_decode_option (argv[i]); 3431 else if (argv[i][0] == '-' && argv[i][1] != 0) 3432 { 3433 register char *str = argv[i] + 1; 3434 if (str[0] == 'Y') 3435 str++; 3436 3437 if (str[0] == 'm') 3438 set_target_switch (&str[1]); 3439 else if (!strcmp (str, "dumpbase")) 3440 { 3441 dump_base_name = argv[++i]; 3442 } 3443 else if (str[0] == 'd') 3444 { 3445 register char *p = &str[1]; 3446 while (*p) 3447 switch (*p++) 3448 { 3449 case 'a': 3450 combine_dump = 1; 3451 dbr_sched_dump = 1; 3452 flow_dump = 1; 3453 global_reg_dump = 1; 3454 jump_opt_dump = 1; 3455 jump2_opt_dump = 1; 3456 local_reg_dump = 1; 3457 loop_dump = 1; 3458 rtl_dump = 1; 3459 cse_dump = 1, cse2_dump = 1; 3460 sched_dump = 1; 3461 sched2_dump = 1; 3462 stack_reg_dump = 1; 3463 break; 3464 case 'k': 3465 stack_reg_dump = 1; 3466 break; 3467 case 'c': 3468 combine_dump = 1; 3469 break; 3470 case 'd': 3471 dbr_sched_dump = 1; 3472 break; 3473 case 'f': 3474 flow_dump = 1; 3475 break; 3476 case 'g': 3477 global_reg_dump = 1; 3478 break; 3479 case 'j': 3480 jump_opt_dump = 1; 3481 break; 3482 case 'J': 3483 jump2_opt_dump = 1; 3484 break; 3485 case 'l': 3486 local_reg_dump = 1; 3487 break; 3488 case 'L': 3489 loop_dump = 1; 3490 break; 3491 case 'm': 3492 flag_print_mem = 1; 3493 break; 3494 case 'p': 3495 flag_print_asm_name = 1; 3496 break; 3497 case 'r': 3498 rtl_dump = 1; 3499 break; 3500 case 's': 3501 cse_dump = 1; 3502 break; 3503 case 't': 3504 cse2_dump = 1; 3505 break; 3506 case 'S': 3507 sched_dump = 1; 3508 break; 3509 case 'R': 3510 sched2_dump = 1; 3511 break; 3512 case 'y': 3513 set_yydebug (1); 3514 break; 3515 3516 case 'x': 3517 rtl_dump_and_exit = 1; 3518 break; 3519 } 3520 } 3521 else if (str[0] == 'f') 3522 { 3523 register char *p = &str[1]; 3524 int found = 0; 3525 3526 /* Some kind of -f option. 3527 P's value is the option sans `-f'. 3528 Search for it in the table of options. */ 3529 3530 for (j = 0; 3531 !found && j < sizeof (f_options) / sizeof (f_options[0]); 3532 j++) 3533 { 3534 if (!strcmp (p, f_options[j].string)) 3535 { 3536 *f_options[j].variable = f_options[j].on_value; 3537 /* A goto here would be cleaner, 3538 but breaks the vax pcc. */ 3539 found = 1; 3540 } 3541 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-' 3542 && ! strcmp (p+3, f_options[j].string)) 3543 { 3544 *f_options[j].variable = ! f_options[j].on_value; 3545 found = 1; 3546 } 3547 } 3548 3549 if (found) 3550 ; 3551 else if (!strncmp (p, "fixed-", 6)) 3552 fix_register (&p[6], 1, 1); 3553 else if (!strncmp (p, "call-used-", 10)) 3554 fix_register (&p[10], 0, 1); 3555 else if (!strncmp (p, "call-saved-", 11)) 3556 fix_register (&p[11], 0, 0); 3557 else 3558 error ("Invalid option `%s'", argv[i]); 3559 } 3560 else if (str[0] == 'O') 3561 { 3562 register char *p = str+1; 3563 while (*p && *p >= '0' && *p <= '9') 3564 p++; 3565 if (*p == '\0') 3566 ; 3567 else 3568 error ("Invalid option `%s'", argv[i]); 3569 } 3570 else if (!strcmp (str, "pedantic")) 3571 pedantic = 1; 3572 else if (!strcmp (str, "pedantic-errors")) 3573 flag_pedantic_errors = pedantic = 1; 3574 else if (!strcmp (str, "quiet")) 3575 quiet_flag = 1; 3576 else if (!strcmp (str, "version")) 3577 version_flag = 1; 3578 else if (!strcmp (str, "w")) 3579 inhibit_warnings = 1; 3580 else if (!strcmp (str, "W")) 3581 { 3582 extra_warnings = 1; 3583 /* We save the value of warn_uninitialized, since if they put 3584 -Wuninitialized on the command line, we need to generate a 3585 warning about not using it without also specifying -O. */ 3586 if (warn_uninitialized != 1) 3587 warn_uninitialized = 2; 3588 } 3589 else if (str[0] == 'W') 3590 { 3591 register char *p = &str[1]; 3592 int found = 0; 3593 3594 /* Some kind of -W option. 3595 P's value is the option sans `-W'. 3596 Search for it in the table of options. */ 3597 3598 for (j = 0; 3599 !found && j < sizeof (W_options) / sizeof (W_options[0]); 3600 j++) 3601 { 3602 if (!strcmp (p, W_options[j].string)) 3603 { 3604 *W_options[j].variable = W_options[j].on_value; 3605 /* A goto here would be cleaner, 3606 but breaks the vax pcc. */ 3607 found = 1; 3608 } 3609 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-' 3610 && ! strcmp (p+3, W_options[j].string)) 3611 { 3612 *W_options[j].variable = ! W_options[j].on_value; 3613 found = 1; 3614 } 3615 } 3616 3617 if (found) 3618 ; 3619 else if (!strncmp (p, "id-clash-", 9)) 3620 { 3621 char *endp = p + 9; 3622 3623 while (*endp) 3624 { 3625 if (*endp >= '0' && *endp <= '9') 3626 endp++; 3627 else 3628 { 3629 error ("Invalid option `%s'", argv[i]); 3630 goto id_clash_lose; 3631 } 3632 } 3633 warn_id_clash = 1; 3634 id_clash_len = atoi (str + 10); 3635 id_clash_lose: ; 3636 } 3637 else if (!strncmp (p, "larger-than-", 12)) 3638 { 3639 char *endp = p + 12; 3640 3641 while (*endp) 3642 { 3643 if (*endp >= '0' && *endp <= '9') 3644 endp++; 3645 else 3646 { 3647 error ("Invalid option `%s'", argv[i]); 3648 goto larger_than_lose; 3649 } 3650 } 3651 warn_larger_than = 1; 3652 larger_than_size = atoi (str + 13); 3653 larger_than_lose: ; 3654 } 3655 else 3656 error ("Invalid option `%s'", argv[i]); 3657 } 3658 else if (!strcmp (str, "p")) 3659 { 3660 if (!output_bytecode) 3661 profile_flag = 1; 3662 else 3663 error ("profiling not supported in bytecode compilation"); 3664 } 3665 else if (!strcmp (str, "a")) 3666 { 3667#if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER) 3668 warning ("`-a' option (basic block profile) not supported"); 3669#else 3670 profile_block_flag = 1; 3671#endif 3672 } 3673 else if (str[0] == 'g') 3674 { 3675 char *p = str + 1; 3676 char *q; 3677 unsigned len; 3678 unsigned level; 3679 3680 while (*p && (*p < '0' || *p > '9')) 3681 p++; 3682 len = p - str; 3683 q = p; 3684 while (*q && (*q >= '0' && *q <= '9')) 3685 q++; 3686 if (*p) 3687 level = atoi (p); 3688 else 3689 level = 2; /* default debugging info level */ 3690 if (*q || level > 3) 3691 { 3692 warning ("invalid debug level specification in option: `-%s'", 3693 str); 3694 warning ("no debugging information will be generated"); 3695 level = 0; 3696 } 3697 3698 /* If more than one debugging type is supported, 3699 you must define PREFERRED_DEBUGGING_TYPE 3700 to choose a format in a system-dependent way. */ 3701 /* This is one long line cause VAXC can't handle a \-newline. */ 3702#if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO)) 3703#ifdef PREFERRED_DEBUGGING_TYPE 3704 if (!strncmp (str, "ggdb", len)) 3705 write_symbols = PREFERRED_DEBUGGING_TYPE; 3706#else /* no PREFERRED_DEBUGGING_TYPE */ 3707You Lose! You must define PREFERRED_DEBUGGING_TYPE! 3708#endif /* no PREFERRED_DEBUGGING_TYPE */ 3709#endif /* More than one debugger format enabled. */ 3710#ifdef DBX_DEBUGGING_INFO 3711 if (write_symbols != NO_DEBUG) 3712 ; 3713 else if (!strncmp (str, "ggdb", len)) 3714 write_symbols = DBX_DEBUG; 3715 else if (!strncmp (str, "gstabs", len)) 3716 write_symbols = DBX_DEBUG; 3717 else if (!strncmp (str, "gstabs+", len)) 3718 write_symbols = DBX_DEBUG; 3719 3720 /* Always enable extensions for -ggdb or -gstabs+, 3721 always disable for -gstabs. 3722 For plain -g, use system-specific default. */ 3723 if (write_symbols == DBX_DEBUG && !strncmp (str, "ggdb", len) 3724 && len >= 2) 3725 use_gnu_debug_info_extensions = 1; 3726 else if (write_symbols == DBX_DEBUG && !strncmp (str, "gstabs+", len) 3727 && len >= 7) 3728 use_gnu_debug_info_extensions = 1; 3729 else if (write_symbols == DBX_DEBUG 3730 && !strncmp (str, "gstabs", len) && len >= 2) 3731 use_gnu_debug_info_extensions = 0; 3732 else 3733 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS; 3734#endif /* DBX_DEBUGGING_INFO */ 3735#ifdef DWARF_DEBUGGING_INFO 3736 if (write_symbols != NO_DEBUG) 3737 ; 3738 else if (!strncmp (str, "g", len)) 3739 write_symbols = DWARF_DEBUG; 3740 else if (!strncmp (str, "ggdb", len)) 3741 write_symbols = DWARF_DEBUG; 3742 else if (!strncmp (str, "gdwarf", len)) 3743 write_symbols = DWARF_DEBUG; 3744 3745 /* Always enable extensions for -ggdb or -gdwarf+, 3746 always disable for -gdwarf. 3747 For plain -g, use system-specific default. */ 3748 if (write_symbols == DWARF_DEBUG && !strncmp (str, "ggdb", len) 3749 && len >= 2) 3750 use_gnu_debug_info_extensions = 1; 3751 else if (write_symbols == DWARF_DEBUG && !strcmp (str, "gdwarf+")) 3752 use_gnu_debug_info_extensions = 1; 3753 else if (write_symbols == DWARF_DEBUG 3754 && !strncmp (str, "gdwarf", len) && len >= 2) 3755 use_gnu_debug_info_extensions = 0; 3756 else 3757 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS; 3758#endif 3759#ifdef SDB_DEBUGGING_INFO 3760 if (write_symbols != NO_DEBUG) 3761 ; 3762 else if (!strncmp (str, "g", len)) 3763 write_symbols = SDB_DEBUG; 3764 else if (!strncmp (str, "gdb", len)) 3765 write_symbols = SDB_DEBUG; 3766 else if (!strncmp (str, "gcoff", len)) 3767 write_symbols = SDB_DEBUG; 3768#endif /* SDB_DEBUGGING_INFO */ 3769#ifdef XCOFF_DEBUGGING_INFO 3770 if (write_symbols != NO_DEBUG) 3771 ; 3772 else if (!strncmp (str, "g", len)) 3773 write_symbols = XCOFF_DEBUG; 3774 else if (!strncmp (str, "ggdb", len)) 3775 write_symbols = XCOFF_DEBUG; 3776 else if (!strncmp (str, "gxcoff", len)) 3777 write_symbols = XCOFF_DEBUG; 3778 3779 /* Always enable extensions for -ggdb or -gxcoff+, 3780 always disable for -gxcoff. 3781 For plain -g, use system-specific default. */ 3782 if (write_symbols == XCOFF_DEBUG && !strncmp (str, "ggdb", len) 3783 && len >= 2) 3784 use_gnu_debug_info_extensions = 1; 3785 else if (write_symbols == XCOFF_DEBUG && !strcmp (str, "gxcoff+")) 3786 use_gnu_debug_info_extensions = 1; 3787 else if (write_symbols == XCOFF_DEBUG 3788 && !strncmp (str, "gxcoff", len) && len >= 2) 3789 use_gnu_debug_info_extensions = 0; 3790 else 3791 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS; 3792#endif 3793 if (write_symbols == NO_DEBUG) 3794 warning ("`-%s' not supported by this configuration of GCC", 3795 str); 3796 else if (level == 0) 3797 write_symbols = NO_DEBUG; 3798 else 3799 debug_info_level = (enum debug_info_level) level; 3800 } 3801 else if (!strcmp (str, "o")) 3802 { 3803 asm_file_name = argv[++i]; 3804 } 3805 else if (str[0] == 'G') 3806 { 3807 g_switch_set = TRUE; 3808 g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]); 3809 } 3810 else if (!strncmp (str, "aux-info", 8)) 3811 { 3812 flag_gen_aux_info = 1; 3813 aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]); 3814 } 3815 else 3816 error ("Invalid option `%s'", argv[i]); 3817 } 3818 else if (argv[i][0] == '+') 3819 error ("Invalid option `%s'", argv[i]); 3820 else 3821 filename = argv[i]; 3822 } 3823 3824 /* Initialize for bytecode output. A good idea to do this as soon as 3825 possible after the "-f" options have been parsed. */ 3826 if (output_bytecode) 3827 { 3828#ifndef TARGET_SUPPORTS_BYTECODE 3829 /* Just die with a fatal error if not supported */ 3830 fatal ("-fbytecode not supporter for this target"); 3831#else 3832 bc_initialize (); 3833#endif 3834 } 3835 3836 if (optimize == 0) 3837 { 3838 /* Inlining does not work if not optimizing, 3839 so force it not to be done. */ 3840 flag_no_inline = 1; 3841 warn_inline = 0; 3842 3843 /* The c_decode_option and lang_decode_option functions set 3844 this to `2' if -Wall is used, so we can avoid giving out 3845 lots of errors for people who don't realize what -Wall does. */ 3846 if (warn_uninitialized == 1) 3847 warning ("-Wuninitialized is not supported without -O"); 3848 } 3849 3850#if defined(DWARF_DEBUGGING_INFO) 3851 if (write_symbols == DWARF_DEBUG 3852 && strcmp (language_string, "GNU C++") == 0) 3853 { 3854 warning ("-g option not supported for C++ on systems using the DWARF debugging format"); 3855 write_symbols = NO_DEBUG; 3856 } 3857#endif /* defined(DWARF_DEBUGGING_INFO) */ 3858 3859#ifdef OVERRIDE_OPTIONS 3860 /* Some machines may reject certain combinations of options. */ 3861 OVERRIDE_OPTIONS; 3862#endif 3863 3864 /* Unrolling all loops implies that standard loop unrolling must also 3865 be done. */ 3866 if (flag_unroll_all_loops) 3867 flag_unroll_loops = 1; 3868 /* Loop unrolling requires that strength_reduction be on also. Silently 3869 turn on strength reduction here if it isn't already on. Also, the loop 3870 unrolling code assumes that cse will be run after loop, so that must 3871 be turned on also. */ 3872 if (flag_unroll_loops) 3873 { 3874 flag_strength_reduce = 1; 3875 flag_rerun_cse_after_loop = 1; 3876 } 3877 3878 /* Warn about options that are not supported on this machine. */ 3879#ifndef INSN_SCHEDULING 3880 if (flag_schedule_insns || flag_schedule_insns_after_reload) 3881 warning ("instruction scheduling not supported on this target machine"); 3882#endif 3883#ifndef DELAY_SLOTS 3884 if (flag_delayed_branch) 3885 warning ("this target machine does not have delayed branches"); 3886#endif 3887 3888 /* If we are in verbose mode, write out the version and maybe all the 3889 option flags in use. */ 3890 if (version_flag) 3891 { 3892 fprintf (stderr, "%s version %s", language_string, version_string); 3893#ifdef TARGET_VERSION 3894 TARGET_VERSION; 3895#endif 3896#ifdef __GNUC__ 3897#ifndef __VERSION__ 3898#define __VERSION__ "[unknown]" 3899#endif 3900 fprintf (stderr, " compiled by GNU C version %s.\n", __VERSION__); 3901#else 3902 fprintf (stderr, " compiled by CC.\n"); 3903#endif 3904 if (! quiet_flag) 3905 print_switch_values (); 3906 } 3907 3908 compile_file (filename); 3909 3910#if !defined(OS2) && !defined(VMS) && !defined(_WIN32) 3911 if (flag_print_mem) 3912 { 3913 char *lim = (char *) sbrk (0); 3914 3915 fprintf (stderr, "Data size %d.\n", 3916 lim - (char *) &environ); 3917 fflush (stderr); 3918 3919#ifdef USG 3920 system ("ps -l 1>&2"); 3921#else /* not USG */ 3922 system ("ps v"); 3923#endif /* not USG */ 3924 } 3925#endif /* not OS2 and not VMS and not _WIN32 */ 3926 3927 if (errorcount) 3928 exit (FATAL_EXIT_CODE); 3929 if (sorrycount) 3930 exit (FATAL_EXIT_CODE); 3931 exit (SUCCESS_EXIT_CODE); 3932 return 0; 3933} 3934 3935/* Decode -m switches. */ 3936 3937/* Here is a table, controlled by the tm.h file, listing each -m switch 3938 and which bits in `target_switches' it should set or clear. 3939 If VALUE is positive, it is bits to set. 3940 If VALUE is negative, -VALUE is bits to clear. 3941 (The sign bit is not used so there is no confusion.) */ 3942 3943struct {char *name; int value;} target_switches [] 3944 = TARGET_SWITCHES; 3945 3946/* This table is similar, but allows the switch to have a value. */ 3947 3948#ifdef TARGET_OPTIONS 3949struct {char *prefix; char ** variable;} target_options [] 3950 = TARGET_OPTIONS; 3951#endif 3952 3953/* Decode the switch -mNAME. */ 3954 3955void 3956set_target_switch (name) 3957 char *name; 3958{ 3959 register int j; 3960 int valid = 0; 3961 3962 for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++) 3963 if (!strcmp (target_switches[j].name, name)) 3964 { 3965 if (target_switches[j].value < 0) 3966 target_flags &= ~-target_switches[j].value; 3967 else 3968 target_flags |= target_switches[j].value; 3969 valid = 1; 3970 } 3971 3972#ifdef TARGET_OPTIONS 3973 if (!valid) 3974 for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++) 3975 { 3976 int len = strlen (target_options[j].prefix); 3977 if (!strncmp (target_options[j].prefix, name, len)) 3978 { 3979 *target_options[j].variable = name + len; 3980 valid = 1; 3981 } 3982 } 3983#endif 3984 3985 if (!valid) 3986 error ("Invalid option `%s'", name); 3987} 3988 3989/* Variable used for communication between the following two routines. */ 3990 3991static int line_position; 3992 3993/* Print an option value and adjust the position in the line. */ 3994 3995static void 3996print_single_switch (type, name) 3997 char *type, *name; 3998{ 3999 fprintf (stderr, " %s%s", type, name); 4000 4001 line_position += strlen (type) + strlen (name) + 1; 4002 4003 if (line_position > 65) 4004 { 4005 fprintf (stderr, "\n\t"); 4006 line_position = 8; 4007 } 4008} 4009 4010/* Print default target switches for -version. */ 4011 4012static void 4013print_switch_values () 4014{ 4015 register int j; 4016 4017 fprintf (stderr, "enabled:"); 4018 line_position = 8; 4019 4020 for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++) 4021 if (*f_options[j].variable == f_options[j].on_value) 4022 print_single_switch ("-f", f_options[j].string); 4023 4024 for (j = 0; j < sizeof W_options / sizeof W_options[0]; j++) 4025 if (*W_options[j].variable == W_options[j].on_value) 4026 print_single_switch ("-W", W_options[j].string); 4027 4028 for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++) 4029 if (target_switches[j].name[0] != '\0' 4030 && target_switches[j].value > 0 4031 && ((target_switches[j].value & target_flags) 4032 == target_switches[j].value)) 4033 print_single_switch ("-m", target_switches[j].name); 4034 4035 fprintf (stderr, "\n"); 4036} 4037