gcc/toplev.c

   1 /* Top level of GNU C compiler
   2    Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* This is the top level of cc1/c++.
  22    It parses command args, opens files, invokes the various passes
  23    in the proper order, and counts the time used by each.
  24    Error messages and low-level interface to malloc also handled here.  */
  25
  26 #include "config.h"
  27 #ifdef __STDC__
  28 #include <stdarg.h>
  29 #else
  30 #include <varargs.h>
  31 #endif
  32 #include <stdio.h>
  33 #include <signal.h>
  34 #include <setjmp.h>
  35 #include <sys/types.h>
  36 #include <ctype.h>
  37 #include <sys/stat.h>
  38
  39 #ifndef _WIN32
  40 #ifdef USG
  41 #undef FLOAT
  42 #include <sys/param.h>
  43 /* This is for hpux.  It is a real screw.  They should change hpux.  */
  44 #undef FLOAT
  45 #include <sys/times.h>
  46 #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  47 #undef FFS  /* Some systems define this in param.h.  */
  48 #else
  49 #ifndef VMS
  50 #include <sys/time.h>
  51 #include <sys/resource.h>
  52 #endif
  53 #endif
  54 #endif
  55
  56 #include "input.h"
  57 #include "tree.h"
  58 #include "rtl.h"
  59 #include "flags.h"
  60 #include "insn-attr.h"
  61 #include "defaults.h"
  62 #include "output.h"
  63 #include "bytecode.h"
  64 #include "bc-emit.h"
  65 #include "except.h"
  66
  67 #ifdef XCOFF_DEBUGGING_INFO
  68 #include "xcoffout.h"
  69 #endif
  70 \f
  71 #ifdef VMS
  72 /* The extra parameters substantially improve the I/O performance.  */
  73 static FILE *
  74 vms_fopen (fname, type)
  75      char * fname;
  76      char * type;
  77 {
  78   /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
  79      fixed arguments, which matches ANSI's specification but not VAXCRTL's
  80      pre-ANSI implementation.  This hack circumvents the mismatch problem.  */
  81   FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
  82
  83   if (*type == 'w')
  84     return (*vmslib_fopen) (fname, type, "mbc=32",
  85                             "deq=64", "fop=tef", "shr=nil");
  86   else
  87     return (*vmslib_fopen) (fname, type, "mbc=32");
  88 }
  89 #define fopen vms_fopen
  90 #endif  /* VMS */
  91
  92 #ifndef DEFAULT_GDB_EXTENSIONS
  93 #define DEFAULT_GDB_EXTENSIONS 1
  94 #endif
  95
  96 /* If more than one debugging type is supported, you must define
  97    PREFERRED_DEBUGGING_TYPE to choose a format in a system-dependent way.
  98
  99    This is one long line cause VAXC can't handle a \-newline.  */
 100 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
 101 #ifndef PREFERRED_DEBUGGING_TYPE
 102 You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
 103 #endif /* no PREFERRED_DEBUGGING_TYPE */
 104 #else /* Only one debugging format supported.  Define PREFERRED_DEBUGGING_TYPE
 105          so the following code needn't care.  */
 106 #ifdef DBX_DEBUGGING_INFO
 107 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
 108 #endif
 109 #ifdef SDB_DEBUGGING_INFO
 110 #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
 111 #endif
 112 #ifdef DWARF_DEBUGGING_INFO
 113 #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
 114 #endif
 115 #ifdef DWARF2_DEBUGGING_INFO
 116 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 117 #endif
 118 #ifdef XCOFF_DEBUGGING_INFO
 119 #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
 120 #endif
 121 #endif /* More than one debugger format enabled.  */
 122
 123 /* If still not defined, must have been because no debugging formats
 124    are supported.  */
 125 #ifndef PREFERRED_DEBUGGING_TYPE
 126 #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
 127 #endif
 128
 129 extern int rtx_equal_function_value_matters;
 130
 131 #if ! (defined (VMS) || defined (OS2))
 132 extern char **environ;
 133 #endif
 134 extern char *version_string, *language_string;
 135
 136 /* Carry information from ASM_DECLARE_OBJECT_NAME
 137    to ASM_FINISH_DECLARE_OBJECT.  */
 138
 139 extern int size_directive_output;
 140 extern tree last_assemble_variable_decl;
 141
 142 extern void init_lex ();
 143 extern void init_decl_processing ();
 144 extern void init_obstacks ();
 145 extern void init_tree_codes ();
 146 extern void init_rtl ();
 147 extern void init_regs ();
 148 extern void init_optabs ();
 149 extern void init_stmt ();
 150 extern void init_reg_sets ();
 151 extern void dump_flow_info ();
 152 extern void dump_sched_info ();
 153 extern void dump_local_alloc ();
 154 extern void regset_release_memory ();
 155
 156 void rest_of_decl_compilation ();
 157 void error_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
 158 void error_with_decl PVPROTO((tree decl, char *s, ...));
 159 void error_for_asm PVPROTO((rtx insn, char *s, ...));
 160 void error PVPROTO((char *s, ...));
 161 void fatal PVPROTO((char *s, ...));
 162 void warning_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
 163 void warning_with_decl PVPROTO((tree decl, char *s, ...));
 164 void warning_for_asm PVPROTO((rtx insn, char *s, ...));
 165 void warning PVPROTO((char *s, ...));
 166 void pedwarn PVPROTO((char *s, ...));
 167 void pedwarn_with_decl PVPROTO((tree decl, char *s, ...));
 168 void pedwarn_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
 169 void sorry PVPROTO((char *s, ...));
 170 void really_sorry PVPROTO((char *s, ...));
 171 void fancy_abort ();
 172 #ifndef abort
 173 void abort ();
 174 #endif
 175 void set_target_switch ();
 176 static char *decl_name ();
 177
 178 void print_version ();
 179 int print_single_switch ();
 180 void print_switch_values ();
 181 /* Length of line when printing switch values.  */
 182 #define MAX_LINE 75
 183
 184 #ifdef __alpha
 185 extern char *sbrk ();
 186 #endif
 187
 188 /* Name of program invoked, sans directories.  */
 189
 190 char *progname;
 191
 192 /* Copy of arguments to main.  */
 193 int save_argc;
 194 char **save_argv;
 195 \f
 196 /* Name of current original source file (what was input to cpp).
 197    This comes from each #-command in the actual input.  */
 198
 199 char *input_filename;
 200
 201 /* Name of top-level original source file (what was input to cpp).
 202    This comes from the #-command at the beginning of the actual input.
 203    If there isn't any there, then this is the cc1 input file name.  */
 204
 205 char *main_input_filename;
 206
 207 #if !USE_CPPLIB
 208 /* Stream for reading from the input file.  */
 209 FILE *finput;
 210 #endif
 211
 212 /* Current line number in real source file.  */
 213
 214 int lineno;
 215
 216 /* Stack of currently pending input files.  */
 217
 218 struct file_stack *input_file_stack;
 219
 220 /* Incremented on each change to input_file_stack.  */
 221 int input_file_stack_tick;
 222
 223 /* FUNCTION_DECL for function now being parsed or compiled.  */
 224
 225 extern tree current_function_decl;
 226
 227 /* Name to use as base of names for dump output files.  */
 228
 229 char *dump_base_name;
 230
 231 /* Bit flags that specify the machine subtype we are compiling for.
 232    Bits are tested using macros TARGET_... defined in the tm.h file
 233    and set by `-m...' switches.  Must be defined in rtlanal.c.  */
 234
 235 extern int target_flags;
 236
 237 /* Flags saying which kinds of debugging dump have been requested.  */
 238
 239 int rtl_dump = 0;
 240 int rtl_dump_and_exit = 0;
 241 int jump_opt_dump = 0;
 242 int cse_dump = 0;
 243 int loop_dump = 0;
 244 int cse2_dump = 0;
 245 int branch_prob_dump = 0;
 246 int flow_dump = 0;
 247 int combine_dump = 0;
 248 int regmove_dump = 0;
 249 int sched_dump = 0;
 250 int local_reg_dump = 0;
 251 int global_reg_dump = 0;
 252 int sched2_dump = 0;
 253 int jump2_opt_dump = 0;
 254 int dbr_sched_dump = 0;
 255 int flag_print_asm_name = 0;
 256 int stack_reg_dump = 0;
 257
 258 /* Name for output file of assembly code, specified with -o.  */
 259
 260 char *asm_file_name;
 261
 262 /* Value of the -G xx switch, and whether it was passed or not.  */
 263 int g_switch_value;
 264 int g_switch_set;
 265
 266 /* Type(s) of debugging information we are producing (if any).
 267    See flags.h for the definitions of the different possible
 268    types of debugging information.  */
 269 enum debug_info_type write_symbols = NO_DEBUG;
 270
 271 /* Level of debugging information we are producing.  See flags.h
 272    for the definitions of the different possible levels.  */
 273 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
 274
 275 /* Nonzero means use GNU-only extensions in the generated symbolic
 276    debugging information.  */
 277 /* Currently, this only has an effect when write_symbols is set to
 278    DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
 279 int use_gnu_debug_info_extensions = 0;
 280
 281 /* Nonzero means do optimizations.  -O.
 282    Particular numeric values stand for particular amounts of optimization;
 283    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
 284    ones are not controlled directly by this variable.  Instead, they are
 285    controlled by individual `flag_...' variables that are defaulted
 286    based on this variable.  */
 287
 288 int optimize = 0;
 289
 290 /* Number of error messages and warning messages so far.  */
 291
 292 int errorcount = 0;
 293 int warningcount = 0;
 294 int sorrycount = 0;
 295
 296 /* Flag to output bytecode instead of native assembler */
 297 int output_bytecode = 0;
 298
 299 /* Pointer to function to compute the name to use to print a declaration.
 300    DECL is the declaration in question.
 301    VERBOSITY determines what information will be printed:
 302      0: DECL_NAME, demangled as necessary.
 303      1: and scope information.
 304      2: and any other information that might be interesting, such as function
 305         parameter types in C++.  */
 306
 307 char *(*decl_printable_name) (/* tree decl, int verbosity */);
 308
 309 /* Pointer to function to compute rtl for a language-specific tree code.  */
 310
 311 struct rtx_def *(*lang_expand_expr) ();
 312
 313 /* Pointer to function to finish handling an incomplete decl at the
 314    end of compilation.  */
 315
 316 void (*incomplete_decl_finalize_hook) () = 0;
 317
 318 /* Highest label number used at the end of reload.  */
 319
 320 int max_label_num_after_reload;
 321
 322 /* Nonzero if generating code to do profiling.  */
 323
 324 int profile_flag = 0;
 325
 326 /* Nonzero if generating code to do profiling on a line-by-line basis.  */
 327
 328 int profile_block_flag;
 329
 330 /* Nonzero if generating code to profile program flow graph arcs.  */
 331
 332 int profile_arc_flag = 0;
 333
 334 /* Nonzero if generating info for gcov to calculate line test coverage.  */
 335
 336 int flag_test_coverage = 0;
 337
 338 /* Nonzero indicates that branch taken probabilities should be calculated.  */
 339
 340 int flag_branch_probabilities = 0;
 341
 342 /* Nonzero for -pedantic switch: warn about anything
 343    that standard spec forbids.  */
 344
 345 int pedantic = 0;
 346
 347 /* Temporarily suppress certain warnings.
 348    This is set while reading code from a system header file.  */
 349
 350 int in_system_header = 0;
 351
 352 /* Nonzero means do stupid register allocation.
 353    Currently, this is 1 if `optimize' is 0.  */
 354
 355 int obey_regdecls = 0;
 356
 357 /* Don't print functions as they are compiled and don't print
 358    times taken by the various passes.  -quiet.  */
 359
 360 int quiet_flag = 0;
 361 \f
 362 /* -f flags.  */
 363
 364 /* Nonzero means `char' should be signed.  */
 365
 366 int flag_signed_char;
 367
 368 /* Nonzero means give an enum type only as many bytes as it needs.  */
 369
 370 int flag_short_enums;
 371
 372 /* Nonzero for -fcaller-saves: allocate values in regs that need to
 373    be saved across function calls, if that produces overall better code.
 374    Optional now, so people can test it.  */
 375
 376 #ifdef DEFAULT_CALLER_SAVES
 377 int flag_caller_saves = 1;
 378 #else
 379 int flag_caller_saves = 0;
 380 #endif
 381
 382 /* Nonzero if structures and unions should be returned in memory.
 383
 384    This should only be defined if compatibility with another compiler or
 385    with an ABI is needed, because it results in slower code.  */
 386
 387 #ifndef DEFAULT_PCC_STRUCT_RETURN
 388 #define DEFAULT_PCC_STRUCT_RETURN 1
 389 #endif
 390
 391 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
 392
 393 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
 394
 395 /* Nonzero for -fforce-mem: load memory value into a register
 396    before arithmetic on it.  This makes better cse but slower compilation.  */
 397
 398 int flag_force_mem = 0;
 399
 400 /* Nonzero for -fforce-addr: load memory address into a register before
 401    reference to memory.  This makes better cse but slower compilation.  */
 402
 403 int flag_force_addr = 0;
 404
 405 /* Nonzero for -fdefer-pop: don't pop args after each function call;
 406    instead save them up to pop many calls' args with one insns.  */
 407
 408 int flag_defer_pop = 0;
 409
 410 /* Nonzero for -ffloat-store: don't allocate floats and doubles
 411    in extended-precision registers.  */
 412
 413 int flag_float_store = 0;
 414
 415 /* Nonzero for -fcse-follow-jumps:
 416    have cse follow jumps to do a more extensive job.  */
 417
 418 int flag_cse_follow_jumps;
 419
 420 /* Nonzero for -fcse-skip-blocks:
 421    have cse follow a branch around a block.  */
 422 int flag_cse_skip_blocks;
 423
 424 /* Nonzero for -fexpensive-optimizations:
 425    perform miscellaneous relatively-expensive optimizations.  */
 426 int flag_expensive_optimizations;
 427
 428 /* Nonzero for -fthread-jumps:
 429    have jump optimize output of loop.  */
 430
 431 int flag_thread_jumps;
 432
 433 /* Nonzero enables strength-reduction in loop.c.  */
 434
 435 int flag_strength_reduce = 0;
 436
 437 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
 438    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
 439    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
 440    unrolled.  */
 441
 442 int flag_unroll_loops;
 443
 444 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
 445    This is generally not a win.  */
 446
 447 int flag_unroll_all_loops;
 448
 449 /* Nonzero forces all invariant computations in loops to be moved
 450    outside the loop. */
 451
 452 int flag_move_all_movables = 0;
 453
 454 /* Nonzero forces all general induction variables in loops to be
 455    strength reduced. */
 456
 457 int flag_reduce_all_givs = 0;
 458
 459 /* Nonzero for -fwritable-strings:
 460    store string constants in data segment and don't uniquize them.  */
 461
 462 int flag_writable_strings = 0;
 463
 464 /* Nonzero means don't put addresses of constant functions in registers.
 465    Used for compiling the Unix kernel, where strange substitutions are
 466    done on the assembly output.  */
 467
 468 int flag_no_function_cse = 0;
 469
 470 /* Nonzero for -fomit-frame-pointer:
 471    don't make a frame pointer in simple functions that don't require one.  */
 472
 473 int flag_omit_frame_pointer = 0;
 474
 475 /* Nonzero means place each function into its own section on those platforms
 476    which support arbitrary section names and unlimited numbers of sections.  */
 477
 478 int flag_function_sections = 0;
 479
 480 /* Nonzero to inhibit use of define_optimization peephole opts.  */
 481
 482 int flag_no_peephole = 0;
 483
 484 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
 485    operations in the interest of optimization.  For example it allows
 486    GCC to assume arguments to sqrt are nonnegative numbers, allowing
 487    faster code for sqrt to be generated.  */
 488
 489 int flag_fast_math = 0;
 490
 491 /* Nonzero means all references through pointers are volatile.  */
 492
 493 int flag_volatile;
 494
 495 /* Nonzero means treat all global and extern variables as global.  */
 496
 497 int flag_volatile_global;
 498
 499 /* Nonzero means just do syntax checking; don't output anything.  */
 500
 501 int flag_syntax_only = 0;
 502
 503 /* Nonzero means to rerun cse after loop optimization.  This increases
 504    compilation time about 20% and picks up a few more common expressions.  */
 505
 506 static int flag_rerun_cse_after_loop;
 507
 508 /* Nonzero for -finline-functions: ok to inline functions that look like
 509    good inline candidates.  */
 510
 511 int flag_inline_functions;
 512
 513 /* Nonzero for -fkeep-inline-functions: even if we make a function
 514    go inline everywhere, keep its definition around for debugging
 515    purposes.  */
 516
 517 int flag_keep_inline_functions;
 518
 519 /* Nonzero means that functions will not be inlined.  */
 520
 521 int flag_no_inline;
 522
 523 /* Nonzero means that we should emit static const variables
 524    regardless of whether or not optimization is turned on.  */
 525
 526 int flag_keep_static_consts = 1;
 527
 528 /* Nonzero means we should be saving declaration info into a .X file.  */
 529
 530 int flag_gen_aux_info = 0;
 531
 532 /* Specified name of aux-info file.  */
 533
 534 static char *aux_info_file_name;
 535
 536 /* Nonzero means make the text shared if supported.  */
 537
 538 int flag_shared_data;
 539
 540 /* Nonzero means schedule into delayed branch slots if supported.  */
 541
 542 int flag_delayed_branch;
 543
 544 /* Nonzero if we are compiling pure (sharable) code.
 545    Value is 1 if we are doing reasonable (i.e. simple
 546    offset into offset table) pic.  Value is 2 if we can
 547    only perform register offsets.  */
 548
 549 int flag_pic;
 550
 551 /* Nonzero means generate extra code for exception handling and enable
 552    exception handling.  */
 553
 554 int flag_exceptions = 1;
 555
 556 /* Nonzero means don't place uninitialized global data in common storage
 557    by default.  */
 558
 559 int flag_no_common;
 560
 561 /* Nonzero means pretend it is OK to examine bits of target floats,
 562    even if that isn't true.  The resulting code will have incorrect constants,
 563    but the same series of instructions that the native compiler would make.  */
 564
 565 int flag_pretend_float;
 566
 567 /* Nonzero means change certain warnings into errors.
 568    Usually these are warnings about failure to conform to some standard.  */
 569
 570 int flag_pedantic_errors = 0;
 571
 572 /* flag_schedule_insns means schedule insns within basic blocks (before
 573    local_alloc).
 574    flag_schedule_insns_after_reload means schedule insns after
 575    global_alloc.  */
 576
 577 int flag_schedule_insns = 0;
 578 int flag_schedule_insns_after_reload = 0;
 579
 580 #ifdef HAIFA
 581 /* The following flags have effect only for scheduling before register
 582    allocation:
 583
 584    flag_schedule_interblock means schedule insns accross basic blocks.
 585    flag_schedule_speculative means allow speculative motion of non-load insns.
 586    flag_schedule_speculative_load means allow speculative motion of some
 587    load insns.
 588    flag_schedule_speculative_load_dangerous allows speculative motion of more
 589    load insns.
 590    flag_schedule_reverse_before_reload means try to reverse original order
 591    of insns (S).
 592    flag_schedule_reverse_after_reload means try to reverse original order
 593    of insns (R).  */
 594
 595 int flag_schedule_interblock = 1;
 596 int flag_schedule_speculative = 1;
 597 int flag_schedule_speculative_load = 0;
 598 int flag_schedule_speculative_load_dangerous = 0;
 599 int flag_schedule_reverse_before_reload = 0;
 600 int flag_schedule_reverse_after_reload = 0;
 601
 602
 603 /* flag_on_branch_count_reg means try to replace add-1,compare,branch tupple
 604    by a cheaper branch, on a count register. */
 605 int flag_branch_on_count_reg;
 606 #endif  /* HAIFA */
 607
 608
 609 /* -finhibit-size-directive inhibits output of .size for ELF.
 610    This is used only for compiling crtstuff.c,
 611    and it may be extended to other effects
 612    needed for crtstuff.c on other systems.  */
 613 int flag_inhibit_size_directive = 0;
 614
 615 /* -fverbose-asm causes extra commentary information to be produced in
 616    the generated assembly code (to make it more readable).  This option
 617    is generally only of use to those who actually need to read the
 618    generated assembly code (perhaps while debugging the compiler itself).
 619    -fverbose-asm is the default.  -fno-verbose-asm causes the extra information
 620    to be omitted and is useful when comparing two assembler files.  */
 621
 622 int flag_verbose_asm = 1;
 623
 624 /* -dA causes debug commentary information to be produced in
 625    the generated assembly code (to make it more readable).  This option
 626    is generally only of use to those who actually need to read the
 627    generated assembly code (perhaps while debugging the compiler itself).
 628    Currently, this switch is only used by dwarfout.c; however, it is intended
 629    to be a catchall for printing debug information in the assembler file.  */
 630
 631 int flag_debug_asm = 0;
 632
 633 /* -fgnu-linker specifies use of the GNU linker for initializations.
 634    (Or, more generally, a linker that handles initializations.)
 635    -fno-gnu-linker says that collect2 will be used.  */
 636 #ifdef USE_COLLECT2
 637 int flag_gnu_linker = 0;
 638 #else
 639 int flag_gnu_linker = 1;
 640 #endif
 641
 642 /* Tag all structures with __attribute__(packed) */
 643 int flag_pack_struct = 0;
 644
 645 /* Emit code to check for stack overflow; also may cause large objects
 646    to be allocated dynamically.  */
 647 int flag_stack_check;
 648
 649 /* -fcheck-memory-usage causes extra code to be generated in order to check
 650    memory accesses.  This is used by a detector of bad memory accesses such
 651    as Checker.  */
 652 int flag_check_memory_usage = 0;
 653
 654 /* -fprefix-function-name causes function name to be prefixed.  This
 655    can be used with -fcheck-memory-usage to isolate code compiled with
 656    -fcheck-memory-usage.  */
 657 int flag_prefix_function_name = 0;
 658
 659 int flag_regmove = 0;
 660
 661 /* 1 if alias checking is on (by default, when -O).  */
 662 int flag_alias_check = 0;
 663
 664 /* 0 if pointer arguments may alias each other.  True in C.
 665    1 if pointer arguments may not alias each other but may alias
 666    global variables.
 667    2 if pointer arguments may not alias each other and may not
 668    alias global variables.  True in Fortran.
 669    This defaults to 0 for C.  */
 670 int flag_argument_noalias = 0;
 671
 672 /* Table of language-independent -f options.
 673    STRING is the option name.  VARIABLE is the address of the variable.
 674    ON_VALUE is the value to store in VARIABLE
 675     if `-fSTRING' is seen as an option.
 676    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
 677
 678 struct { char *string; int *variable; int on_value;} f_options[] =
 679 {
 680   {"float-store", &flag_float_store, 1},
 681   {"volatile", &flag_volatile, 1},
 682   {"volatile-global", &flag_volatile_global, 1},
 683   {"defer-pop", &flag_defer_pop, 1},
 684   {"omit-frame-pointer", &flag_omit_frame_pointer, 1},
 685   {"cse-follow-jumps", &flag_cse_follow_jumps, 1},
 686   {"cse-skip-blocks", &flag_cse_skip_blocks, 1},
 687   {"expensive-optimizations", &flag_expensive_optimizations, 1},
 688   {"thread-jumps", &flag_thread_jumps, 1},
 689   {"strength-reduce", &flag_strength_reduce, 1},
 690   {"unroll-loops", &flag_unroll_loops, 1},
 691   {"unroll-all-loops", &flag_unroll_all_loops, 1},
 692   {"move-all-movables", &flag_move_all_movables, 1},
 693   {"reduce-all-givs", &flag_reduce_all_givs, 1},
 694   {"writable-strings", &flag_writable_strings, 1},
 695   {"peephole", &flag_no_peephole, 0},
 696   {"force-mem", &flag_force_mem, 1},
 697   {"force-addr", &flag_force_addr, 1},
 698   {"function-cse", &flag_no_function_cse, 0},
 699   {"inline-functions", &flag_inline_functions, 1},
 700   {"keep-inline-functions", &flag_keep_inline_functions, 1},
 701   {"inline", &flag_no_inline, 0},
 702   {"keep-static-consts", &flag_keep_static_consts, 1},
 703   {"syntax-only", &flag_syntax_only, 1},
 704   {"shared-data", &flag_shared_data, 1},
 705   {"caller-saves", &flag_caller_saves, 1},
 706   {"pcc-struct-return", &flag_pcc_struct_return, 1},
 707   {"reg-struct-return", &flag_pcc_struct_return, 0},
 708   {"delayed-branch", &flag_delayed_branch, 1},
 709   {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1},
 710   {"pretend-float", &flag_pretend_float, 1},
 711   {"schedule-insns", &flag_schedule_insns, 1},
 712   {"schedule-insns2", &flag_schedule_insns_after_reload, 1},
 713 #ifdef HAIFA
 714   {"sched-interblock",&flag_schedule_interblock, 1},
 715   {"sched-spec",&flag_schedule_speculative, 1},
 716   {"sched-spec-load",&flag_schedule_speculative_load, 1},
 717   {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1},
 718   {"sched-reverse-S",&flag_schedule_reverse_before_reload, 1},
 719   {"sched-reverse-R",&flag_schedule_reverse_after_reload, 1},
 720   {"branch-count-reg",&flag_branch_on_count_reg, 1},
 721 #endif  /* HAIFA */
 722   {"pic", &flag_pic, 1},
 723   {"PIC", &flag_pic, 2},
 724   {"exceptions", &flag_exceptions, 1},
 725   {"sjlj-exceptions", &exceptions_via_longjmp, 1},
 726   {"asynchronous-exceptions", &asynchronous_exceptions, 1},
 727   {"profile-arcs", &profile_arc_flag, 1},
 728   {"test-coverage", &flag_test_coverage, 1},
 729   {"branch-probabilities", &flag_branch_probabilities, 1},
 730   {"fast-math", &flag_fast_math, 1},
 731   {"common", &flag_no_common, 0},
 732   {"inhibit-size-directive", &flag_inhibit_size_directive, 1},
 733   {"function-sections", &flag_function_sections, 1},
 734   {"verbose-asm", &flag_verbose_asm, 1},
 735   {"gnu-linker", &flag_gnu_linker, 1},
 736   {"regmove", &flag_regmove, 1},
 737   {"pack-struct", &flag_pack_struct, 1},
 738   {"stack-check", &flag_stack_check, 1},
 739   {"bytecode", &output_bytecode, 1},
 740   {"alias-check", &flag_alias_check, 1},
 741   {"argument-alias", &flag_argument_noalias, 0},
 742   {"argument-noalias", &flag_argument_noalias, 1},
 743   {"argument-noalias-global", &flag_argument_noalias, 2},
 744   {"check-memory-usage", &flag_check_memory_usage, 1},
 745   {"prefix-function-name", &flag_prefix_function_name, 1}
 746 };
 747
 748 /* Table of language-specific options.  */
 749
 750 char *lang_options[] =
 751 {
 752   "-ansi",
 753   "-fallow-single-precision",
 754
 755   "-fsigned-bitfields",
 756   "-funsigned-bitfields",
 757   "-fno-signed-bitfields",
 758   "-fno-unsigned-bitfields",
 759   "-fsigned-char",
 760   "-funsigned-char",
 761   "-fno-signed-char",
 762   "-fno-unsigned-char",
 763
 764   "-ftraditional",
 765   "-traditional",
 766   "-fnotraditional",
 767   "-fno-traditional",
 768
 769   "-fasm",
 770   "-fno-asm",
 771   "-fbuiltin",
 772   "-fno-builtin",
 773   "-fhosted",
 774   "-fno-hosted",
 775   "-ffreestanding",
 776   "-fno-freestanding",
 777   "-fcond-mismatch",
 778   "-fno-cond-mismatch",
 779   "-fdollars-in-identifiers",
 780   "-fno-dollars-in-identifiers",
 781   "-fident",
 782   "-fno-ident",
 783   "-fshort-double",
 784   "-fno-short-double",
 785   "-fshort-enums",
 786   "-fno-short-enums",
 787
 788   "-Wall",
 789   "-Wbad-function-cast",
 790   "-Wno-bad-function-cast",
 791   "-Wcast-qual",
 792   "-Wno-cast-qual",
 793   "-Wchar-subscripts",
 794   "-Wno-char-subscripts",
 795   "-Wcomment",
 796   "-Wno-comment",
 797   "-Wcomments",
 798   "-Wno-comments",
 799   "-Wconversion",
 800   "-Wno-conversion",
 801   "-Wformat",
 802   "-Wno-format",
 803   "-Wimport",
 804   "-Wno-import",
 805   "-Wimplicit",
 806   "-Wno-implicit",
 807   "-Wmain",
 808   "-Wno-main",
 809   "-Wmissing-braces",
 810   "-Wno-missing-braces",
 811   "-Wmissing-declarations",
 812   "-Wno-missing-declarations",
 813   "-Wmissing-prototypes",
 814   "-Wno-missing-prototypes",
 815   "-Wnested-externs",
 816   "-Wno-nested-externs",
 817   "-Wparentheses",
 818   "-Wno-parentheses",
 819   "-Wpointer-arith",
 820   "-Wno-pointer-arith",
 821   "-Wredundant-decls",
 822   "-Wno-redundant-decls",
 823   "-Wsign-compare",
 824   "-Wno-sign-compare",
 825   "-Wstrict-prototypes",
 826   "-Wno-strict-prototypes",
 827   "-Wtraditional",
 828   "-Wno-traditional",
 829   "-Wtrigraphs",
 830   "-Wno-trigraphs",
 831   "-Wundef",
 832   "-Wno-undef",
 833   "-Wwrite-strings",
 834   "-Wno-write-strings",
 835
 836   /* these are for obj c */
 837   "-lang-objc",
 838   "-gen-decls",
 839   "-fgnu-runtime",
 840   "-fno-gnu-runtime",
 841   "-fnext-runtime",
 842   "-fno-next-runtime",
 843   "-Wselector",
 844   "-Wno-selector",
 845   "-Wprotocol",
 846   "-Wno-protocol",
 847
 848 #include "options.h"
 849   0
 850 };
 851 \f
 852 /* Options controlling warnings */
 853
 854 /* Don't print warning messages.  -w.  */
 855
 856 int inhibit_warnings = 0;
 857
 858 /* Print various extra warnings.  -W.  */
 859
 860 int extra_warnings = 0;
 861
 862 /* Treat warnings as errors.  -Werror.  */
 863
 864 int warnings_are_errors = 0;
 865
 866 /* Nonzero to warn about unused local variables.  */
 867
 868 int warn_unused;
 869
 870 /* Nonzero to warn about variables used before they are initialized.  */
 871
 872 int warn_uninitialized;
 873
 874 /* Nonzero means warn about all declarations which shadow others.   */
 875
 876 int warn_shadow;
 877
 878 /* Warn if a switch on an enum fails to have a case for every enum value.  */
 879
 880 int warn_switch;
 881
 882 /* Nonzero means warn about function definitions that default the return type
 883    or that use a null return and have a return-type other than void.  */
 884
 885 int warn_return_type;
 886
 887 /* Nonzero means warn about pointer casts that increase the required
 888    alignment of the target type (and might therefore lead to a crash
 889    due to a misaligned access).  */
 890
 891 int warn_cast_align;
 892
 893 /* Nonzero means warn about any identifiers that match in the first N
 894    characters.  The value N is in `id_clash_len'.  */
 895
 896 int warn_id_clash;
 897 unsigned id_clash_len;
 898
 899 /* Nonzero means warn about any objects definitions whose size is larger
 900    than N bytes.  Also want about function definitions whose returned
 901    values are larger than N bytes. The value N is in `larger_than_size'.  */
 902
 903 int warn_larger_than;
 904 unsigned larger_than_size;
 905
 906 /* Nonzero means warn if inline function is too large.  */
 907
 908 int warn_inline;
 909
 910 /* Warn if a function returns an aggregate,
 911    since there are often incompatible calling conventions for doing this.  */
 912
 913 int warn_aggregate_return;
 914
 915 /* Likewise for -W.  */
 916
 917 struct { char *string; int *variable; int on_value;} W_options[] =
 918 {
 919   {"unused", &warn_unused, 1},
 920   {"error", &warnings_are_errors, 1},
 921   {"shadow", &warn_shadow, 1},
 922   {"switch", &warn_switch, 1},
 923   {"aggregate-return", &warn_aggregate_return, 1},
 924   {"cast-align", &warn_cast_align, 1},
 925   {"uninitialized", &warn_uninitialized, 1},
 926   {"inline", &warn_inline, 1}
 927 };
 928 \f
 929 /* Output files for assembler code (real compiler output)
 930    and debugging dumps.  */
 931
 932 FILE *asm_out_file;
 933 FILE *aux_info_file;
 934 FILE *rtl_dump_file;
 935 FILE *jump_opt_dump_file;
 936 FILE *cse_dump_file;
 937 FILE *loop_dump_file;
 938 FILE *cse2_dump_file;
 939 FILE *branch_prob_dump_file;
 940 FILE *flow_dump_file;
 941 FILE *combine_dump_file;
 942 FILE *regmove_dump_file;
 943 FILE *sched_dump_file;
 944 FILE *local_reg_dump_file;
 945 FILE *global_reg_dump_file;
 946 FILE *sched2_dump_file;
 947 FILE *jump2_opt_dump_file;
 948 FILE *dbr_sched_dump_file;
 949 FILE *stack_reg_dump_file;
 950
 951 /* Time accumulators, to count the total time spent in various passes.  */
 952
 953 int parse_time;
 954 int varconst_time;
 955 int integration_time;
 956 int jump_time;
 957 int cse_time;
 958 int loop_time;
 959 int cse2_time;
 960 int branch_prob_time;
 961 int flow_time;
 962 int combine_time;
 963 int regmove_time;
 964 int sched_time;
 965 int local_alloc_time;
 966 int global_alloc_time;
 967 int sched2_time;
 968 int dbr_sched_time;
 969 int shorten_branch_time;
 970 int stack_reg_time;
 971 int final_time;
 972 int symout_time;
 973 int dump_time;
 974 \f
 975 /* Return time used so far, in microseconds.  */
 976
 977 int
 978 get_run_time ()
 979 {
 980 #ifndef _WIN32
 981 #ifdef USG
 982   struct tms tms;
 983 #else
 984 #ifndef VMS
 985   struct rusage rusage;
 986 #else
 987   struct
 988     {
 989       int proc_user_time;
 990       int proc_system_time;
 991       int child_user_time;
 992       int child_system_time;
 993     } vms_times;
 994 #endif
 995 #endif
 996 #endif
 997
 998   if (quiet_flag)
 999     return 0;
1000 #ifdef _WIN32
1001   if (clock() < 0)
1002     return 0;
1003   else
1004     return (clock() * 1000);
1005 #else /* not _WIN32 */
1006 #ifdef USG
1007   times (&tms);
1008   return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
1009 #else
1010 #ifndef VMS
1011   getrusage (0, &rusage);
1012   return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
1013           + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
1014 #else /* VMS */
1015   times (&vms_times);
1016   return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
1017 #endif
1018 #endif
1019 #endif
1020 }
1021
1022 #define TIMEVAR(VAR, BODY)    \
1023 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
1024
1025 void
1026 print_time (str, total)
1027      char *str;
1028      int total;
1029 {
1030   fprintf (stderr,
1031            "time in %s: %d.%06d\n",
1032            str, total / 1000000, total % 1000000);
1033 }
1034
1035 /* Count an error or warning.  Return 1 if the message should be printed.  */
1036
1037 int
1038 count_error (warningp)
1039      int warningp;
1040 {
1041   if (warningp && inhibit_warnings)
1042     return 0;
1043
1044   if (warningp && !warnings_are_errors)
1045     warningcount++;
1046   else
1047     {
1048       static int warning_message = 0;
1049
1050       if (warningp && !warning_message)
1051         {
1052           fprintf (stderr, "%s: warnings being treated as errors\n", progname);
1053           warning_message = 1;
1054         }
1055       errorcount++;
1056     }
1057
1058   return 1;
1059 }
1060
1061 /* Print a fatal error message.  NAME is the text.
1062    Also include a system error message based on `errno'.  */
1063
1064 void
1065 pfatal_with_name (name)
1066      char *name;
1067 {
1068   fprintf (stderr, "%s: ", progname);
1069   perror (name);
1070   exit (FATAL_EXIT_CODE);
1071 }
1072
1073 void
1074 fatal_io_error (name)
1075      char *name;
1076 {
1077   fprintf (stderr, "%s: %s: I/O error\n", progname, name);
1078   exit (FATAL_EXIT_CODE);
1079 }
1080
1081 /* Called to give a better error message for a bad insn rather than
1082    just calling abort().  */
1083
1084 void
1085 fatal_insn (message, insn)
1086      char *message;
1087      rtx insn;
1088 {
1089   if (!output_bytecode)
1090     {
1091       error (message);
1092       debug_rtx (insn);
1093     }
1094   if (asm_out_file)
1095     fflush (asm_out_file);
1096   if (aux_info_file)
1097     fflush (aux_info_file);
1098   if (rtl_dump_file)
1099     fflush (rtl_dump_file);
1100   if (jump_opt_dump_file)
1101     fflush (jump_opt_dump_file);
1102   if (cse_dump_file)
1103     fflush (cse_dump_file);
1104   if (loop_dump_file)
1105     fflush (loop_dump_file);
1106   if (cse2_dump_file)
1107     fflush (cse2_dump_file);
1108   if (flow_dump_file)
1109     fflush (flow_dump_file);
1110   if (combine_dump_file)
1111     fflush (combine_dump_file);
1112   if (regmove_dump_file)
1113     fflush (regmove_dump_file);
1114   if (sched_dump_file)
1115     fflush (sched_dump_file);
1116   if (local_reg_dump_file)
1117     fflush (local_reg_dump_file);
1118   if (global_reg_dump_file)
1119     fflush (global_reg_dump_file);
1120   if (sched2_dump_file)
1121     fflush (sched2_dump_file);
1122   if (jump2_opt_dump_file)
1123     fflush (jump2_opt_dump_file);
1124   if (dbr_sched_dump_file)
1125     fflush (dbr_sched_dump_file);
1126   if (stack_reg_dump_file)
1127     fflush (stack_reg_dump_file);
1128   fflush (stdout);
1129   fflush (stderr);
1130   abort ();
1131 }
1132
1133 /* Called to give a better error message when we don't have an insn to match
1134    what we are looking for or if the insn's constraints aren't satisfied,
1135    rather than just calling abort().  */
1136
1137 void
1138 fatal_insn_not_found (insn)
1139      rtx insn;
1140 {
1141   if (INSN_CODE (insn) < 0)
1142     fatal_insn ("internal error--unrecognizable insn:", insn);
1143   else
1144     fatal_insn ("internal error--insn does not satisfy its constraints:", insn);
1145 }
1146
1147 /* This is the default decl_printable_name function.  */
1148
1149 static char *
1150 decl_name (decl, verbosity)
1151      tree decl;
1152      int verbosity;
1153 {
1154   return IDENTIFIER_POINTER (DECL_NAME (decl));
1155 }
1156 \f
1157 static int need_error_newline;
1158
1159 /* Function of last error message;
1160    more generally, function such that if next error message is in it
1161    then we don't have to mention the function name.  */
1162 static tree last_error_function = NULL;
1163
1164 /* Used to detect when input_file_stack has changed since last described.  */
1165 static int last_error_tick;
1166
1167 /* Called when the start of a function definition is parsed,
1168    this function prints on stderr the name of the function.  */
1169
1170 void
1171 announce_function (decl)
1172      tree decl;
1173 {
1174   if (! quiet_flag)
1175     {
1176       if (rtl_dump_and_exit)
1177         fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
1178       else
1179         fprintf (stderr, " %s", (*decl_printable_name) (decl, 2));
1180       fflush (stderr);
1181       need_error_newline = 1;
1182       last_error_function = current_function_decl;
1183     }
1184 }
1185
1186 /* The default function to print out name of current function that caused
1187    an error.  */
1188
1189 void
1190 default_print_error_function (file)
1191      char *file;
1192 {
1193   if (last_error_function != current_function_decl)
1194     {
1195       char *kind = "function";
1196       if (current_function_decl != 0
1197           && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1198         kind = "method";
1199
1200       if (file)
1201         fprintf (stderr, "%s: ", file);
1202
1203       if (current_function_decl == NULL)
1204         fprintf (stderr, "At top level:\n");
1205       else
1206         {
1207           char *name = (*decl_printable_name) (current_function_decl, 2);
1208           fprintf (stderr, "In %s `%s':\n", kind, name);
1209         }
1210
1211       last_error_function = current_function_decl;
1212     }
1213 }
1214
1215 /* Called by report_error_function to print out function name.
1216  * Default may be overridden by language front-ends.  */
1217
1218 void (*print_error_function) PROTO((char *)) = default_print_error_function;
1219
1220 /* Prints out, if necessary, the name of the current function
1221   that caused an error.  Called from all error and warning functions.  */
1222
1223 void
1224 report_error_function (file)
1225      char *file;
1226 {
1227   struct file_stack *p;
1228
1229   if (need_error_newline)
1230     {
1231       fprintf (stderr, "\n");
1232       need_error_newline = 0;
1233     }
1234
1235   (*print_error_function) (file);
1236
1237   if (input_file_stack && input_file_stack->next != 0
1238       && input_file_stack_tick != last_error_tick
1239       && file == input_filename)
1240     {
1241       fprintf (stderr, "In file included");
1242       for (p = input_file_stack->next; p; p = p->next)
1243         {
1244           fprintf (stderr, " from %s:%d", p->name, p->line);
1245           if (p->next)
1246             fprintf (stderr, ",\n                ");
1247         }
1248       fprintf (stderr, ":\n");
1249       last_error_tick = input_file_stack_tick;
1250     }
1251 }
1252 \f
1253 /* Print a message.  */
1254
1255 static void
1256 vmessage (prefix, s, ap)
1257      char *prefix;
1258      char *s;
1259      va_list ap;
1260 {
1261   if (prefix)
1262     fprintf (stderr, "%s: ", prefix);
1263
1264 #ifdef HAVE_VPRINTF
1265   vfprintf (stderr, s, ap);
1266 #else
1267   {
1268     HOST_WIDE_INT v1 = va_arg(ap, HOST_WIDE_INT);
1269     HOST_WIDE_INT v2 = va_arg(ap, HOST_WIDE_INT);
1270     HOST_WIDE_INT v3 = va_arg(ap, HOST_WIDE_INT);
1271     HOST_WIDE_INT v4 = va_arg(ap, HOST_WIDE_INT);
1272     fprintf (stderr, s, v1, v2, v3, v4);
1273   }
1274 #endif
1275 }
1276
1277 /* Print a message relevant to line LINE of file FILE.  */
1278
1279 static void
1280 v_message_with_file_and_line (file, line, prefix, s, ap)
1281      char *file;
1282      int line;
1283      char *prefix;
1284      char *s;
1285      va_list ap;
1286 {
1287   if (file)
1288     fprintf (stderr, "%s:%d: ", file, line);
1289   else
1290     fprintf (stderr, "%s: ", progname);
1291
1292   vmessage (prefix, s, ap);
1293   fputc ('\n', stderr);
1294 }
1295
1296 /* Print a message relevant to the given DECL.  */
1297
1298 static void
1299 v_message_with_decl (decl, prefix, s, ap)
1300      tree decl;
1301      char *prefix;
1302      char *s;
1303      va_list ap;
1304 {
1305   char *n, *p;
1306
1307   fprintf (stderr, "%s:%d: ",
1308            DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1309
1310   if (prefix)
1311     fprintf (stderr, "%s: ", prefix);
1312
1313   /* Do magic to get around lack of varargs support for insertion
1314      of arguments into existing list.  We know that the decl is first;
1315      we ass_u_me that it will be printed with "%s".  */
1316
1317   for (p = s; *p; ++p)
1318     {
1319       if (*p == '%')
1320         {
1321           if (*(p + 1) == '%')
1322             ++p;
1323           else
1324             break;
1325         }
1326     }
1327
1328   if (p > s)                    /* Print the left-hand substring.  */
1329     {
1330       char fmt[sizeof "%.255s"];
1331       long width = p - s;
1332
1333       if (width > 255L) width = 255L;   /* arbitrary */
1334       sprintf (fmt, "%%.%lds", width);
1335       fprintf (stderr, fmt, s);
1336     }
1337
1338   if (*p == '%')                /* Print the name.  */
1339     {
1340       char *n = (DECL_NAME (decl)
1341                  ? (*decl_printable_name) (decl, 2)
1342                  : "((anonymous))");
1343       fputs (n, stderr);
1344       while (*p)
1345         {
1346           ++p;
1347           if (isalpha (*(p - 1) & 0xFF))
1348             break;
1349         }
1350     }
1351
1352   if (*p)                       /* Print the rest of the message.  */
1353     vmessage ((char *)NULL, p, ap);
1354
1355   fputc ('\n', stderr);
1356 }
1357
1358 /* Figure file and line of the given INSN.  */
1359
1360 static void
1361 file_and_line_for_asm (insn, pfile, pline)
1362      rtx insn;
1363      char **pfile;
1364      int *pline;
1365 {
1366   rtx body = PATTERN (insn);
1367   rtx asmop;
1368
1369   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
1370   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1371     asmop = SET_SRC (body);
1372   else if (GET_CODE (body) == ASM_OPERANDS)
1373     asmop = body;
1374   else if (GET_CODE (body) == PARALLEL
1375            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1376     asmop = SET_SRC (XVECEXP (body, 0, 0));
1377   else if (GET_CODE (body) == PARALLEL
1378            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1379     asmop = XVECEXP (body, 0, 0);
1380   else
1381     asmop = NULL;
1382
1383   if (asmop)
1384     {
1385       *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
1386       *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
1387     }
1388   else
1389     {
1390       *pfile = input_filename;
1391       *pline = lineno;
1392     }
1393 }
1394
1395 /* Report an error at line LINE of file FILE.  */
1396
1397 static void
1398 v_error_with_file_and_line (file, line, s, ap)
1399      char *file;
1400      int line;
1401      char *s;
1402      va_list ap;
1403 {
1404   count_error (0);
1405   report_error_function (file);
1406   v_message_with_file_and_line (file, line, (char *)NULL, s, ap);
1407 }
1408
1409 void
1410 error_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1411 {
1412 #ifndef __STDC__
1413   char *file;
1414   int line;
1415   char *s;
1416 #endif
1417   va_list ap;
1418
1419   VA_START (ap, s);
1420
1421 #ifndef __STDC__
1422   file = va_arg (ap, char *);
1423   line = va_arg (ap, int);
1424   s = va_arg (ap, char *);
1425 #endif
1426
1427   v_error_with_file_and_line (file, line, s, ap);
1428   va_end (ap);
1429 }
1430
1431 /* Report an error at the declaration DECL.
1432    S is a format string which uses %s to substitute the declaration
1433    name; subsequent substitutions are a la printf.  */
1434
1435 static void
1436 v_error_with_decl (decl, s, ap)
1437      tree decl;
1438      char *s;
1439      va_list ap;
1440 {
1441   count_error (0);
1442   report_error_function (DECL_SOURCE_FILE (decl));
1443   v_message_with_decl (decl, (char *)NULL, s, ap);
1444 }
1445
1446 void
1447 error_with_decl VPROTO((tree decl, char *s, ...))
1448 {
1449 #ifndef __STDC__
1450   tree decl;
1451   char *s;
1452 #endif
1453   va_list ap;
1454
1455   VA_START (ap, s);
1456
1457 #ifndef __STDC__
1458   decl = va_arg (ap, tree);
1459   s = va_arg (ap, char *);
1460 #endif
1461
1462   v_error_with_decl (decl, s, ap);
1463   va_end (ap);
1464 }
1465
1466 /* Report an error at the line number of the insn INSN.
1467    This is used only when INSN is an `asm' with operands,
1468    and each ASM_OPERANDS records its own source file and line.  */
1469
1470 static void
1471 v_error_for_asm (insn, s, ap)
1472      rtx insn;
1473      char *s;
1474      va_list ap;
1475 {
1476   char *file;
1477   int line;
1478
1479   count_error (0);
1480   file_and_line_for_asm (insn, &file, &line);
1481   report_error_function (file);
1482   v_message_with_file_and_line (file, line, (char *)NULL, s, ap);
1483 }
1484
1485 void
1486 error_for_asm VPROTO((rtx insn, char *s, ...))
1487 {
1488 #ifndef __STDC__
1489   rtx insn;
1490   char *s;
1491 #endif
1492   va_list ap;
1493
1494   VA_START (ap, s);
1495
1496 #ifndef __STDC__
1497   insn = va_arg (ap, rtx);
1498   s = va_arg (ap, char *);
1499 #endif
1500
1501   v_error_for_asm (insn, s, ap);
1502   va_end (ap);
1503 }
1504
1505 /* Report an error at the current line number.  */
1506
1507 static void
1508 verror (s, ap)
1509      char *s;
1510      va_list ap;
1511 {
1512   v_error_with_file_and_line (input_filename, lineno, s, ap);
1513 }
1514
1515 void
1516 error VPROTO((char *s, ...))
1517 {
1518 #ifndef __STDC__
1519   char *s;
1520 #endif
1521   va_list ap;
1522
1523   VA_START (ap, s);
1524
1525 #ifndef __STDC__
1526   s = va_arg (ap, char *);
1527 #endif
1528
1529   verror (s, ap);
1530   va_end (ap);
1531 }
1532
1533 /* Report a fatal error at the current line number.  */
1534
1535 static void
1536 vfatal (s, ap)
1537      char *s;
1538      va_list ap;
1539 {
1540   verror (s, ap);
1541   exit (FATAL_EXIT_CODE);
1542 }
1543
1544 void
1545 fatal VPROTO((char *s, ...))
1546 {
1547 #ifndef __STDC__
1548   char *s;
1549 #endif
1550   va_list ap;
1551
1552   VA_START (ap, s);
1553
1554 #ifndef __STDC__
1555   s = va_arg (ap, char *);
1556 #endif
1557
1558   vfatal (s, ap);
1559   va_end (ap);
1560 }
1561
1562 /* Report a warning at line LINE of file FILE.  */
1563
1564 static void
1565 v_warning_with_file_and_line (file, line, s, ap)
1566      char *file;
1567      int line;
1568      char *s;
1569      va_list ap;
1570 {
1571   if (count_error (1))
1572     {
1573       report_error_function (file);
1574       v_message_with_file_and_line (file, line, "warning", s, ap);
1575     }
1576 }
1577
1578 void
1579 warning_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1580 {
1581 #ifndef __STDC__
1582   char *file;
1583   int line;
1584   char *s;
1585 #endif
1586   va_list ap;
1587
1588   VA_START (ap, s);
1589
1590 #ifndef __STDC__
1591   file = va_arg (ap, char *);
1592   line = va_arg (ap, int);
1593   s = va_arg (ap, char *);
1594 #endif
1595
1596   v_warning_with_file_and_line (file, line, s, ap);
1597   va_end (ap);
1598 }
1599
1600 /* Report a warning at the declaration DECL.
1601    S is a format string which uses %s to substitute the declaration
1602    name; subsequent substitutions are a la printf.  */
1603
1604 static void
1605 v_warning_with_decl (decl, s, ap)
1606      tree decl;
1607      char *s;
1608      va_list ap;
1609 {
1610   if (count_error (1))
1611     {
1612       report_error_function (DECL_SOURCE_FILE (decl));
1613       v_message_with_decl (decl, "warning", s, ap);
1614     }
1615 }
1616
1617 void
1618 warning_with_decl VPROTO((tree decl, char *s, ...))
1619 {
1620 #ifndef __STDC__
1621   tree decl;
1622   char *s;
1623 #endif
1624   va_list ap;
1625
1626   VA_START (ap, s);
1627
1628 #ifndef __STDC__
1629   decl = va_arg (ap, tree);
1630   s = va_arg (ap, char *);
1631 #endif
1632
1633   v_warning_with_decl (decl, s, ap);
1634   va_end (ap);
1635 }
1636
1637 /* Report a warning at the line number of the insn INSN.
1638    This is used only when INSN is an `asm' with operands,
1639    and each ASM_OPERANDS records its own source file and line.  */
1640
1641 static void
1642 v_warning_for_asm (insn, s, ap)
1643      rtx insn;
1644      char *s;
1645      va_list ap;
1646 {
1647   if (count_error (1))
1648     {
1649       char *file;
1650       int line;
1651
1652       file_and_line_for_asm (insn, &file, &line);
1653       report_error_function (file);
1654       v_message_with_file_and_line (file, line, "warning", s, ap);
1655     }
1656 }
1657
1658 void
1659 warning_for_asm VPROTO((rtx insn, char *s, ...))
1660 {
1661 #ifndef __STDC__
1662   rtx insn;
1663   char *s;
1664 #endif
1665   va_list ap;
1666
1667   VA_START (ap, s);
1668
1669 #ifndef __STDC__
1670   insn = va_arg (ap, rtx);
1671   s = va_arg (ap, char *);
1672 #endif
1673
1674   v_warning_for_asm (insn, s, ap);
1675   va_end (ap);
1676 }
1677
1678 /* Report a warning at the current line number.  */
1679
1680 static void
1681 vwarning (s, ap)
1682      char *s;
1683      va_list ap;
1684 {
1685   v_warning_with_file_and_line (input_filename, lineno, s, ap);
1686 }
1687
1688 void
1689 warning VPROTO((char *s, ...))
1690 {
1691 #ifndef __STDC__
1692   char *s;
1693 #endif
1694   va_list ap;
1695
1696   VA_START (ap, s);
1697
1698 #ifndef __STDC__
1699   s = va_arg (ap, char *);
1700 #endif
1701
1702   vwarning (s, ap);
1703   va_end (ap);
1704 }
1705
1706 /* These functions issue either warnings or errors depending on
1707    -pedantic-errors.  */
1708
1709 static void
1710 vpedwarn (s, ap)
1711      char *s;
1712      va_list ap;
1713 {
1714   if (flag_pedantic_errors)
1715     verror (s, ap);
1716   else
1717     vwarning (s, ap);
1718 }
1719
1720 void
1721 pedwarn VPROTO((char *s, ...))
1722 {
1723 #ifndef __STDC__
1724   char *s;
1725 #endif
1726   va_list ap;
1727
1728   VA_START (ap, s);
1729
1730 #ifndef __STDC__
1731   s = va_arg (ap, char *);
1732 #endif
1733
1734   vpedwarn (s, ap);
1735   va_end (ap);
1736 }
1737
1738 static void
1739 v_pedwarn_with_decl (decl, s, ap)
1740      tree decl;
1741      char *s;
1742      va_list ap;
1743 {
1744   /* We don't want -pedantic-errors to cause the compilation to fail from
1745      "errors" in system header files.  Sometimes fixincludes can't fix what's
1746      broken (eg: unsigned char bitfields - fixing it may change the alignment
1747      which will cause programs to mysteriously fail because the C library
1748      or kernel uses the original layout).  There's no point in issuing a
1749      warning either, it's just unnecessary noise.  */
1750
1751   if (! DECL_IN_SYSTEM_HEADER (decl))
1752     {
1753       if (flag_pedantic_errors)
1754         v_error_with_decl (decl, s, ap);
1755       else
1756         v_warning_with_decl (decl, s, ap);
1757     }
1758 }
1759
1760 void
1761 pedwarn_with_decl VPROTO((tree decl, char *s, ...))
1762 {
1763 #ifndef __STDC__
1764   tree decl;
1765   char *s;
1766 #endif
1767   va_list ap;
1768
1769   VA_START (ap, s);
1770
1771 #ifndef __STDC__
1772   decl = va_arg (ap, tree);
1773   s = va_arg (ap, char *);
1774 #endif
1775
1776   v_pedwarn_with_decl (decl, s, ap);
1777   va_end (ap);
1778 }
1779
1780 static void
1781 v_pedwarn_with_file_and_line (file, line, s, ap)
1782      char *file;
1783      int line;
1784      char *s;
1785      va_list ap;
1786 {
1787   if (flag_pedantic_errors)
1788     v_error_with_file_and_line (file, line, s, ap);
1789   else
1790     v_warning_with_file_and_line (file, line, s, ap);
1791 }
1792
1793 void
1794 pedwarn_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1795 {
1796 #ifndef __STDC__
1797   char *file;
1798   int line;
1799   char *s;
1800 #endif
1801   va_list ap;
1802
1803   VA_START (ap, s);
1804
1805 #ifndef __STDC__
1806   file = va_arg (ap, char *);
1807   line = va_arg (ap, int);
1808   s = va_arg (ap, char *);
1809 #endif
1810
1811   v_pedwarn_with_file_and_line (file, line, s, ap);
1812   va_end (ap);
1813 }
1814
1815 /* Apologize for not implementing some feature.  */
1816
1817 static void
1818 vsorry (s, ap)
1819      char *s;
1820      va_list ap;
1821 {
1822   sorrycount++;
1823   if (input_filename)
1824     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1825   else
1826     fprintf (stderr, "%s: ", progname);
1827   vmessage ("sorry, not implemented", s, ap);
1828   fputc ('\n', stderr);
1829 }
1830
1831 void
1832 sorry VPROTO((char *s, ...))
1833 {
1834 #ifndef __STDC__
1835   char *s;
1836 #endif
1837   va_list ap;
1838
1839   VA_START (ap, s);
1840
1841 #ifndef __STDC__
1842   s = va_arg (ap, char *);
1843 #endif
1844
1845   vsorry (s, ap);
1846   va_end (ap);
1847 }
1848
1849 /* Apologize for not implementing some feature, then quit.  */
1850
1851 static void
1852 v_really_sorry (s, ap)
1853      char *s;
1854      va_list ap;
1855 {
1856   sorrycount++;
1857   if (input_filename)
1858     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1859   else
1860     fprintf (stderr, "%s: ", progname);
1861   vmessage ("sorry, not implemented", s, ap);
1862   fatal (" (fatal)\n");
1863 }
1864
1865 void
1866 really_sorry VPROTO((char *s, ...))
1867 {
1868 #ifndef __STDC__
1869   char *s;
1870 #endif
1871   va_list ap;
1872
1873   VA_START (ap, s);
1874
1875 #ifndef __STDC__
1876   s = va_arg (ap, char *);
1877 #endif
1878
1879   v_really_sorry (s, ap);
1880   va_end (ap);
1881 }
1882 \f
1883 /* More 'friendly' abort that prints the line and file.
1884    config.h can #define abort fancy_abort if you like that sort of thing.
1885
1886    I don't think this is actually a good idea.
1887    Other sorts of crashes will look a certain way.
1888    It is a good thing if crashes from calling abort look the same way.
1889      -- RMS  */
1890
1891 void
1892 fancy_abort ()
1893 {
1894   fatal ("internal gcc abort");
1895 }
1896
1897 /* This calls abort and is used to avoid problems when abort if a macro.
1898    It is used when we need to pass the address of abort.  */
1899
1900 void
1901 do_abort ()
1902 {
1903   abort ();
1904 }
1905
1906 /* When `malloc.c' is compiled with `rcheck' defined,
1907    it calls this function to report clobberage.  */
1908
1909 void
1910 botch (s)
1911 {
1912   abort ();
1913 }
1914
1915 /* Same as `malloc' but report error if no memory available.  */
1916
1917 char *
1918 xmalloc (size)
1919      unsigned size;
1920 {
1921   register char *value = (char *) malloc (size);
1922   if (value == 0 && size != 0)
1923     fatal ("virtual memory exhausted");
1924   return value;
1925 }
1926
1927 /* Same as `realloc' but report error if no memory available.  */
1928
1929 char *
1930 xrealloc (ptr, size)
1931      char *ptr;
1932      int size;
1933 {
1934   char *result = (char *) realloc (ptr, size);
1935   if (!result)
1936     fatal ("virtual memory exhausted");
1937   return result;
1938 }
1939
1940 /* Same as `strdup' but report error if no memory available.  */
1941
1942 char *
1943 xstrdup (s)
1944      register char *s;
1945 {
1946   register char *result = (char *) malloc (strlen (s) + 1);
1947
1948   if (! result)
1949     fatal ("virtual memory exhausted");
1950   strcpy (result, s);
1951   return result;
1952 }
1953 \f
1954 /* Return the logarithm of X, base 2, considering X unsigned,
1955    if X is a power of 2.  Otherwise, returns -1.
1956
1957    This should be used via the `exact_log2' macro.  */
1958
1959 int
1960 exact_log2_wide (x)
1961      register unsigned HOST_WIDE_INT x;
1962 {
1963   register int log = 0;
1964   /* Test for 0 or a power of 2.  */
1965   if (x == 0 || x != (x & -x))
1966     return -1;
1967   while ((x >>= 1) != 0)
1968     log++;
1969   return log;
1970 }
1971
1972 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1973    If X is 0, return -1.
1974
1975    This should be used via the floor_log2 macro.  */
1976
1977 int
1978 floor_log2_wide (x)
1979      register unsigned HOST_WIDE_INT x;
1980 {
1981   register int log = -1;
1982   while (x != 0)
1983     log++,
1984     x >>= 1;
1985   return log;
1986 }
1987
1988 static int float_handler_set;
1989 int float_handled;
1990 jmp_buf float_handler;
1991
1992 /* Signals actually come here.  */
1993
1994 static void
1995 float_signal (signo)
1996      /* If this is missing, some compilers complain.  */
1997      int signo;
1998 {
1999   if (float_handled == 0)
2000     abort ();
2001 #if defined (USG) || defined (hpux)
2002   signal (SIGFPE, float_signal);  /* re-enable the signal catcher */
2003 #endif
2004   float_handled = 0;
2005   signal (SIGFPE, float_signal);
2006   longjmp (float_handler, 1);
2007 }
2008
2009 /* Specify where to longjmp to when a floating arithmetic error happens.
2010    If HANDLER is 0, it means don't handle the errors any more.  */
2011
2012 void
2013 set_float_handler (handler)
2014      jmp_buf handler;
2015 {
2016   float_handled = (handler != 0);
2017   if (handler)
2018     bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
2019
2020   if (float_handled && ! float_handler_set)
2021     {
2022       signal (SIGFPE, float_signal);
2023       float_handler_set = 1;
2024     }
2025 }
2026
2027 /* Specify, in HANDLER, where to longjmp to when a floating arithmetic
2028    error happens, pushing the previous specification into OLD_HANDLER.
2029    Return an indication of whether there was a previous handler in effect.  */
2030
2031 int
2032 push_float_handler (handler, old_handler)
2033      jmp_buf handler, old_handler;
2034 {
2035   int was_handled = float_handled;
2036
2037   float_handled = 1;
2038   if (was_handled)
2039     bcopy ((char *) float_handler, (char *) old_handler,
2040            sizeof (float_handler));
2041
2042   bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
2043   return was_handled;
2044 }
2045
2046 /* Restore the previous specification of whether and where to longjmp to
2047    when a floating arithmetic error happens.  */
2048
2049 void
2050 pop_float_handler (handled, handler)
2051      int handled;
2052      jmp_buf handler;
2053 {
2054   float_handled = handled;
2055   if (handled)
2056     bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
2057 }
2058
2059 /* Handler for SIGPIPE.  */
2060
2061 static void
2062 pipe_closed (signo)
2063      /* If this is missing, some compilers complain.  */
2064      int signo;
2065 {
2066   fatal ("output pipe has been closed");
2067 }
2068
2069 /* Strip off a legitimate source ending from the input string NAME of
2070    length LEN.  Rather than having to know the names used by all of
2071    our front ends, we strip off an ending of a period followed by one,
2072    two, or three characters.  */
2073
2074 void
2075 strip_off_ending (name, len)
2076      char *name;
2077      int len;
2078 {
2079   if (len > 2 && name[len - 2] == '.')
2080     name[len - 2] = '\0';
2081   else if (len > 3 && name[len - 3] == '.')
2082     name[len - 3] = '\0';
2083   else if (len > 4 && name[len - 4] == '.')
2084     name[len - 4] = '\0';
2085 }
2086
2087 /* Output a quoted string.  */
2088
2089 void
2090 output_quoted_string (asm_file, string)
2091      FILE *asm_file;
2092      char *string;
2093 {
2094   char c;
2095
2096   putc ('\"', asm_file);
2097   while ((c = *string++) != 0)
2098     {
2099       if (c == '\"' || c == '\\')
2100         putc ('\\', asm_file);
2101       putc (c, asm_file);
2102     }
2103   putc ('\"', asm_file);
2104 }
2105
2106 /* Output a file name in the form wanted by System V.  */
2107
2108 void
2109 output_file_directive (asm_file, input_name)
2110      FILE *asm_file;
2111      char *input_name;
2112 {
2113   int len = strlen (input_name);
2114   char *na = input_name + len;
2115
2116   /* NA gets INPUT_NAME sans directory names.  */
2117   while (na > input_name)
2118     {
2119       if (na[-1] == '/')
2120         break;
2121       na--;
2122     }
2123
2124 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
2125   ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
2126 #else
2127 #ifdef ASM_OUTPUT_SOURCE_FILENAME
2128   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
2129 #else
2130   fprintf (asm_file, "\t.file\t");
2131   output_quoted_string (asm_file, na);
2132   fputc ('\n', asm_file);
2133 #endif
2134 #endif
2135 }
2136 \f
2137 /* Routine to build language identifier for object file.  */
2138
2139 static void
2140 output_lang_identify (asm_out_file)
2141      FILE *asm_out_file;
2142 {
2143   int len = strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1;
2144   char *s = (char *) alloca (len);
2145   sprintf (s, "__gnu_compiled_%s", lang_identify ());
2146   ASM_OUTPUT_LABEL (asm_out_file, s);
2147 }
2148
2149 /* Routine to open a dump file.  */
2150
2151 static FILE *
2152 open_dump_file (base_name, suffix)
2153      char *base_name;
2154      char *suffix;
2155 {
2156   FILE *f;
2157   char *dumpname = (char *) alloca (strlen (base_name) + strlen (suffix) + 1);
2158
2159   strcpy (dumpname, base_name);
2160   strcat (dumpname, suffix);
2161   f = fopen (dumpname, "w");
2162   if (f == 0)
2163     pfatal_with_name (dumpname);
2164   return f;
2165 }
2166
2167 /* Compile an entire file of output from cpp, named NAME.
2168    Write a file of assembly output and various debugging dumps.  */
2169
2170 static void
2171 compile_file (name)
2172      char *name;
2173 {
2174   tree globals;
2175   int start_time;
2176
2177   int name_specified = name != 0;
2178
2179   if (dump_base_name == 0)
2180     dump_base_name = name ? name : "gccdump";
2181
2182   parse_time = 0;
2183   varconst_time = 0;
2184   integration_time = 0;
2185   jump_time = 0;
2186   cse_time = 0;
2187   loop_time = 0;
2188   cse2_time = 0;
2189   branch_prob_time = 0;
2190   flow_time = 0;
2191   combine_time = 0;
2192   regmove_time = 0;
2193   sched_time = 0;
2194   local_alloc_time = 0;
2195   global_alloc_time = 0;
2196   sched2_time = 0;
2197   dbr_sched_time = 0;
2198   shorten_branch_time = 0;
2199   stack_reg_time = 0;
2200   final_time = 0;
2201   symout_time = 0;
2202   dump_time = 0;
2203
2204 #if !USE_CPPLIB
2205   /* Open input file.  */
2206
2207   if (name == 0 || !strcmp (name, "-"))
2208     {
2209       finput = stdin;
2210       name = "stdin";
2211     }
2212   else
2213     finput = fopen (name, "r");
2214   if (finput == 0)
2215     pfatal_with_name (name);
2216
2217 #ifdef IO_BUFFER_SIZE
2218   setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
2219 #endif
2220 #endif /* !USE_CPPLIB */
2221
2222   /* Initialize data in various passes.  */
2223
2224   init_obstacks ();
2225   init_tree_codes ();
2226 #if USE_CPPLIB
2227   init_parse (name);
2228 #else
2229   init_lex ();
2230 #endif
2231   /* Some of these really don't need to be called when generating bytecode,
2232      but the options would have to be parsed first to know that. -bson */
2233   init_rtl ();
2234   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
2235                   || debug_info_level == DINFO_LEVEL_VERBOSE
2236                   || flag_test_coverage);
2237   init_regs ();
2238   init_decl_processing ();
2239   init_optabs ();
2240   init_stmt ();
2241   init_expmed ();
2242   init_expr_once ();
2243   init_loop ();
2244   init_reload ();
2245
2246   if (flag_caller_saves)
2247     init_caller_save ();
2248
2249   /* If auxiliary info generation is desired, open the output file.
2250      This goes in the same directory as the source file--unlike
2251      all the other output files.  */
2252   if (flag_gen_aux_info)
2253     {
2254       aux_info_file = fopen (aux_info_file_name, "w");
2255       if (aux_info_file == 0)
2256         pfatal_with_name (aux_info_file_name);
2257     }
2258
2259   /* If rtl dump desired, open the output file.  */
2260   if (rtl_dump)
2261     rtl_dump_file = open_dump_file (dump_base_name, ".rtl");
2262
2263   /* If jump_opt dump desired, open the output file.  */
2264   if (jump_opt_dump)
2265     jump_opt_dump_file = open_dump_file (dump_base_name, ".jump");
2266
2267   /* If cse dump desired, open the output file.  */
2268   if (cse_dump)
2269     cse_dump_file = open_dump_file (dump_base_name, ".cse");
2270
2271   /* If loop dump desired, open the output file.  */
2272   if (loop_dump)
2273     loop_dump_file = open_dump_file (dump_base_name, ".loop");
2274
2275   /* If cse2 dump desired, open the output file.  */
2276   if (cse2_dump)
2277     cse2_dump_file = open_dump_file (dump_base_name, ".cse2");
2278
2279   /* If branch_prob dump desired, open the output file.  */
2280   if (branch_prob_dump)
2281     branch_prob_dump_file = open_dump_file (dump_base_name, ".bp");
2282
2283   /* If flow dump desired, open the output file.  */
2284   if (flow_dump)
2285     flow_dump_file = open_dump_file (dump_base_name, ".flow");
2286
2287   /* If combine dump desired, open the output file.  */
2288   if (combine_dump)
2289     combine_dump_file = open_dump_file (dump_base_name, ".combine");
2290
2291   /* If regmove dump desired, open the output file.  */
2292   if (regmove_dump)
2293     regmove_dump_file = open_dump_file (dump_base_name, ".regmove");
2294
2295   /* If scheduling dump desired, open the output file.  */
2296   if (sched_dump)
2297     sched_dump_file = open_dump_file (dump_base_name, ".sched");
2298
2299   /* If local_reg dump desired, open the output file.  */
2300   if (local_reg_dump)
2301     local_reg_dump_file = open_dump_file (dump_base_name, ".lreg");
2302
2303   /* If global_reg dump desired, open the output file.  */
2304   if (global_reg_dump)
2305     global_reg_dump_file = open_dump_file (dump_base_name, ".greg");
2306
2307   /* If 2nd scheduling dump desired, open the output file.  */
2308   if (sched2_dump)
2309     sched2_dump_file = open_dump_file (dump_base_name, ".sched2");
2310
2311   /* If jump2_opt dump desired, open the output file.  */
2312   if (jump2_opt_dump)
2313     jump2_opt_dump_file = open_dump_file (dump_base_name, ".jump2");
2314
2315   /* If dbr_sched dump desired, open the output file.  */
2316   if (dbr_sched_dump)
2317     dbr_sched_dump_file = open_dump_file (dump_base_name, ".dbr");
2318
2319 #ifdef STACK_REGS
2320
2321   /* If stack_reg dump desired, open the output file.  */
2322   if (stack_reg_dump)
2323     stack_reg_dump_file = open_dump_file (dump_base_name, ".stack");
2324
2325 #endif
2326
2327   /* Open assembler code output file.  */
2328
2329   if (! name_specified && asm_file_name == 0)
2330     asm_out_file = stdout;
2331   else
2332     {
2333       int len = strlen (dump_base_name);
2334       register char *dumpname = (char *) xmalloc (len + 6);
2335       strcpy (dumpname, dump_base_name);
2336       strip_off_ending (dumpname, len);
2337       strcat (dumpname, ".s");
2338       if (asm_file_name == 0)
2339         {
2340           asm_file_name = (char *) xmalloc (strlen (dumpname) + 1);
2341           strcpy (asm_file_name, dumpname);
2342         }
2343       if (!strcmp (asm_file_name, "-"))
2344         asm_out_file = stdout;
2345       else
2346         asm_out_file = fopen (asm_file_name, "w");
2347       if (asm_out_file == 0)
2348         pfatal_with_name (asm_file_name);
2349     }
2350
2351 #ifdef IO_BUFFER_SIZE
2352   setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
2353            _IOFBF, IO_BUFFER_SIZE);
2354 #endif
2355
2356   input_filename = name;
2357
2358   /* Put an entry on the input file stack for the main input file.  */
2359   input_file_stack
2360     = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2361   input_file_stack->next = 0;
2362   input_file_stack->name = input_filename;
2363
2364   /* Perform language-specific initialization.
2365      This may set main_input_filename.  */
2366   lang_init ();
2367
2368   /* If the input doesn't start with a #line, use the input name
2369      as the official input file name.  */
2370   if (main_input_filename == 0)
2371     main_input_filename = name;
2372
2373   if (!output_bytecode)
2374     {
2375       ASM_FILE_START (asm_out_file);
2376
2377 #ifdef ASM_COMMENT_START
2378       if (flag_verbose_asm)
2379         {
2380           /* Print the list of options in effect.  */
2381           print_version (asm_out_file, ASM_COMMENT_START);
2382           print_switch_values (asm_out_file, 0, MAX_LINE,
2383                                ASM_COMMENT_START, " ", "\n");
2384           /* Add a blank line here so it appears in assembler output but not
2385              screen output.  */
2386           fprintf (asm_out_file, "\n");
2387         }
2388 #endif
2389     }
2390
2391   /* Output something to inform GDB that this compilation was by GCC.  Also
2392      serves to tell GDB file consists of bytecodes.  */
2393   if (output_bytecode)
2394     fprintf (asm_out_file, "bc_gcc2_compiled.:\n");
2395   else
2396     {
2397 #ifndef ASM_IDENTIFY_GCC
2398       fprintf (asm_out_file, "gcc2_compiled.:\n");
2399 #else
2400       ASM_IDENTIFY_GCC (asm_out_file);
2401 #endif
2402     }
2403
2404   /* Output something to identify which front-end produced this file.  */
2405 #ifdef ASM_IDENTIFY_LANGUAGE
2406   ASM_IDENTIFY_LANGUAGE (asm_out_file);
2407 #endif
2408
2409 #ifndef ASM_OUTPUT_SECTION_NAME
2410   if (flag_function_sections)
2411     {
2412       warning ("-ffunction-sections not supported for this target.");
2413       flag_function_sections = 0;
2414     }
2415 #endif
2416
2417   if (flag_function_sections
2418       && (profile_flag || profile_block_flag))
2419     {
2420       warning ("-ffunction-sections disabled; it makes profiling impossible.");
2421       flag_function_sections = 0;
2422     }
2423
2424   if (flag_function_sections && write_symbols != NO_DEBUG)
2425     warning ("-ffunction-sections may affect debugging on some targets.");
2426
2427   if (output_bytecode)
2428     {
2429       if (profile_flag || profile_block_flag)
2430         error ("profiling not supported in bytecode compilation");
2431     }
2432   else
2433     {
2434       /* ??? Note: There used to be a conditional here
2435          to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined.
2436          This was to guarantee separation between gcc_compiled. and
2437          the first function, for the sake of dbx on Suns.
2438          However, having the extra zero here confused the Emacs
2439          code for unexec, and might confuse other programs too.
2440          Therefore, I took out that change.
2441          In future versions we should find another way to solve
2442          that dbx problem.  -- rms, 23 May 93.  */
2443
2444       /* Don't let the first function fall at the same address
2445          as gcc_compiled., if profiling.  */
2446       if (profile_flag || profile_block_flag)
2447         assemble_zeros (UNITS_PER_WORD);
2448     }
2449
2450   /* If dbx symbol table desired, initialize writing it
2451      and output the predefined types.  */
2452 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2453   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2454     TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
2455                                        getdecls ()));
2456 #endif
2457 #ifdef SDB_DEBUGGING_INFO
2458   if (write_symbols == SDB_DEBUG)
2459     TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
2460                                        getdecls ()));
2461 #endif
2462 #ifdef DWARF_DEBUGGING_INFO
2463   if (write_symbols == DWARF_DEBUG)
2464     TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
2465 #endif
2466 #ifdef DWARF2_UNWIND_INFO
2467   if (dwarf2out_do_frame ())
2468     dwarf2out_frame_init ();
2469 #endif
2470 #ifdef DWARF2_DEBUGGING_INFO
2471   if (write_symbols == DWARF2_DEBUG)
2472     TIMEVAR (symout_time, dwarf2out_init (asm_out_file, main_input_filename));
2473 #endif
2474
2475   /* Initialize yet another pass.  */
2476
2477   if (!output_bytecode)
2478     init_final (main_input_filename);
2479   init_branch_prob (dump_base_name);
2480
2481   start_time = get_run_time ();
2482
2483   /* Call the parser, which parses the entire file
2484      (calling rest_of_compilation for each function).  */
2485
2486   if (yyparse () != 0)
2487     {
2488       if (errorcount == 0)
2489         fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)");
2490
2491       /* In case there were missing closebraces,
2492          get us back to the global binding level.  */
2493       while (! global_bindings_p ())
2494         poplevel (0, 0, 0);
2495     }
2496
2497   output_func_start_profiler ();
2498
2499   /* Compilation is now finished except for writing
2500      what's left of the symbol table output.  */
2501
2502   parse_time += get_run_time () - start_time;
2503
2504   parse_time -= integration_time;
2505   parse_time -= varconst_time;
2506
2507   globals = getdecls ();
2508
2509   /* Really define vars that have had only a tentative definition.
2510      Really output inline functions that must actually be callable
2511      and have not been output so far.  */
2512
2513   {
2514     int len = list_length (globals);
2515     tree *vec = (tree *) alloca (sizeof (tree) * len);
2516     int i;
2517     tree decl;
2518     int reconsider = 1;
2519
2520     /* Process the decls in reverse order--earliest first.
2521        Put them into VEC from back to front, then take out from front.  */
2522
2523     for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2524       vec[len - i - 1] = decl;
2525
2526     for (i = 0; i < len; i++)
2527       {
2528         decl = vec[i];
2529
2530         /* We're not deferring this any longer.  */
2531         DECL_DEFER_OUTPUT (decl) = 0;
2532
2533         if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
2534             && incomplete_decl_finalize_hook != 0)
2535           (*incomplete_decl_finalize_hook) (decl);
2536       }
2537
2538     /* Now emit any global variables or functions that we have been putting
2539        off.  We need to loop in case one of the things emitted here
2540        references another one which comes earlier in the list.  */
2541     while (reconsider)
2542       {
2543         reconsider = 0;
2544         for (i = 0; i < len; i++)
2545           {
2546             decl = vec[i];
2547
2548             if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
2549               continue;
2550
2551             /* Don't write out static consts, unless we still need them.
2552
2553                We also keep static consts if not optimizing (for debugging),
2554                unless the user specified -fno-keep-static-consts.
2555                ??? They might be better written into the debug information.
2556                This is possible when using DWARF.
2557
2558                A language processor that wants static constants to be always
2559                written out (even if it is not used) is responsible for
2560                calling rest_of_decl_compilation itself.  E.g. the C front-end
2561                calls rest_of_decl_compilation from finish_decl.
2562                One motivation for this is that is conventional in some
2563                environments to write things like:
2564                    static const char rcsid[] = "... version string ...";
2565                intending to force the string to be in the executable.
2566
2567                A language processor that would prefer to have unneeded
2568                static constants "optimized away" would just defer writing
2569                them out until here.  E.g. C++ does this, because static
2570                constants are often defined in header files.
2571
2572                ??? A tempting alternative (for both C and C++) would be
2573                to force a constant to be written if and only if it is
2574                defined in a main file, as opposed to an include file.  */
2575
2576             if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2577                 && (! TREE_READONLY (decl)
2578                     || TREE_PUBLIC (decl)
2579                     || (!optimize && flag_keep_static_consts)
2580                     || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
2581               {
2582                 reconsider = 1;
2583                 rest_of_decl_compilation (decl, NULL_PTR, 1, 1);
2584               }
2585
2586             if (TREE_CODE (decl) == FUNCTION_DECL
2587                 && DECL_INITIAL (decl) != 0
2588                 && DECL_SAVED_INSNS (decl) != 0
2589                 && (flag_keep_inline_functions
2590                     || TREE_PUBLIC (decl)
2591                     || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
2592               {
2593                 reconsider = 1;
2594                 temporary_allocation ();
2595                 output_inline_function (decl);
2596                 permanent_allocation (1);
2597               }
2598           }
2599       }
2600
2601     /* Now that all possible functions have been output, we can dump
2602        the exception table.  */
2603
2604     output_exception_table ();
2605
2606     for (i = 0; i < len; i++)
2607       {
2608         decl = vec[i];
2609
2610         if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2611             && ! TREE_ASM_WRITTEN (decl))
2612           /* Cancel the RTL for this decl so that, if debugging info
2613              output for global variables is still to come,
2614              this one will be omitted.  */
2615           DECL_RTL (decl) = NULL;
2616
2617         /* Warn about any function
2618            declared static but not defined.
2619            We don't warn about variables,
2620            because many programs have static variables
2621            that exist only to get some text into the object file.  */
2622         if (TREE_CODE (decl) == FUNCTION_DECL
2623             && (warn_unused
2624                 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2625             && DECL_INITIAL (decl) == 0
2626             && DECL_EXTERNAL (decl)
2627             && ! DECL_ARTIFICIAL (decl)
2628             && ! TREE_PUBLIC (decl))
2629           {
2630             pedwarn_with_decl (decl,
2631                                "`%s' declared `static' but never defined");
2632             /* This symbol is effectively an "extern" declaration now.  */
2633             TREE_PUBLIC (decl) = 1;
2634             assemble_external (decl);
2635           }
2636
2637         /* Warn about static fns or vars defined but not used,
2638            but not about inline functions or static consts
2639            since defining those in header files is normal practice.  */
2640         if (warn_unused
2641             && ((TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2642                 || (TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2643             && ! DECL_IN_SYSTEM_HEADER (decl)
2644             && ! DECL_EXTERNAL (decl)
2645             && ! TREE_PUBLIC (decl)
2646             && ! TREE_USED (decl)
2647             && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
2648             /* The TREE_USED bit for file-scope decls
2649                is kept in the identifier, to handle multiple
2650                external decls in different scopes.  */
2651             && ! TREE_USED (DECL_NAME (decl)))
2652           warning_with_decl (decl, "`%s' defined but not used");
2653
2654 #ifdef SDB_DEBUGGING_INFO
2655         /* The COFF linker can move initialized global vars to the end.
2656            And that can screw up the symbol ordering.
2657            By putting the symbols in that order to begin with,
2658            we avoid a problem.  mcsun!unido!fauern!tumuc!pes@uunet.uu.net.  */
2659         if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
2660             && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
2661             && ! DECL_EXTERNAL (decl)
2662             && DECL_RTL (decl) != 0)
2663           TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2664
2665         /* Output COFF information for non-global
2666            file-scope initialized variables.  */
2667         if (write_symbols == SDB_DEBUG
2668             && TREE_CODE (decl) == VAR_DECL
2669             && DECL_INITIAL (decl)
2670             && ! DECL_EXTERNAL (decl)
2671             && DECL_RTL (decl) != 0
2672             && GET_CODE (DECL_RTL (decl)) == MEM)
2673           TIMEVAR (symout_time, sdbout_toplevel_data (decl));
2674 #endif /* SDB_DEBUGGING_INFO */
2675 #ifdef DWARF_DEBUGGING_INFO
2676         /* Output DWARF information for file-scope tentative data object
2677            declarations, file-scope (extern) function declarations (which
2678            had no corresponding body) and file-scope tagged type declarations
2679            and definitions which have not yet been forced out.  */
2680
2681         if (write_symbols == DWARF_DEBUG
2682             && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
2683           TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
2684 #endif
2685 #ifdef DWARF2_DEBUGGING_INFO
2686         /* Output DWARF2 information for file-scope tentative data object
2687            declarations, file-scope (extern) function declarations (which
2688            had no corresponding body) and file-scope tagged type declarations
2689            and definitions which have not yet been forced out.  */
2690
2691         if (write_symbols == DWARF2_DEBUG
2692             && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
2693           TIMEVAR (symout_time, dwarf2out_decl (decl));
2694 #endif
2695       }
2696   }
2697
2698   /* Write out any pending weak symbol declarations.  */
2699
2700   weak_finish ();
2701
2702   /* Do dbx symbols */
2703 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2704   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2705     TIMEVAR (symout_time,
2706              {
2707                dbxout_finish (asm_out_file, main_input_filename);
2708              });
2709 #endif
2710
2711 #ifdef DWARF_DEBUGGING_INFO
2712   if (write_symbols == DWARF_DEBUG)
2713     TIMEVAR (symout_time,
2714              {
2715                dwarfout_finish ();
2716              });
2717 #endif
2718
2719 #ifdef DWARF2_UNWIND_INFO
2720   if (dwarf2out_do_frame ())
2721     dwarf2out_frame_finish ();
2722 #endif
2723
2724 #ifdef DWARF2_DEBUGGING_INFO
2725   if (write_symbols == DWARF2_DEBUG)
2726     TIMEVAR (symout_time,
2727              {
2728                dwarf2out_finish ();
2729              });
2730 #endif
2731
2732   /* Output some stuff at end of file if nec.  */
2733
2734   if (!output_bytecode)
2735     {
2736       end_final (dump_base_name);
2737       end_branch_prob (branch_prob_dump_file);
2738
2739 #ifdef ASM_FILE_END
2740       ASM_FILE_END (asm_out_file);
2741 #endif
2742     }
2743
2744   /* Language-specific end of compilation actions.  */
2745
2746   lang_finish ();
2747
2748   if (output_bytecode)
2749     bc_write_file (asm_out_file);
2750
2751   /* Close the dump files.  */
2752
2753   if (flag_gen_aux_info)
2754     {
2755       fclose (aux_info_file);
2756       if (errorcount)
2757         unlink (aux_info_file_name);
2758     }
2759
2760   if (rtl_dump)
2761     fclose (rtl_dump_file);
2762
2763   if (jump_opt_dump)
2764     fclose (jump_opt_dump_file);
2765
2766   if (cse_dump)
2767     fclose (cse_dump_file);
2768
2769   if (loop_dump)
2770     fclose (loop_dump_file);
2771
2772   if (cse2_dump)
2773     fclose (cse2_dump_file);
2774
2775   if (branch_prob_dump)
2776     fclose (branch_prob_dump_file);
2777
2778   if (flow_dump)
2779     fclose (flow_dump_file);
2780
2781   if (combine_dump)
2782     {
2783       dump_combine_total_stats (combine_dump_file);
2784       fclose (combine_dump_file);
2785     }
2786
2787   if (regmove_dump)
2788     fclose (regmove_dump_file);
2789
2790   if (sched_dump)
2791     fclose (sched_dump_file);
2792
2793   if (local_reg_dump)
2794     fclose (local_reg_dump_file);
2795
2796   if (global_reg_dump)
2797     fclose (global_reg_dump_file);
2798
2799   if (sched2_dump)
2800     fclose (sched2_dump_file);
2801
2802   if (jump2_opt_dump)
2803     fclose (jump2_opt_dump_file);
2804
2805   if (dbr_sched_dump)
2806     fclose (dbr_sched_dump_file);
2807
2808 #ifdef STACK_REGS
2809   if (stack_reg_dump)
2810     fclose (stack_reg_dump_file);
2811 #endif
2812
2813   /* Close non-debugging input and output files.  Take special care to note
2814      whether fclose returns an error, since the pages might still be on the
2815      buffer chain while the file is open.  */
2816
2817 #if USE_CPPLIB
2818   finish_parse ();
2819 #else
2820   fclose (finput);
2821 #endif
2822   if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0)
2823     fatal_io_error (asm_file_name);
2824
2825   /* Print the times.  */
2826
2827   if (! quiet_flag)
2828     {
2829       fprintf (stderr,"\n");
2830       print_time ("parse", parse_time);
2831
2832       if (!output_bytecode)
2833         {
2834           print_time ("integration", integration_time);
2835           print_time ("jump", jump_time);
2836           print_time ("cse", cse_time);
2837           print_time ("loop", loop_time);
2838           print_time ("cse2", cse2_time);
2839           print_time ("branch-prob", branch_prob_time);
2840           print_time ("flow", flow_time);
2841           print_time ("combine", combine_time);
2842           print_time ("regmove", regmove_time);
2843           print_time ("sched", sched_time);
2844           print_time ("local-alloc", local_alloc_time);
2845           print_time ("global-alloc", global_alloc_time);
2846           print_time ("sched2", sched2_time);
2847           print_time ("dbranch", dbr_sched_time);
2848           print_time ("shorten-branch", shorten_branch_time);
2849           print_time ("stack-reg", stack_reg_time);
2850           print_time ("final", final_time);
2851           print_time ("varconst", varconst_time);
2852           print_time ("symout", symout_time);
2853           print_time ("dump", dump_time);
2854         }
2855     }
2856 }
2857 \f
2858 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2859    and TYPE_DECL nodes.
2860
2861    This does nothing for local (non-static) variables.
2862    Otherwise, it sets up the RTL and outputs any assembler code
2863    (label definition, storage allocation and initialization).
2864
2865    DECL is the declaration.  If ASMSPEC is nonzero, it specifies
2866    the assembler symbol name to be used.  TOP_LEVEL is nonzero
2867    if this declaration is not within a function.  */
2868
2869 void
2870 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2871      tree decl;
2872      char *asmspec;
2873      int top_level;
2874      int at_end;
2875 {
2876   /* Declarations of variables, and of functions defined elsewhere.  */
2877
2878 /* The most obvious approach, to put an #ifndef around where
2879    this macro is used, doesn't work since it's inside a macro call.  */
2880 #ifndef ASM_FINISH_DECLARE_OBJECT
2881 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2882 #endif
2883
2884   /* Forward declarations for nested functions are not "external",
2885      but we need to treat them as if they were.  */
2886   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2887       || TREE_CODE (decl) == FUNCTION_DECL)
2888     TIMEVAR (varconst_time,
2889              {
2890                make_decl_rtl (decl, asmspec, top_level);
2891                /* Initialized extern variable exists to be replaced
2892                   with its value, or represents something that will be
2893                   output in another file.  */
2894                if (! (TREE_CODE (decl) == VAR_DECL
2895                       && DECL_EXTERNAL (decl) && TREE_READONLY (decl)
2896                       && DECL_INITIAL (decl) != 0
2897                       && DECL_INITIAL (decl) != error_mark_node))
2898                  /* Don't output anything
2899                     when a tentative file-scope definition is seen.
2900                     But at end of compilation, do output code for them.  */
2901                  if (! (! at_end && top_level
2902                         && (DECL_INITIAL (decl) == 0
2903                             || DECL_INITIAL (decl) == error_mark_node)))
2904                    assemble_variable (decl, top_level, at_end, 0);
2905                if (!output_bytecode
2906                    && decl == last_assemble_variable_decl)
2907                  {
2908                    ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2909                                               top_level, at_end);
2910                  }
2911              });
2912   else if (DECL_REGISTER (decl) && asmspec != 0)
2913     {
2914       if (decode_reg_name (asmspec) >= 0)
2915         {
2916           DECL_RTL (decl) = 0;
2917           make_decl_rtl (decl, asmspec, top_level);
2918         }
2919       else
2920         error ("invalid register name `%s' for register variable", asmspec);
2921     }
2922 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2923   else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2924            && TREE_CODE (decl) == TYPE_DECL)
2925     TIMEVAR (symout_time, dbxout_symbol (decl, 0));
2926 #endif
2927 #ifdef SDB_DEBUGGING_INFO
2928   else if (write_symbols == SDB_DEBUG && top_level
2929            && TREE_CODE (decl) == TYPE_DECL)
2930     TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2931 #endif
2932 }
2933
2934 /* Called after finishing a record, union or enumeral type.  */
2935
2936 void
2937 rest_of_type_compilation (type, toplev)
2938      tree type;
2939      int toplev;
2940 {
2941 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2942   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2943     TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
2944 #endif
2945 #ifdef SDB_DEBUGGING_INFO
2946   if (write_symbols == SDB_DEBUG)
2947     TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
2948 #endif
2949 }
2950
2951 /* This is called from finish_function (within yyparse)
2952    after each top-level definition is parsed.
2953    It is supposed to compile that function or variable
2954    and output the assembler code for it.
2955    After we return, the tree storage is freed.  */
2956
2957 void
2958 rest_of_compilation (decl)
2959      tree decl;
2960 {
2961   register rtx insns;
2962   int start_time = get_run_time ();
2963   int tem;
2964   /* Nonzero if we have saved the original DECL_INITIAL of the function,
2965      to be restored after we finish compiling the function
2966      (for use when compiling inline calls to this function).  */
2967   tree saved_block_tree = 0;
2968   /* Likewise, for DECL_ARGUMENTS.  */
2969   tree saved_arguments = 0;
2970   int failure = 0;
2971
2972   if (output_bytecode)
2973     return;
2974
2975   /* If we are reconsidering an inline function
2976      at the end of compilation, skip the stuff for making it inline.  */
2977
2978   if (DECL_SAVED_INSNS (decl) == 0)
2979     {
2980       int inlineable = 0;
2981       char *lose;
2982
2983       /* If requested, consider whether to make this function inline.  */
2984       if (DECL_INLINE (decl) || flag_inline_functions)
2985         TIMEVAR (integration_time,
2986                  {
2987                    lose = function_cannot_inline_p (decl);
2988                    if (lose || ! optimize)
2989                      {
2990                        if (warn_inline && DECL_INLINE (decl))
2991                          warning_with_decl (decl, lose);
2992                        DECL_ABSTRACT_ORIGIN (decl) = 0;
2993                        /* Don't really compile an extern inline function.
2994                           If we can't make it inline, pretend
2995                           it was only declared.  */
2996                        if (DECL_EXTERNAL (decl))
2997                          {
2998                            DECL_INITIAL (decl) = 0;
2999                            goto exit_rest_of_compilation;
3000                          }
3001                      }
3002                    else
3003                      /* ??? Note that this has the effect of making it look
3004                         like "inline" was specified for a function if we choose
3005                         to inline it.  This isn't quite right, but it's
3006                         probably not worth the trouble to fix.  */
3007                      inlineable = DECL_INLINE (decl) = 1;
3008                  });
3009
3010       insns = get_insns ();
3011
3012       /* Dump the rtl code if we are dumping rtl.  */
3013
3014       if (rtl_dump)
3015         TIMEVAR (dump_time,
3016                  {
3017                    fprintf (rtl_dump_file, "\n;; Function %s\n\n",
3018                             (*decl_printable_name) (decl, 2));
3019                    if (DECL_SAVED_INSNS (decl))
3020                      fprintf (rtl_dump_file, ";; (integrable)\n\n");
3021                    print_rtl (rtl_dump_file, insns);
3022                    fflush (rtl_dump_file);
3023                  });
3024
3025       /* If function is inline, and we don't yet know whether to
3026          compile it by itself, defer decision till end of compilation.
3027          finish_compilation will call rest_of_compilation again
3028          for those functions that need to be output.  Also defer those
3029          functions that we are supposed to defer.  We cannot defer
3030          functions containing nested functions since the nested function
3031          data is in our non-saved obstack.  */
3032
3033       if (! current_function_contains_functions
3034           && (DECL_DEFER_OUTPUT (decl)
3035               || (DECL_INLINE (decl)
3036                   && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
3037                        && ! flag_keep_inline_functions)
3038                       || DECL_EXTERNAL (decl)))))
3039         {
3040           DECL_DEFER_OUTPUT (decl) = 1;
3041
3042           /* If -Wreturn-type, we have to do a bit of compilation.  */
3043           if (! warn_return_type)
3044             {
3045 #ifdef DWARF_DEBUGGING_INFO
3046               /* Generate the DWARF info for the "abstract" instance
3047                  of a function which we may later generate inlined and/or
3048                  out-of-line instances of.  */
3049               if (write_symbols == DWARF_DEBUG)
3050                 {
3051                   set_decl_abstract_flags (decl, 1);
3052                   TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
3053                   set_decl_abstract_flags (decl, 0);
3054                 }
3055 #endif
3056 #ifdef DWARF2_DEBUGGING_INFO
3057               /* Generate the DWARF2 info for the "abstract" instance
3058                  of a function which we may later generate inlined and/or
3059                  out-of-line instances of.  */
3060               if (write_symbols == DWARF2_DEBUG)
3061                 {
3062                   set_decl_abstract_flags (decl, 1);
3063                   TIMEVAR (symout_time, dwarf2out_decl (decl));
3064                   set_decl_abstract_flags (decl, 0);
3065                 }
3066 #endif
3067               TIMEVAR (integration_time, save_for_inline_nocopy (decl));
3068               RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl)) = inlineable;
3069               goto exit_rest_of_compilation;
3070             }
3071         }
3072
3073       /* If we have to compile the function now, save its rtl and subdecls
3074          so that its compilation will not affect what others get.  */
3075       if (inlineable || DECL_DEFER_OUTPUT (decl))
3076         {
3077 #ifdef DWARF_DEBUGGING_INFO
3078           /* Generate the DWARF info for the "abstract" instance of
3079              a function which we will generate an out-of-line instance
3080              of almost immediately (and which we may also later generate
3081              various inlined instances of).  */
3082           if (write_symbols == DWARF_DEBUG)
3083             {
3084               set_decl_abstract_flags (decl, 1);
3085               TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
3086               set_decl_abstract_flags (decl, 0);
3087             }
3088 #endif
3089 #ifdef DWARF2_DEBUGGING_INFO
3090           /* Generate the DWARF2 info for the "abstract" instance of
3091              a function which we will generate an out-of-line instance
3092              of almost immediately (and which we may also later generate
3093              various inlined instances of).  */
3094           if (write_symbols == DWARF2_DEBUG)
3095             {
3096               set_decl_abstract_flags (decl, 1);
3097               TIMEVAR (symout_time, dwarf2out_decl (decl));
3098               set_decl_abstract_flags (decl, 0);
3099             }
3100 #endif
3101           saved_block_tree = DECL_INITIAL (decl);
3102           saved_arguments = DECL_ARGUMENTS (decl);
3103           TIMEVAR (integration_time, save_for_inline_copying (decl));
3104           RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl)) = inlineable;
3105         }
3106
3107       /* If specified extern inline but we aren't inlining it, we are
3108          done.  */
3109       if (DECL_INLINE (decl) && DECL_EXTERNAL (decl))
3110         goto exit_rest_of_compilation;
3111     }
3112
3113   if (! DECL_DEFER_OUTPUT (decl))
3114     TREE_ASM_WRITTEN (decl) = 1;
3115
3116   /* Now that integrate will no longer see our rtl, we need not distinguish
3117      between the return value of this function and the return value of called
3118      functions.  */
3119   rtx_equal_function_value_matters = 0;
3120
3121   /* Don't return yet if -Wreturn-type; we need to do jump_optimize.  */
3122   if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
3123     {
3124       goto exit_rest_of_compilation;
3125     }
3126
3127   /* Add an unwinder for exception handling, if needed.
3128      This must be done before we finalize PIC code.  */
3129   emit_unwinder ();
3130
3131 #ifdef FINALIZE_PIC
3132   /* If we are doing position-independent code generation, now
3133      is the time to output special prologues and epilogues.
3134      We do not want to do this earlier, because it just clutters
3135      up inline functions with meaningless insns.  */
3136   if (flag_pic)
3137     FINALIZE_PIC;
3138 #endif
3139
3140   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
3141      Note that that may have been done above, in save_for_inline_copying.
3142      The call to resume_temporary_allocation near the end of this function
3143      goes back to the usual state of affairs.  This must be done after
3144      we've built up any unwinders for exception handling, and done
3145      the FINALIZE_PIC work, if necessary.  */
3146
3147   rtl_in_current_obstack ();
3148
3149   insns = get_insns ();
3150
3151   /* Copy any shared structure that should not be shared.  */
3152
3153   unshare_all_rtl (insns);
3154
3155   /* Instantiate all virtual registers.  */
3156
3157   instantiate_virtual_regs (current_function_decl, get_insns ());
3158
3159   /* See if we have allocated stack slots that are not directly addressable.
3160      If so, scan all the insns and create explicit address computation
3161      for all references to such slots.  */
3162 /*   fixup_stack_slots (); */
3163
3164   /* Find all the EH handlers.  */
3165   find_exception_handler_labels ();
3166
3167   /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
3168      are initialized and to compute whether control can drop off the end
3169      of the function.  */
3170   TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
3171   TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
3172
3173   /* Now is when we stop if -fsyntax-only and -Wreturn-type.  */
3174   if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
3175     goto exit_rest_of_compilation;
3176
3177   /* Dump rtl code after jump, if we are doing that.  */
3178
3179   if (jump_opt_dump)
3180     TIMEVAR (dump_time,
3181              {
3182                fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
3183                         (*decl_printable_name) (decl, 2));
3184                print_rtl (jump_opt_dump_file, insns);
3185                fflush (jump_opt_dump_file);
3186              });
3187
3188   /* Perform common subexpression elimination.
3189      Nonzero value from `cse_main' means that jumps were simplified
3190      and some code may now be unreachable, so do
3191      jump optimization again.  */
3192
3193   if (cse_dump)
3194     TIMEVAR (dump_time,
3195              {
3196                fprintf (cse_dump_file, "\n;; Function %s\n\n",
3197                         (*decl_printable_name) (decl, 2));
3198              });
3199
3200   if (optimize > 0)
3201     {
3202       TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
3203
3204       if (flag_thread_jumps)
3205         /* Hacks by tiemann & kenner.  */
3206         TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1));
3207
3208       TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
3209                                          0, cse_dump_file));
3210       TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ()));
3211
3212       if (tem || optimize > 1)
3213         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
3214     }
3215
3216   /* Dump rtl code after cse, if we are doing that.  */
3217
3218   if (cse_dump)
3219     TIMEVAR (dump_time,
3220              {
3221                print_rtl (cse_dump_file, insns);
3222                fflush (cse_dump_file);
3223              });
3224
3225   if (loop_dump)
3226     TIMEVAR (dump_time,
3227              {
3228                fprintf (loop_dump_file, "\n;; Function %s\n\n",
3229                         (*decl_printable_name) (decl, 2));
3230              });
3231
3232   /* Move constant computations out of loops.  */
3233
3234   if (optimize > 0)
3235     {
3236       TIMEVAR (loop_time,
3237                {
3238                  loop_optimize (insns, loop_dump_file);
3239                });
3240     }
3241
3242   /* Dump rtl code after loop opt, if we are doing that.  */
3243
3244   if (loop_dump)
3245     TIMEVAR (dump_time,
3246              {
3247                print_rtl (loop_dump_file, insns);
3248                fflush (loop_dump_file);
3249              });
3250
3251   if (cse2_dump)
3252     TIMEVAR (dump_time,
3253              {
3254                fprintf (cse2_dump_file, "\n;; Function %s\n\n",
3255                         (*decl_printable_name) (decl, 2));
3256              });
3257
3258   if (optimize > 0 && flag_rerun_cse_after_loop)
3259     {
3260       /* Running another jump optimization pass before the second
3261          cse pass sometimes simplifies the RTL enough to allow
3262          the second CSE pass to do a better job.  Jump_optimize can change
3263          max_reg_num so we must rerun reg_scan afterwards.
3264          ??? Rework to not call reg_scan so often.  */
3265       TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
3266       TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
3267
3268       TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
3269       TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
3270                                           1, cse2_dump_file));
3271       if (tem)
3272         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
3273     }
3274
3275   if (optimize > 0 && flag_thread_jumps)
3276     {
3277       /* This pass of jump threading straightens out code
3278          that was kinked by loop optimization.  */
3279       TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
3280       TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
3281     }
3282   /* Dump rtl code after cse, if we are doing that.  */
3283
3284   if (cse2_dump)
3285     TIMEVAR (dump_time,
3286              {
3287                print_rtl (cse2_dump_file, insns);
3288                fflush (cse2_dump_file);
3289              });
3290
3291   if (branch_prob_dump)
3292     TIMEVAR (dump_time,
3293              {
3294                fprintf (branch_prob_dump_file, "\n;; Function %s\n\n",
3295                         (*decl_printable_name) (decl, 2));
3296              });
3297
3298   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
3299     TIMEVAR (branch_prob_time,
3300              {
3301                branch_prob (insns, branch_prob_dump_file);
3302              });
3303
3304   if (branch_prob_dump)
3305     TIMEVAR (dump_time,
3306              {
3307                print_rtl (branch_prob_dump_file, insns);
3308                fflush (branch_prob_dump_file);
3309              });
3310   /* We are no longer anticipating cse in this function, at least.  */
3311
3312   cse_not_expected = 1;
3313
3314   /* Now we choose between stupid (pcc-like) register allocation
3315      (if we got the -noreg switch and not -opt)
3316      and smart register allocation.  */
3317
3318   if (optimize > 0)                     /* Stupid allocation probably won't work */
3319     obey_regdecls = 0;          /* if optimizations being done.  */
3320
3321   regclass_init ();
3322
3323   /* Print function header into flow dump now
3324      because doing the flow analysis makes some of the dump.  */
3325
3326   if (flow_dump)
3327     TIMEVAR (dump_time,
3328              {
3329                fprintf (flow_dump_file, "\n;; Function %s\n\n",
3330                         (*decl_printable_name) (decl, 2));
3331              });
3332
3333   if (obey_regdecls)
3334     {
3335       TIMEVAR (flow_time,
3336                {
3337                  regclass (insns, max_reg_num ());
3338                  stupid_life_analysis (insns, max_reg_num (),
3339                                        flow_dump_file);
3340                });
3341     }
3342   else
3343     {
3344       /* Do control and data flow analysis,
3345          and write some of the results to dump file.  */
3346
3347       TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
3348                                          flow_dump_file));
3349       if (warn_uninitialized)
3350         {
3351           uninitialized_vars_warning (DECL_INITIAL (decl));
3352           setjmp_args_warning ();
3353         }
3354     }
3355
3356   /* Dump rtl after flow analysis.  */
3357
3358   if (flow_dump)
3359     TIMEVAR (dump_time,
3360              {
3361                print_rtl_with_bb (flow_dump_file, insns);
3362                fflush (flow_dump_file);
3363              });
3364
3365   /* If -opt, try combining insns through substitution.  */
3366
3367   if (optimize > 0)
3368     TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
3369
3370   /* Dump rtl code after insn combination.  */
3371
3372   if (combine_dump)
3373     TIMEVAR (dump_time,
3374              {
3375                fprintf (combine_dump_file, "\n;; Function %s\n\n",
3376                         (*decl_printable_name) (decl, 2));
3377                dump_combine_stats (combine_dump_file);
3378                print_rtl_with_bb (combine_dump_file, insns);
3379                fflush (combine_dump_file);
3380              });
3381
3382   if (regmove_dump)
3383     TIMEVAR (dump_time,
3384              {
3385                fprintf (regmove_dump_file, "\n;; Function %s\n\n",
3386                         (*decl_printable_name) (decl, 2));
3387              });
3388
3389   /* Register allocation pre-pass, to reduce number of moves
3390      necessary for two-address machines.  */
3391   if (optimize > 0 && flag_regmove)
3392     TIMEVAR (regmove_time, regmove_optimize (insns, max_reg_num (),
3393                                              regmove_dump_file));
3394
3395   if (regmove_dump)
3396     TIMEVAR (dump_time,
3397              {
3398                print_rtl_with_bb (regmove_dump_file, insns);
3399                fflush (regmove_dump_file);
3400              });
3401
3402   /* Print function header into sched dump now
3403      because doing the sched analysis makes some of the dump.  */
3404
3405   if (sched_dump)
3406     TIMEVAR (dump_time,
3407              {
3408                fprintf (sched_dump_file, "\n;; Function %s\n\n",
3409                         (*decl_printable_name) (decl, 2));
3410              });
3411
3412   if (optimize > 0 && flag_schedule_insns)
3413     {
3414       /* Do control and data sched analysis,
3415          and write some of the results to dump file.  */
3416
3417       TIMEVAR (sched_time, schedule_insns (sched_dump_file));
3418     }
3419
3420   /* Dump rtl after instruction scheduling.  */
3421
3422   if (sched_dump)
3423     TIMEVAR (dump_time,
3424              {
3425                print_rtl_with_bb (sched_dump_file, insns);
3426                fflush (sched_dump_file);
3427              });
3428
3429   /* Unless we did stupid register allocation,
3430      allocate pseudo-regs that are used only within 1 basic block.  */
3431
3432   if (!obey_regdecls)
3433     TIMEVAR (local_alloc_time,
3434              {
3435                regclass (insns, max_reg_num ());
3436                local_alloc ();
3437              });
3438
3439   /* Dump rtl code after allocating regs within basic blocks.  */
3440
3441   if (local_reg_dump)
3442     TIMEVAR (dump_time,
3443              {
3444                fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
3445                         (*decl_printable_name) (decl, 2));
3446                dump_flow_info (local_reg_dump_file);
3447                dump_local_alloc (local_reg_dump_file);
3448                print_rtl_with_bb (local_reg_dump_file, insns);
3449                fflush (local_reg_dump_file);
3450              });
3451
3452   if (global_reg_dump)
3453     TIMEVAR (dump_time,
3454              fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
3455                       (*decl_printable_name) (decl, 2)));
3456
3457   /* Save the last label number used so far, so reorg can tell
3458      when it's safe to kill spill regs.  */
3459   max_label_num_after_reload = max_label_num ();
3460
3461   /* Unless we did stupid register allocation,
3462      allocate remaining pseudo-regs, then do the reload pass
3463      fixing up any insns that are invalid.  */
3464
3465   TIMEVAR (global_alloc_time,
3466            {
3467              if (!obey_regdecls)
3468                failure = global_alloc (global_reg_dump_file);
3469              else
3470                failure = reload (insns, 0, global_reg_dump_file);
3471            });
3472
3473   if (global_reg_dump)
3474     TIMEVAR (dump_time,
3475              {
3476                dump_global_regs (global_reg_dump_file);
3477                print_rtl_with_bb (global_reg_dump_file, insns);
3478                fflush (global_reg_dump_file);
3479              });
3480
3481   if (failure)
3482     goto exit_rest_of_compilation;
3483
3484   reload_completed = 1;
3485
3486   /* Do a very simple CSE pass over just the hard registers.  */
3487   if (optimize > 0)
3488     reload_cse_regs (insns);
3489
3490   /* On some machines, the prologue and epilogue code, or parts thereof,
3491      can be represented as RTL.  Doing so lets us schedule insns between
3492      it and the rest of the code and also allows delayed branch
3493      scheduling to operate in the epilogue.  */
3494
3495   thread_prologue_and_epilogue_insns (insns);
3496
3497   if (optimize > 0 && flag_schedule_insns_after_reload)
3498     {
3499       if (sched2_dump)
3500         TIMEVAR (dump_time,
3501                  {
3502                    fprintf (sched2_dump_file, "\n;; Function %s\n\n",
3503                             (*decl_printable_name) (decl, 2));
3504                  });
3505
3506       /* Do control and data sched analysis again,
3507          and write some more of the results to dump file.  */
3508
3509       TIMEVAR (sched2_time, schedule_insns (sched2_dump_file));
3510
3511       /* Dump rtl after post-reorder instruction scheduling.  */
3512
3513       if (sched2_dump)
3514         TIMEVAR (dump_time,
3515                  {
3516                    print_rtl_with_bb (sched2_dump_file, insns);
3517                    fflush (sched2_dump_file);
3518                  });
3519     }
3520
3521 #ifdef LEAF_REGISTERS
3522   leaf_function = 0;
3523   if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
3524     leaf_function = 1;
3525 #endif
3526
3527   /* One more attempt to remove jumps to .+1
3528      left by dead-store-elimination.
3529      Also do cross-jumping this time
3530      and delete no-op move insns.  */
3531
3532   if (optimize > 0)
3533     {
3534       TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0));
3535     }
3536
3537   /* Dump rtl code after jump, if we are doing that.  */
3538
3539   if (jump2_opt_dump)
3540     TIMEVAR (dump_time,
3541              {
3542                fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
3543                         (*decl_printable_name) (decl, 2));
3544                print_rtl_with_bb (jump2_opt_dump_file, insns);
3545                fflush (jump2_opt_dump_file);
3546              });
3547
3548   /* If a machine dependent reorganization is needed, call it.  */
3549 #ifdef MACHINE_DEPENDENT_REORG
3550    MACHINE_DEPENDENT_REORG (insns);
3551 #endif
3552
3553   /* If a scheduling pass for delayed branches is to be done,
3554      call the scheduling code.  */
3555
3556 #ifdef DELAY_SLOTS
3557   if (optimize > 0 && flag_delayed_branch)
3558     {
3559       TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file));
3560       if (dbr_sched_dump)
3561         {
3562           TIMEVAR (dump_time,
3563                  {
3564                    fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n",
3565                             (*decl_printable_name) (decl, 2));
3566                    print_rtl_with_bb (dbr_sched_dump_file, insns);
3567                    fflush (dbr_sched_dump_file);
3568                  });
3569         }
3570     }
3571 #endif
3572
3573   /* Shorten branches.  */
3574   TIMEVAR (shorten_branch_time,
3575            {
3576              shorten_branches (get_insns ());
3577            });
3578
3579 #ifdef STACK_REGS
3580   TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file));
3581   if (stack_reg_dump)
3582     {
3583       TIMEVAR (dump_time,
3584                {
3585                  fprintf (stack_reg_dump_file, "\n;; Function %s\n\n",
3586                           (*decl_printable_name) (decl, 2));
3587                  print_rtl_with_bb (stack_reg_dump_file, insns);
3588                  fflush (stack_reg_dump_file);
3589                });
3590     }
3591 #endif
3592
3593   /* Now turn the rtl into assembler code.  */
3594
3595   TIMEVAR (final_time,
3596            {
3597              rtx x;
3598              char *fnname;
3599
3600              /* Get the function's name, as described by its RTL.
3601                 This may be different from the DECL_NAME name used
3602                 in the source file.  */
3603
3604              x = DECL_RTL (decl);
3605              if (GET_CODE (x) != MEM)
3606                abort ();
3607              x = XEXP (x, 0);
3608              if (GET_CODE (x) != SYMBOL_REF)
3609                abort ();
3610              fnname = XSTR (x, 0);
3611
3612              assemble_start_function (decl, fnname);
3613              final_start_function (insns, asm_out_file, optimize);
3614              final (insns, asm_out_file, optimize, 0);
3615              final_end_function (insns, asm_out_file, optimize);
3616              assemble_end_function (decl, fnname);
3617              fflush (asm_out_file);
3618
3619              /* Release all memory held by regsets now */
3620              regset_release_memory ();
3621            });
3622
3623   /* Write DBX symbols if requested */
3624
3625   /* Note that for those inline functions where we don't initially
3626      know for certain that we will be generating an out-of-line copy,
3627      the first invocation of this routine (rest_of_compilation) will
3628      skip over this code by doing a `goto exit_rest_of_compilation;'.
3629      Later on, finish_compilation will call rest_of_compilation again
3630      for those inline functions that need to have out-of-line copies
3631      generated.  During that call, we *will* be routed past here.  */
3632
3633 #ifdef DBX_DEBUGGING_INFO
3634   if (write_symbols == DBX_DEBUG)
3635     TIMEVAR (symout_time, dbxout_function (decl));
3636 #endif
3637
3638 #ifdef DWARF_DEBUGGING_INFO
3639   if (write_symbols == DWARF_DEBUG)
3640     TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
3641 #endif
3642
3643 #ifdef DWARF2_DEBUGGING_INFO
3644   if (write_symbols == DWARF2_DEBUG)
3645     TIMEVAR (symout_time, dwarf2out_decl (decl));
3646 #endif
3647
3648  exit_rest_of_compilation:
3649
3650   /* In case the function was not output,
3651      don't leave any temporary anonymous types
3652      queued up for sdb output.  */
3653 #ifdef SDB_DEBUGGING_INFO
3654   if (write_symbols == SDB_DEBUG)
3655     sdbout_types (NULL_TREE);
3656 #endif
3657
3658   /* Put back the tree of subblocks and list of arguments
3659      from before we copied them.
3660      Code generation and the output of debugging info may have modified
3661      the copy, but the original is unchanged.  */
3662
3663   if (saved_block_tree != 0)
3664     {
3665       DECL_INITIAL (decl) = saved_block_tree;
3666       DECL_ARGUMENTS (decl) = saved_arguments;
3667       DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
3668     }
3669
3670   reload_completed = 0;
3671
3672   /* Clear out the insn_length contents now that they are no longer valid.  */
3673   init_insn_lengths ();
3674
3675   /* Clear out the real_constant_chain before some of the rtx's
3676      it runs through become garbage.  */
3677
3678   clear_const_double_mem ();
3679
3680   /* Cancel the effect of rtl_in_current_obstack.  */
3681
3682   resume_temporary_allocation ();
3683
3684   /* Show no temporary slots allocated.  */
3685
3686   init_temp_slots ();
3687
3688   /* The parsing time is all the time spent in yyparse
3689      *except* what is spent in this function.  */
3690
3691   parse_time -= get_run_time () - start_time;
3692 }
3693 \f
3694 /* Entry point of cc1/c++.  Decode command args, then call compile_file.
3695    Exit code is 35 if can't open files, 34 if fatal error,
3696    33 if had nonfatal errors, else success.  */
3697
3698 int
3699 main (argc, argv, envp)
3700      int argc;
3701      char **argv;
3702      char **envp;
3703 {
3704   register int i;
3705   char *filename = 0;
3706   int flag_print_mem = 0;
3707   int version_flag = 0;
3708   char *p;
3709
3710   /* save in case md file wants to emit args as a comment.  */
3711   save_argc = argc;
3712   save_argv = argv;
3713
3714   p = argv[0] + strlen (argv[0]);
3715   while (p != argv[0] && p[-1] != '/'
3716 #ifdef DIR_SEPARATOR
3717          && p[-1] != DIR_SEPARATOR
3718 #endif
3719          )
3720     --p;
3721   progname = p;
3722
3723 #ifdef RLIMIT_STACK
3724   /* Get rid of any avoidable limit on stack size.  */
3725   {
3726     struct rlimit rlim;
3727
3728     /* Set the stack limit huge so that alloca does not fail.  */
3729     getrlimit (RLIMIT_STACK, &rlim);
3730     rlim.rlim_cur = rlim.rlim_max;
3731     setrlimit (RLIMIT_STACK, &rlim);
3732   }
3733 #endif /* RLIMIT_STACK */
3734
3735   signal (SIGFPE, float_signal);
3736
3737 #ifdef SIGPIPE
3738   signal (SIGPIPE, pipe_closed);
3739 #endif
3740
3741   decl_printable_name = decl_name;
3742   lang_expand_expr = (struct rtx_def *(*)()) do_abort;
3743
3744   /* Initialize whether `char' is signed.  */
3745   flag_signed_char = DEFAULT_SIGNED_CHAR;
3746 #ifdef DEFAULT_SHORT_ENUMS
3747   /* Initialize how much space enums occupy, by default.  */
3748   flag_short_enums = DEFAULT_SHORT_ENUMS;
3749 #endif
3750
3751   /* Scan to see what optimization level has been specified.  That will
3752      determine the default value of many flags.  */
3753   for (i = 1; i < argc; i++)
3754     {
3755       if (!strcmp (argv[i], "-O"))
3756         {
3757           optimize = 1;
3758         }
3759       else if (argv[i][0] == '-' && argv[i][1] == 'O')
3760         {
3761           /* Handle -O2, -O3, -O69, ...  */
3762           char *p = &argv[i][2];
3763           int c;
3764
3765           while (c = *p++)
3766             if (! (c >= '0' && c <= '9'))
3767               break;
3768           if (c == 0)
3769             optimize = atoi (&argv[i][2]);
3770         }
3771     }
3772
3773   obey_regdecls = (optimize == 0);
3774
3775   if (optimize >= 1)
3776     {
3777       flag_defer_pop = 1;
3778       flag_thread_jumps = 1;
3779 #ifdef DELAY_SLOTS
3780       flag_delayed_branch = 1;
3781 #endif
3782 #ifdef CAN_DEBUG_WITHOUT_FP
3783       flag_omit_frame_pointer = 1;
3784 #endif
3785       flag_alias_check = 1;
3786     }
3787
3788   if (optimize >= 2)
3789     {
3790       flag_cse_follow_jumps = 1;
3791       flag_cse_skip_blocks = 1;
3792       flag_expensive_optimizations = 1;
3793       flag_strength_reduce = 1;
3794       flag_rerun_cse_after_loop = 1;
3795       flag_caller_saves = 1;
3796       flag_force_mem = 1;
3797 #ifdef INSN_SCHEDULING
3798       flag_schedule_insns = 1;
3799       flag_schedule_insns_after_reload = 1;
3800 #endif
3801       flag_regmove = 1;
3802     }
3803
3804   if (optimize >= 3)
3805     {
3806       flag_inline_functions = 1;
3807     }
3808
3809   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
3810      modify it.  */
3811   target_flags = 0;
3812   set_target_switch ("");
3813
3814 #ifdef OPTIMIZATION_OPTIONS
3815   /* Allow default optimizations to be specified on a per-machine basis.  */
3816   OPTIMIZATION_OPTIONS (optimize);
3817 #endif
3818
3819   /* Initialize register usage now so switches may override.  */
3820   init_reg_sets ();
3821
3822   for (i = 1; i < argc; i++)
3823     {
3824       int j;
3825       /* If this is a language-specific option,
3826          decode it in a language-specific way.  */
3827       for (j = 0; lang_options[j] != 0; j++)
3828         if (!strncmp (argv[i], lang_options[j],
3829                       strlen (lang_options[j])))
3830           break;
3831       if (lang_options[j] != 0)
3832         /* If the option is valid for *some* language,
3833            treat it as valid even if this language doesn't understand it.  */
3834         lang_decode_option (argv[i]);
3835       else if (argv[i][0] == '-' && argv[i][1] != 0)
3836         {
3837           register char *str = argv[i] + 1;
3838           if (str[0] == 'Y')
3839             str++;
3840
3841           if (str[0] == 'm')
3842             set_target_switch (&str[1]);
3843           else if (!strcmp (str, "dumpbase"))
3844             {
3845               dump_base_name = argv[++i];
3846             }
3847           else if (str[0] == 'd')
3848             {
3849               register char *p = &str[1];
3850               while (*p)
3851                 switch (*p++)
3852                   {
3853                   case 'a':
3854                     branch_prob_dump = 1;
3855                     combine_dump = 1;
3856                     dbr_sched_dump = 1;
3857                     flow_dump = 1;
3858                     global_reg_dump = 1;
3859                     jump_opt_dump = 1;
3860                     jump2_opt_dump = 1;
3861                     local_reg_dump = 1;
3862                     loop_dump = 1;
3863                     regmove_dump = 1;
3864                     rtl_dump = 1;
3865                     cse_dump = 1, cse2_dump = 1;
3866                     sched_dump = 1;
3867                     sched2_dump = 1;
3868                     stack_reg_dump = 1;
3869                     break;
3870                   case 'b':
3871                     branch_prob_dump = 1;
3872                     break;
3873                   case 'k':
3874                     stack_reg_dump = 1;
3875                     break;
3876                   case 'c':
3877                     combine_dump = 1;
3878                     break;
3879                   case 'd':
3880                     dbr_sched_dump = 1;
3881                     break;
3882                   case 'f':
3883                     flow_dump = 1;
3884                     break;
3885                   case 'g':
3886                     global_reg_dump = 1;
3887                     break;
3888                   case 'j':
3889                     jump_opt_dump = 1;
3890                     break;
3891                   case 'J':
3892                     jump2_opt_dump = 1;
3893                     break;
3894                   case 'l':
3895                     local_reg_dump = 1;
3896                     break;
3897                   case 'L':
3898                     loop_dump = 1;
3899                     break;
3900                   case 'm':
3901                     flag_print_mem = 1;
3902                     break;
3903                   case 'p':
3904                     flag_print_asm_name = 1;
3905                     break;
3906                   case 'r':
3907                     rtl_dump = 1;
3908                     break;
3909                   case 's':
3910                     cse_dump = 1;
3911                     break;
3912                   case 't':
3913                     cse2_dump = 1;
3914                     break;
3915                   case 'N':
3916                     regmove_dump = 1;
3917                     break;
3918                   case 'S':
3919                     sched_dump = 1;
3920                     break;
3921                   case 'R':
3922                     sched2_dump = 1;
3923                     break;
3924                   case 'y':
3925                     set_yydebug (1);
3926                     break;
3927                   case 'x':
3928                     rtl_dump_and_exit = 1;
3929                     break;
3930                   case 'A':
3931                     flag_debug_asm = 1;
3932                     break;
3933                   }
3934             }
3935           else if (str[0] == 'f')
3936             {
3937               register char *p = &str[1];
3938               int found = 0;
3939
3940               /* Some kind of -f option.
3941                  P's value is the option sans `-f'.
3942                  Search for it in the table of options.  */
3943
3944               for (j = 0;
3945                    !found && j < sizeof (f_options) / sizeof (f_options[0]);
3946                    j++)
3947                 {
3948                   if (!strcmp (p, f_options[j].string))
3949                     {
3950                       *f_options[j].variable = f_options[j].on_value;
3951                       /* A goto here would be cleaner,
3952                          but breaks the vax pcc.  */
3953                       found = 1;
3954                     }
3955                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
3956                       && ! strcmp (p+3, f_options[j].string))
3957                     {
3958                       *f_options[j].variable = ! f_options[j].on_value;
3959                       found = 1;
3960                     }
3961                 }
3962
3963               if (found)
3964                 ;
3965 #ifdef HAIFA
3966 #ifdef INSN_SCHEDULING
3967               else if (!strncmp (p, "sched-verbose-",14))
3968                 fix_sched_param("verbose",&p[14]);
3969               else if (!strncmp (p, "sched-max-",10))
3970                 fix_sched_param("max",&p[10]);
3971               else if (!strncmp (p, "sched-inter-max-b-",18))
3972                 fix_sched_param("interblock-max-blocks",&p[18]);
3973               else if (!strncmp (p, "sched-inter-max-i-",18))
3974                 fix_sched_param("interblock-max-insns",&p[18]);
3975 #endif
3976 #endif  /* HAIFA */
3977               else if (!strncmp (p, "fixed-", 6))
3978                 fix_register (&p[6], 1, 1);
3979               else if (!strncmp (p, "call-used-", 10))
3980                 fix_register (&p[10], 0, 1);
3981               else if (!strncmp (p, "call-saved-", 11))
3982                 fix_register (&p[11], 0, 0);
3983               else
3984                 error ("Invalid option `%s'", argv[i]);
3985             }
3986           else if (str[0] == 'O')
3987             {
3988               register char *p = str+1;
3989               while (*p && *p >= '0' && *p <= '9')
3990                 p++;
3991               if (*p == '\0')
3992                 ;
3993               else
3994                 error ("Invalid option `%s'", argv[i]);
3995             }
3996           else if (!strcmp (str, "pedantic"))
3997             pedantic = 1;
3998           else if (!strcmp (str, "pedantic-errors"))
3999             flag_pedantic_errors = pedantic = 1;
4000           else if (!strcmp (str, "quiet"))
4001             quiet_flag = 1;
4002           else if (!strcmp (str, "version"))
4003             version_flag = 1;
4004           else if (!strcmp (str, "w"))
4005             inhibit_warnings = 1;
4006           else if (!strcmp (str, "W"))
4007             {
4008               extra_warnings = 1;
4009               /* We save the value of warn_uninitialized, since if they put
4010                  -Wuninitialized on the command line, we need to generate a
4011                  warning about not using it without also specifying -O.  */
4012               if (warn_uninitialized != 1)
4013                 warn_uninitialized = 2;
4014             }
4015           else if (str[0] == 'W')
4016             {
4017               register char *p = &str[1];
4018               int found = 0;
4019
4020               /* Some kind of -W option.
4021                  P's value is the option sans `-W'.
4022                  Search for it in the table of options.  */
4023
4024               for (j = 0;
4025                    !found && j < sizeof (W_options) / sizeof (W_options[0]);
4026                    j++)
4027                 {
4028                   if (!strcmp (p, W_options[j].string))
4029                     {
4030                       *W_options[j].variable = W_options[j].on_value;
4031                       /* A goto here would be cleaner,
4032                          but breaks the vax pcc.  */
4033                       found = 1;
4034                     }
4035                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
4036                       && ! strcmp (p+3, W_options[j].string))
4037                     {
4038                       *W_options[j].variable = ! W_options[j].on_value;
4039                       found = 1;
4040                     }
4041                 }
4042
4043               if (found)
4044                 ;
4045               else if (!strncmp (p, "id-clash-", 9))
4046                 {
4047                   char *endp = p + 9;
4048
4049                   while (*endp)
4050                     {
4051                       if (*endp >= '0' && *endp <= '9')
4052                         endp++;
4053                       else
4054                         {
4055                           error ("Invalid option `%s'", argv[i]);
4056                           goto id_clash_lose;
4057                         }
4058                     }
4059                   warn_id_clash = 1;
4060                   id_clash_len = atoi (str + 10);
4061                 id_clash_lose: ;
4062                 }
4063               else if (!strncmp (p, "larger-than-", 12))
4064                 {
4065                   char *endp = p + 12;
4066
4067                   while (*endp)
4068                     {
4069                       if (*endp >= '0' && *endp <= '9')
4070                         endp++;
4071                       else
4072                         {
4073                           error ("Invalid option `%s'", argv[i]);
4074                           goto larger_than_lose;
4075                         }
4076                     }
4077                   warn_larger_than = 1;
4078                   larger_than_size = atoi (str + 13);
4079                 larger_than_lose: ;
4080                 }
4081               else
4082                 error ("Invalid option `%s'", argv[i]);
4083             }
4084           else if (!strcmp (str, "p"))
4085             {
4086               profile_flag = 1;
4087             }
4088           else if (!strcmp (str, "a"))
4089             {
4090 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4091               warning ("`-a' option (basic block profile) not supported");
4092 #else
4093               profile_block_flag = (profile_block_flag < 2) ? 1 : 3;
4094 #endif
4095             }
4096           else if (!strcmp (str, "ax"))
4097             {
4098 #if !defined (FUNCTION_BLOCK_PROFILER_EXIT) || !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4099               warning ("`-ax' option (jump profiling) not supported");
4100 #else
4101               profile_block_flag = (!profile_block_flag
4102                                        || profile_block_flag == 2) ? 2 : 3;
4103 #endif
4104             }
4105           else if (str[0] == 'g')
4106             {
4107               unsigned len;
4108               unsigned level;
4109               /* A lot of code assumes write_symbols == NO_DEBUG if the
4110                  debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
4111                  of what debugging type has been selected).  This records the
4112                  selected type.  It is an error to specify more than one
4113                  debugging type.  */
4114               static enum debug_info_type selected_debug_type = NO_DEBUG;
4115               /* Non-zero if debugging format has been explicitly set.
4116                  -g and -ggdb don't explicitly set the debugging format so
4117                  -gdwarf -g3 is equivalent to -gdwarf3.  */
4118               static int type_explicitly_set_p = 0;
4119               /* Table of supported debugging formats.  */
4120               static struct {
4121                 char *arg;
4122                 /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
4123                    constant expression, we use NO_DEBUG in its place.  */
4124                 enum debug_info_type debug_type;
4125                 int use_extensions_p;
4126               } *da, debug_args[] = {
4127                 { "g", NO_DEBUG, DEFAULT_GDB_EXTENSIONS },
4128                 { "ggdb", NO_DEBUG, 1 },
4129 #ifdef DBX_DEBUGGING_INFO
4130                 { "gstabs", DBX_DEBUG, 0 },
4131                 { "gstabs+", DBX_DEBUG, 1 },
4132 #endif
4133 #ifdef DWARF_DEBUGGING_INFO
4134                 { "gdwarf", DWARF_DEBUG, 0 },
4135                 { "gdwarf+", DWARF_DEBUG, 1 },
4136 #endif
4137 #ifdef DWARF2_DEBUGGING_INFO
4138                 { "gdwarf-2", DWARF2_DEBUG, 0 },
4139 #endif
4140 #ifdef XCOFF_DEBUGGING_INFO
4141                 { "gxcoff", XCOFF_DEBUG, 0 },
4142                 { "gxcoff+", XCOFF_DEBUG, 1 },
4143 #endif
4144 #ifdef SDB_DEBUGGING_INFO
4145                 { "gcoff", SDB_DEBUG, 0 },
4146 #endif
4147                 { 0, 0, 0 }
4148               };
4149               /* Indexed by enum debug_info_type.  */
4150               static char *debug_type_names[] = {
4151                 "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff"
4152               };
4153
4154               /* Look up STR in the table.  */
4155               for (da = debug_args; da->arg; da++)
4156                 {
4157                   if (! strncmp (str, da->arg, strlen (da->arg)))
4158                     {
4159                       enum debug_info_type type = da->debug_type;
4160                       char *p, *q;
4161
4162                       p = str + strlen (da->arg);
4163                       if (*p && (*p < '0' || *p > '9'))
4164                         continue;
4165                       q = p;
4166                       len = p - str;
4167                       while (*q && (*q >= '0' && *q <= '9'))
4168                         q++;
4169                       if (*p)
4170                         level = atoi (p);
4171                       else
4172                         level = 2;      /* default debugging info level */
4173                       if (*q || level > 3)
4174                         {
4175                           warning ("invalid debug level specification in option: `-%s'",
4176                                    str);
4177                           /* ??? This error message is incorrect in the case of
4178                              -g4 -g.  */
4179                           warning ("no debugging information will be generated");
4180                           level = 0;
4181                         }
4182
4183                       if (type == NO_DEBUG)
4184                         {
4185                           type = PREFERRED_DEBUGGING_TYPE;
4186                           if (len > 1 && strncmp (str, "ggdb", len) == 0)
4187                             {
4188 #ifdef DWARF2_DEBUGGING_INFO
4189                               type = DWARF2_DEBUG;
4190 #else
4191 #ifdef DBX_DEBUGGING_INFO
4192                               type = DBX_DEBUG;
4193 #endif
4194 #endif
4195                             }
4196                         }
4197
4198                       if (type == NO_DEBUG)
4199                         warning ("`-%s' not supported by this configuration of GCC",
4200                                  str);
4201
4202                       /* Does it conflict with an already selected type?  */
4203                       if (type_explicitly_set_p
4204                           /* -g/-ggdb don't conflict with anything */
4205                           && da->debug_type != NO_DEBUG
4206                           && type != selected_debug_type)
4207                         warning ("`-%s' ignored, conflicts with `-g%s'",
4208                                  str, debug_type_names[(int) selected_debug_type]);
4209                       else
4210                         {
4211                           /* If the format has already been set, -g/-ggdb
4212                              only change the debug level.  */
4213                           if (type_explicitly_set_p
4214                               && da->debug_type == NO_DEBUG)
4215                             ; /* don't change debugging type */
4216                           else
4217                             {
4218                               selected_debug_type = type;
4219                               type_explicitly_set_p = da->debug_type != NO_DEBUG;
4220                             }
4221                           write_symbols = (level == 0
4222                                            ? NO_DEBUG
4223                                            : selected_debug_type);
4224                           use_gnu_debug_info_extensions = da->use_extensions_p;
4225                           debug_info_level = (enum debug_info_level) level;
4226                         }
4227                       break;
4228                     }
4229                 }
4230               if (! da->arg)
4231                 warning ("`-%s' not supported by this configuration of GCC",
4232                          str);
4233             }
4234           else if (!strcmp (str, "o"))
4235             {
4236               asm_file_name = argv[++i];
4237             }
4238           else if (str[0] == 'G')
4239             {
4240               g_switch_set = TRUE;
4241               g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]);
4242             }
4243           else if (!strncmp (str, "aux-info", 8))
4244             {
4245               flag_gen_aux_info = 1;
4246               aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]);
4247             }
4248           else
4249             error ("Invalid option `%s'", argv[i]);
4250         }
4251       else if (argv[i][0] == '+')
4252         error ("Invalid option `%s'", argv[i]);
4253       else
4254         filename = argv[i];
4255     }
4256
4257   /* Checker uses the frame pointer.  */
4258   if (flag_check_memory_usage)
4259     flag_omit_frame_pointer = 0;
4260
4261   /* Initialize for bytecode output.  A good idea to do this as soon as
4262      possible after the "-f" options have been parsed.  */
4263   if (output_bytecode)
4264     {
4265 #ifndef TARGET_SUPPORTS_BYTECODE
4266       /* Just die with a fatal error if not supported */
4267       fatal ("-fbytecode not supported for this target");
4268 #else
4269       bc_initialize ();
4270 #endif
4271     }
4272
4273   if (optimize == 0)
4274     {
4275       /* Inlining does not work if not optimizing,
4276          so force it not to be done.  */
4277       flag_no_inline = 1;
4278       warn_inline = 0;
4279
4280       /* The c_decode_option and lang_decode_option functions set
4281          this to `2' if -Wall is used, so we can avoid giving out
4282          lots of errors for people who don't realize what -Wall does.  */
4283       if (warn_uninitialized == 1)
4284         warning ("-Wuninitialized is not supported without -O");
4285     }
4286
4287 #ifdef OVERRIDE_OPTIONS
4288   /* Some machines may reject certain combinations of options.  */
4289   OVERRIDE_OPTIONS;
4290 #endif
4291
4292   if (profile_block_flag == 3)
4293     {
4294       warning ("`-ax' and `-a' are conflicting options. `-a' ignored.");
4295       profile_block_flag = 2;
4296     }
4297
4298   /* Unrolling all loops implies that standard loop unrolling must also
4299      be done.  */
4300   if (flag_unroll_all_loops)
4301     flag_unroll_loops = 1;
4302   /* Loop unrolling requires that strength_reduction be on also.  Silently
4303      turn on strength reduction here if it isn't already on.  Also, the loop
4304      unrolling code assumes that cse will be run after loop, so that must
4305      be turned on also.  */
4306   if (flag_unroll_loops)
4307     {
4308       flag_strength_reduce = 1;
4309       flag_rerun_cse_after_loop = 1;
4310     }
4311
4312   /* Warn about options that are not supported on this machine.  */
4313 #ifndef INSN_SCHEDULING
4314   if (flag_schedule_insns || flag_schedule_insns_after_reload)
4315     warning ("instruction scheduling not supported on this target machine");
4316 #endif
4317 #ifndef DELAY_SLOTS
4318   if (flag_delayed_branch)
4319     warning ("this target machine does not have delayed branches");
4320 #endif
4321
4322   /* If we are in verbose mode, write out the version and maybe all the
4323      option flags in use.  */
4324   if (version_flag)
4325     {
4326       print_version (stderr, "");
4327       if (! quiet_flag)
4328         print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
4329     }
4330
4331   compile_file (filename);
4332
4333 #if !defined(OS2) && !defined(VMS) && (!defined(_WIN32) || defined (__CYGWIN32__))
4334   if (flag_print_mem)
4335     {
4336       char *lim = (char *) sbrk (0);
4337
4338       fprintf (stderr, "Data size %d.\n",
4339                lim - (char *) &environ);
4340       fflush (stderr);
4341
4342 #ifdef USG
4343       system ("ps -l 1>&2");
4344 #else /* not USG */
4345       system ("ps v");
4346 #endif /* not USG */
4347     }
4348 #endif /* ! OS2 && ! VMS && (! _WIN32 || CYGWIN32) */
4349
4350   if (errorcount)
4351     exit (FATAL_EXIT_CODE);
4352   if (sorrycount)
4353     exit (FATAL_EXIT_CODE);
4354   exit (SUCCESS_EXIT_CODE);
4355   return 0;
4356 }
4357 \f
4358 /* Decode -m switches.  */
4359
4360 /* Here is a table, controlled by the tm.h file, listing each -m switch
4361    and which bits in `target_switches' it should set or clear.
4362    If VALUE is positive, it is bits to set.
4363    If VALUE is negative, -VALUE is bits to clear.
4364    (The sign bit is not used so there is no confusion.)  */
4365
4366 struct {char *name; int value;} target_switches []
4367   = TARGET_SWITCHES;
4368
4369 /* This table is similar, but allows the switch to have a value.  */
4370
4371 #ifdef TARGET_OPTIONS
4372 struct {char *prefix; char ** variable;} target_options []
4373   = TARGET_OPTIONS;
4374 #endif
4375
4376 /* Decode the switch -mNAME.  */
4377
4378 void
4379 set_target_switch (name)
4380      char *name;
4381 {
4382   register int j;
4383   int valid = 0;
4384
4385   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
4386     if (!strcmp (target_switches[j].name, name))
4387       {
4388         if (target_switches[j].value < 0)
4389           target_flags &= ~-target_switches[j].value;
4390         else
4391           target_flags |= target_switches[j].value;
4392         valid = 1;
4393       }
4394
4395 #ifdef TARGET_OPTIONS
4396   if (!valid)
4397     for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
4398       {
4399         int len = strlen (target_options[j].prefix);
4400         if (!strncmp (target_options[j].prefix, name, len))
4401           {
4402             *target_options[j].variable = name + len;
4403             valid = 1;
4404           }
4405       }
4406 #endif
4407
4408   if (!valid)
4409     error ("Invalid option `%s'", name);
4410 }
4411 \f
4412 /* Print version information to FILE.
4413    Each line begins with INDENT (for the case where FILE is the
4414    assembler output file).  */
4415
4416 void
4417 print_version (file, indent)
4418      FILE *file;
4419      char *indent;
4420 {
4421   fprintf (file, "%s%s%s version %s", indent, *indent != 0 ? " " : "",
4422            language_string, version_string);
4423   fprintf (file, " (%s)", TARGET_NAME);
4424 #ifdef __GNUC__
4425 #ifndef __VERSION__
4426 #define __VERSION__ "[unknown]"
4427 #endif
4428   fprintf (file, " compiled by GNU C version %s.\n", __VERSION__);
4429 #else
4430   fprintf (file, " compiled by CC.\n");
4431 #endif
4432 }
4433
4434 /* Print an option value and return the adjusted position in the line.
4435    ??? We don't handle error returns from fprintf (disk full); presumably
4436    other code will catch a disk full though.  */
4437
4438 int
4439 print_single_switch (file, pos, max, indent, sep, term, type, name)
4440      FILE *file;
4441      int pos, max;
4442      char *indent, *sep, *term, *type, *name;
4443 {
4444   /* The ultrix fprintf returns 0 on success, so compute the result we want
4445      here since we need it for the following test.  */
4446   int len = strlen (sep) + strlen (type) + strlen (name);
4447
4448   if (pos != 0
4449       && pos + len > max)
4450     {
4451       fprintf (file, "%s", term);
4452       pos = 0;
4453     }
4454   if (pos == 0)
4455     {
4456       fprintf (file, "%s", indent);
4457       pos = strlen (indent);
4458     }
4459   fprintf (file, "%s%s%s", sep, type, name);
4460   pos += len;
4461   return pos;
4462 }
4463
4464 /* Print active target switches to FILE.
4465    POS is the current cursor position and MAX is the size of a "line".
4466    Each line begins with INDENT and ends with TERM.
4467    Each switch is separated from the next by SEP.  */
4468
4469 void
4470 print_switch_values (file, pos, max, indent, sep, term)
4471      FILE *file;
4472      int pos, max;
4473      char *indent, *sep, *term;
4474 {
4475   int j, flags;
4476   char **p;
4477
4478   /* Print the options as passed.  */
4479
4480   pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
4481                              "options passed: ", "");
4482
4483   for (p = &save_argv[1]; *p != NULL; p++)
4484     if (**p == '-')
4485       {
4486         /* Ignore these.  */
4487         if (strcmp (*p, "-o") == 0)
4488           {
4489             if (p[1] != NULL)
4490               p++;
4491             continue;
4492           }
4493         if (strcmp (*p, "-quiet") == 0)
4494           continue;
4495         if (strcmp (*p, "-version") == 0)
4496           continue;
4497         if ((*p)[1] == 'd')
4498           continue;
4499
4500         pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
4501       }
4502   if (pos > 0)
4503     fprintf (file, "%s", term);
4504
4505   /* Print the -f and -m options that have been enabled.
4506      We don't handle language specific options but printing argv
4507      should suffice.  */
4508
4509   pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
4510                              "options enabled: ", "");
4511
4512   for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++)
4513     if (*f_options[j].variable == f_options[j].on_value)
4514       pos = print_single_switch (file, pos, max, indent, sep, term,
4515                                  "-f", f_options[j].string);
4516
4517   /* Print target specific options.  */
4518
4519   flags = target_flags;
4520   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
4521     if (target_switches[j].name[0] != '\0'
4522         && target_switches[j].value > 0
4523         && ((target_switches[j].value & target_flags)
4524             == target_switches[j].value))
4525       {
4526         pos = print_single_switch (file, pos, max, indent, sep, term,
4527                                    "-m", target_switches[j].name);
4528         flags &= ~ target_switches[j].value;
4529       }
4530
4531 #ifdef TARGET_OPTIONS
4532   for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
4533     if (*target_options[j].variable != NULL)
4534       {
4535         char prefix[256];
4536         sprintf (prefix, "-m%s", target_options[j].prefix);
4537         pos = print_single_switch (file, pos, max, indent, sep, term,
4538                                    prefix, *target_options[j].variable);
4539       }
4540 #endif
4541
4542   fprintf (file, "%s", term);
4543 }
4544
4545 /* Record the beginning of a new source file, named FILENAME.  */
4546
4547 void
4548 debug_start_source_file (filename)
4549      register char *filename;
4550 {
4551 #ifdef DBX_DEBUGGING_INFO
4552   if (write_symbols == DBX_DEBUG)
4553     dbxout_start_new_source_file (filename);
4554 #endif
4555 #ifdef DWARF_DEBUGGING_INFO
4556   if (debug_info_level == DINFO_LEVEL_VERBOSE
4557       && write_symbols == DWARF_DEBUG)
4558     dwarfout_start_new_source_file (filename);
4559 #endif /* DWARF_DEBUGGING_INFO */
4560 #ifdef DWARF2_DEBUGGING_INFO
4561   if (debug_info_level == DINFO_LEVEL_VERBOSE
4562       && write_symbols == DWARF2_DEBUG)
4563     dwarf2out_start_source_file (filename);
4564 #endif /* DWARF2_DEBUGGING_INFO */
4565 #ifdef SDB_DEBUGGING_INFO
4566   if (write_symbols == SDB_DEBUG)
4567     sdbout_start_new_source_file (filename);
4568 #endif
4569 }
4570
4571 /* Record the resumption of a source file.  LINENO is the line number in
4572    the source file we are returning to.  */
4573
4574 void
4575 debug_end_source_file (lineno)
4576      register unsigned lineno;
4577 {
4578 #ifdef DBX_DEBUGGING_INFO
4579   if (write_symbols == DBX_DEBUG)
4580     dbxout_resume_previous_source_file ();
4581 #endif
4582 #ifdef DWARF_DEBUGGING_INFO
4583   if (debug_info_level == DINFO_LEVEL_VERBOSE
4584       && write_symbols == DWARF_DEBUG)
4585     dwarfout_resume_previous_source_file (lineno);
4586 #endif /* DWARF_DEBUGGING_INFO */
4587 #ifdef DWARF2_DEBUGGING_INFO
4588   if (debug_info_level == DINFO_LEVEL_VERBOSE
4589       && write_symbols == DWARF2_DEBUG)
4590     dwarf2out_end_source_file ();
4591 #endif /* DWARF2_DEBUGGING_INFO */
4592 #ifdef SDB_DEBUGGING_INFO
4593   if (write_symbols == SDB_DEBUG)
4594     sdbout_resume_previous_source_file ();
4595 #endif
4596 }
4597
4598 /* Called from check_newline in c-parse.y.  The `buffer' parameter contains
4599    the tail part of the directive line, i.e. the part which is past the
4600    initial whitespace, #, whitespace, directive-name, whitespace part.  */
4601
4602 void
4603 debug_define (lineno, buffer)
4604      register unsigned lineno;
4605      register char *buffer;
4606 {
4607 #ifdef DWARF_DEBUGGING_INFO
4608   if (debug_info_level == DINFO_LEVEL_VERBOSE
4609       && write_symbols == DWARF_DEBUG)
4610     dwarfout_define (lineno, buffer);
4611 #endif /* DWARF_DEBUGGING_INFO */
4612 #ifdef DWARF2_DEBUGGING_INFO
4613   if (debug_info_level == DINFO_LEVEL_VERBOSE
4614       && write_symbols == DWARF2_DEBUG)
4615     dwarf2out_define (lineno, buffer);
4616 #endif /* DWARF2_DEBUGGING_INFO */
4617 }
4618
4619 /* Called from check_newline in c-parse.y.  The `buffer' parameter contains
4620    the tail part of the directive line, i.e. the part which is past the
4621    initial whitespace, #, whitespace, directive-name, whitespace part.  */
4622
4623 void
4624 debug_undef (lineno, buffer)
4625      register unsigned lineno;
4626      register char *buffer;
4627 {
4628 #ifdef DWARF_DEBUGGING_INFO
4629   if (debug_info_level == DINFO_LEVEL_VERBOSE
4630       && write_symbols == DWARF_DEBUG)
4631     dwarfout_undef (lineno, buffer);
4632 #endif /* DWARF_DEBUGGING_INFO */
4633 #ifdef DWARF2_DEBUGGING_INFO
4634   if (debug_info_level == DINFO_LEVEL_VERBOSE
4635       && write_symbols == DWARF2_DEBUG)
4636     dwarf2out_undef (lineno, buffer);
4637 #endif /* DWARF2_DEBUGGING_INFO */
4638 }